



"""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    __lowercase     (					_UpperCAmelCase					,    _UpperCAmelCase					,    _UpperCAmelCase					,    unittest.TestCase):







						"""simple docstring"""







						_A		:							int							       =		StableUnCLIPPipeline
						_A		:							Union[str, Any]							       =		TEXT_TO_IMAGE_PARAMS
						_A		:							Any							       =		TEXT_TO_IMAGE_BATCH_PARAMS
						_A		:							Optional[Any]							       =		TEXT_TO_IMAGE_IMAGE_PARAMS
						_A		:							Any							       =		TEXT_TO_IMAGE_IMAGE_PARAMS

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







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		List[str] 					=					32
											snake_case_					:		List[str] 					=					embedder_hidden_size

											# prior components

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

											torch.manual_seed(0       )
											snake_case_					:		Union[str, Any] 					=					CLIPTextModelWithProjection(
											    CLIPTextConfig(
											        bos_token_id=0   ,		eos_token_id=2   ,		hidden_size=lowercase__   ,		projection_dim=lowercase__   ,		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       )
											snake_case_					:		Union[str, Any] 					=					PriorTransformer(
											    num_attention_heads=2   ,		attention_head_dim=12   ,		embedding_dim=lowercase__   ,		num_layers=1   ,		)

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

											# regular denoising components

											torch.manual_seed(0       )
											snake_case_					:		int 					=					StableUnCLIPImageNormalizer(embedding_dim=lowercase__       )
											snake_case_					:		List[Any] 					=					DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""       )

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

											torch.manual_seed(0       )
											snake_case_					:		Optional[int] 					=					CLIPTextModel(
											    CLIPTextConfig(
											        bos_token_id=0   ,		eos_token_id=2   ,		hidden_size=lowercase__   ,		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       )
											snake_case_					:		Union[str, Any] 					=					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=lowercase__   ,		layers_per_block=1   ,		upcast_attention=lowercase__   ,		use_linear_projection=lowercase__   ,		)

											torch.manual_seed(0       )
											snake_case_					:		str 					=					DDIMScheduler(
											    beta_schedule="""scaled_linear"""   ,		beta_start=0.00085   ,		beta_end=0.012   ,		prediction_type="""v_prediction"""   ,		set_alpha_to_one=lowercase__   ,		steps_offset=1   ,		)

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

											snake_case_					:		Union[str, Any] 					=					{
											    # 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 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__=0       ):
											if str(lowercase__       ).startswith("""mps"""       ):
																snake_case_					:		Optional[Any] 					=					torch.manual_seed(lowercase__       )
											else:
																snake_case_					:		List[Any] 					=					torch.Generator(device=lowercase__       ).manual_seed(lowercase__       )
											snake_case_					:		Dict 					=					{
											    """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 						__UpperCamelCase							(self       ):
											snake_case_					:		int 					=					torch_device == """cpu"""

											self._test_attention_slicing_forward_pass(test_max_difference=lowercase__       )







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Any 					=					torch_device in ["""cpu""", """mps"""]

											self._test_inference_batch_single_identical(test_max_difference=lowercase__       )







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







						"""simple docstring"""







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







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Optional[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"""       )

											snake_case_					:		Dict 					=					StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""   ,		torch_dtype=torch.floataa       )
											pipe.to(lowercase__       )
											pipe.set_progress_bar_config(disable=lowercase__       )
											# 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()

											snake_case_					:		int 					=					torch.Generator(device="""cpu"""       ).manual_seed(0       )
											snake_case_					:		List[str] 					=					pipe("""anime turle"""   ,		generator=lowercase__   ,		output_type="""np"""       )

											snake_case_					:		Tuple 					=					output.images[0]

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

											assert_mean_pixel_difference(lowercase__   ,		lowercase__       )







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

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

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

											snake_case_					:		Tuple 					=					torch.cuda.max_memory_allocated()
											# make sure that less than 7 GB is allocated
											assert mem_bytes < 7 * 10**9









"""simple docstring"""

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    __lowercase     (					_UpperCAmelCase):







						"""simple docstring"""







						_A		:							Dict							       =		"""deberta-v2"""







						def __init__(self   ,		lowercase__=12_81_00   ,		lowercase__=15_36   ,		lowercase__=24   ,		lowercase__=24   ,		lowercase__=61_44   ,		lowercase__="gelu"   ,		lowercase__=0.1   ,		lowercase__=0.1   ,		lowercase__=5_12   ,		lowercase__=0   ,		lowercase__=0.02   ,		lowercase__=1e-7   ,		lowercase__=False   ,		lowercase__=-1   ,		lowercase__=0   ,		lowercase__=True   ,		lowercase__=None   ,		lowercase__=0   ,		lowercase__="gelu"   ,		**lowercase__   ,		):
											super().__init__(**lowercase__       )

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

											# Backwards compatibility
											if type(lowercase__       ) == str:
																snake_case_					:		Union[str, Any] 					=					[x.strip() for x in pos_att_type.lower().split("""|"""       )]

											snake_case_					:		Optional[int] 					=					pos_att_type
											snake_case_					:		List[str] 					=					vocab_size
											snake_case_					:		Tuple 					=					layer_norm_eps

											snake_case_					:		List[Any] 					=					kwargs.get("""pooler_hidden_size"""   ,		lowercase__       )
											snake_case_					:		List[str] 					=					pooler_dropout
											snake_case_					:		int 					=					pooler_hidden_act







class    __lowercase     (					_UpperCAmelCase):







						"""simple docstring"""







						@property
						def 						__UpperCamelCase							(self       ):
											if self.task == "multiple-choice":
																snake_case_					:		List[Any] 					=					{0: """batch""", 1: """choice""", 2: """sequence"""}
											else:
																snake_case_					:		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 						__UpperCamelCase							(self       ):
											return 12







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__ = -1   ,		lowercase__ = -1   ,		lowercase__ = -1   ,		lowercase__ = False   ,		lowercase__ = None   ,		lowercase__ = 3   ,		lowercase__ = 40   ,		lowercase__ = 40   ,		lowercase__ = None   ,		):
											snake_case_					:		str 					=					super().generate_dummy_inputs(preprocessor=lowercase__   ,		framework=lowercase__       )
											if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
																del dummy_inputs["token_type_ids"]
											return dummy_inputs




