





import gc
import unittest

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

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


UpperCAmelCase	:	Any		     =       False







class 				__lowerCAmelCase       (    unittest.TestCase):







      def    _lowercase  (    self							)   ->						str:



        '''simple docstring'''




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







      @property
      def    _lowercase  (    self							)   ->						Optional[int]:



        '''simple docstring'''




        return 1_2







      @property
      def    _lowercase  (    self							)   ->						str:



        '''simple docstring'''




        return 1_2







      @property
      def    _lowercase  (    self							)   ->						List[Any]:



        '''simple docstring'''




        return 3_2







      @property
      def    _lowercase  (    self							)   ->						Any:



        '''simple docstring'''




        torch.manual_seed(0							)
        a__	:					Dict										=VQModel(
            block_out_channels=[3_2, 6_4]		,      in_channels=3		,      out_channels=3		,      down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]		,      up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]		,      latent_channels=3		,      num_vq_embeddings=self.num_embed		,      vq_embed_dim=3		,      )
        return model







      @property
      def    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




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







      @property
      def    _lowercase  (    self							)   ->						Dict:



        '''simple docstring'''




        torch.manual_seed(0							)
        a__	:					Union[str, Any]										=CLIPTextConfig(
            bos_token_id=0		,      eos_token_id=2		,      hidden_size=self.text_embedder_hidden_size		,      intermediate_size=3_7		,      layer_norm_eps=1E-05		,      num_attention_heads=4		,      num_hidden_layers=5		,      pad_token_id=1		,      vocab_size=1_0_0_0		,      )
        return CLIPTextModel(lowerCAmelCase__							)







      @property
      def    _lowercase  (    self							)   ->						int:



        '''simple docstring'''




        torch.manual_seed(0							)

        a__	:					str										=1_2
        a__	:					List[str]										=1_2

        a__	:					List[Any]										={
            "attention_bias": True,
            "cross_attention_dim": 3_2,
            "attention_head_dim": height * width,
            "num_attention_heads": 1,
            "num_vector_embeds": self.num_embed,
            "num_embeds_ada_norm": self.num_embeds_ada_norm,
            "norm_num_groups": 3_2,
            "sample_size": width,
            "activation_fn": "geglu-approximate",
        }

        a__	:					List[str]										=TransformeraDModel(**lowerCAmelCase__							)
        return model







      def    _lowercase  (    self							)   ->						Tuple:



        '''simple docstring'''




        a__	:					Optional[int]										="cpu"

        a__	:					int										=self.dummy_vqvae
        a__	:					Union[str, Any]										=self.dummy_text_encoder
        a__	:					List[Any]										=self.dummy_tokenizer
        a__	:					Optional[int]										=self.dummy_transformer
        a__	:					Tuple										=VQDiffusionScheduler(self.num_embed							)
        a__	:					int										=LearnedClassifierFreeSamplingEmbeddings(learnable=lowerCAmelCase__							)

        a__	:					Any										=VQDiffusionPipeline(
            vqvae=lowerCAmelCase__		,      text_encoder=lowerCAmelCase__		,      tokenizer=lowerCAmelCase__		,      transformer=lowerCAmelCase__		,      scheduler=lowerCAmelCase__		,      learned_classifier_free_sampling_embeddings=lowerCAmelCase__		,      )
        a__	:					str										=pipe.to(lowerCAmelCase__							)
        pipe.set_progress_bar_config(disable=lowerCAmelCase__							)

        a__	:					int										="teddy bear playing in the pool"

        a__	:					int										=torch.Generator(device=lowerCAmelCase__							).manual_seed(0							)
        a__	:					Union[str, Any]										=pipe([prompt]		,      generator=lowerCAmelCase__		,      num_inference_steps=2		,      output_type="np"							)
        a__	:					Union[str, Any]										=output.images

        a__	:					List[str]										=torch.Generator(device=lowerCAmelCase__							).manual_seed(0							)
        a__	:					Optional[Any]										=pipe(
            [prompt]		,      generator=lowerCAmelCase__		,      output_type="np"		,      return_dict=lowerCAmelCase__		,      num_inference_steps=2							)[0]

        a__	:					Dict										=image[0, -3:, -3:, -1]
        a__	:					Tuple										=image_from_tuple[0, -3:, -3:, -1]

        assert image.shape == (1, 2_4, 2_4, 3)

        a__	:					Dict										=np.array([0.65_51, 0.61_68, 0.50_08, 0.56_76, 0.56_59, 0.42_95, 0.60_73, 0.55_99, 0.49_92]							)

        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							)   ->						Optional[Any]:



        '''simple docstring'''




        a__	:					Any										="cpu"

        a__	:					str										=self.dummy_vqvae
        a__	:					str										=self.dummy_text_encoder
        a__	:					Any										=self.dummy_tokenizer
        a__	:					Union[str, Any]										=self.dummy_transformer
        a__	:					str										=VQDiffusionScheduler(self.num_embed							)
        a__	:					Tuple										=LearnedClassifierFreeSamplingEmbeddings(
            learnable=lowerCAmelCase__		,      hidden_size=self.text_embedder_hidden_size		,      length=tokenizer.model_max_length							)

        a__	:					List[str]										=VQDiffusionPipeline(
            vqvae=lowerCAmelCase__		,      text_encoder=lowerCAmelCase__		,      tokenizer=lowerCAmelCase__		,      transformer=lowerCAmelCase__		,      scheduler=lowerCAmelCase__		,      learned_classifier_free_sampling_embeddings=lowerCAmelCase__		,      )
        a__	:					str										=pipe.to(lowerCAmelCase__							)
        pipe.set_progress_bar_config(disable=lowerCAmelCase__							)

        a__	:					Optional[Any]										="teddy bear playing in the pool"

        a__	:					Tuple										=torch.Generator(device=lowerCAmelCase__							).manual_seed(0							)
        a__	:					int										=pipe([prompt]		,      generator=lowerCAmelCase__		,      num_inference_steps=2		,      output_type="np"							)
        a__	:					Any										=output.images

        a__	:					str										=torch.Generator(device=lowerCAmelCase__							).manual_seed(0							)
        a__	:					List[str]										=pipe(
            [prompt]		,      generator=lowerCAmelCase__		,      output_type="np"		,      return_dict=lowerCAmelCase__		,      num_inference_steps=2							)[0]

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

        assert image.shape == (1, 2_4, 2_4, 3)

        a__	:					Any										=np.array([0.66_93, 0.60_75, 0.49_59, 0.57_01, 0.55_83, 0.43_33, 0.61_71, 0.56_84, 0.49_88]							)

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







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







      def    _lowercase  (    self							)   ->						Optional[Any]:



        '''simple docstring'''




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







      def    _lowercase  (    self							)   ->						Dict:



        '''simple docstring'''




        a__	:					Union[str, Any]										=load_numpy(
            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
            "/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy"							)

        a__	:					Tuple										=VQDiffusionPipeline.from_pretrained("microsoft/vq-diffusion-ithq"							)
        a__	:					Optional[int]										=pipeline.to(lowerCAmelCase__							)
        pipeline.set_progress_bar_config(disable=lowerCAmelCase__							)

        # requires GPU generator for gumbel softmax
        # don't use GPU generator in tests though
        a__	:					Tuple										=torch.Generator(device=lowerCAmelCase__							).manual_seed(0							)
        a__	:					List[str]										=pipeline(
            "teddy bear playing in the pool"		,      num_images_per_prompt=1		,      generator=lowerCAmelCase__		,      output_type="np"		,      )

        a__	:					int										=output.images[0]

        assert image.shape == (2_5_6, 2_5_6, 3)
        assert np.abs(expected_image - image							).max() < 2.0













from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase	:	Dict		     =       logging.get_logger(__name__)

UpperCAmelCase	:	Tuple		     =       {
    """caidas/swin2sr-classicalsr-x2-64""": (
        """https://huggingface.co/caidas/swin2sr-classicalsr-x2-64/resolve/main/config.json"""
    ),
}







class 				__lowerCAmelCase       (    UpperCamelCase__):
      _lowercase				:					Any						=			"""swin2sr"""

      _lowercase				:					Tuple						=			{
          """hidden_size""": """embed_dim""",
          """num_attention_heads""": """num_heads""",
          """num_hidden_layers""": """num_layers""",
      }







      def __init__(    self		,      lowerCAmelCase__=6_4		,      lowerCAmelCase__=1		,      lowerCAmelCase__=3		,      lowerCAmelCase__=1_8_0		,      lowerCAmelCase__=[6, 6, 6, 6, 6, 6]		,      lowerCAmelCase__=[6, 6, 6, 6, 6, 6]		,      lowerCAmelCase__=8		,      lowerCAmelCase__=2.0		,      lowerCAmelCase__=True		,      lowerCAmelCase__=0.0		,      lowerCAmelCase__=0.0		,      lowerCAmelCase__=0.1		,      lowerCAmelCase__="gelu"		,      lowerCAmelCase__=False		,      lowerCAmelCase__=0.02		,      lowerCAmelCase__=1E-5		,      lowerCAmelCase__=2		,      lowerCAmelCase__=1.0		,      lowerCAmelCase__="1conv"		,      lowerCAmelCase__="pixelshuffle"		,      **lowerCAmelCase__		,      )   ->						int:



        '''simple docstring'''




        super().__init__(**lowerCAmelCase__							)

        a__	:					Optional[Any]										=image_size
        a__	:					Dict										=patch_size
        a__	:					Tuple										=num_channels
        a__	:					Union[str, Any]										=embed_dim
        a__	:					Optional[Any]										=depths
        a__	:					List[str]										=len(lowerCAmelCase__							)
        a__	:					Any										=num_heads
        a__	:					Any										=window_size
        a__	:					str										=mlp_ratio
        a__	:					List[str]										=qkv_bias
        a__	:					Dict										=hidden_dropout_prob
        a__	:					List[str]										=attention_probs_dropout_prob
        a__	:					Dict										=drop_path_rate
        a__	:					Optional[Any]										=hidden_act
        a__	:					Union[str, Any]										=use_absolute_embeddings
        a__	:					Optional[Any]										=layer_norm_eps
        a__	:					List[Any]										=initializer_range
        a__	:					int										=upscale
        a__	:					Optional[int]										=img_range
        a__	:					Any										=resi_connection
        a__	:					Optional[Any]										=upsampler






