




'''simple docstring'''




import tempfile
import unittest

import numpy as np
import torch

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






class     UpperCamelCase_     (unittest.TestCase    ):







						"""simple docstring"""


						def       _a    (     self      :       Any							, _lowerCamelCase      :       bool = False    ):





											"""simple docstring"""







											A_ :     Dict =							10

											if only_cross_attention:
																A_ :     Union[str, Any] =							12
											else:
																# when only cross attention is not set, the cross attention dim must be the same as the query dim
																A_ :     str =							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       _a    (     self      :       List[str]							, _lowerCamelCase      :       Tuple							, _lowerCamelCase      :       List[Any]    ):





											"""simple docstring"""







											A_ :     Dict =							2

											A_ :     Dict =							torch.rand(_lowerCamelCase							, _lowerCamelCase							, 3							, 2    )
											A_ :     int =							torch.rand(_lowerCamelCase							, 4							, _lowerCamelCase    )
											A_ :     Dict =							None

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







						def       _a    (     self      :       int    ):





											"""simple docstring"""







											torch.manual_seed(0    )

											A_ :     str =							self.get_constructor_arguments(only_cross_attention=_lowerCamelCase    )
											A_ :     Optional[Any] =							Attention(**_lowerCamelCase    )

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

											A_ :     int =							self.get_forward_arguments(
											    query_dim=constructor_args['''query_dim''']							, added_kv_proj_dim=constructor_args['''added_kv_proj_dim''']    )

											A_ :     Optional[Any] =							attn(**_lowerCamelCase    )

											# only self attention

											torch.manual_seed(0    )

											A_ :     List[str] =							self.get_constructor_arguments(only_cross_attention=_lowerCamelCase    )
											A_ :     Optional[Any] =							Attention(**_lowerCamelCase    )

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

											A_ :     Optional[int] =							self.get_forward_arguments(
											    query_dim=constructor_args['''query_dim''']							, added_kv_proj_dim=constructor_args['''added_kv_proj_dim''']    )

											A_ :     Dict =							attn(**_lowerCamelCase    )

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






class     UpperCamelCase_     (unittest.TestCase    ):







						"""simple docstring"""


						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     List[str] =							DiffusionPipeline.from_pretrained('''hf-internal-testing/tiny-stable-diffusion-pipe'''							, safety_checker=_lowerCamelCase    )

											A_ :     Optional[Any] =							pipe(
											    '''foo'''							, num_inference_steps=2							, generator=torch.Generator('''cpu'''    ).manual_seed(0    )							, output_type='''np'''							, ).images

											# the initial conversion succeeds
											A_ :     Dict =							DiffusionPipeline.from_pretrained(
											    '''hf-internal-testing/tiny-stable-diffusion-pipe'''							, device_map='''sequential'''							, safety_checker=_lowerCamelCase    )

											A_ :     List[Any] =							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(_lowerCamelCase    )

																# can also load the converted weights
																A_ :     Optional[int] =							DiffusionPipeline.from_pretrained(_lowerCamelCase							, device_map='''sequential'''							, safety_checker=_lowerCamelCase    )

											A_ :     Dict =							pipe(
											    '''foo'''							, num_inference_steps=2							, generator=torch.Generator('''cpu'''    ).manual_seed(0    )							, output_type='''np'''							, ).images

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









'''simple docstring'''




import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()






class     UpperCamelCase_     (unittest.TestCase     ):







						"""simple docstring"""


						@property
						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     Dict =							1
											A_ :     Any =							3
											A_ :     Any =							(32, 32)

											A_ :     Dict =							floats_tensor((batch_size, num_channels) + sizes							, rng=random.Random(0    )    ).to(_lowerCamelCase    )
											return image







						@property
						def       _a    (     self      :       Dict    ):





											"""simple docstring"""







											torch.manual_seed(0    )
											A_ :     Optional[int] =							UNetaDModel(
											    block_out_channels=(32, 64)							, layers_per_block=2							, sample_size=32							, in_channels=6							, out_channels=3							, down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')							, up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')							, )
											return model







						@property
						def       _a    (     self      :       Any    ):





											"""simple docstring"""







											torch.manual_seed(0    )
											A_ :     Dict =							VQModel(
											    block_out_channels=[32, 64]							, in_channels=3							, out_channels=3							, down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']							, up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']							, latent_channels=3							, )
											return model







						def       _a    (     self      :       List[Any]    ):





											"""simple docstring"""







											A_ :     Any =							'''cpu'''
											A_ :     Optional[Any] =							self.dummy_uncond_unet
											A_ :     str =							DDIMScheduler()
											A_ :     Optional[int] =							self.dummy_vq_model

											A_ :     Optional[Any] =							LDMSuperResolutionPipeline(unet=_lowerCamelCase							, vqvae=_lowerCamelCase							, scheduler=_lowerCamelCase    )
											ldm.to(_lowerCamelCase    )
											ldm.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     Any =							self.dummy_image.to(_lowerCamelCase    )

											A_ :     str =							torch.Generator(device=_lowerCamelCase    ).manual_seed(0    )
											A_ :     List[Any] =							ldm(image=_lowerCamelCase							, generator=_lowerCamelCase							, num_inference_steps=2							, output_type='''numpy'''    ).images

											A_ :     str =							image[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 3)
											A_ :     List[Any] =							np.array([0.86_78, 0.82_45, 0.63_81, 0.68_30, 0.43_85, 0.55_99, 0.46_41, 0.62_01, 0.51_50]    )

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







						@unittest.skipIf(torch_device != '''cuda'''							, '''This test requires a GPU'''    )
						def       _a    (     self      :       Optional[int]    ):





											"""simple docstring"""







											A_ :     Tuple =							self.dummy_uncond_unet
											A_ :     List[str] =							DDIMScheduler()
											A_ :     str =							self.dummy_vq_model

											# put models in fp16
											A_ :     List[Any] =							unet.half()
											A_ :     Optional[int] =							vqvae.half()

											A_ :     Optional[Any] =							LDMSuperResolutionPipeline(unet=_lowerCamelCase							, vqvae=_lowerCamelCase							, scheduler=_lowerCamelCase    )
											ldm.to(_lowerCamelCase    )
											ldm.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     Optional[Any] =							self.dummy_image.to(_lowerCamelCase    )

											A_ :     Optional[Any] =							ldm(_lowerCamelCase							, num_inference_steps=2							, output_type='''numpy'''    ).images

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






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







						"""simple docstring"""


						def       _a    (     self      :       int    ):





											"""simple docstring"""







											A_ :     Optional[int] =							load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/vq_diffusion/teddy_bear_pool.png'''    )
											A_ :     List[str] =							init_image.resize((64, 64)							, resample=PIL_INTERPOLATION['''lanczos''']    )

											A_ :     List[str] =							LDMSuperResolutionPipeline.from_pretrained('''duongna/ldm-super-resolution'''							, device_map='''auto'''    )
											ldm.set_progress_bar_config(disable=_lowerCamelCase    )

											A_ :     List[str] =							torch.manual_seed(0    )
											A_ :     str =							ldm(image=_lowerCamelCase							, generator=_lowerCamelCase							, num_inference_steps=20							, output_type='''numpy'''    ).images

											A_ :     str =							image[0, -3:, -3:, -1]

											assert image.shape == (1, 256, 256, 3)
											A_ :     Optional[Any] =							np.array([0.76_44, 0.76_79, 0.76_42, 0.76_33, 0.76_66, 0.75_60, 0.74_25, 0.72_57, 0.69_07]    )

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



