




import tempfile
import unittest

import numpy as np
import torch

from diffusers import DiffusionPipeline
from diffusers.models.attention_processor import Attention, AttnAddedKVProcessor

class 	__lowerCAmelCase			(			unittest.TestCase				):
							def    lowerCamelCase__							(		self		:str	,   __magic_name__		:Tuple = False       ):







								'''simple docstring'''







								a		       =							10

								if only_cross_attention:
									a		       =							12
								else:
									# when only cross attention is not set, the cross attention dim must be the same as the query dim
									a		       =							query_dim

								return {
								    "query_dim": query_dim,
								    "cross_attention_dim": cross_attention_dim,
								    "heads": 2,
								    "dim_head": 4,
								    "added_kv_proj_dim": 6,
								    "norm_num_groups": 1,
								    "only_cross_attention": only_cross_attention,
								    "processor": AttnAddedKVProcessor(),
								}
							def    lowerCamelCase__							(		self		:Any	,   __magic_name__		:Union[str, Any]	,   __magic_name__		:Tuple       ):







								'''simple docstring'''







								a		       =							2

								a		       =							torch.rand(__magic_name__	,   __magic_name__	,   3	,   2       )
								a		       =							torch.rand(__magic_name__	,   4	,   __magic_name__       )
								a		       =							None

								return {
								    "hidden_states": hidden_states,
								    "encoder_hidden_states": encoder_hidden_states,
								    "attention_mask": attention_mask,
								}





							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								torch.manual_seed(0       )

								a		       =							self.get_constructor_arguments(only_cross_attention=__magic_name__       )
								a		       =							Attention(**__magic_name__       )

								self.assertTrue(attn.to_k is not None       )
								self.assertTrue(attn.to_v is not None       )

								a		       =							self.get_forward_arguments(
								    query_dim=constructor_args["""query_dim"""]	,   added_kv_proj_dim=constructor_args["""added_kv_proj_dim"""]       )

								a		       =							attn(**__magic_name__       )

								# only self attention

								torch.manual_seed(0       )

								a		       =							self.get_constructor_arguments(only_cross_attention=__magic_name__       )
								a		       =							Attention(**__magic_name__       )

								self.assertTrue(attn.to_k is None       )
								self.assertTrue(attn.to_v is None       )

								a		       =							self.get_forward_arguments(
								    query_dim=constructor_args["""query_dim"""]	,   added_kv_proj_dim=constructor_args["""added_kv_proj_dim"""]       )

								a		       =							attn(**__magic_name__       )

								self.assertTrue((only_cross_attn_out != self_and_cross_attn_out).all()       )







class 	__lowerCAmelCase			(			unittest.TestCase				):
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								a		       =							DiffusionPipeline.from_pretrained("""hf-internal-testing/tiny-stable-diffusion-pipe"""	,   safety_checker=__magic_name__       )

								a		       =							pipe(
								    """foo"""	,   num_inference_steps=2	,   generator=torch.Generator("""cpu"""       ).manual_seed(0       )	,   output_type="""np"""	,   ).images

								# the initial conversion succeeds
								a		       =							DiffusionPipeline.from_pretrained(
								    """hf-internal-testing/tiny-stable-diffusion-pipe"""	,   device_map="""sequential"""	,   safety_checker=__magic_name__       )

								a		       =							pipe(
								    """foo"""	,   num_inference_steps=2	,   generator=torch.Generator("""cpu"""       ).manual_seed(0       )	,   output_type="""np"""	,   ).images

								with tempfile.TemporaryDirectory() as tmpdir:
									# save the converted model
									pipe.save_pretrained(__magic_name__       )

									# can also load the converted weights
									a		       =							DiffusionPipeline.from_pretrained(__magic_name__	,   device_map="""sequential"""	,   safety_checker=__magic_name__       )

								a		       =							pipe(
								    """foo"""	,   num_inference_steps=2	,   generator=torch.Generator("""cpu"""       ).manual_seed(0       )	,   output_type="""np"""	,   ).images

								self.assertTrue(np.allclose(__magic_name__	,   __magic_name__	,   atol=1E-5       )       )
								self.assertTrue(np.allclose(__magic_name__	,   __magic_name__	,   atol=1E-5       )       )







import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
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 PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class 	__lowerCAmelCase			(			__magic_name__   , __magic_name__   , unittest.TestCase				):
							UpperCamelCase__        =						StableDiffusionParadigmsPipeline
							UpperCamelCase__        =						TEXT_TO_IMAGE_PARAMS
							UpperCamelCase__        =						TEXT_TO_IMAGE_BATCH_PARAMS
							UpperCamelCase__        =						TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCamelCase__        =						TEXT_TO_IMAGE_IMAGE_PARAMS
							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								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	,   attention_head_dim=(2, 4)	,   use_linear_projection=__magic_name__	,   )
								a		       =							DDIMParallelScheduler(
								    beta_start=0.00085	,   beta_end=0.012	,   beta_schedule="""scaled_linear"""	,   clip_sample=__magic_name__	,   set_alpha_to_one=__magic_name__	,   )
								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	,   sample_size=128	,   )
								torch.manual_seed(0       )
								a		       =							CLIPTextConfig(
								    bos_token_id=0	,   eos_token_id=2	,   hidden_size=32	,   intermediate_size=37	,   layer_norm_eps=1E-0_5	,   num_attention_heads=4	,   num_hidden_layers=5	,   pad_token_id=1	,   vocab_size=1000	,   hidden_act="""gelu"""	,   projection_dim=512	,   )
								a		       =							CLIPTextModel(__magic_name__       )
								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    lowerCamelCase__							(		self		:Any	,   __magic_name__		:List[Any]	,   __magic_name__		:Tuple=0       ):







								'''simple docstring'''







								if str(__magic_name__       ).startswith("""mps"""       ):
									a		       =							torch.manual_seed(__magic_name__       )
								else:
									a		       =							torch.Generator(device=__magic_name__       ).manual_seed(__magic_name__       )
								a		       =							{
								    """prompt""": """a photograph of an astronaut riding a horse""",
								    """generator""": generator,
								    """num_inference_steps""": 10,
								    """guidance_scale""": 6.0,
								    """output_type""": """numpy""",
								    """parallel""": 3,
								    """debug""": True,
								}
								return inputs
							def    lowerCamelCase__							(		self		:Dict       ):







								'''simple docstring'''







								a		       =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								a		       =							StableDiffusionParadigmsPipeline(**__magic_name__       )
								a		       =							sd_pipe.to(__magic_name__       )
								sd_pipe.set_progress_bar_config(disable=__magic_name__       )

								a		       =							self.get_dummy_inputs(__magic_name__       )
								a		       =							sd_pipe(**__magic_name__       ).images
								a		       =							image[0, -3:, -3:, -1]
								assert image.shape == (1, 64, 64, 3)

								a		       =							np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]       )

								assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2
							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								a		       =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								torch.manual_seed(0       )
								a		       =							DDPMParallelScheduler()
								torch.manual_seed(0       )
								a		       =							StableDiffusionParadigmsPipeline(**__magic_name__       )
								a		       =							sd_pipe.to(__magic_name__       )
								sd_pipe.set_progress_bar_config(disable=__magic_name__       )

								a		       =							self.get_dummy_inputs(__magic_name__       )
								a		       =							sd_pipe(**__magic_name__       ).images
								a		       =							image[0, -3:, -3:, -1]
								assert image.shape == (1, 64, 64, 3)

								a		       =							np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]       )

								assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								super().test_inference_batch_consistent(batch_sizes=[1, 2]       )
							def    lowerCamelCase__							(		self		:str       ):







								'''simple docstring'''







								super().test_inference_batch_single_identical(batch_size=2	,   expected_max_diff=3E-3       )





							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								a		       =							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								a		       =							StableDiffusionParadigmsPipeline(**__magic_name__       )
								a		       =							sd_pipe.to(__magic_name__       )
								sd_pipe.set_progress_bar_config(disable=__magic_name__       )

								a		       =							self.get_dummy_inputs(__magic_name__       )
								a		       =							"""french fries"""
								a		       =							sd_pipe(**__magic_name__	,   negative_prompt=__magic_name__       )
								a		       =							output.images
								a		       =							image[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)

								a		       =							np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]       )

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







@slow
@require_torch_gpu
class 	__lowerCAmelCase			(			unittest.TestCase				):
							def    lowerCamelCase__							(		self		:Optional[int]       ):







								'''simple docstring'''







								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()
							def    lowerCamelCase__							(		self		:str	,   __magic_name__		:Union[str, Any]=0       ):







								'''simple docstring'''







								a		       =							torch.Generator(device=__magic_name__       ).manual_seed(__magic_name__       )
								a		       =							{
								    """prompt""": """a photograph of an astronaut riding a horse""",
								    """generator""": generator,
								    """num_inference_steps""": 10,
								    """guidance_scale""": 7.5,
								    """output_type""": """numpy""",
								    """parallel""": 3,
								    """debug""": True,
								}
								return inputs





							def    lowerCamelCase__							(		self		:Dict       ):







								'''simple docstring'''







								a		       =							"""stabilityai/stable-diffusion-2-base"""
								a		       =							DDIMParallelScheduler.from_pretrained(__magic_name__	,   subfolder="""scheduler"""       )
								a		       =							StableDiffusionParadigmsPipeline.from_pretrained(__magic_name__	,   scheduler=__magic_name__	,   safety_checker=__magic_name__       )
								pipe.to(__magic_name__       )
								pipe.set_progress_bar_config(disable=__magic_name__       )
								pipe.enable_attention_slicing()

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

								assert image.shape == (1, 512, 512, 3)

								a		       =							np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]       )

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

