



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 		UpperCAmelCase__			(			__UpperCamelCase						,__UpperCamelCase						,__UpperCamelCase						,unittest.TestCase   ):




			'''simple docstring'''






			UpperCamelCase									=       StableUnCLIPPipeline
			UpperCamelCase									=       TEXT_TO_IMAGE_PARAMS
			UpperCamelCase									=       TEXT_TO_IMAGE_BATCH_PARAMS
			UpperCamelCase									=       TEXT_TO_IMAGE_IMAGE_PARAMS
			UpperCamelCase									=       TEXT_TO_IMAGE_IMAGE_PARAMS

			# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
			UpperCamelCase									=       False




			def  snake_case__     (   self							: Optional[int] ):
					'''simple docstring'''





					__UpperCAmelCase    :     List[str]													=	32
					__UpperCAmelCase    :     Optional[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    :     Union[str, Any]													=	CLIPTextModelWithProjection(
					    CLIPTextConfig(
					        bos_token_id=0       ,       eos_token_id=2       ,       hidden_size=a_       ,       projection_dim=a_       ,       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    :     Dict													=	PriorTransformer(
					    num_attention_heads=2       ,       attention_head_dim=12       ,       embedding_dim=a_       ,       num_layers=1       ,       )

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

					# regular denoising components

					torch.manual_seed(0 )
					__UpperCAmelCase    :     List[str]													=	StableUnCLIPImageNormalizer(embedding_dim=a_ )
					__UpperCAmelCase    :     Any													=	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=a_       ,       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    :     Dict													=	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=a_       ,       layers_per_block=1       ,       upcast_attention=a_       ,       use_linear_projection=a_       ,       )

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

					torch.manual_seed(0 )
					__UpperCAmelCase    :     Any													=	AutoencoderKL()

					__UpperCAmelCase    :     Dict													=	{
					    # 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							: Tuple       ,       a_							: Tuple       ,       a_							: Dict=0 ):
					'''simple docstring'''





					if str(a_ ).startswith('''mps''' ):
							__UpperCAmelCase    :     Optional[Any]													=	torch.manual_seed(a_ )
					else:
							__UpperCAmelCase    :     List[str]													=	torch.Generator(device=a_ ).manual_seed(a_ )
					__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							: Any ):
					'''simple docstring'''





					__UpperCAmelCase    :     Optional[int]													=	torch_device == '''cpu'''

					self._test_attention_slicing_forward_pass(test_max_difference=a_ )




			def  snake_case__     (   self							: str ):
					'''simple docstring'''





					__UpperCAmelCase    :     Optional[int]													=	torch_device in ['''cpu''', '''mps''']

					self._test_inference_batch_single_identical(test_max_difference=a_ )

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




			'''simple docstring'''






			def  snake_case__     (   self							: Optional[int] ):
					'''simple docstring'''





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




			def  snake_case__     (   self							: Optional[Any] ):
					'''simple docstring'''





					__UpperCAmelCase    :     Dict													=	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(a_ )
					pipe.set_progress_bar_config(disable=a_ )
					# 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    :     str													=	torch.Generator(device='''cpu''' ).manual_seed(0 )
					__UpperCAmelCase    :     List[str]													=	pipe('''anime turle'''       ,       generator=a_       ,       output_type='''np''' )

					__UpperCAmelCase    :     List[Any]													=	output.images[0]

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

					assert_mean_pixel_difference(a_       ,       a_ )




			def  snake_case__     (   self							: Dict ):
					'''simple docstring'''





					torch.cuda.empty_cache()
					torch.cuda.reset_max_memory_allocated()
					torch.cuda.reset_peak_memory_stats()

					__UpperCAmelCase    :     Optional[Any]													=	StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''       ,       torch_dtype=torch.floataa )
					__UpperCAmelCase    :     Union[str, Any]													=	pipe.to(a_ )
					pipe.set_progress_bar_config(disable=a_ )
					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    :     List[Any]													=	torch.cuda.max_memory_allocated()
					# make sure that less than 7 GB is allocated
					assert mem_bytes < 7 * 10**9










from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
				from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


__A   			=logging.get_logger(__name__)

__A   			={
    "microsoft/deberta-v2-xlarge": "https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json",
    "microsoft/deberta-v2-xxlarge": "https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json",
    "microsoft/deberta-v2-xlarge-mnli": (
        "https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json"
    ),
    "microsoft/deberta-v2-xxlarge-mnli": (
        "https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json"
    ),
}

class 		UpperCAmelCase__			(			__UpperCamelCase   ):




			'''simple docstring'''






			UpperCamelCase									=       """deberta-v2"""




			def __init__(   self							: Optional[int]       ,       a_							: List[str]=12_81_00       ,       a_							: Optional[Any]=15_36       ,       a_							: Optional[Any]=24       ,       a_							: List[Any]=24       ,       a_							: Optional[int]=61_44       ,       a_							: List[Any]="gelu"       ,       a_							: Any=0.1       ,       a_							: Tuple=0.1       ,       a_							: Optional[Any]=5_12       ,       a_							: Tuple=0       ,       a_							: Dict=0.0_2       ,       a_							: Optional[Any]=1e-7       ,       a_							: List[str]=False       ,       a_							: List[Any]=-1       ,       a_							: List[str]=0       ,       a_							: Optional[Any]=True       ,       a_							: List[Any]=None       ,       a_							: Optional[int]=0       ,       a_							: Tuple="gelu"       ,       **a_							: List[str]       ,       ):
					'''simple docstring'''





					super().__init__(**a_ )

					__UpperCAmelCase    :     Any													=	hidden_size
					__UpperCAmelCase    :     Any													=	num_hidden_layers
					__UpperCAmelCase    :     List[Any]													=	num_attention_heads
					__UpperCAmelCase    :     Union[str, Any]													=	intermediate_size
					__UpperCAmelCase    :     List[str]													=	hidden_act
					__UpperCAmelCase    :     int													=	hidden_dropout_prob
					__UpperCAmelCase    :     List[str]													=	attention_probs_dropout_prob
					__UpperCAmelCase    :     str													=	max_position_embeddings
					__UpperCAmelCase    :     int													=	type_vocab_size
					__UpperCAmelCase    :     Tuple													=	initializer_range
					__UpperCAmelCase    :     Optional[int]													=	relative_attention
					__UpperCAmelCase    :     int													=	max_relative_positions
					__UpperCAmelCase    :     Any													=	pad_token_id
					__UpperCAmelCase    :     int													=	position_biased_input

					# Backwards compatibility
					if type(a_ ) == str:
							__UpperCAmelCase    :     Optional[Any]													=	[x.strip() for x in pos_att_type.lower().split('''|''' )]

					__UpperCAmelCase    :     Tuple													=	pos_att_type
					__UpperCAmelCase    :     int													=	vocab_size
					__UpperCAmelCase    :     Optional[Any]													=	layer_norm_eps

					__UpperCAmelCase    :     str													=	kwargs.get('''pooler_hidden_size'''       ,       a_ )
					__UpperCAmelCase    :     Union[str, Any]													=	pooler_dropout
					__UpperCAmelCase    :     Tuple													=	pooler_hidden_act

class 		UpperCAmelCase__			(			__UpperCamelCase   ):




			'''simple docstring'''






			@property
			def  snake_case__     (   self							: Optional[Any] ):
					'''simple docstring'''





					if self.task == "multiple-choice":
							__UpperCAmelCase    :     List[Any]													=	{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
					else:
							__UpperCAmelCase    :     int													=	{0: '''batch''', 1: '''sequence'''}
					if self._config.type_vocab_size > 0:
							return OrderedDict(
							    [('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ('''token_type_ids''', dynamic_axis)] )
					else:
							return OrderedDict([('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis)] )




			@property
			def  snake_case__     (   self							: Union[str, Any] ):
					'''simple docstring'''





					return 12




			def  snake_case__     (   self							: Any       ,       a_							: Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]       ,       a_							: int = -1       ,       a_							: int = -1       ,       a_							: int = -1       ,       a_							: bool = False       ,       a_							: Optional["TensorType"] = None       ,       a_							: int = 3       ,       a_							: int = 40       ,       a_							: int = 40       ,       a_							: "PreTrainedTokenizerBase" = None       ,       ):
					'''simple docstring'''





					__UpperCAmelCase    :     List[Any]													=	super().generate_dummy_inputs(preprocessor=a_       ,       framework=a_ )
					if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
							del dummy_inputs["token_type_ids"]
					return dummy_inputs





