

import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


_SCREAMING_SNAKE_CASE  :						Dict         =    logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE  :						int         =    {
    '''ut/deta''': '''https://huggingface.co/ut/deta/resolve/main/config.json''',
}






class  UpperCAmelCase__	( A__ ):






  """simple docstring"""


  a     =      "deta"
  a     =      {
      "hidden_size": "d_model",
      "num_attention_heads": "encoder_attention_heads",
  }






  def __init__(							self		:	str			,     __lowerCamelCase		:	int=None			,     __lowerCamelCase		:	List[str]=900			,     __lowerCamelCase		:	int=2048			,     __lowerCamelCase		:	Optional[int]=6			,     __lowerCamelCase		:	Optional[int]=2048			,     __lowerCamelCase		:	Optional[int]=8			,     __lowerCamelCase		:	str=6			,     __lowerCamelCase		:	int=1024			,     __lowerCamelCase		:	Any=8			,     __lowerCamelCase		:	Tuple=0.0			,     __lowerCamelCase		:	Optional[Any]=True			,     __lowerCamelCase		:	Any="relu"			,     __lowerCamelCase		:	int=256			,     __lowerCamelCase		:	List[Any]=0.1			,     __lowerCamelCase		:	List[str]=0.0			,     __lowerCamelCase		:	List[str]=0.0			,     __lowerCamelCase		:	int=0.02			,     __lowerCamelCase		:	Union[str, Any]=1.0			,     __lowerCamelCase		:	Dict=True			,     __lowerCamelCase		:	List[Any]=False			,     __lowerCamelCase		:	List[Any]="sine"			,     __lowerCamelCase		:	Union[str, Any]=5			,     __lowerCamelCase		:	Optional[Any]=4			,     __lowerCamelCase		:	int=4			,     __lowerCamelCase		:	Union[str, Any]=True			,     __lowerCamelCase		:	Optional[Any]=300			,     __lowerCamelCase		:	Optional[Any]=True			,     __lowerCamelCase		:	Dict=True			,     __lowerCamelCase		:	List[str]=1			,     __lowerCamelCase		:	Optional[Any]=5			,     __lowerCamelCase		:	str=2			,     __lowerCamelCase		:	Tuple=1			,     __lowerCamelCase		:	List[str]=1			,     __lowerCamelCase		:	Dict=5			,     __lowerCamelCase		:	int=2			,     __lowerCamelCase		:	List[str]=0.1			,     __lowerCamelCase		:	List[str]=0.25			,     **__lowerCamelCase		:	Any			,     )	->							List[Any]:
       if backbone_config is None:
            logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''      )
            SCREAMING_SNAKE_CASE__					=					CONFIG_MAPPING['''resnet'''](out_features=['''stage2''', '''stage3''', '''stage4''']      )
       else:
            if isinstance(__lowerCamelCase			,     __lowerCamelCase      ):
                 SCREAMING_SNAKE_CASE__					=					backbone_config.pop('''model_type'''      )
                 SCREAMING_SNAKE_CASE__					=					CONFIG_MAPPING[backbone_model_type]
                 SCREAMING_SNAKE_CASE__					=					config_class.from_dict(__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					backbone_config
       SCREAMING_SNAKE_CASE__					=					num_queries
       SCREAMING_SNAKE_CASE__					=					max_position_embeddings
       SCREAMING_SNAKE_CASE__					=					d_model
       SCREAMING_SNAKE_CASE__					=					encoder_ffn_dim
       SCREAMING_SNAKE_CASE__					=					encoder_layers
       SCREAMING_SNAKE_CASE__					=					encoder_attention_heads
       SCREAMING_SNAKE_CASE__					=					decoder_ffn_dim
       SCREAMING_SNAKE_CASE__					=					decoder_layers
       SCREAMING_SNAKE_CASE__					=					decoder_attention_heads
       SCREAMING_SNAKE_CASE__					=					dropout
       SCREAMING_SNAKE_CASE__					=					attention_dropout
       SCREAMING_SNAKE_CASE__					=					activation_dropout
       SCREAMING_SNAKE_CASE__					=					activation_function
       SCREAMING_SNAKE_CASE__					=					init_std
       SCREAMING_SNAKE_CASE__					=					init_xavier_std
       SCREAMING_SNAKE_CASE__					=					encoder_layerdrop
       SCREAMING_SNAKE_CASE__					=					auxiliary_loss
       SCREAMING_SNAKE_CASE__					=					position_embedding_type
       # deformable attributes
       SCREAMING_SNAKE_CASE__					=					num_feature_levels
       SCREAMING_SNAKE_CASE__					=					encoder_n_points
       SCREAMING_SNAKE_CASE__					=					decoder_n_points
       SCREAMING_SNAKE_CASE__					=					two_stage
       SCREAMING_SNAKE_CASE__					=					two_stage_num_proposals
       SCREAMING_SNAKE_CASE__					=					with_box_refine
       SCREAMING_SNAKE_CASE__					=					assign_first_stage
       if two_stage is True and with_box_refine is False:
            raise ValueError('''If two_stage is True, with_box_refine must be True.'''      )
       # Hungarian matcher
       SCREAMING_SNAKE_CASE__					=					class_cost
       SCREAMING_SNAKE_CASE__					=					bbox_cost
       SCREAMING_SNAKE_CASE__					=					giou_cost
       # Loss coefficients
       SCREAMING_SNAKE_CASE__					=					mask_loss_coefficient
       SCREAMING_SNAKE_CASE__					=					dice_loss_coefficient
       SCREAMING_SNAKE_CASE__					=					bbox_loss_coefficient
       SCREAMING_SNAKE_CASE__					=					giou_loss_coefficient
       SCREAMING_SNAKE_CASE__					=					eos_coefficient
       SCREAMING_SNAKE_CASE__					=					focal_alpha
       super().__init__(is_encoder_decoder=__lowerCamelCase			,     **__lowerCamelCase      )






  @property
  def    lowercase_	(							self		:	Dict      )	->							int:
       return self.encoder_attention_heads






  @property
  def    lowercase_	(							self		:	Optional[int]      )	->							int:
       return self.d_model







  def    lowercase_	(							self		:	Union[str, Any]      )	->							Dict:
       SCREAMING_SNAKE_CASE__					=					copy.deepcopy(self.__dict__      )
       SCREAMING_SNAKE_CASE__					=					self.backbone_config.to_dict()
       SCREAMING_SNAKE_CASE__					=					self.__class__.model_type
       return output





import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class  UpperCAmelCase__	( A__		,  unittest.TestCase ):






  """simple docstring"""


  a     =      KandinskyImgaImgPipeline
  a     =      ["prompt", "image_embeds", "negative_image_embeds", "image"]
  a     =      [
      "prompt",
      "negative_prompt",
      "image_embeds",
      "negative_image_embeds",
      "image",
  ]
  a     =      [
      "generator",
      "height",
      "width",
      "strength",
      "guidance_scale",
      "negative_prompt",
      "num_inference_steps",
      "return_dict",
      "guidance_scale",
      "num_images_per_prompt",
      "output_type",
      "return_dict",
  ]
  a     =      False






  @property
  def    lowercase_	(							self		:	str      )	->							List[str]:
       return 32






  @property
  def    lowercase_	(							self		:	Optional[int]      )	->							int:
       return 32






  @property
  def    lowercase_	(							self		:	Union[str, Any]      )	->							int:
       return self.time_input_dim






  @property
  def    lowercase_	(							self		:	List[str]      )	->							int:
       return self.time_input_dim * 4






  @property
  def    lowercase_	(							self		:	Union[str, Any]      )	->							Any:
       return 100






  @property
  def    lowercase_	(							self		:	Any      )	->							List[Any]:
       SCREAMING_SNAKE_CASE__					=					XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''      )
       return tokenizer






  @property
  def    lowercase_	(							self		:	List[Any]      )	->							List[Any]:
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					MCLIPConfig(
           numDims=self.cross_attention_dim			,     transformerDimensions=self.text_embedder_hidden_size			,     hidden_size=self.text_embedder_hidden_size			,     intermediate_size=37			,     num_attention_heads=4			,     num_hidden_layers=5			,     vocab_size=1005			,     )

       SCREAMING_SNAKE_CASE__					=					MultilingualCLIP(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					text_encoder.eval()

       return text_encoder






  @property
  def    lowercase_	(							self		:	str      )	->							Dict:
       torch.manual_seed(0      )

       SCREAMING_SNAKE_CASE__					=					{
           '''in_channels''': 4,
           # Out channels is double in channels because predicts mean and variance
           '''out_channels''': 8,
           '''addition_embed_type''': '''text_image''',
           '''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,
           '''encoder_hid_dim''': self.text_embedder_hidden_size,
           '''encoder_hid_dim_type''': '''text_image_proj''',
           '''cross_attention_dim''': self.cross_attention_dim,
           '''attention_head_dim''': 4,
           '''resnet_time_scale_shift''': '''scale_shift''',
           '''class_embed_type''': None,
       }

       SCREAMING_SNAKE_CASE__					=					UNetaDConditionModel(**__lowerCamelCase      )
       return model






  @property
  def    lowercase_	(							self		:	Dict      )	->							Optional[Any]:
       return {
           "block_out_channels": [32, 64],
           "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
           "in_channels": 3,
           "latent_channels": 4,
           "layers_per_block": 1,
           "norm_num_groups": 8,
           "norm_type": "spatial",
           "num_vq_embeddings": 12,
           "out_channels": 3,
           "up_block_types": [
               "AttnUpDecoderBlock2D",
               "UpDecoderBlock2D",
           ],
           "vq_embed_dim": 4,
       }






  @property
  def    lowercase_	(							self		:	Tuple      )	->							Optional[int]:
       torch.manual_seed(0      )
       SCREAMING_SNAKE_CASE__					=					VQModel(**self.dummy_movq_kwargs      )
       return model






  def    lowercase_	(							self		:	int      )	->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__					=					self.dummy_text_encoder
       SCREAMING_SNAKE_CASE__					=					self.dummy_tokenizer
       SCREAMING_SNAKE_CASE__					=					self.dummy_unet
       SCREAMING_SNAKE_CASE__					=					self.dummy_movq

       SCREAMING_SNAKE_CASE__					=					{
           '''num_train_timesteps''': 1000,
           '''beta_schedule''': '''linear''',
           '''beta_start''': 0.00085,
           '''beta_end''': 0.012,
           '''clip_sample''': False,
           '''set_alpha_to_one''': False,
           '''steps_offset''': 0,
           '''prediction_type''': '''epsilon''',
           '''thresholding''': False,
       }

       SCREAMING_SNAKE_CASE__					=					DDIMScheduler(**__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					{
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''movq''': movq,
       }

       return components






  def    lowercase_	(							self		:	List[Any]			,     __lowerCamelCase		:	List[str]			,     __lowerCamelCase		:	Union[str, Any]=0      )	->							str:
       SCREAMING_SNAKE_CASE__					=					floats_tensor((1, self.cross_attention_dim)			,     rng=random.Random(__lowerCamelCase      )      ).to(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					floats_tensor((1, self.cross_attention_dim)			,     rng=random.Random(seed + 1      )      ).to(__lowerCamelCase      )
       # create init_image
       SCREAMING_SNAKE_CASE__					=					floats_tensor((1, 3, 64, 64)			,     rng=random.Random(__lowerCamelCase      )      ).to(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					image.cpu().permute(0			,     2			,     3			,     1      )[0]
       SCREAMING_SNAKE_CASE__					=					Image.fromarray(np.uinta(__lowerCamelCase      )      ).convert('''RGB'''      ).resize((256, 256)      )

       if str(__lowerCamelCase      ).startswith('''mps'''      ):
            SCREAMING_SNAKE_CASE__					=					torch.manual_seed(__lowerCamelCase      )
       else:
            SCREAMING_SNAKE_CASE__					=					torch.Generator(device=__lowerCamelCase      ).manual_seed(__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					{
           '''prompt''': '''horse''',
           '''image''': init_image,
           '''image_embeds''': image_embeds,
           '''negative_image_embeds''': negative_image_embeds,
           '''generator''': generator,
           '''height''': 64,
           '''width''': 64,
           '''num_inference_steps''': 10,
           '''guidance_scale''': 7.0,
           '''strength''': 0.2,
           '''output_type''': '''np''',
       }
       return inputs







  def    lowercase_	(							self		:	int      )	->							Any:
       SCREAMING_SNAKE_CASE__					=					'''cpu'''

       SCREAMING_SNAKE_CASE__					=					self.get_dummy_components()

       SCREAMING_SNAKE_CASE__					=					self.pipeline_class(**__lowerCamelCase      )
       SCREAMING_SNAKE_CASE__					=					pipe.to(__lowerCamelCase      )

       pipe.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					pipe(**self.get_dummy_inputs(__lowerCamelCase      )      )
       SCREAMING_SNAKE_CASE__					=					output.images

       SCREAMING_SNAKE_CASE__					=					pipe(
           **self.get_dummy_inputs(__lowerCamelCase      )			,     return_dict=__lowerCamelCase			,     )[0]

       SCREAMING_SNAKE_CASE__					=					image[0, -3:, -3:, -1]
       SCREAMING_SNAKE_CASE__					=					image_from_tuple[0, -3:, -3:, -1]

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

       SCREAMING_SNAKE_CASE__					=					np.array(
           [0.61474943, 0.6073539, 0.43308544, 0.5928269, 0.47493595, 0.46755973, 0.4613838, 0.45368797, 0.50119233]      )
       assert (
           np.abs(image_slice.flatten() - expected_slice      ).max() < 1e-2
       ), f''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''
       assert (
           np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1e-2
       ), f''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''






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






  """simple docstring"""


  def    lowercase_	(							self		:	Tuple      )	->							Dict:
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







  def    lowercase_	(							self		:	List[str]      )	->							List[str]:
       SCREAMING_SNAKE_CASE__					=					load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/kandinsky/kandinsky_img2img_frog.npy'''      )

       SCREAMING_SNAKE_CASE__					=					load_image(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''      )
       SCREAMING_SNAKE_CASE__					=					'''A red cartoon frog, 4k'''

       SCREAMING_SNAKE_CASE__					=					KandinskyPriorPipeline.from_pretrained(
           '''kandinsky-community/kandinsky-2-1-prior'''			,     torch_dtype=torch.floataa      )
       pipe_prior.to(__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					KandinskyImgaImgPipeline.from_pretrained(
           '''kandinsky-community/kandinsky-2-1'''			,     torch_dtype=torch.floataa      )
       SCREAMING_SNAKE_CASE__					=					pipeline.to(__lowerCamelCase      )

       pipeline.set_progress_bar_config(disable=__lowerCamelCase      )

       SCREAMING_SNAKE_CASE__					=					torch.Generator(device='''cpu'''      ).manual_seed(0      )
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__					=					pipe_prior(
           __lowerCamelCase			,     generator=__lowerCamelCase			,     num_inference_steps=5			,     negative_prompt=''''''			,     ).to_tuple()

       SCREAMING_SNAKE_CASE__					=					pipeline(
           __lowerCamelCase			,     image=__lowerCamelCase			,     image_embeds=__lowerCamelCase			,     negative_image_embeds=__lowerCamelCase			,     generator=__lowerCamelCase			,     num_inference_steps=100			,     height=768			,     width=768			,     strength=0.2			,     output_type='''np'''			,     )

       SCREAMING_SNAKE_CASE__					=					output.images[0]

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

       assert_mean_pixel_difference(__lowerCamelCase			,     __lowerCamelCase      )


