'''simple docstring'''




import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()






class 		__A       (__magic_name__ ,					__magic_name__ ,					__magic_name__ ,					unittest.TestCase   ):
       snake_case       :Optional[int]				    =					StableUnCLIPPipeline
       snake_case       :Optional[Any]				    =					TEXT_TO_IMAGE_PARAMS
       snake_case       :List[Any]				    =					TEXT_TO_IMAGE_BATCH_PARAMS
       snake_case       :Union[str, Any]				    =					TEXT_TO_IMAGE_IMAGE_PARAMS
       snake_case       :Any				    =					TEXT_TO_IMAGE_IMAGE_PARAMS

       # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
       snake_case       :Optional[int]				    =					False






       def 			_snake_case						(      self      ):
              __UpperCAmelCase  :				Optional[int]       				=		32
              __UpperCAmelCase  :				Any       				=		embedder_hidden_size

              # prior components

              torch.manual_seed(0      )
              __UpperCAmelCase  :				Optional[Any]       				=		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"      )

              torch.manual_seed(0      )
              __UpperCAmelCase  :				Dict       				=		CLIPTextModelWithProjection(
                  CLIPTextConfig(
                      bos_token_id=0				,     eos_token_id=2				,     hidden_size=UpperCamelCase_				,     projection_dim=UpperCamelCase_				,     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      )
              __UpperCAmelCase  :				str       				=		PriorTransformer(
                  num_attention_heads=2				,     attention_head_dim=12				,     embedding_dim=UpperCamelCase_				,     num_layers=1				,     )

              torch.manual_seed(0      )
              __UpperCAmelCase  :				Optional[Any]       				=		DDPMScheduler(
                  variance_type="fixed_small_log"				,     prediction_type="sample"				,     num_train_timesteps=10_00				,     clip_sample=UpperCamelCase_				,     clip_sample_range=5.0				,     beta_schedule="squaredcos_cap_v2"				,     )

              # regular denoising components

              torch.manual_seed(0      )
              __UpperCAmelCase  :				Optional[Any]       				=		StableUnCLIPImageNormalizer(embedding_dim=UpperCamelCase_      )
              __UpperCAmelCase  :				Optional[int]       				=		DDPMScheduler(beta_schedule="squaredcos_cap_v2"      )

              torch.manual_seed(0      )
              __UpperCAmelCase  :				Optional[int]       				=		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"      )

              torch.manual_seed(0      )
              __UpperCAmelCase  :				List[str]       				=		CLIPTextModel(
                  CLIPTextConfig(
                      bos_token_id=0				,     eos_token_id=2				,     hidden_size=UpperCamelCase_				,     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      )
              __UpperCAmelCase  :				str       				=		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=UpperCamelCase_				,     layers_per_block=1				,     upcast_attention=UpperCamelCase_				,     use_linear_projection=UpperCamelCase_				,     )

              torch.manual_seed(0      )
              __UpperCAmelCase  :				int       				=		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=UpperCamelCase_				,     steps_offset=1				,     )

              torch.manual_seed(0      )
              __UpperCAmelCase  :				List[Any]       				=		AutoencoderKL()

              __UpperCAmelCase  :				int       				=		{
                  # prior components
                  "prior_tokenizer": prior_tokenizer,
                  "prior_text_encoder": prior_text_encoder,
                  "prior": prior,
                  "prior_scheduler": prior_scheduler,
                  # image noising components
                  "image_normalizer": image_normalizer,
                  "image_noising_scheduler": image_noising_scheduler,
                  # regular denoising components
                  "tokenizer": tokenizer,
                  "text_encoder": text_encoder,
                  "unet": unet,
                  "scheduler": scheduler,
                  "vae": vae,
              }

              return components






       def 			_snake_case						(      self				,     UpperCamelCase_				,     UpperCamelCase_=0      ):
              if str(UpperCamelCase_      ).startswith("mps"      ):
                     __UpperCAmelCase  :				List[Any]       				=		torch.manual_seed(UpperCamelCase_      )
              else:
                     __UpperCAmelCase  :				Optional[int]       				=		torch.Generator(device=UpperCamelCase_      ).manual_seed(UpperCamelCase_      )
              __UpperCAmelCase  :				Optional[int]       				=		{
                  "prompt": "A painting of a squirrel eating a burger",
                  "generator": generator,
                  "num_inference_steps": 2,
                  "prior_num_inference_steps": 2,
                  "output_type": "numpy",
              }
              return inputs






       def 			_snake_case						(      self      ):
              __UpperCAmelCase  :				Union[str, Any]       				=		torch_device == "cpu"

              self._test_attention_slicing_forward_pass(test_max_difference=UpperCamelCase_      )







       def 			_snake_case						(      self      ):
              __UpperCAmelCase  :				str       				=		torch_device in ["cpu", "mps"]

              self._test_inference_batch_single_identical(test_max_difference=UpperCamelCase_      )






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






       def 			_snake_case						(      self      ):
              # clean up the VRAM after each test
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()






       def 			_snake_case						(      self      ):
              __UpperCAmelCase  :				Any       				=		load_numpy(
                  "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"      )

              __UpperCAmelCase  :				List[str]       				=		StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l"				,     torch_dtype=torch.floataa      )
              pipe.to(UpperCamelCase_      )
              pipe.set_progress_bar_config(disable=UpperCamelCase_      )
              # 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()

              __UpperCAmelCase  :				int       				=		torch.Generator(device="cpu"      ).manual_seed(0      )
              __UpperCAmelCase  :				Tuple       				=		pipe("anime turle"				,     generator=UpperCamelCase_				,     output_type="np"      )

              __UpperCAmelCase  :				Tuple       				=		output.images[0]

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

              assert_mean_pixel_difference(UpperCamelCase_				,     UpperCamelCase_      )







       def 			_snake_case						(      self      ):
              torch.cuda.empty_cache()
              torch.cuda.reset_max_memory_allocated()
              torch.cuda.reset_peak_memory_stats()

              __UpperCAmelCase  :				List[Any]       				=		StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l"				,     torch_dtype=torch.floataa      )
              __UpperCAmelCase  :				int       				=		pipe.to(UpperCamelCase_      )
              pipe.set_progress_bar_config(disable=UpperCamelCase_      )
              pipe.enable_attention_slicing()
              pipe.enable_sequential_cpu_offload()

              __UpperCAmelCase  :				Optional[int]       				=		pipe(
                  "anime turtle"				,     prior_num_inference_steps=2				,     num_inference_steps=2				,     output_type="np"				,     )

              __UpperCAmelCase  :				Dict       				=		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


_a   :	Any 							=   logging.get_logger(__name__)

_a   :	List[Any] 							=   {
    "microsoft/cvt-13": "https://huggingface.co/microsoft/cvt-13/resolve/main/config.json",
    # See all Cvt models at https://huggingface.co/models?filter=cvt
}






class 		__A       (__magic_name__   ):
       snake_case       :Any				    =					"cvt"






       def __init__(      self				,     UpperCamelCase_=3				,     UpperCamelCase_=[7, 3, 3]				,     UpperCamelCase_=[4, 2, 2]				,     UpperCamelCase_=[2, 1, 1]				,     UpperCamelCase_=[64, 1_92, 3_84]				,     UpperCamelCase_=[1, 3, 6]				,     UpperCamelCase_=[1, 2, 10]				,     UpperCamelCase_=[4.0, 4.0, 4.0]				,     UpperCamelCase_=[0.0, 0.0, 0.0]				,     UpperCamelCase_=[0.0, 0.0, 0.0]				,     UpperCamelCase_=[0.0, 0.0, 0.1]				,     UpperCamelCase_=[True, True, True]				,     UpperCamelCase_=[False, False, True]				,     UpperCamelCase_=["dw_bn", "dw_bn", "dw_bn"]				,     UpperCamelCase_=[3, 3, 3]				,     UpperCamelCase_=[1, 1, 1]				,     UpperCamelCase_=[2, 2, 2]				,     UpperCamelCase_=[1, 1, 1]				,     UpperCamelCase_=[1, 1, 1]				,     UpperCamelCase_=0.0_2				,     UpperCamelCase_=1E-12				,     **UpperCamelCase_				,     ):
              super().__init__(**UpperCamelCase_      )
              __UpperCAmelCase  :				Optional[int]       				=		num_channels
              __UpperCAmelCase  :				Optional[Any]       				=		patch_sizes
              __UpperCAmelCase  :				List[str]       				=		patch_stride
              __UpperCAmelCase  :				Tuple       				=		patch_padding
              __UpperCAmelCase  :				int       				=		embed_dim
              __UpperCAmelCase  :				str       				=		num_heads
              __UpperCAmelCase  :				Any       				=		depth
              __UpperCAmelCase  :				List[str]       				=		mlp_ratio
              __UpperCAmelCase  :				List[str]       				=		attention_drop_rate
              __UpperCAmelCase  :				Dict       				=		drop_rate
              __UpperCAmelCase  :				Dict       				=		drop_path_rate
              __UpperCAmelCase  :				str       				=		qkv_bias
              __UpperCAmelCase  :				Optional[int]       				=		cls_token
              __UpperCAmelCase  :				Optional[Any]       				=		qkv_projection_method
              __UpperCAmelCase  :				Tuple       				=		kernel_qkv
              __UpperCAmelCase  :				Optional[Any]       				=		padding_kv
              __UpperCAmelCase  :				Optional[int]       				=		stride_kv
              __UpperCAmelCase  :				Any       				=		padding_q
              __UpperCAmelCase  :				List[Any]       				=		stride_q
              __UpperCAmelCase  :				Union[str, Any]       				=		initializer_range
              __UpperCAmelCase  :				Any       				=		layer_norm_eps






