





"""simple docstring"""
import gc
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_numpy,
    nightly,
    require_torch_gpu,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()






class 					_UpperCAmelCase   (	a__     ,							unittest.TestCase ):
					UpperCamelCase      =							LDMTextToImagePipeline
					UpperCamelCase      =							TEXT_TO_IMAGE_PARAMS - {
					    '''negative_prompt''',
					    '''negative_prompt_embeds''',
					    '''cross_attention_kwargs''',
					    '''prompt_embeds''',
					}
					UpperCamelCase      =							PipelineTesterMixin.required_optional_params - {
					    '''num_images_per_prompt''',
					    '''callback''',
					    '''callback_steps''',
					}
					UpperCamelCase      =							TEXT_TO_IMAGE_BATCH_PARAMS
					UpperCamelCase      =							False


					def 	lowerCamelCase       (					self			:int		):
												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.00_085     ,       beta_end=0.012     ,       beta_schedule="scaled_linear"     ,       clip_sample=SCREAMING_SNAKE_CASE__     ,       set_alpha_to_one=SCREAMING_SNAKE_CASE__     ,       )
												torch.manual_seed(0		)
												A		=  AutoencoderKL(
												    block_out_channels=(32, 64)     ,       in_channels=3     ,       out_channels=3     ,       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=10_00     ,       )
												A		=  CLIPTextModel(SCREAMING_SNAKE_CASE__		)
												A		=  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

												A		=  {
												    """unet""": unet,
												    """scheduler""": scheduler,
												    """vqvae""": vae,
												    """bert""": text_encoder,
												    """tokenizer""": tokenizer,
												}
												return components


					def 	lowerCamelCase       (					self			:List[str]     ,       __UpperCamelCase			:Optional[Any]     ,       __UpperCamelCase			:Optional[Any]=0		):




												if str(SCREAMING_SNAKE_CASE__		).startswith("mps"		):
																			A		=  torch.manual_seed(SCREAMING_SNAKE_CASE__		)
												else:
																			A		=  torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(SCREAMING_SNAKE_CASE__		)
												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 	lowerCamelCase       (					self			:Any		):
												A		=  """cpu"""  # ensure determinism for the device-dependent torch.Generator

												A		=  self.get_dummy_components()
												A		=  LDMTextToImagePipeline(**SCREAMING_SNAKE_CASE__		)
												pipe.to(SCREAMING_SNAKE_CASE__		)
												pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

												A		=  self.get_dummy_inputs(SCREAMING_SNAKE_CASE__		)
												A		=  pipe(**SCREAMING_SNAKE_CASE__		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 16, 16, 3)
												A		=  np.array([0.6_101, 0.6_156, 0.5_622, 0.4_895, 0.6_661, 0.3_804, 0.5_748, 0.6_136, 0.5_014]		)

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







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


					def 	lowerCamelCase       (					self			:Any		):
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()


					def 	lowerCamelCase       (					self			:Tuple     ,       __UpperCamelCase			:Dict     ,       __UpperCamelCase			:Union[str, Any]=torch.floataa     ,       __UpperCamelCase			:Optional[Any]=0		):
												A		=  torch.manual_seed(SCREAMING_SNAKE_CASE__		)
												A		=  np.random.RandomState(SCREAMING_SNAKE_CASE__		).standard_normal((1, 4, 32, 32)		)
												A		=  torch.from_numpy(SCREAMING_SNAKE_CASE__		).to(device=SCREAMING_SNAKE_CASE__     ,       dtype=SCREAMING_SNAKE_CASE__		)
												A		=  {
												    """prompt""": """A painting of a squirrel eating a burger""",
												    """latents""": latents,
												    """generator""": generator,
												    """num_inference_steps""": 3,
												    """guidance_scale""": 6.0,
												    """output_type""": """numpy""",
												}
												return inputs


					def 	lowerCamelCase       (					self			:Optional[Any]		):
												A		=  LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256"		).to(SCREAMING_SNAKE_CASE__		)
												pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

												A		=  self.get_inputs(SCREAMING_SNAKE_CASE__		)
												A		=  pipe(**SCREAMING_SNAKE_CASE__		).images
												A		=  image[0, -3:, -3:, -1].flatten()

												assert image.shape == (1, 2_56, 2_56, 3)
												A		=  np.array([0.51_825, 0.52_850, 0.52_543, 0.54_258, 0.52_304, 0.52_569, 0.54_363, 0.55_276, 0.56_878]		)
												A		=  np.abs(expected_slice - image_slice		).max()
												assert max_diff < 1e-3







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


					def 	lowerCamelCase       (					self			:Optional[int]		):
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()


					def 	lowerCamelCase       (					self			:str     ,       __UpperCamelCase			:str     ,       __UpperCamelCase			:Tuple=torch.floataa     ,       __UpperCamelCase			:int=0		):
												A		=  torch.manual_seed(SCREAMING_SNAKE_CASE__		)
												A		=  np.random.RandomState(SCREAMING_SNAKE_CASE__		).standard_normal((1, 4, 32, 32)		)
												A		=  torch.from_numpy(SCREAMING_SNAKE_CASE__		).to(device=SCREAMING_SNAKE_CASE__     ,       dtype=SCREAMING_SNAKE_CASE__		)
												A		=  {
												    """prompt""": """A painting of a squirrel eating a burger""",
												    """latents""": latents,
												    """generator""": generator,
												    """num_inference_steps""": 50,
												    """guidance_scale""": 6.0,
												    """output_type""": """numpy""",
												}
												return inputs


					def 	lowerCamelCase       (					self			:Any		):
												A		=  LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256"		).to(SCREAMING_SNAKE_CASE__		)
												pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

												A		=  self.get_inputs(SCREAMING_SNAKE_CASE__		)
												A		=  pipe(**SCREAMING_SNAKE_CASE__		).images[0]

												A		=  load_numpy(
												    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy"		)
												A		=  np.abs(expected_image - image		).max()
												assert max_diff < 1e-3




"""simple docstring"""




UpperCAmelCase__      :    Any    							= '\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n'

UpperCAmelCase__      :    Any    							= [{'type': 'code', 'content': INSTALL_CONTENT}]
UpperCAmelCase__      :    Optional[int]    							= {
    '{processor_class}': 'FakeProcessorClass',
    '{model_class}': 'FakeModelClass',
    '{object_class}': 'FakeObjectClass',
}




