


'''simple docstring'''
import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()






class 					__lowerCAmelCase   (   lowercase				,			lowercase				,			lowercase				,			unittest.TestCase						):

						"""simple docstring"""






						_UpperCAmelCase		:       str   						=StableUnCLIPImgaImgPipeline
						_UpperCAmelCase		:       Union[str, Any]   						=TEXT_GUIDED_IMAGE_VARIATION_PARAMS
						_UpperCAmelCase		:       str   						=TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
						_UpperCAmelCase		:       List[str]   						=frozenset(
						    []						)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
						_UpperCAmelCase		:       int   						=frozenset([]						)






						def 				_UpperCAmelCase       (  self							:      int	):
													A_			    =		32
													A_			    =		embedder_hidden_size

													# image encoding components

													A_			    =		CLIPImageProcessor(crop_size=32 ,  size=32	)

													torch.manual_seed(0	)
													A_			    =		CLIPVisionModelWithProjection(
													    CLIPVisionConfig(
													        hidden_size=lowerCAmelCase ,  projection_dim=lowerCAmelCase ,  num_hidden_layers=5 ,  num_attention_heads=4 ,  image_size=32 ,  intermediate_size=37 ,  patch_size=1 ,  )	)

													# regular denoising components

													torch.manual_seed(0	)
													A_			    =		StableUnCLIPImageNormalizer(embedding_dim=lowerCAmelCase	)
													A_			    =		DDPMScheduler(beta_schedule="squaredcos_cap_v2"	)

													torch.manual_seed(0	)
													A_			    =		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

													torch.manual_seed(0	)
													A_			    =		CLIPTextModel(
													    CLIPTextConfig(
													        bos_token_id=0 ,  eos_token_id=2 ,  hidden_size=lowerCAmelCase ,  projection_dim=32 ,  intermediate_size=37 ,  layer_norm_eps=1e-05 ,  num_attention_heads=4 ,  num_hidden_layers=5 ,  pad_token_id=1 ,  vocab_size=10_00 ,  )	)

													torch.manual_seed(0	)
													A_			    =		UNetaDConditionModel(
													    sample_size=32 ,  in_channels=4 ,  out_channels=4 ,  down_block_types=("CrossAttnDownBlock2D", "DownBlock2D") ,  up_block_types=("UpBlock2D", "CrossAttnUpBlock2D") ,  block_out_channels=(32, 64) ,  attention_head_dim=(2, 4) ,  class_embed_type="projection" ,  projection_class_embeddings_input_dim=embedder_projection_dim * 2 ,  cross_attention_dim=lowerCAmelCase ,  layers_per_block=1 ,  upcast_attention=lowerCAmelCase ,  use_linear_projection=lowerCAmelCase ,  )

													torch.manual_seed(0	)
													A_			    =		DDIMScheduler(
													    beta_schedule="scaled_linear" ,  beta_start=0.0_0_0_8_5 ,  beta_end=0.0_1_2 ,  prediction_type="v_prediction" ,  set_alpha_to_one=lowerCAmelCase ,  steps_offset=1 ,  )

													torch.manual_seed(0	)
													A_			    =		AutoencoderKL()

													A_			    =		{
													    # image encoding components
													    "feature_extractor": feature_extractor,
													    "image_encoder": image_encoder.eval(),
													    # image noising components
													    "image_normalizer": image_normalizer.eval(),
													    "image_noising_scheduler": image_noising_scheduler,
													    # regular denoising components
													    "tokenizer": tokenizer,
													    "text_encoder": text_encoder.eval(),
													    "unet": unet.eval(),
													    "scheduler": scheduler,
													    "vae": vae.eval(),
													}

													return components






						def 				_UpperCAmelCase       (  self							:      Optional[Any] ,  lowerCAmelCase							:      str ,  lowerCAmelCase							:      List[Any]=0 ,  lowerCAmelCase							:      int=True	):
													if str(lowerCAmelCase	).startswith("mps"	):
																				A_			    =		torch.manual_seed(lowerCAmelCase	)
													else:
																				A_			    =		torch.Generator(device=lowerCAmelCase	).manual_seed(lowerCAmelCase	)

													A_			    =		floats_tensor((1, 3, 32, 32) ,  rng=random.Random(lowerCAmelCase	)	).to(lowerCAmelCase	)

													if pil_image:
																				A_			    =		input_image * 0.5 + 0.5
																				A_			    =		input_image.clamp(0 ,  1	)
																				A_			    =		input_image.cpu().permute(0 ,  2 ,  3 ,  1	).float().numpy()
																				A_			    =		DiffusionPipeline.numpy_to_pil(lowerCAmelCase	)[0]

													return {
													    "prompt": "An anime racoon running a marathon",
													    "image": input_image,
													    "generator": generator,
													    "num_inference_steps": 2,
													    "output_type": "np",
													}






						@skip_mps
						def 				_UpperCAmelCase       (  self							:      int	):
													A_			    =		"cpu"  # ensure determinism for the device-dependent torch.Generator
													A_			    =		self.get_dummy_components()
													A_			    =		StableUnCLIPImgaImgPipeline(**lowerCAmelCase	)
													A_			    =		sd_pipe.to(lowerCAmelCase	)
													sd_pipe.set_progress_bar_config(disable=lowerCAmelCase	)

													A_			    =		self.get_dummy_inputs(lowerCAmelCase	)
													inputs.update({"image_embeds": None}	)
													A_			    =		sd_pipe(**lowerCAmelCase	).images
													A_			    =		image[0, -3:, -3:, -1]

													assert image.shape == (1, 32, 32, 3)
													A_			    =		np.array([0.3_8_7_2, 0.7_2_2_4, 0.5_6_0_1, 0.4_7_4_1, 0.6_8_7_2, 0.5_8_1_4, 0.4_6_3_6, 0.3_8_6_7, 0.5_0_7_8]	)

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






						def 				_UpperCAmelCase       (  self							:      Optional[Any]	):
													A_			    =		torch_device in ["cpu", "mps"]

													self._test_attention_slicing_forward_pass(test_max_difference=lowerCAmelCase	)






						def 				_UpperCAmelCase       (  self							:      List[Any]	):
													A_			    =		torch_device in ["cpu", "mps"]

													self._test_inference_batch_single_identical(test_max_difference=lowerCAmelCase	)






						@unittest.skipIf(
						    torch_device != "cuda" or not is_xformers_available() ,  reason="XFormers attention is only available with CUDA and `xformers` installed" ,  )
						def 				_UpperCAmelCase       (  self							:      Tuple	):
													self._test_xformers_attention_forwardGenerator_pass(test_max_difference=lowerCAmelCase	)






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

						"""simple docstring"""






						def 				_UpperCAmelCase       (  self							:      Union[str, Any]	):
													# clean up the VRAM after each test
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()






						def 				_UpperCAmelCase       (  self							:      Tuple	):
													A_			    =		load_image(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"	)

													A_			    =		load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy"	)

													A_			    =		StableUnCLIPImgaImgPipeline.from_pretrained(
													    "fusing/stable-unclip-2-1-l-img2img" ,  torch_dtype=torch.floataa	)
													pipe.to(lowerCAmelCase	)
													pipe.set_progress_bar_config(disable=lowerCAmelCase	)
													# stable unclip will oom when integration tests are run on a V100,
													# so turn on memory savings
													pipe.enable_attention_slicing()
													pipe.enable_sequential_cpu_offload()

													A_			    =		torch.Generator(device="cpu"	).manual_seed(0	)
													A_			    =		pipe(lowerCAmelCase ,  "anime turle" ,  generator=lowerCAmelCase ,  output_type="np"	)

													A_			    =		output.images[0]

													assert image.shape == (7_68, 7_68, 3)

													assert_mean_pixel_difference(lowerCAmelCase ,  lowerCAmelCase	)






						def 				_UpperCAmelCase       (  self							:      int	):
													A_			    =		load_image(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"	)

													A_			    =		load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy"	)

													A_			    =		StableUnCLIPImgaImgPipeline.from_pretrained(
													    "fusing/stable-unclip-2-1-h-img2img" ,  torch_dtype=torch.floataa	)
													pipe.to(lowerCAmelCase	)
													pipe.set_progress_bar_config(disable=lowerCAmelCase	)
													# stable unclip will oom when integration tests are run on a V100,
													# so turn on memory savings
													pipe.enable_attention_slicing()
													pipe.enable_sequential_cpu_offload()

													A_			    =		torch.Generator(device="cpu"	).manual_seed(0	)
													A_			    =		pipe(lowerCAmelCase ,  "anime turle" ,  generator=lowerCAmelCase ,  output_type="np"	)

													A_			    =		output.images[0]

													assert image.shape == (7_68, 7_68, 3)

													assert_mean_pixel_difference(lowerCAmelCase ,  lowerCAmelCase	)






						def 				_UpperCAmelCase       (  self							:      List[str]	):
													A_			    =		load_image(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"	)

													torch.cuda.empty_cache()
													torch.cuda.reset_max_memory_allocated()
													torch.cuda.reset_peak_memory_stats()

													A_			    =		StableUnCLIPImgaImgPipeline.from_pretrained(
													    "fusing/stable-unclip-2-1-h-img2img" ,  torch_dtype=torch.floataa	)
													A_			    =		pipe.to(lowerCAmelCase	)
													pipe.set_progress_bar_config(disable=lowerCAmelCase	)
													pipe.enable_attention_slicing()
													pipe.enable_sequential_cpu_offload()

													A_			    =		pipe(
													    lowerCAmelCase ,  "anime turtle" ,  num_inference_steps=2 ,  output_type="np" ,  )

													A_			    =		torch.cuda.max_memory_allocated()
													# make sure that less than 7 GB is allocated
													assert mem_bytes < 7 * 10**9









'''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."	)





