


import gc
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class _lowerCamelCase(		_a,				_a,				unittest.TestCase     ):
       lowercase_				:			Dict									=    StableDiffusionXLImgaImgPipeline
       lowercase_				:			Tuple									=    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
       lowercase_				:			List[str]									=    PipelineTesterMixin.required_optional_params - {"""latents"""}
       lowercase_				:			Optional[Any]									=    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
       lowercase_				:			Tuple									=    IMAGE_TO_IMAGE_IMAGE_PARAMS
       lowercase_				:			Union[str, Any]									=    IMAGE_TO_IMAGE_IMAGE_PARAMS
       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           torch.manual_seed(0)
           _lowercase :							Optional[int]   	=	UNetaDConditionModel(
               block_out_channels=(32, 64),   layers_per_block=2,   sample_size=32,   in_channels=4,   out_channels=4,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),   up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'),   attention_head_dim=(2, 4),   use_linear_projection=lowerCamelCase,   addition_embed_type='text_time',   addition_time_embed_dim=8,   transformer_layers_per_block=(1, 2),   projection_class_embeddings_input_dim=80,   cross_attention_dim=64,   )
           _lowercase :							Tuple   	=	EulerDiscreteScheduler(
               beta_start=0.0_0_0_8_5,   beta_end=0.0_1_2,   steps_offset=1,   beta_schedule='scaled_linear',   timestep_spacing='leading',   )
           torch.manual_seed(0)
           _lowercase :							Dict   	=	AutoencoderKL(
               block_out_channels=[32, 64],   in_channels=3,   out_channels=3,   down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'],   up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'],   latent_channels=4,   sample_size=1_28,   )
           torch.manual_seed(0)
           _lowercase :							Dict   	=	CLIPTextConfig(
               bos_token_id=0,   eos_token_id=2,   hidden_size=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,   hidden_act='gelu',   projection_dim=32,   )
           _lowercase :							Optional[int]   	=	CLIPTextModel(lowerCamelCase)
           _lowercase :							List[str]   	=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip',   local_files_only=lowerCamelCase)

           _lowercase :							str   	=	CLIPTextModelWithProjection(lowerCamelCase)
           _lowercase :							str   	=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip',   local_files_only=lowerCamelCase)

           _lowercase :							int   	=	{
               'unet': unet,
               'scheduler': scheduler,
               'vae': vae,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'text_encoder_2': text_encoder_a,
               'tokenizer_2': tokenizer_a,
               # "safety_checker": None,
               # "feature_extractor": None,
           }
           return components
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase=0) ->     List[str]:




           """simple docstring"""

           _lowercase :							Dict   	=	floats_tensor((1, 3, 32, 32),   rng=random.Random(lowerCamelCase)).to(lowerCamelCase)
           _lowercase :							Tuple   	=	image / 2 + 0.5
           if str(lowerCamelCase).startswith('mps'):
               _lowercase :							Union[str, Any]   	=	torch.manual_seed(lowerCamelCase)
           else:
               _lowercase :							Optional[int]   	=	torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase)
           _lowercase :							Optional[int]   	=	{
               'prompt': 'A painting of a squirrel eating a burger',
               'image': image,
               'generator': generator,
               'num_inference_steps': 2,
               'guidance_scale': 5.0,
               'output_type': 'numpy',
               'strength': 0.7_5,
           }
           return inputs
       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	'cpu'  # ensure determinism for the device-dependent torch.Generator
           _lowercase :							List[Any]   	=	self.get_dummy_components()
           _lowercase :							Dict   	=	StableDiffusionXLImgaImgPipeline(**lowerCamelCase)
           _lowercase :							Optional[int]   	=	sd_pipe.to(lowerCamelCase)
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase)

           _lowercase :							Any   	=	self.get_dummy_inputs(lowerCamelCase)
           _lowercase :							Dict   	=	sd_pipe(**lowerCamelCase).images
           _lowercase :							List[str]   	=	image[0, -3:, -3:, -1]

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

           _lowercase :							Union[str, Any]   	=	np.array([0.4_6_5_6, 0.4_8_4_0, 0.4_4_3_9, 0.6_6_9_8, 0.5_5_7_4, 0.4_5_2_4, 0.5_7_9_9, 0.5_9_4_3, 0.5_1_6_5])

           assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           super().test_attention_slicing_forward_pass(expected_max_diff=3E-3)
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           super().test_inference_batch_single_identical(expected_max_diff=3E-3)
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           pass




       def     UpperCamelCase  (      self) ->     List[Any]:




           """simple docstring"""

           _lowercase :							int   	=	self.get_dummy_components()
           _lowercase :							Any   	=	StableDiffusionXLImgaImgPipeline(**lowerCamelCase)
           _lowercase :							Dict   	=	sd_pipe.to(lowerCamelCase)
           _lowercase :							Optional[int]   	=	sd_pipe.to(lowerCamelCase)
           sd_pipe.set_progress_bar_config(disable=lowerCamelCase)

           # forward without prompt embeds
           _lowercase :							List[Any]   	=	self.get_dummy_inputs(lowerCamelCase)
           _lowercase :							Union[str, Any]   	=	3 * ['this is a negative prompt']
           _lowercase :							Optional[Any]   	=	negative_prompt
           _lowercase :							int   	=	3 * [inputs['prompt']]

           _lowercase :							Optional[Any]   	=	sd_pipe(**lowerCamelCase)
           _lowercase :							Optional[int]   	=	output.images[0, -3:, -3:, -1]

           # forward with prompt embeds
           _lowercase :							str   	=	self.get_dummy_inputs(lowerCamelCase)
           _lowercase :							Optional[int]   	=	3 * ['this is a negative prompt']
           _lowercase :							Tuple   	=	3 * [inputs.pop('prompt')]

           (
               (
               _lowercase
           )	,       (
               _lowercase
           )	,       (
               _lowercase
           )	,       (
               _lowercase
           )	,       
           ) :							Optional[int]   	=	sd_pipe.encode_prompt(lowerCamelCase,   negative_prompt=lowerCamelCase)

           _lowercase :							Union[str, Any]   	=	sd_pipe(
               **lowerCamelCase,   prompt_embeds=lowerCamelCase,   negative_prompt_embeds=lowerCamelCase,   pooled_prompt_embeds=lowerCamelCase,   negative_pooled_prompt_embeds=lowerCamelCase,   )
           _lowercase :							Optional[int]   	=	output.images[0, -3:, -3:, -1]

           # make sure that it's equal
           assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1E-4






@slow
@require_torch_gpu
class _lowerCamelCase(		unittest.TestCase     ):
       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase="cpu",   lowerCamelCase=torch.floataa,   lowerCamelCase=0) ->     List[str]:




           """simple docstring"""

           _lowercase :							List[Any]   	=	torch.Generator(device=lowerCamelCase).manual_seed(lowerCamelCase)
           _lowercase :							str   	=	np.random.RandomState(lowerCamelCase).standard_normal((1, 4, 64, 64))
           _lowercase :							str   	=	torch.from_numpy(lowerCamelCase).to(device=lowerCamelCase,   dtype=lowerCamelCase)
           _lowercase :							Optional[int]   	=	{
               'prompt': 'a photograph of an astronaut riding a horse',
               'latents': latents,
               'generator': generator,
               'num_inference_steps': 3,
               'guidance_scale': 7.5,
               'output_type': 'numpy',
           }
           return inputs




       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Dict   	=	DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base')
           pipe.to(lowerCamelCase)
           pipe.set_progress_bar_config(disable=lowerCamelCase)

           _lowercase :							Tuple   	=	self.get_inputs(lowerCamelCase)
           _lowercase :							Optional[int]   	=	pipe(**lowerCamelCase).images
           _lowercase :							List[Any]   	=	image[0, -3:, -3:, -1].flatten()

           assert image.shape == (1, 5_12, 5_12, 3)
           _lowercase :							Dict   	=	np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6])
           assert np.abs(image_slice - expected_slice).max() < 7E-3






import unittest

from transformers import DebertaVaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     DebertaVaForMaskedLM,
     DebertaVaForMultipleChoice,
     DebertaVaForQuestionAnswering,
     DebertaVaForSequenceClassification,
     DebertaVaForTokenClassification,
     DebertaVaModel,
 )
 from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST






class _lowerCamelCase(		_a     ):
       def __init__(      self,   lowerCamelCase,   lowerCamelCase=13,   lowerCamelCase=7,   lowerCamelCase=True,   lowerCamelCase=True,   lowerCamelCase=True,   lowerCamelCase=True,   lowerCamelCase=99,   lowerCamelCase=32,   lowerCamelCase=5,   lowerCamelCase=4,   lowerCamelCase=37,   lowerCamelCase="gelu",   lowerCamelCase=0.1,   lowerCamelCase=0.1,   lowerCamelCase=5_12,   lowerCamelCase=16,   lowerCamelCase=2,   lowerCamelCase=0.0_2,   lowerCamelCase=False,   lowerCamelCase=True,   lowerCamelCase="None",   lowerCamelCase=3,   lowerCamelCase=4,   lowerCamelCase=None,   ) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	parent
           _lowercase :							Optional[Any]   	=	batch_size
           _lowercase :							Optional[Any]   	=	seq_length
           _lowercase :							Dict   	=	is_training
           _lowercase :							Optional[Any]   	=	use_input_mask
           _lowercase :							Optional[int]   	=	use_token_type_ids
           _lowercase :							str   	=	use_labels
           _lowercase :							List[Any]   	=	vocab_size
           _lowercase :							Dict   	=	hidden_size
           _lowercase :							Any   	=	num_hidden_layers
           _lowercase :							Union[str, Any]   	=	num_attention_heads
           _lowercase :							int   	=	intermediate_size
           _lowercase :							List[str]   	=	hidden_act
           _lowercase :							Tuple   	=	hidden_dropout_prob
           _lowercase :							Optional[Any]   	=	attention_probs_dropout_prob
           _lowercase :							int   	=	max_position_embeddings
           _lowercase :							Any   	=	type_vocab_size
           _lowercase :							Tuple   	=	type_sequence_label_size
           _lowercase :							List[Any]   	=	initializer_range
           _lowercase :							Optional[Any]   	=	num_labels
           _lowercase :							Tuple   	=	num_choices
           _lowercase :							Dict   	=	relative_attention
           _lowercase :							Optional[int]   	=	position_biased_input
           _lowercase :							str   	=	pos_att_type
           _lowercase :							Optional[Any]   	=	scope
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							int   	=	ids_tensor([self.batch_size, self.seq_length],   self.vocab_size)

           _lowercase :							Union[str, Any]   	=	None
           if self.use_input_mask:
               _lowercase :							int   	=	ids_tensor([self.batch_size, self.seq_length],   vocab_size=2)

           _lowercase :							Tuple   	=	None
           if self.use_token_type_ids:
               _lowercase :							Tuple   	=	ids_tensor([self.batch_size, self.seq_length],   self.type_vocab_size)

           _lowercase :							Union[str, Any]   	=	None
           _lowercase :							Tuple   	=	None
           _lowercase :							str   	=	None
           if self.use_labels:
               _lowercase :							List[Any]   	=	ids_tensor([self.batch_size],   self.type_sequence_label_size)
               _lowercase :							Optional[int]   	=	ids_tensor([self.batch_size, self.seq_length],   self.num_labels)
               _lowercase :							str   	=	ids_tensor([self.batch_size],   self.num_choices)

           _lowercase :							Union[str, Any]   	=	self.get_config()

           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           return DebertaVaConfig(
               vocab_size=self.vocab_size,   hidden_size=self.hidden_size,   num_hidden_layers=self.num_hidden_layers,   num_attention_heads=self.num_attention_heads,   intermediate_size=self.intermediate_size,   hidden_act=self.hidden_act,   hidden_dropout_prob=self.hidden_dropout_prob,   attention_probs_dropout_prob=self.attention_probs_dropout_prob,   max_position_embeddings=self.max_position_embeddings,   type_vocab_size=self.type_vocab_size,   initializer_range=self.initializer_range,   relative_attention=self.relative_attention,   position_biased_input=self.position_biased_input,   pos_att_type=self.pos_att_type,   )
       def     UpperCamelCase  (      self,   lowerCamelCase) ->     int:




           """simple docstring"""

           self.parent.assertListEqual(list(result.loss.size()),   [])
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     Union[str, Any]:




           """simple docstring"""

           _lowercase :							List[str]   	=	DebertaVaModel(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase :							int   	=	model(lowerCamelCase,   attention_mask=lowerCamelCase,   token_type_ids=lowerCamelCase)[0]
           _lowercase :							Optional[int]   	=	model(lowerCamelCase,   token_type_ids=lowerCamelCase)[0]
           _lowercase :							Dict   	=	model(lowerCamelCase)[0]

           self.parent.assertListEqual(list(sequence_output.size()),   [self.batch_size, self.seq_length, self.hidden_size])
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     List[Any]:




           """simple docstring"""

           _lowercase :							List[Any]   	=	DebertaVaForMaskedLM(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase :							str   	=	model(lowerCamelCase,   attention_mask=lowerCamelCase,   token_type_ids=lowerCamelCase,   labels=lowerCamelCase)

           self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.seq_length, self.vocab_size))
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     List[str]:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	self.num_labels
           _lowercase :							Any   	=	DebertaVaForSequenceClassification(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase :							Any   	=	model(lowerCamelCase,   attention_mask=lowerCamelCase,   token_type_ids=lowerCamelCase,   labels=lowerCamelCase)
           self.parent.assertListEqual(list(result.logits.size()),   [self.batch_size, self.num_labels])
           self.check_loss_output(lowerCamelCase)
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	self.num_labels
           _lowercase :							Optional[int]   	=	DebertaVaForTokenClassification(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase :							Optional[Any]   	=	model(lowerCamelCase,   attention_mask=lowerCamelCase,   token_type_ids=lowerCamelCase,   labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.seq_length, self.num_labels))
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     Union[str, Any]:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	DebertaVaForQuestionAnswering(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase :							Union[str, Any]   	=	model(
               lowerCamelCase,   attention_mask=lowerCamelCase,   token_type_ids=lowerCamelCase,   start_positions=lowerCamelCase,   end_positions=lowerCamelCase,   )
           self.parent.assertEqual(result.start_logits.shape,   (self.batch_size, self.seq_length))
           self.parent.assertEqual(result.end_logits.shape,   (self.batch_size, self.seq_length))
       def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase,   lowerCamelCase) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Any   	=	DebertaVaForMultipleChoice(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase :							Optional[int]   	=	input_ids.unsqueeze(1).expand(-1,   self.num_choices,   -1).contiguous()
           _lowercase :							List[Any]   	=	token_type_ids.unsqueeze(1).expand(-1,   self.num_choices,   -1).contiguous()
           _lowercase :							int   	=	input_mask.unsqueeze(1).expand(-1,   self.num_choices,   -1).contiguous()
           _lowercase :							str   	=	model(
               lowerCamelCase,   attention_mask=lowerCamelCase,   token_type_ids=lowerCamelCase,   labels=lowerCamelCase,   )
           self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.num_choices))




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




           """simple docstring"""

           _lowercase :							Any   	=	self.prepare_config_and_inputs()
           (
               (
               _lowercase
           )	,       (
               _lowercase
           )	,       (
               _lowercase
           )	,       (
               _lowercase
           )	,       (
               _lowercase
           )	,       (
               _lowercase
           )	,       (
               _lowercase
           )	,       
           ) :							List[str]   	=	config_and_inputs
           _lowercase :							int   	=	{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
           return config, inputs_dict






@require_torch
class _lowerCamelCase(		_a,				_a,				unittest.TestCase     ):
       lowercase_				:			Any									=    (
           (
               DebertaVaModel,
               DebertaVaForMaskedLM,
               DebertaVaForSequenceClassification,
               DebertaVaForTokenClassification,
               DebertaVaForQuestionAnswering,
               DebertaVaForMultipleChoice,
           )
           if is_torch_available()
           else ()
       )
       lowercase_				:			Any									=    (
           {
               """feature-extraction""": DebertaVaModel,
               """fill-mask""": DebertaVaForMaskedLM,
               """question-answering""": DebertaVaForQuestionAnswering,
               """text-classification""": DebertaVaForSequenceClassification,
               """token-classification""": DebertaVaForTokenClassification,
               """zero-shot""": DebertaVaForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )

       lowercase_				:			int									=    True
       lowercase_				:			str									=    False
       lowercase_				:			str									=    False
       lowercase_				:			str									=    False
       lowercase_				:			List[Any]									=    False
       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           _lowercase :							List[Any]   	=	DebertaVaModelTester(self)
           _lowercase :							List[Any]   	=	ConfigTester(self,   config_class=lowerCamelCase,   hidden_size=37)
       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           self.config_tester.run_common_tests()
       def     UpperCamelCase  (      self) ->     Union[str, Any]:




           """simple docstring"""

           _lowercase :							Tuple   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_deberta_model(*lowerCamelCase)
       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							int   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_deberta_for_sequence_classification(*lowerCamelCase)
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_deberta_for_masked_lm(*lowerCamelCase)
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           _lowercase :							List[Any]   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_deberta_for_question_answering(*lowerCamelCase)
       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_deberta_for_token_classification(*lowerCamelCase)
       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							Tuple   	=	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_deberta_for_multiple_choice(*lowerCamelCase)




       @slow
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _lowercase :							Dict   	=	DebertaVaModel.from_pretrained(lowerCamelCase)
               self.assertIsNotNone(lowerCamelCase)






@require_torch
@require_sentencepiece
@require_tokenizers
class _lowerCamelCase(		unittest.TestCase     ):
       @unittest.skip(reason='Model not available yet')
       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           pass




       @slow
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Dict   	=	DebertaVaModel.from_pretrained('microsoft/deberta-v2-xlarge')

           _lowercase :							str   	=	torch.tensor([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]])
           _lowercase :							Any   	=	torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
           with torch.no_grad():
               _lowercase :							Tuple   	=	model(lowerCamelCase,   attention_mask=lowerCamelCase)[0]
           # compare the actual values for a slice.
           _lowercase :							int   	=	torch.tensor(
               [[[0.2_3_5_6, 0.1_9_4_8, 0.0_3_6_9], [-0.1_0_6_3, 0.3_5_8_6, -0.5_1_5_2], [-0.6_3_9_9, -0.0_2_5_9, -0.2_5_2_5]]])
           self.assertTrue(torch.allclose(output[:, 1:4, 1:4],   lowerCamelCase,   atol=1E-4),   F'''{output[:, 1:4, 1:4]}''')


