


import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    PNDMScheduler,
    StableDiffusionLDMaDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import nightly, 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


enable_full_determinism()




class       lowercase_					(unittest.TestCase   ):
				snake_case	    =StableDiffusionLDMaDPipeline
				snake_case	    =TEXT_TO_IMAGE_PARAMS
				snake_case	    =TEXT_TO_IMAGE_BATCH_PARAMS
				snake_case	    =TEXT_TO_IMAGE_IMAGE_PARAMS





				def 						__UpperCamelCase    (				self)  -> Any:
											torch.manual_seed(0)
											a__      =UNetaDConditionModel(
											    block_out_channels=(32, 64)       ,  layers_per_block=2       ,  sample_size=32       ,  in_channels=4       ,  out_channels=4       ,  down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,  up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')       ,  cross_attention_dim=32       ,  )
											a__      =DDIMScheduler(
											    beta_start=0.0_00_85       ,  beta_end=0.0_12       ,  beta_schedule='scaled_linear'       ,  clip_sample=lowercase_       ,  set_alpha_to_one=lowercase_       ,  )
											torch.manual_seed(0)
											a__      =AutoencoderKL(
											    block_out_channels=[32, 64]       ,  in_channels=6       ,  out_channels=6       ,  down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']       ,  up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']       ,  latent_channels=4       ,  )
											torch.manual_seed(0)
											a__      =CLIPTextConfig(
											    bos_token_id=0       ,  eos_token_id=2       ,  hidden_size=32       ,  intermediate_size=37       ,  layer_norm_eps=1e-05       ,  num_attention_heads=4       ,  num_hidden_layers=5       ,  pad_token_id=1       ,  vocab_size=1000       ,  )
											a__      =CLIPTextModel(lowercase_)
											a__      =CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

											a__      ={
											    'unet': unet,
											    'scheduler': scheduler,
											    'vae': vae,
											    'text_encoder': text_encoder,
											    'tokenizer': tokenizer,
											    'safety_checker': None,
											    'feature_extractor': None,
											}
											return components





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_=0)  -> List[str]:
											if str(lowercase_).startswith('mps'):
																		a__      =torch.manual_seed(lowercase_)
											else:
																		a__      =torch.Generator(device=lowercase_).manual_seed(lowercase_)
											a__      ={
											    '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 						__UpperCamelCase    (				self)  -> Any:
											a__      ='cpu'  # ensure determinism for the device-dependent torch.Generator

											a__      =self.get_dummy_components()
											a__      =StableDiffusionLDMaDPipeline(**lowercase_)
											a__      =ldmad_pipe.to(lowercase_)
											ldmad_pipe.set_progress_bar_config(disable=lowercase_)

											a__      =self.get_dummy_inputs(lowercase_)
											a__      =ldmad_pipe(**lowercase_)
											a__    ,     a__      =output.rgb, output.depth

											a__      =rgb[0, -3:, -3:, -1]
											a__      =depth[0, -3:, -1]

											assert rgb.shape == (1, 64, 64, 3)
											assert depth.shape == (1, 64, 64)

											a__      =np.array(
											    [0.37_33_81_76, 0.7_02_47, 0.74_20_31_93, 0.51_64_36_04, 0.58_25_67_93, 0.60_93_21_36, 0.4_18_10_95, 0.48_35_58_77, 0.46_53_52_62])
											a__      =np.array([1_03.4_67_27, 85.81_20_04, 87.84_92_36])

											assert np.abs(image_slice_rgb.flatten() - expected_slice_rgb).max() < 1e-2
											assert np.abs(image_slice_depth.flatten() - expected_slice_depth).max() < 1e-2





				def 						__UpperCamelCase    (				self)  -> Optional[int]:
											a__      =self.get_dummy_components()
											a__      =StableDiffusionLDMaDPipeline(**lowercase_)
											a__      =ldmad_pipe.to(lowercase_)
											ldmad_pipe.set_progress_bar_config(disable=lowercase_)

											a__      =self.get_dummy_inputs(lowercase_)
											a__      =3 * [inputs['prompt']]

											# forward
											a__      =ldmad_pipe(**lowercase_)
											a__    ,     a__      =output.rgb, output.depth
											a__      =rgb_slice_a[0, -3:, -3:, -1]
											a__      =depth_slice_a[0, -3:, -1]

											a__      =self.get_dummy_inputs(lowercase_)
											a__      =3 * [inputs.pop('prompt')]

											a__      =ldmad_pipe.tokenizer(
											    lowercase_       ,  padding='max_length'       ,  max_length=ldmad_pipe.tokenizer.model_max_length       ,  truncation=lowercase_       ,  return_tensors='pt'       ,  )
											a__      =text_inputs['input_ids'].to(lowercase_)

											a__      =ldmad_pipe.text_encoder(lowercase_)[0]

											a__      =prompt_embeds

											# forward
											a__      =ldmad_pipe(**lowercase_)
											a__    ,     a__      =output.rgb, output.depth
											a__      =rgb_slice_a[0, -3:, -3:, -1]
											a__      =depth_slice_a[0, -3:, -1]

											assert np.abs(rgb_slice_a.flatten() - rgb_slice_a.flatten()).max() < 1e-4
											assert np.abs(depth_slice_a.flatten() - depth_slice_a.flatten()).max() < 1e-4





				def 						__UpperCamelCase    (				self)  -> Dict:
											a__      ='cpu'  # ensure determinism for the device-dependent torch.Generator
											a__      =self.get_dummy_components()
											a__      =PNDMScheduler(skip_prk_steps=lowercase_)
											a__      =StableDiffusionLDMaDPipeline(**lowercase_)
											a__      =ldmad_pipe.to(lowercase_)
											ldmad_pipe.set_progress_bar_config(disable=lowercase_)

											a__      =self.get_dummy_inputs(lowercase_)
											a__      ='french fries'
											a__      =ldmad_pipe(**lowercase_       ,  negative_prompt=lowercase_)

											a__    ,     a__      =output.rgb, output.depth
											a__      =rgb[0, -3:, -3:, -1]
											a__      =depth[0, -3:, -1]

											assert rgb.shape == (1, 64, 64, 3)
											assert depth.shape == (1, 64, 64)

											a__      =np.array(
											    [0.3_70_44, 0.71_81_15_03, 0.7_22_32_51, 0.48_60_36_75, 0.5_63_83_91, 0.6_36_49_48, 0.42_83_37_04, 0.4_90_13_15, 0.47_92_62_17])
											a__      =np.array([1_07.8_47_38, 84.6_28_02, 89.96_21_35])
											assert np.abs(rgb_slice.flatten() - expected_slice_rgb).max() < 1e-2
											assert np.abs(depth_slice.flatten() - expected_slice_depth).max() < 1e-2







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





				def 						__UpperCamelCase    (				self)  -> Tuple:
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_="cpu"       ,  lowercase_=torch.floataa       ,  lowercase_=0)  -> Optional[Any]:
											a__      =torch.Generator(device=lowercase_).manual_seed(lowercase_)
											a__      =np.random.RandomState(lowercase_).standard_normal((1, 4, 64, 64))
											a__      =torch.from_numpy(lowercase_).to(device=lowercase_       ,  dtype=lowercase_)
											a__      ={
											    'prompt': 'a photograph of an astronaut riding a horse',
											    'latents': latents,
											    'generator': generator,
											    'num_inference_steps': 3,
											    'guidance_scale': 7.5,
											    'output_type': 'numpy',
											}
											return inputs





				def 						__UpperCamelCase    (				self)  -> List[Any]:
											a__      =StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d')
											a__      =ldmad_pipe.to(lowercase_)
											ldmad_pipe.set_progress_bar_config(disable=lowercase_)

											a__      =self.get_inputs(lowercase_)
											a__      =ldmad_pipe(**lowercase_)
											a__    ,     a__      =output.rgb, output.depth
											a__      =rgb[0, -3:, -3:, -1].flatten()
											a__      =rgb[0, -3:, -1].flatten()

											assert rgb.shape == (1, 512, 512, 3)
											assert depth.shape == (1, 512, 512)

											a__      =np.array(
											    [0.53_80_54_65, 0.56_70_73_05, 0.5_48_65_15, 0.57_01_22_36, 0.5_81_45_11, 0.56_25_34_87, 0.54_84_30_14, 0.55_09_22_63, 0.6_45_97_06])
											a__      =np.array(
											    [0.9_26_37_81, 0.6_67_86_72, 0.5_48_65_15, 0.92_20_21_45, 0.67_83_11_35, 0.56_25_34_87, 0.9_24_16_94, 0.7_55_14_78, 0.6_45_97_06])
											assert np.abs(rgb_slice - expected_slice_rgb).max() < 3e-3
											assert np.abs(depth_slice - expected_slice_depth).max() < 3e-3







@nightly
@require_torch_gpu
class       lowercase_					(unittest.TestCase   ):





				def 						__UpperCamelCase    (				self)  -> Any:
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_="cpu"       ,  lowercase_=torch.floataa       ,  lowercase_=0)  -> List[str]:
											a__      =torch.Generator(device=lowercase_).manual_seed(lowercase_)
											a__      =np.random.RandomState(lowercase_).standard_normal((1, 4, 64, 64))
											a__      =torch.from_numpy(lowercase_).to(device=lowercase_       ,  dtype=lowercase_)
											a__      ={
											    'prompt': 'a photograph of an astronaut riding a horse',
											    'latents': latents,
											    'generator': generator,
											    'num_inference_steps': 50,
											    'guidance_scale': 7.5,
											    'output_type': 'numpy',
											}
											return inputs





				def 						__UpperCamelCase    (				self)  -> List[Any]:
											a__      =StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d').to(lowercase_)
											ldmad_pipe.set_progress_bar_config(disable=lowercase_)

											a__      =self.get_inputs(lowercase_)
											a__      =ldmad_pipe(**lowercase_)
											a__    ,     a__      =output.rgb, output.depth

											a__      =0.49_55_86
											a__      =0.33_79_55_15
											a__      =1_12.4_85_18
											a__      =98.48_97_46
											assert np.abs(expected_rgb_mean - rgb.mean()) < 1e-3
											assert np.abs(expected_rgb_std - rgb.std()) < 1e-3
											assert np.abs(expected_depth_mean - depth.mean()) < 1e-3
											assert np.abs(expected_depth_std - depth.std()) < 1e-3





				def 						__UpperCamelCase    (				self)  -> Optional[int]:
											a__      =StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d-4c').to(lowercase_)
											ldmad_pipe.set_progress_bar_config(disable=lowercase_)

											a__      =self.get_inputs(lowercase_)
											a__      =ldmad_pipe(**lowercase_)
											a__    ,     a__      =output.rgb, output.depth

											a__      =0.4_19_41_27
											a__      =0.35_37_55_86
											a__      =0.5_63_85_02
											a__      =0.34_68_61_03

											assert rgb.shape == (1, 512, 512, 3)
											assert depth.shape == (1, 512, 512, 1)
											assert np.abs(expected_rgb_mean - rgb.mean()) < 1e-3
											assert np.abs(expected_rgb_std - rgb.std()) < 1e-3
											assert np.abs(expected_depth_mean - depth.mean()) < 1e-3
											assert np.abs(expected_depth_std - depth.std()) < 1e-3





'''simple docstring'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging


__SCREAMING_SNAKE_CASE					:				Tuple									=		logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE					:				Union[str, Any]									=		{
    '''transfo-xl-wt103''': '''https://huggingface.co/transfo-xl-wt103/resolve/main/config.json''',
}






class 					__lowerCAmelCase   (   lowercase						):

						"""simple docstring"""






						_UpperCAmelCase		:       Optional[Any]   						="transfo-xl"
						_UpperCAmelCase		:       str   						=["mems"]
						_UpperCAmelCase		:       Optional[int]   						={
						    "n_token": "vocab_size",
						    "hidden_size": "d_model",
						    "num_attention_heads": "n_head",
						    "num_hidden_layers": "n_layer",
						}






						def __init__(  self							:      str ,  lowerCAmelCase							:      Tuple=26_77_35 ,  lowerCAmelCase							:      List[Any]=[2_00_00, 4_00_00, 20_00_00] ,  lowerCAmelCase							:      Dict=10_24 ,  lowerCAmelCase							:      List[str]=10_24 ,  lowerCAmelCase							:      int=16 ,  lowerCAmelCase							:      Optional[Any]=64 ,  lowerCAmelCase							:      str=40_96 ,  lowerCAmelCase							:      Optional[int]=4 ,  lowerCAmelCase							:      Any=False ,  lowerCAmelCase							:      List[str]=18 ,  lowerCAmelCase							:      Any=16_00 ,  lowerCAmelCase							:      List[str]=10_00 ,  lowerCAmelCase							:      int=True ,  lowerCAmelCase							:      List[str]=True ,  lowerCAmelCase							:      List[str]=0 ,  lowerCAmelCase							:      Tuple=-1 ,  lowerCAmelCase							:      Optional[int]=True ,  lowerCAmelCase							:      List[str]=0.1 ,  lowerCAmelCase							:      int=0.0 ,  lowerCAmelCase							:      Tuple=True ,  lowerCAmelCase							:      List[str]="normal" ,  lowerCAmelCase							:      Tuple=0.0_1 ,  lowerCAmelCase							:      Optional[int]=0.0_1 ,  lowerCAmelCase							:      List[Any]=0.0_2 ,  lowerCAmelCase							:      Dict=1e-5 ,  lowerCAmelCase							:      Optional[int]=0 ,  **lowerCAmelCase							:      List[str] ,  ):
													A_			    =		vocab_size
													A_			    =		[]
													self.cutoffs.extend(lowerCAmelCase	)
													if proj_share_all_but_first:
																				A_			    =		[False] + [True] * len(self.cutoffs	)
													else:
																				A_			    =		[False] + [False] * len(self.cutoffs	)
													A_			    =		d_model
													A_			    =		d_embed
													A_			    =		d_head
													A_			    =		d_inner
													A_			    =		div_val
													A_			    =		pre_lnorm
													A_			    =		n_layer
													A_			    =		n_head
													A_			    =		mem_len
													A_			    =		same_length
													A_			    =		attn_type
													A_			    =		clamp_len
													A_			    =		sample_softmax
													A_			    =		adaptive
													A_			    =		dropout
													A_			    =		dropatt
													A_			    =		untie_r
													A_			    =		init
													A_			    =		init_range
													A_			    =		proj_init_std
													A_			    =		init_std
													A_			    =		layer_norm_epsilon
													super().__init__(eos_token_id=lowerCAmelCase ,  **lowerCAmelCase	)






						@property
						def 				_UpperCAmelCase       (  self							:      str	):
													# Message copied from Transformer-XL documentation
													logger.info(F"The model {self.model_type} is one of the few models that has no sequence length limit."	)
													return -1






						@max_position_embeddings.setter
						def 				_UpperCAmelCase       (  self							:      Tuple ,  lowerCAmelCase							:      Dict	):
													# Message copied from Transformer-XL documentation
													raise NotImplementedError(
													    F"The model {self.model_type} is one of the few models that has no sequence length limit."	)





