






from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__      :			int							=		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_				(      lowerCamelCase ):
				a__					       =  '''transfo-xl'''
				a__					       =  ['''mems''']
				a__					       =  {
				    '''n_token''': '''vocab_size''',
				    '''hidden_size''': '''d_model''',
				    '''num_attention_heads''': '''n_head''',
				    '''num_hidden_layers''': '''n_layer''',
				}







				def __init__(						self       ,					__lowerCAmelCase=2_6_7_7_3_5       ,					__lowerCAmelCase=[2_0_0_0_0, 4_0_0_0_0, 2_0_0_0_0_0]       ,					__lowerCAmelCase=1_0_2_4       ,					__lowerCAmelCase=1_0_2_4       ,					__lowerCAmelCase=1_6       ,					__lowerCAmelCase=6_4       ,					__lowerCAmelCase=4_0_9_6       ,					__lowerCAmelCase=4       ,					__lowerCAmelCase=False       ,					__lowerCAmelCase=1_8       ,					__lowerCAmelCase=1_6_0_0       ,					__lowerCAmelCase=1_0_0_0       ,					__lowerCAmelCase=True       ,					__lowerCAmelCase=True       ,					__lowerCAmelCase=0       ,					__lowerCAmelCase=-1       ,					__lowerCAmelCase=True       ,					__lowerCAmelCase=0.1       ,					__lowerCAmelCase=0.0       ,					__lowerCAmelCase=True       ,					__lowerCAmelCase="normal"       ,					__lowerCAmelCase=0.01       ,					__lowerCAmelCase=0.01       ,					__lowerCAmelCase=0.02       ,					__lowerCAmelCase=1E-5       ,					__lowerCAmelCase=0       ,					**__lowerCAmelCase       ,					):
								"""simple docstring"""
								__magic_name__		:int        =      vocab_size
								__magic_name__		:Optional[int]        =      []
								self.cutoffs.extend(__lowerCAmelCase     )
								if proj_share_all_but_first:
												__magic_name__		:Any        =      [False] + [True] * len(self.cutoffs     )
								else:
												__magic_name__		:Union[str, Any]        =      [False] + [False] * len(self.cutoffs     )
								__magic_name__		:Any        =      d_model
								__magic_name__		:int        =      d_embed
								__magic_name__		:int        =      d_head
								__magic_name__		:str        =      d_inner
								__magic_name__		:str        =      div_val
								__magic_name__		:Optional[int]        =      pre_lnorm
								__magic_name__		:List[str]        =      n_layer
								__magic_name__		:Optional[int]        =      n_head
								__magic_name__		:Optional[Any]        =      mem_len
								__magic_name__		:Union[str, Any]        =      same_length
								__magic_name__		:Tuple        =      attn_type
								__magic_name__		:Union[str, Any]        =      clamp_len
								__magic_name__		:int        =      sample_softmax
								__magic_name__		:Union[str, Any]        =      adaptive
								__magic_name__		:List[str]        =      dropout
								__magic_name__		:str        =      dropatt
								__magic_name__		:Any        =      untie_r
								__magic_name__		:Tuple        =      init
								__magic_name__		:Optional[Any]        =      init_range
								__magic_name__		:Tuple        =      proj_init_std
								__magic_name__		:Optional[int]        =      init_std
								__magic_name__		:List[str]        =      layer_norm_epsilon
								super().__init__(eos_token_id=__lowerCAmelCase       ,					**__lowerCAmelCase     )







				@property
				def 			A	(						self     ):
								"""simple docstring"""
								# 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 			A	(						self       ,					__lowerCAmelCase     ):
								"""simple docstring"""
								# 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.'''     )














import unittest

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

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()
class 						lowerCamelCase_				(      unittest.TestCase ):







				@property
				def 			A	(						self     ):
								"""simple docstring"""
								torch.manual_seed(0     )
								__magic_name__		:Dict        =      UNetaDModel(
								    block_out_channels=(3_2, 6_4)       ,					layers_per_block=2       ,					sample_size=3_2       ,					in_channels=3       ,					out_channels=3       ,					down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')       ,					up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')       ,					)
								return model







				@property
				def 			A	(						self     ):
								"""simple docstring"""
								torch.manual_seed(0     )
								__magic_name__		:List[str]        =      VQModel(
								    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=3       ,					)
								return model







				@property
				def 			A	(						self     ):
								"""simple docstring"""
								torch.manual_seed(0     )
								__magic_name__		:int        =      CLIPTextConfig(
								    bos_token_id=0       ,					eos_token_id=2       ,					hidden_size=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=1_0_0_0       ,					)
								return CLIPTextModel(__lowerCAmelCase     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]        =      self.dummy_uncond_unet
								__magic_name__		:Optional[int]        =      DDIMScheduler()
								__magic_name__		:List[str]        =      self.dummy_vq_model

								__magic_name__		:Tuple        =      LDMPipeline(unet=__lowerCAmelCase       ,					vqvae=__lowerCAmelCase       ,					scheduler=__lowerCAmelCase     )
								ldm.to(__lowerCAmelCase     )
								ldm.set_progress_bar_config(disable=__lowerCAmelCase     )

								__magic_name__		:List[Any]        =      torch.manual_seed(0     )
								__magic_name__		:List[str]        =      ldm(generator=__lowerCAmelCase       ,					num_inference_steps=2       ,					output_type='''numpy'''     ).images

								__magic_name__		:List[Any]        =      torch.manual_seed(0     )
								__magic_name__		:Any        =      ldm(generator=__lowerCAmelCase       ,					num_inference_steps=2       ,					output_type='''numpy'''       ,					return_dict=__lowerCAmelCase     )[0]

								__magic_name__		:Any        =      image[0, -3:, -3:, -1]
								__magic_name__		:Dict        =      image_from_tuple[0, -3:, -3:, -1]

								assert image.shape == (1, 6_4, 6_4, 3)
								__magic_name__		:Union[str, Any]        =      np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172]     )
								__magic_name__		:Any        =      1E-2 if torch_device != '''mps''' else 3E-2

								assert np.abs(image_slice.flatten() - expected_slice     ).max() < tolerance
								assert np.abs(image_from_tuple_slice.flatten() - expected_slice     ).max() < tolerance







@slow
@require_torch
class 						lowerCamelCase_				(      unittest.TestCase ):







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Tuple        =      LDMPipeline.from_pretrained('''CompVis/ldm-celebahq-256'''     )
								ldm.to(__lowerCAmelCase     )
								ldm.set_progress_bar_config(disable=__lowerCAmelCase     )

								__magic_name__		:Optional[Any]        =      torch.manual_seed(0     )
								__magic_name__		:Optional[int]        =      ldm(generator=__lowerCAmelCase       ,					num_inference_steps=5       ,					output_type='''numpy'''     ).images

								__magic_name__		:Optional[Any]        =      image[0, -3:, -3:, -1]

								assert image.shape == (1, 2_5_6, 2_5_6, 3)
								__magic_name__		:List[str]        =      np.array([0.4399, 0.44975, 0.46825, 0.474, 0.4359, 0.4581, 0.45095, 0.4341, 0.4447]     )
								__magic_name__		:Tuple        =      1E-2 if torch_device != '''mps''' else 3E-2

								assert np.abs(image_slice.flatten() - expected_slice     ).max() < tolerance






