


"""simple docstring"""







import gc
import random
import unittest

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

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class       SCREAMING_SNAKE_CASE__				(		lowercase   ,    unittest.TestCase				):
       """simple docstring"""


       a  :				Optional[int]   =UnCLIPImageVariationPipeline
       a  :				Optional[int]   =IMAGE_VARIATION_PARAMS - {"height", "width", "guidance_scale"}
       a  :				Optional[Any]   =IMAGE_VARIATION_BATCH_PARAMS

       a  :				Optional[Any]   =[
           "generator",
           "return_dict",
           "decoder_num_inference_steps",
           "super_res_num_inference_steps",
       ]
       a  :				int   =False

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         return 32

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         return 32

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         return self.time_input_dim

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         return self.time_input_dim * 4

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         return 100

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Optional[Any]								=							CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)
         return tokenizer

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         torch.manual_seed(0						)
         lowerCAmelCase     :     Union[str, Any]								=							CLIPTextConfig(
             bos_token_id=0		,     eos_token_id=2		,     hidden_size=self.text_embedder_hidden_size		,     projection_dim=self.text_embedder_hidden_size		,     intermediate_size=37		,     layer_norm_eps=1e-05		,     num_attention_heads=4		,     num_hidden_layers=5		,     pad_token_id=1		,     vocab_size=1_000		,     )
         return CLIPTextModelWithProjection(snake_case__						)

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         torch.manual_seed(0						)
         lowerCAmelCase     :     Tuple								=							CLIPVisionConfig(
             hidden_size=self.text_embedder_hidden_size		,     projection_dim=self.text_embedder_hidden_size		,     num_hidden_layers=5		,     num_attention_heads=4		,     image_size=32		,     intermediate_size=37		,     patch_size=1		,     )
         return CLIPVisionModelWithProjection(snake_case__						)

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         torch.manual_seed(0						)

         lowerCAmelCase     :     Optional[int]								=							{
             "clip_embeddings_dim": self.text_embedder_hidden_size,
             "time_embed_dim": self.time_embed_dim,
             "cross_attention_dim": self.cross_attention_dim,
         }

         lowerCAmelCase     :     List[str]								=							UnCLIPTextProjModel(**snake_case__						)
         return model

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         torch.manual_seed(0						)

         lowerCAmelCase     :     Tuple								=							{
             "sample_size": 32,
             # RGB in channels
             "in_channels": 3,
             # Out channels is double in channels because predicts mean and variance
             "out_channels": 6,
             "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
             "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
             "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
             "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
             "layers_per_block": 1,
             "cross_attention_dim": self.cross_attention_dim,
             "attention_head_dim": 4,
             "resnet_time_scale_shift": "scale_shift",
             "class_embed_type": "identity",
         }

         lowerCAmelCase     :     Optional[Any]								=							UNetaDConditionModel(**snake_case__						)
         return model

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         return {
             "sample_size": 64,
             "layers_per_block": 1,
             "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
             "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
             "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
             "in_channels": 6,
             "out_channels": 3,
         }

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         torch.manual_seed(0						)

         lowerCAmelCase     :     Tuple								=							UNetaDModel(**self.dummy_super_res_kwargs						)
         return model

       @property
       def        lowercase__							(						self						):






         """simple docstring"""





         torch.manual_seed(1						)

         lowerCAmelCase     :     Any								=							UNetaDModel(**self.dummy_super_res_kwargs						)
         return model

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     str								=							self.dummy_decoder
         lowerCAmelCase     :     Optional[Any]								=							self.dummy_text_proj
         lowerCAmelCase     :     Dict								=							self.dummy_text_encoder
         lowerCAmelCase     :     Tuple								=							self.dummy_tokenizer
         lowerCAmelCase     :     List[str]								=							self.dummy_super_res_first
         lowerCAmelCase     :     List[Any]								=							self.dummy_super_res_last

         lowerCAmelCase     :     Tuple								=							UnCLIPScheduler(
             variance_type="learned_range"		,     prediction_type="epsilon"		,     num_train_timesteps=1_000		,     )

         lowerCAmelCase     :     Union[str, Any]								=							UnCLIPScheduler(
             variance_type="fixed_small_log"		,     prediction_type="epsilon"		,     num_train_timesteps=1_000		,     )

         lowerCAmelCase     :     int								=							CLIPImageProcessor(crop_size=32		,     size=32						)

         lowerCAmelCase     :     Any								=							self.dummy_image_encoder

         return {
             "decoder": decoder,
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "text_proj": text_proj,
             "feature_extractor": feature_extractor,
             "image_encoder": image_encoder,
             "super_res_first": super_res_first,
             "super_res_last": super_res_last,
             "decoder_scheduler": decoder_scheduler,
             "super_res_scheduler": super_res_scheduler,
         }

       def        lowercase__							(						self		,     snake_case__		,     snake_case__=0		,     snake_case__=True						):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							floats_tensor((1, 3, 32, 32)		,     rng=random.Random(snake_case__						)						).to(snake_case__						)
         if str(snake_case__						).startswith("mps"						):
           lowerCAmelCase     :     Optional[Any]								=							torch.manual_seed(snake_case__						)
         else:
           lowerCAmelCase     :     Dict								=							torch.Generator(device=snake_case__						).manual_seed(snake_case__						)

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

         return {
             "image": input_image,
             "generator": generator,
             "decoder_num_inference_steps": 2,
             "super_res_num_inference_steps": 2,
             "output_type": "np",
         }

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[str]								=							"cpu"

         lowerCAmelCase     :     List[Any]								=							self.get_dummy_components()

         lowerCAmelCase     :     Dict								=							self.pipeline_class(**snake_case__						)
         lowerCAmelCase     :     Any								=							pipe.to(snake_case__						)

         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase     :     List[Any]								=							self.get_dummy_inputs(snake_case__		,     pil_image=snake_case__						)

         lowerCAmelCase     :     List[Any]								=							pipe(**snake_case__						)
         lowerCAmelCase     :     Optional[Any]								=							output.images

         lowerCAmelCase     :     Tuple								=							self.get_dummy_inputs(snake_case__		,     pil_image=snake_case__						)

         lowerCAmelCase     :     List[str]								=							pipe(
             **snake_case__		,     return_dict=snake_case__		,     )[0]

         lowerCAmelCase     :     List[Any]								=							image[0, -3:, -3:, -1]
         lowerCAmelCase     :     List[Any]								=							image_from_tuple[0, -3:, -3:, -1]

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

         lowerCAmelCase     :     Union[str, Any]								=							np.array(
             [
                 0.9997,
                 0.0002,
                 0.9997,
                 0.9997,
                 0.9969,
                 0.0023,
                 0.9997,
                 0.9969,
                 0.9970,
             ]						)

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

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Any								=							"cpu"

         lowerCAmelCase     :     Tuple								=							self.get_dummy_components()

         lowerCAmelCase     :     List[str]								=							self.pipeline_class(**snake_case__						)
         lowerCAmelCase     :     Union[str, Any]								=							pipe.to(snake_case__						)

         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase     :     Dict								=							self.get_dummy_inputs(snake_case__		,     pil_image=snake_case__						)

         lowerCAmelCase     :     Dict								=							pipe(**snake_case__						)
         lowerCAmelCase     :     Dict								=							output.images

         lowerCAmelCase     :     Optional[int]								=							self.get_dummy_inputs(snake_case__		,     pil_image=snake_case__						)

         lowerCAmelCase     :     List[Any]								=							pipe(
             **snake_case__		,     return_dict=snake_case__		,     )[0]

         lowerCAmelCase     :     int								=							image[0, -3:, -3:, -1]
         lowerCAmelCase     :     int								=							image_from_tuple[0, -3:, -3:, -1]

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

         lowerCAmelCase     :     Union[str, Any]								=							np.array([0.9997, 0.0003, 0.9997, 0.9997, 0.9970, 0.0024, 0.9997, 0.9971, 0.9971]						)

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

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Dict								=							"cpu"

         lowerCAmelCase     :     Optional[int]								=							self.get_dummy_components()

         lowerCAmelCase     :     Dict								=							self.pipeline_class(**snake_case__						)
         lowerCAmelCase     :     Any								=							pipe.to(snake_case__						)

         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase     :     Any								=							self.get_dummy_inputs(snake_case__		,     pil_image=snake_case__						)
         lowerCAmelCase     :     Union[str, Any]								=							[
             pipeline_inputs["image"],
             pipeline_inputs["image"],
         ]

         lowerCAmelCase     :     List[Any]								=							pipe(**snake_case__						)
         lowerCAmelCase     :     List[str]								=							output.images

         lowerCAmelCase     :     int								=							self.get_dummy_inputs(snake_case__		,     pil_image=snake_case__						)
         lowerCAmelCase     :     List[Any]								=							[
             tuple_pipeline_inputs["image"],
             tuple_pipeline_inputs["image"],
         ]

         lowerCAmelCase     :     Optional[Any]								=							pipe(
             **snake_case__		,     return_dict=snake_case__		,     )[0]

         lowerCAmelCase     :     str								=							image[0, -3:, -3:, -1]
         lowerCAmelCase     :     Optional[Any]								=							image_from_tuple[0, -3:, -3:, -1]

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

         lowerCAmelCase     :     int								=							np.array(
             [
                 0.9997,
                 0.9989,
                 0.0008,
                 0.0021,
                 0.9960,
                 0.0018,
                 0.0014,
                 0.0002,
                 0.9933,
             ]						)

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

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     str								=							torch.device("cpu"						)


         class       SCREAMING_SNAKE_CASE__				:
                """simple docstring"""


                a  :				Any   =1

         lowerCAmelCase     :     Optional[int]								=							self.get_dummy_components()

         lowerCAmelCase     :     Union[str, Any]								=							self.pipeline_class(**snake_case__						)
         lowerCAmelCase     :     Tuple								=							pipe.to(snake_case__						)

         pipe.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase     :     Union[str, Any]								=							torch.Generator(device=snake_case__						).manual_seed(0						)
         lowerCAmelCase     :     Union[str, Any]								=							pipe.decoder.dtype
         lowerCAmelCase     :     List[str]								=							1

         lowerCAmelCase     :     Any								=							(
             batch_size,
             pipe.decoder.config.in_channels,
             pipe.decoder.config.sample_size,
             pipe.decoder.config.sample_size,
         )
         lowerCAmelCase     :     Optional[int]								=							pipe.prepare_latents(
             snake_case__		,     dtype=snake_case__		,     device=snake_case__		,     generator=snake_case__		,     latents=snake_case__		,     scheduler=DummyScheduler()						)

         lowerCAmelCase     :     List[Any]								=							(
             batch_size,
             pipe.super_res_first.config.in_channels // 2,
             pipe.super_res_first.config.sample_size,
             pipe.super_res_first.config.sample_size,
         )
         lowerCAmelCase     :     str								=							pipe.prepare_latents(
             snake_case__		,     dtype=snake_case__		,     device=snake_case__		,     generator=snake_case__		,     latents=snake_case__		,     scheduler=DummyScheduler()						)

         lowerCAmelCase     :     Union[str, Any]								=							self.get_dummy_inputs(snake_case__		,     pil_image=snake_case__						)

         lowerCAmelCase     :     List[str]								=							pipe(
             **snake_case__		,     decoder_latents=snake_case__		,     super_res_latents=snake_case__						).images

         lowerCAmelCase     :     Any								=							self.get_dummy_inputs(snake_case__		,     pil_image=snake_case__						)
         # Don't pass image, instead pass embedding
         lowerCAmelCase     :     Dict								=							pipeline_inputs.pop("image"						)
         lowerCAmelCase     :     List[str]								=							pipe.image_encoder(snake_case__						).image_embeds

         lowerCAmelCase     :     Optional[Any]								=							pipe(
             **snake_case__		,     decoder_latents=snake_case__		,     super_res_latents=snake_case__		,     image_embeddings=snake_case__		,     ).images

         # make sure passing text embeddings manually is identical
         assert np.abs(img_out_a - img_out_a						).max() < 1e-4

       @skip_mps
       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Optional[int]								=							torch_device == "cpu"

         # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
         lowerCAmelCase     :     List[str]								=							1e-2

         self._test_attention_slicing_forward_pass(
             test_max_difference=snake_case__		,     expected_max_diff=snake_case__						)

       @skip_mps
       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Tuple								=							torch_device == "cpu"
         lowerCAmelCase     :     Any								=							True
         lowerCAmelCase     :     List[Any]								=							[
             "decoder_num_inference_steps",
             "super_res_num_inference_steps",
         ]

         self._test_inference_batch_single_identical(
             test_max_difference=snake_case__		,     relax_max_difference=snake_case__		,     additional_params_copy_to_batched_inputs=snake_case__		,     )

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Tuple								=							[
             "decoder_num_inference_steps",
             "super_res_num_inference_steps",
         ]

         if torch_device == "mps":
           # TODO: MPS errors with larger batch sizes
           lowerCAmelCase     :     Tuple								=							[2, 3]
           self._test_inference_batch_consistent(
               batch_sizes=snake_case__		,     additional_params_copy_to_batched_inputs=snake_case__		,     )
         else:
           self._test_inference_batch_consistent(
               additional_params_copy_to_batched_inputs=snake_case__						)

       @skip_mps
       def        lowercase__							(						self						):






         """simple docstring"""





         return super().test_dict_tuple_outputs_equivalent()

       @skip_mps
       def        lowercase__							(						self						):






         """simple docstring"""





         return super().test_save_load_local()







       @skip_mps
       def        lowercase__							(						self						):






         """simple docstring"""





         return super().test_save_load_optional_components()


@slow
@require_torch_gpu
class       SCREAMING_SNAKE_CASE__				(		unittest.TestCase				):
       """simple docstring"""


       def        lowercase__							(						self						):






         """simple docstring"""





         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()







       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     List[Any]								=							load_image(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png"						)
         lowerCAmelCase     :     int								=							load_numpy(
             "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
             "/unclip/karlo_v1_alpha_cat_variation_fp16.npy"						)

         lowerCAmelCase     :     Union[str, Any]								=							UnCLIPImageVariationPipeline.from_pretrained(
             "kakaobrain/karlo-v1-alpha-image-variations"		,     torch_dtype=torch.floataa						)
         lowerCAmelCase     :     Union[str, Any]								=							pipeline.to(snake_case__						)
         pipeline.set_progress_bar_config(disable=snake_case__						)

         lowerCAmelCase     :     Any								=							torch.Generator(device="cpu"						).manual_seed(0						)
         lowerCAmelCase     :     Optional[int]								=							pipeline(
             snake_case__		,     generator=snake_case__		,     output_type="np"		,     )

         lowerCAmelCase     :     Optional[Any]								=							output.images[0]

         assert image.shape == (256, 256, 3)

         assert_mean_pixel_difference(snake_case__		,     snake_case__		,     15						)









"""simple docstring"""







import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation


class       SCREAMING_SNAKE_CASE__				(		unittest.TestCase				):
       """simple docstring"""


       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     int								=							get_activation("swish"						)

         self.assertIsInstance(snake_case__		,     nn.SiLU						)

         self.assertEqual(act(torch.tensor(-100		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertNotEqual(act(torch.tensor(-1		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(0		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(20		,     dtype=torch.floataa						)						).item()		,     20						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Union[str, Any]								=							get_activation("silu"						)

         self.assertIsInstance(snake_case__		,     nn.SiLU						)

         self.assertEqual(act(torch.tensor(-100		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertNotEqual(act(torch.tensor(-1		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(0		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(20		,     dtype=torch.floataa						)						).item()		,     20						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Dict								=							get_activation("mish"						)

         self.assertIsInstance(snake_case__		,     nn.Mish						)

         self.assertEqual(act(torch.tensor(-200		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertNotEqual(act(torch.tensor(-1		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(0		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(20		,     dtype=torch.floataa						)						).item()		,     20						)







       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Union[str, Any]								=							get_activation("gelu"						)

         self.assertIsInstance(snake_case__		,     nn.GELU						)

         self.assertEqual(act(torch.tensor(-100		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertNotEqual(act(torch.tensor(-1		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(0		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(20		,     dtype=torch.floataa						)						).item()		,     20						)





