





'''simple docstring'''



import unittest

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

from diffusers import KandinskyVaaPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()






class 							__lowercase    ( __UpperCamelCase	, unittest.TestCase  ):







 '''simple docstring'''

 a      :			Optional[Any]     =    KandinskyVaaPriorPipeline
 a      :			Optional[int]     =    ["prompt"]
 a      :			Optional[Any]     =    ["prompt", "negative_prompt"]
 a      :			Dict     =    [
     "num_images_per_prompt",
     "generator",
     "num_inference_steps",
     "latents",
     "negative_prompt",
     "guidance_scale",
     "output_type",
     "return_dict",
 ]
 a      :			Tuple     =    False


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







    '''simple docstring'''





    return 32


 @property
 def   _UpperCAmelCase       (self	)							->							str:







    '''simple docstring'''





    return 32


 @property
 def   _UpperCAmelCase       (self	)							->							Tuple:







    '''simple docstring'''





    return self.time_input_dim


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







    '''simple docstring'''





    return self.time_input_dim * 4


 @property
 def   _UpperCAmelCase       (self	)							->							int:







    '''simple docstring'''





    return 100


 @property
 def   _UpperCAmelCase       (self	)							->							int:







    '''simple docstring'''





    __lowercase			  =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''	)
    return tokenizer


 @property
 def   _UpperCAmelCase       (self	)							->							Dict:







    '''simple docstring'''





    torch.manual_seed(0	)
    __lowercase			  =							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-0_5       ,num_attention_heads=4       ,num_hidden_layers=5       ,pad_token_id=1       ,vocab_size=1000       ,)
    return CLIPTextModelWithProjection(_lowerCamelCase	)


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







    '''simple docstring'''





    torch.manual_seed(0	)

    __lowercase			  =							{
        'num_attention_heads': 2,
        'attention_head_dim': 12,
        'embedding_dim': self.text_embedder_hidden_size,
        'num_layers': 1,
    }

    __lowercase			  =							PriorTransformer(**_lowerCamelCase	)
    # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
    __lowercase			  =							nn.Parameter(torch.ones(model.clip_std.shape	)	)
    return model


 @property
 def   _UpperCAmelCase       (self	)							->							Union[str, Any]:







    '''simple docstring'''





    torch.manual_seed(0	)
    __lowercase			  =							CLIPVisionConfig(
        hidden_size=self.text_embedder_hidden_size       ,image_size=224       ,projection_dim=self.text_embedder_hidden_size       ,intermediate_size=37       ,num_attention_heads=4       ,num_channels=3       ,num_hidden_layers=5       ,patch_size=14       ,)

    __lowercase			  =							CLIPVisionModelWithProjection(_lowerCamelCase	)
    return model


 @property
 def   _UpperCAmelCase       (self	)							->							Dict:







    '''simple docstring'''





    __lowercase			  =							CLIPImageProcessor(
        crop_size=224       ,do_center_crop=_lowerCamelCase       ,do_normalize=_lowerCamelCase       ,do_resize=_lowerCamelCase       ,image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3]       ,image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1]       ,resample=3       ,size=224       ,)

    return image_processor


 def   _UpperCAmelCase       (self	)							->							Any:







    '''simple docstring'''





    __lowercase			  =							self.dummy_prior
    __lowercase			  =							self.dummy_image_encoder
    __lowercase			  =							self.dummy_text_encoder
    __lowercase			  =							self.dummy_tokenizer
    __lowercase			  =							self.dummy_image_processor

    __lowercase			  =							UnCLIPScheduler(
        variance_type='''fixed_small_log'''       ,prediction_type='''sample'''       ,num_train_timesteps=1000       ,clip_sample=_lowerCamelCase       ,clip_sample_range=10.0       ,)

    __lowercase			  =							{
        'prior': prior,
        'image_encoder': image_encoder,
        'text_encoder': text_encoder,
        'tokenizer': tokenizer,
        'scheduler': scheduler,
        'image_processor': image_processor,
    }

    return components


 def   _UpperCAmelCase       (self       ,_lowerCamelCase       ,_lowerCamelCase=0	)							->							Union[str, Any]:







    '''simple docstring'''





    if str(_lowerCamelCase	).startswith('''mps'''	):
       __lowercase			  =							torch.manual_seed(_lowerCamelCase	)
    else:
       __lowercase			  =							torch.Generator(device=_lowerCamelCase	).manual_seed(_lowerCamelCase	)
    __lowercase			  =							{
        'prompt': 'horse',
        'generator': generator,
        'guidance_scale': 4.0,
        'num_inference_steps': 2,
        'output_type': 'np',
    }
    return inputs


 def   _UpperCAmelCase       (self	)							->							Union[str, Any]:







    '''simple docstring'''





    __lowercase			  =							'cpu'

    __lowercase			  =							self.get_dummy_components()

    __lowercase			  =							self.pipeline_class(**_lowerCamelCase	)
    __lowercase			  =							pipe.to(_lowerCamelCase	)

    pipe.set_progress_bar_config(disable=_lowerCamelCase	)

    __lowercase			  =							pipe(**self.get_dummy_inputs(_lowerCamelCase	)	)
    __lowercase			  =							output.image_embeds

    __lowercase			  =							pipe(
        **self.get_dummy_inputs(_lowerCamelCase	)       ,return_dict=_lowerCamelCase       ,)[0]

    __lowercase			  =							image[0, -10:]
    __lowercase			  =							image_from_tuple[0, -10:]

    assert image.shape == (1, 32)

    __lowercase			  =							np.array(
        [-0.0_5_3_2, 1.7_1_2_0, 0.3_6_5_6, -1.0_8_5_2, -0.8_9_4_6, -1.1_7_5_6, 0.4_3_4_8, 0.2_4_8_2, 0.5_1_4_6, -0.1_1_5_6]	)

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


 @skip_mps
 def   _UpperCAmelCase       (self	)							->							List[Any]:







    '''simple docstring'''





    __lowercase			  =							torch_device == 'cpu'
    __lowercase			  =							True
    __lowercase			  =							False

    self._test_inference_batch_single_identical(
        test_max_difference=_lowerCamelCase       ,relax_max_difference=_lowerCamelCase       ,test_mean_pixel_difference=_lowerCamelCase       ,)


 @skip_mps
 def   _UpperCAmelCase       (self	)							->							Optional[int]:







    '''simple docstring'''





    __lowercase			  =							torch_device == 'cpu'
    __lowercase			  =							False

    self._test_attention_slicing_forward_pass(
        test_max_difference=_lowerCamelCase       ,test_mean_pixel_difference=_lowerCamelCase       ,)












'''simple docstring'''



import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..bit import BitConfig


_SCREAMING_SNAKE_CASE   =      logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE   =      {
    '''Intel/dpt-large''': '''https://huggingface.co/Intel/dpt-large/resolve/main/config.json''',
    # See all DPT models at https://huggingface.co/models?filter=dpt
}






class 							__lowercase    ( lowerCAmelCase__  ):







	'''simple docstring'''

	a      :			Union[str, Any]     =    "dpt"


	def __init__(self       ,_lowerCamelCase=768       ,_lowerCamelCase=12       ,_lowerCamelCase=12       ,_lowerCamelCase=3072       ,_lowerCamelCase="gelu"       ,_lowerCamelCase=0.0       ,_lowerCamelCase=0.0       ,_lowerCamelCase=0.0_2       ,_lowerCamelCase=1E-1_2       ,_lowerCamelCase=384       ,_lowerCamelCase=16       ,_lowerCamelCase=3       ,_lowerCamelCase=False       ,_lowerCamelCase=True       ,_lowerCamelCase=[2, 5, 8, 11]       ,_lowerCamelCase="project"       ,_lowerCamelCase=[4, 2, 1, 0.5]       ,_lowerCamelCase=[96, 192, 384, 768]       ,_lowerCamelCase=256       ,_lowerCamelCase=-1       ,_lowerCamelCase=False       ,_lowerCamelCase=True       ,_lowerCamelCase=0.4       ,_lowerCamelCase=255       ,_lowerCamelCase=0.1       ,_lowerCamelCase=[1, 1024, 24, 24]       ,_lowerCamelCase=[0, 1]       ,_lowerCamelCase=None       ,**_lowerCamelCase       ,)							->							Tuple:







				'''simple docstring'''





				super().__init__(**_lowerCamelCase	)

				__lowercase			  =							hidden_size
				__lowercase			  =							is_hybrid

				if self.is_hybrid:
							if backbone_config is None:
										logger.info('''Initializing the config with a `BiT` backbone.'''	)
										__lowercase			  =							{
										    '''global_padding''': '''same''',
										    '''layer_type''': '''bottleneck''',
										    '''depths''': [3, 4, 9],
										    '''out_features''': ['''stage1''', '''stage2''', '''stage3'''],
										    '''embedding_dynamic_padding''': True,
										}
										__lowercase			  =							BitConfig(**_lowerCamelCase	)
							elif isinstance(_lowerCamelCase       ,_lowerCamelCase	):
										logger.info('''Initializing the config with a `BiT` backbone.'''	)
										__lowercase			  =							BitConfig(**_lowerCamelCase	)
							elif isinstance(_lowerCamelCase       ,_lowerCamelCase	):
										__lowercase			  =							backbone_config
							else:
										raise ValueError(
										    f"backbone_config must be a dictionary or a `PretrainedConfig`, got {backbone_config.__class__}."	)

							__lowercase			  =							backbone_featmap_shape
							__lowercase			  =							neck_ignore_stages

							if readout_type != "project":
										raise ValueError('''Readout type must be \'project\' when using `DPT-hybrid` mode.'''	)
				else:
							__lowercase			  =							None
							__lowercase			  =							None
							__lowercase			  =							[]

				__lowercase			  =							num_hidden_layers
				__lowercase			  =							num_attention_heads
				__lowercase			  =							intermediate_size
				__lowercase			  =							hidden_act
				__lowercase			  =							hidden_dropout_prob
				__lowercase			  =							attention_probs_dropout_prob
				__lowercase			  =							initializer_range
				__lowercase			  =							layer_norm_eps
				__lowercase			  =							image_size
				__lowercase			  =							patch_size
				__lowercase			  =							num_channels
				__lowercase			  =							qkv_bias
				__lowercase			  =							backbone_out_indices
				if readout_type not in ["ignore", "add", "project"]:
							raise ValueError('''Readout_type must be one of [\'ignore\', \'add\', \'project\']'''	)
				__lowercase			  =							readout_type
				__lowercase			  =							reassemble_factors
				__lowercase			  =							neck_hidden_sizes
				__lowercase			  =							fusion_hidden_size
				__lowercase			  =							head_in_index
				__lowercase			  =							use_batch_norm_in_fusion_residual
				# auxiliary head attributes (semantic segmentation)
				__lowercase			  =							use_auxiliary_head
				__lowercase			  =							auxiliary_loss_weight
				__lowercase			  =							semantic_loss_ignore_index
				__lowercase			  =							semantic_classifier_dropout


	def   _UpperCAmelCase       (self	)							->							Union[str, Any]:







				'''simple docstring'''





				__lowercase			  =							copy.deepcopy(self.__dict__	)

				if output["backbone_config"] is not None:
							__lowercase			  =							self.backbone_config.to_dict()

				__lowercase			  =							self.__class__.model_type
				return output





