
import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, XLMRobertaTokenizer

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()
class 					lowercase__(							UpperCAmelCase					,		UpperCAmelCase					,		UpperCAmelCase					,		unittest.TestCase				):



	"""simple docstring"""




	a     :List[str]       	=      AltDiffusionPipeline
	a     :List[Any]       	=      TEXT_TO_IMAGE_PARAMS
	a     :Any       	=      TEXT_TO_IMAGE_BATCH_PARAMS
	a     :Dict       	=      TEXT_TO_IMAGE_IMAGE_PARAMS
	a     :Optional[Any]       	=      TEXT_TO_IMAGE_IMAGE_PARAMS
	def 		_lowercase    (			self    :     Optional[Any]			)			->	List[Any]:
					torch.manual_seed(0			)
					lowercase_	    =   UNetaDConditionModel(
					    block_out_channels=(3_2, 6_4)			,				layers_per_block=2			,				sample_size=3_2			,				in_channels=4			,				out_channels=4			,				down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')			,				up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')			,				cross_attention_dim=3_2			,				)
					lowercase_	    =   DDIMScheduler(
					    beta_start=0.0_00_85			,				beta_end=0.0_12			,				beta_schedule='''scaled_linear'''			,				clip_sample=SCREAMING_SNAKE_CASE_			,				set_alpha_to_one=SCREAMING_SNAKE_CASE_			,				)
					torch.manual_seed(0			)
					lowercase_	    =   AutoencoderKL(
					    block_out_channels=[3_2, 6_4]			,				in_channels=3			,				out_channels=3			,				down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']			,				up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']			,				latent_channels=4			,				)

					# TODO: address the non-deterministic text encoder (fails for save-load tests)
					# torch.manual_seed(0)
					# text_encoder_config = RobertaSeriesConfig(
					#     hidden_size=32,
					#     project_dim=32,
					#     intermediate_size=37,
					#     layer_norm_eps=1e-05,
					#     num_attention_heads=4,
					#     num_hidden_layers=5,
					#     vocab_size=5002,
					# )
					# text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

					torch.manual_seed(0			)
					lowercase_	    =   CLIPTextConfig(
					    bos_token_id=0			,				eos_token_id=2			,				hidden_size=3_2			,				projection_dim=3_2			,				intermediate_size=3_7			,				layer_norm_eps=1e-05			,				num_attention_heads=4			,				num_hidden_layers=5			,				pad_token_id=1			,				vocab_size=5_0_0_2			,				)
					lowercase_	    =   CLIPTextModel(SCREAMING_SNAKE_CASE_			)

					lowercase_	    =   XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''			)
					lowercase_	    =   7_7

					lowercase_	    =   {
					    '''unet''': unet,
					    '''scheduler''': scheduler,
					    '''vae''': vae,
					    '''text_encoder''': text_encoder,
					    '''tokenizer''': tokenizer,
					    '''safety_checker''': None,
					    '''feature_extractor''': None,
					}
					return components
	def 		_lowercase    (			self    :     Optional[int]			,				SCREAMING_SNAKE_CASE_    :     Optional[Any]			,				SCREAMING_SNAKE_CASE_    :     List[str]=0			)			->	Any:
					if str(SCREAMING_SNAKE_CASE_			).startswith('''mps'''			):
									lowercase_	    =   torch.manual_seed(SCREAMING_SNAKE_CASE_			)
					else:
									lowercase_	    =   torch.Generator(device=SCREAMING_SNAKE_CASE_			).manual_seed(SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   {
					    '''prompt''': '''A painting of a squirrel eating a burger''',
					    '''generator''': generator,
					    '''num_inference_steps''': 2,
					    '''guidance_scale''': 6.0,
					    '''output_type''': '''numpy''',
					}
					return inputs
	def 		_lowercase    (			self    :     Tuple			)			->	str:
					super().test_attention_slicing_forward_pass(expected_max_diff=3e-3			)
	def 		_lowercase    (			self    :     Dict			)			->	str:
					super().test_inference_batch_single_identical(expected_max_diff=3e-3			)
	def 		_lowercase    (			self    :     List[Any]			)			->	Any:
					lowercase_	    =   '''cpu'''  # ensure determinism for the device-dependent torch.Generator

					lowercase_	    =   self.get_dummy_components()
					torch.manual_seed(0			)
					lowercase_	    =   RobertaSeriesConfig(
					    hidden_size=3_2			,				project_dim=3_2			,				intermediate_size=3_7			,				layer_norm_eps=1e-05			,				num_attention_heads=4			,				num_hidden_layers=5			,				vocab_size=5_0_0_2			,				)
					# TODO: remove after fixing the non-deterministic text encoder
					lowercase_	    =   RobertaSeriesModelWithTransformation(SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   text_encoder

					lowercase_	    =   AltDiffusionPipeline(**SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   alt_pipe.to(SCREAMING_SNAKE_CASE_			)
					alt_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

					lowercase_	    =   self.get_dummy_inputs(SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   '''A photo of an astronaut'''
					lowercase_	    =   alt_pipe(**SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   output.images
					lowercase_	    =   image[0, -3:, -3:, -1]

					assert image.shape == (1, 6_4, 6_4, 3)
					lowercase_	    =   np.array(
					    [0.5_74_81_62, 0.60_44_71_45, 0.48_82_12_17, 0.50_10_06_36, 0.5_43_11_85, 0.45_76_36_83, 0.49_65_76_96, 0.48_13_27_33, 0.47_57_30_93]			)

					assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2




	def 		_lowercase    (			self    :     Union[str, Any]			)			->	int:
					lowercase_	    =   '''cpu'''  # ensure determinism for the device-dependent torch.Generator

					lowercase_	    =   self.get_dummy_components()
					lowercase_	    =   PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_			)
					torch.manual_seed(0			)
					lowercase_	    =   RobertaSeriesConfig(
					    hidden_size=3_2			,				project_dim=3_2			,				intermediate_size=3_7			,				layer_norm_eps=1e-05			,				num_attention_heads=4			,				num_hidden_layers=5			,				vocab_size=5_0_0_2			,				)
					# TODO: remove after fixing the non-deterministic text encoder
					lowercase_	    =   RobertaSeriesModelWithTransformation(SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   text_encoder
					lowercase_	    =   AltDiffusionPipeline(**SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   alt_pipe.to(SCREAMING_SNAKE_CASE_			)
					alt_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

					lowercase_	    =   self.get_dummy_inputs(SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   alt_pipe(**SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   output.images
					lowercase_	    =   image[0, -3:, -3:, -1]

					assert image.shape == (1, 6_4, 6_4, 3)
					lowercase_	    =   np.array(
					    [0.51_60_50_93, 0.5_70_72_41, 0.47_36_55_07, 0.50_57_88_86, 0.5_63_38_77, 0.4_64_25_03, 0.5_18_20_81, 0.48_76_34_84, 0.49_08_42_37]			)

					assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2

@slow
@require_torch_gpu
class 					lowercase__(							unittest.TestCase				):



	"""simple docstring"""




	def 		_lowercase    (			self    :     Dict			)			->	List[Any]:
					# clean up the VRAM after each test
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()
	def 		_lowercase    (			self    :     List[str]			)			->	Dict:
					# make sure here that pndm scheduler skips prk
					lowercase_	    =   AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''			,				safety_checker=SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   alt_pipe.to(SCREAMING_SNAKE_CASE_			)
					alt_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

					lowercase_	    =   '''A painting of a squirrel eating a burger'''
					lowercase_	    =   torch.manual_seed(0			)
					lowercase_	    =   alt_pipe([prompt]			,				generator=SCREAMING_SNAKE_CASE_			,				guidance_scale=6.0			,				num_inference_steps=2_0			,				output_type='''np'''			)

					lowercase_	    =   output.images

					lowercase_	    =   image[0, -3:, -3:, -1]

					assert image.shape == (1, 5_1_2, 5_1_2, 3)
					lowercase_	    =   np.array([0.10_10, 0.08_00, 0.07_94, 0.08_85, 0.08_43, 0.07_62, 0.07_69, 0.07_29, 0.05_86]			)

					assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2




	def 		_lowercase    (			self    :     Any			)			->	Optional[int]:
					lowercase_	    =   DDIMScheduler.from_pretrained('''BAAI/AltDiffusion'''			,				subfolder='''scheduler'''			)

					lowercase_	    =   AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion'''			,				scheduler=SCREAMING_SNAKE_CASE_			,				safety_checker=SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   alt_pipe.to(SCREAMING_SNAKE_CASE_			)
					alt_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

					lowercase_	    =   '''A painting of a squirrel eating a burger'''
					lowercase_	    =   torch.manual_seed(0			)

					lowercase_	    =   alt_pipe([prompt]			,				generator=SCREAMING_SNAKE_CASE_			,				num_inference_steps=2			,				output_type='''numpy'''			)
					lowercase_	    =   output.images

					lowercase_	    =   image[0, -3:, -3:, -1]

					assert image.shape == (1, 5_1_2, 5_1_2, 3)
					lowercase_	    =   np.array([0.40_19, 0.40_52, 0.38_10, 0.41_19, 0.39_16, 0.39_82, 0.46_51, 0.41_95, 0.53_23]			)

					assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2











'''simple docstring'''






import os

from huggingface_hub.constants import HUGGINGFACE_HUB_CACHE, hf_cache_home


__UpperCamelCase					    =	HUGGINGFACE_HUB_CACHE


__UpperCamelCase					    =	"config.json"
__UpperCamelCase					    =	"diffusion_pytorch_model.bin"
__UpperCamelCase					    =	"diffusion_flax_model.msgpack"
__UpperCamelCase					    =	"model.onnx"
__UpperCamelCase					    =	"diffusion_pytorch_model.safetensors"
__UpperCamelCase					    =	"weights.pb"
__UpperCamelCase					    =	"https://huggingface.co"
__UpperCamelCase					    =	default_cache_path
__UpperCamelCase					    =	"diffusers_modules"
__UpperCamelCase					    =	os.getenv("HF_MODULES_CACHE", os.path.join(hf_cache_home, "modules"))
__UpperCamelCase					    =	["fp16", "non-ema"]
__UpperCamelCase					    =	".self_attn"


