



"""simple docstring"""


import tempfile
import unittest

from transformers import TaConfig, is_torch_available
from transformers.testing_utils import (
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
    torch_device,
)

from ...generation.test_utils import GenerationTesterMixin
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel







class 				A_      :



      """simple docstring"""






      def __init__( self			:Tuple       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:int=99       ,  lowercase_			:Dict=13       ,  lowercase_			:List[str]=7       ,  lowercase_			:Optional[int]=9       ,  lowercase_			:int=True       ,  lowercase_			:str=True       ,  lowercase_			:Optional[int]=False       ,  lowercase_			:Any=32       ,  lowercase_			:str=5       ,  lowercase_			:int=4       ,  lowercase_			:List[Any]=37       ,  lowercase_			:Any=8       ,  lowercase_			:str=0.1       ,  lowercase_			:Any=0.002       ,  lowercase_			:Any=1       ,  lowercase_			:Tuple=0       ,  lowercase_			:Tuple=0       ,  lowercase_			:Tuple=None       ,  lowercase_			:Union[str, Any]=None       ,  )    ->      str:
            UpperCAmelCase					=			parent
            UpperCAmelCase					=			batch_size
            UpperCAmelCase					=			encoder_seq_length
            UpperCAmelCase					=			decoder_seq_length
            # For common tests
            UpperCAmelCase					=			self.decoder_seq_length
            UpperCAmelCase					=			is_training
            UpperCAmelCase					=			use_attention_mask
            UpperCAmelCase					=			use_labels
            UpperCAmelCase					=			vocab_size
            UpperCAmelCase					=			hidden_size
            UpperCAmelCase					=			num_hidden_layers
            UpperCAmelCase					=			num_attention_heads
            UpperCAmelCase					=			d_ff
            UpperCAmelCase					=			relative_attention_num_buckets
            UpperCAmelCase					=			dropout_rate
            UpperCAmelCase					=			initializer_factor
            UpperCAmelCase					=			eos_token_id
            UpperCAmelCase					=			pad_token_id
            UpperCAmelCase					=			decoder_start_token_id
            UpperCAmelCase					=			None
            UpperCAmelCase					=			decoder_layers






      def      UpperCAmelCase__					( self			:Optional[int] )    ->      Optional[int]:
            return TaConfig.from_pretrained('google/umt5-base' )






      def      UpperCAmelCase__					( self			:int       ,  lowercase_			:str       ,  lowercase_			:Any       ,  lowercase_			:List[Any]       ,  lowercase_			:int=None       ,  lowercase_			:str=None       ,  lowercase_			:Dict=None       ,  lowercase_			:List[str]=None       ,  lowercase_			:int=None       ,  )    ->      Union[str, Any]:


            if attention_mask is None:
                  UpperCAmelCase					=			input_ids.ne(config.pad_token_id )
            if decoder_attention_mask is None:
                  UpperCAmelCase					=			decoder_input_ids.ne(config.pad_token_id )
            if head_mask is None:
                  UpperCAmelCase					=			torch.ones(config.num_hidden_layers       ,  config.num_attention_heads       ,  device=UpperCamelCase__ )
            if decoder_head_mask is None:
                  UpperCAmelCase					=			torch.ones(config.num_decoder_layers       ,  config.num_attention_heads       ,  device=UpperCamelCase__ )
            if cross_attn_head_mask is None:
                  UpperCAmelCase					=			torch.ones(
                      config.num_decoder_layers       ,  config.num_attention_heads       ,  device=UpperCamelCase__ )
            return {
                "input_ids": input_ids,
                "decoder_input_ids": decoder_input_ids,
                "attention_mask": attention_mask,
                "decoder_attention_mask": decoder_attention_mask,
                "head_mask": head_mask,
                "decoder_head_mask": decoder_head_mask,
                "cross_attn_head_mask": cross_attn_head_mask,
            }






      def      UpperCAmelCase__					( self			:Any )    ->      Dict:
            UpperCAmelCase					=			ids_tensor([self.batch_size, self.encoder_seq_length]       ,  self.vocab_size )
            UpperCAmelCase					=			ids_tensor([self.batch_size, self.decoder_seq_length]       ,  self.vocab_size )

            # we need to clamp the input ids here to avoid having pad token in between
            # this is because for NllbMoe the position_ids are prepared such that
            # all pad tokens have pos id = 2 and rest are between 2..seq_length
            # and the seq_length here is seq_length - num_pad_tokens
            # but when using past, there is no way of knowing if the past input ids had
            # pad tokens in them, which results in incorrect seq_lenth and which in turn results in
            # position_ids being off by num_pad_tokens in past input
            UpperCAmelCase					=			input_ids.clamp(self.pad_token_id + 1 )
            UpperCAmelCase					=			decoder_input_ids.clamp(self.pad_token_id + 1 )

            UpperCAmelCase					=			self.get_config()
            UpperCAmelCase					=			config.num_attention_heads
            UpperCAmelCase					=			self.prepare_inputs_dict(UpperCamelCase__       ,  UpperCamelCase__       ,  UpperCamelCase__ )
            return config, input_dict






      def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[int]:
            UpperCAmelCase					=			self.prepare_config_and_inputs()
            return config, inputs_dict






      def      UpperCAmelCase__					( self			:Tuple )    ->      Optional[int]:
            return TaConfig(
                vocab_size=1_66       ,  d_model=self.hidden_size       ,  d_ff=self.d_ff       ,  d_kv=self.hidden_size // self.num_attention_heads       ,  num_layers=self.num_hidden_layers       ,  num_decoder_layers=self.decoder_layers       ,  num_heads=self.num_attention_heads       ,  relative_attention_num_buckets=self.relative_attention_num_buckets       ,  dropout_rate=self.dropout_rate       ,  initializer_factor=self.initializer_factor       ,  eos_token_id=self.eos_token_id       ,  bos_token_id=self.pad_token_id       ,  pad_token_id=self.pad_token_id       ,  decoder_start_token_id=self.decoder_start_token_id       ,  )






      def      UpperCAmelCase__					( self			:List[str] )    ->      str:
            return TaConfig(
                vocab_size=self.vocab_size       ,  d_model=self.hidden_size       ,  d_ff=self.d_ff       ,  d_kv=self.hidden_size // self.num_attention_heads       ,  num_layers=self.num_hidden_layers       ,  num_decoder_layers=self.decoder_layers       ,  num_heads=self.num_attention_heads       ,  relative_attention_num_buckets=self.relative_attention_num_buckets       ,  dropout_rate=self.dropout_rate       ,  initializer_factor=self.initializer_factor       ,  eos_token_id=self.eos_token_id       ,  bos_token_id=self.pad_token_id       ,  pad_token_id=self.pad_token_id       ,  decoder_start_token_id=self.decoder_start_token_id       ,  )






      def      UpperCAmelCase__					( self			:Tuple       ,  lowercase_			:Tuple       ,  lowercase_			:Dict       ,  lowercase_			:Dict       ,  lowercase_			:List[Any]       ,  lowercase_			:Optional[Any]       ,  lowercase_			:str       ,  )    ->      int:
            UpperCAmelCase					=			UMTaModel(config=UpperCamelCase__ )
            model.to(UpperCamelCase__ )
            model.eval()
            UpperCAmelCase					=			model(
                input_ids=UpperCamelCase__       ,  decoder_input_ids=UpperCamelCase__       ,  attention_mask=UpperCamelCase__       ,  decoder_attention_mask=UpperCamelCase__       ,  )
            UpperCAmelCase					=			model(input_ids=UpperCamelCase__       ,  decoder_input_ids=UpperCamelCase__ )
            UpperCAmelCase					=			result.last_hidden_state
            UpperCAmelCase					=			result.past_key_values
            UpperCAmelCase					=			result.encoder_last_hidden_state

            self.parent.assertEqual(encoder_output.size()       ,  (self.batch_size, self.encoder_seq_length, self.hidden_size) )
            self.parent.assertEqual(decoder_output.size()       ,  (self.batch_size, self.decoder_seq_length, self.hidden_size) )
            # There should be `num_layers` key value embeddings stored in decoder_past
            self.parent.assertEqual(len(UpperCamelCase__ )       ,  config.num_layers )
            # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple
            self.parent.assertEqual(len(decoder_past[0] )       ,  4 )






      def      UpperCAmelCase__					( self			:Optional[int]       ,  lowercase_			:Optional[int]       ,  lowercase_			:List[Any]       ,  lowercase_			:str       ,  lowercase_			:str       ,  lowercase_			:Optional[int]       ,  lowercase_			:Optional[Any]       ,  )    ->      Tuple:
            UpperCAmelCase					=			UMTaModel(config=UpperCamelCase__ ).get_decoder().to(UpperCamelCase__ ).eval()
            # first forward pass
            UpperCAmelCase					=			model(UpperCamelCase__       ,  use_cache=UpperCamelCase__ )
            UpperCAmelCase					=			model(UpperCamelCase__ )
            UpperCAmelCase					=			model(UpperCamelCase__       ,  use_cache=UpperCamelCase__ )

            self.parent.assertTrue(len(UpperCamelCase__ ) == len(UpperCamelCase__ ) )
            self.parent.assertTrue(len(UpperCamelCase__ ) == len(UpperCamelCase__ ) + 1 )

            UpperCAmelCase					=			outputs.to_tuple()

            # create hypothetical next token and extent to next_input_ids
            UpperCAmelCase					=			ids_tensor((self.batch_size, 1)       ,  config.vocab_size )

            # append to next input_ids and
            UpperCAmelCase					=			torch.cat([input_ids, next_tokens]       ,  dim=-1 )

            UpperCAmelCase					=			model(UpperCamelCase__ )["last_hidden_state"]
            UpperCAmelCase					=			model(UpperCamelCase__       ,  past_key_values=UpperCamelCase__ )["last_hidden_state"]

            # select random slice
            UpperCAmelCase					=			ids_tensor((1,)       ,  output_from_past.shape[-1] ).item()
            UpperCAmelCase					=			output_from_no_past[:, -1, random_slice_idx].detach()
            UpperCAmelCase					=			output_from_past[:, 0, random_slice_idx].detach()

            # test that outputs are equal for slice
            self.parent.assertTrue(torch.allclose(UpperCamelCase__       ,  UpperCamelCase__       ,  atol=1E-3 ) )






      def      UpperCAmelCase__					( self			:Optional[Any]       ,  lowercase_			:int       ,  lowercase_			:str       ,  )    ->      int:
            UpperCAmelCase					=			UMTaModel(config=UpperCamelCase__ ).to(UpperCamelCase__ ).half().eval()
            UpperCAmelCase					=			model(**UpperCamelCase__ )["last_hidden_state"]
            self.parent.assertFalse(torch.isnan(UpperCamelCase__ ).any().item() )







@require_torch
class 				A_      (					__snake_case     ,       __snake_case     ,       __snake_case     ,       unittest.TestCase    ):



      """simple docstring"""
      __UpperCamelCase		    =							(
          (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else ()
      )
      __UpperCamelCase		    =							(UMTaForConditionalGeneration,) if is_torch_available() else ()
      __UpperCamelCase		    =							(
          {
              """conversational""": UMTaForConditionalGeneration,
              """feature-extraction""": UMTaModel,
              """summarization""": UMTaForConditionalGeneration,
              """text2text-generation""": UMTaForConditionalGeneration,
              """translation""": UMTaForConditionalGeneration,
              """question-answering""": UMTaForQuestionAnswering,
          }
          if is_torch_available()
          else {}
      )
      __UpperCamelCase		    =							True
      __UpperCamelCase		    =							False
      __UpperCamelCase		    =							False
      __UpperCamelCase		    =							True
      __UpperCamelCase		    =							True
      # The small UMT5 model needs higher percentages for CPU/MP tests
      __UpperCamelCase		    =							[0.8, 0.9]






      def      UpperCAmelCase__					( self			:List[str] )    ->      str:
            UpperCAmelCase					=			UMTaModelTester(self )






      @unittest.skip('Test has a segmentation fault on torch 1.8.0' )
      def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      List[Any]:
            UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
            UpperCAmelCase					=			UMTaModel(config_and_inputs[0] ).to(UpperCamelCase__ )
            with tempfile.TemporaryDirectory() as tmpdirname:
                  torch.onnx.export(
                      UpperCamelCase__       ,  (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2])       ,  f"""{tmpdirname}/t5_test.onnx"""       ,  export_params=UpperCamelCase__       ,  opset_version=9       ,  input_names=['input_ids', 'decoder_input_ids']       ,  )






      @unittest.skipIf(torch_device == 'cpu'       ,  'Cant do half precision' )
      def      UpperCAmelCase__					( self			:int )    ->      List[str]:
            UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model_fpaa_forward(*UpperCamelCase__ )






      def      UpperCAmelCase__					( self			:List[str] )    ->      Optional[Any]:
            UpperCAmelCase					=			["encoder_attentions", "decoder_attentions", "cross_attentions"]
            UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
            UpperCAmelCase					=			config_and_inputs[0]
            UpperCAmelCase					=			UMTaForConditionalGeneration(UpperCamelCase__ ).eval()
            model.to(UpperCamelCase__ )

            UpperCAmelCase					=			{
                "head_mask": torch.zeros(config.num_layers       ,  config.num_heads       ,  device=UpperCamelCase__ ),
                "decoder_head_mask": torch.zeros(config.num_decoder_layers       ,  config.num_heads       ,  device=UpperCamelCase__ ),
                "cross_attn_head_mask": torch.zeros(config.num_decoder_layers       ,  config.num_heads       ,  device=UpperCamelCase__ ),
            }

            for attn_name, (name, mask) in zip(UpperCamelCase__       ,  head_masking.items() ):
                  UpperCAmelCase					=			{name: mask}
                  # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified
                  if name == "head_mask":
                        UpperCAmelCase					=			torch.ones(
                            config.num_decoder_layers       ,  config.num_heads       ,  device=UpperCamelCase__ )

                  UpperCAmelCase					=			model.generate(
                      config_and_inputs[1]['input_ids']       ,  num_beams=1       ,  max_length=3       ,  output_attentions=UpperCamelCase__       ,  return_dict_in_generate=UpperCamelCase__       ,  **UpperCamelCase__       ,  )
                  # We check the state of decoder_attentions and cross_attentions just from the last step
                  UpperCAmelCase					=			out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1]
                  self.assertEqual(sum([w.sum().item() for w in attn_weights] )       ,  0.0 )






      @unittest.skip('Does not work on the tiny model as we keep hitting edge cases.' )
      def      UpperCAmelCase__					( self			:List[str] )    ->      int:
            pass







@require_torch
@require_sentencepiece
@require_tokenizers
class 				A_      (					unittest.TestCase    ):



      """simple docstring"""






      @slow
      @unittest.skip(
          'Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged' )
      def      UpperCAmelCase__					( self			:List[str] )    ->      List[str]:
            UpperCAmelCase					=			UMTaForConditionalGeneration.from_pretrained('google/umt5-small'       ,  return_dict=UpperCamelCase__ ).to(UpperCamelCase__ )
            UpperCAmelCase					=			AutoTokenizer.from_pretrained('google/umt5-small'       ,  use_fast=UpperCamelCase__       ,  legacy=UpperCamelCase__ )
            UpperCAmelCase					=			[
                "Bonjour monsieur <extra_id_0> bien <extra_id_1>.",
                "No se como puedo <extra_id_0>.",
                "This is the reason why we <extra_id_0> them.",
                "The <extra_id_0> walks in <extra_id_1>, seats",
                "A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.",
            ]
            UpperCAmelCase					=			tokenizer(UpperCamelCase__       ,  return_tensors='pt'       ,  padding=UpperCamelCase__ ).input_ids
            # fmt: off
            UpperCAmelCase					=			torch.tensor(
                [
                    [ 3_85_30, 21_07_03, 25_62_99, 14_10, 25_62_98, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
                    [   8_26, 3_21, 6_71, 2_59_22, 25_62_99, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
                    [  14_60, 3_39, 3_12, 1_90_14, 1_06_20, 7_58, 25_62_99, 23_55,2_74, 1, 0, 0, 0, 0, 0, 0,0, 0],
                    [   5_17, 25_62_99, 1_48_69, 2_81, 3_01, 25_62_98, 2_75, 11_99_83,1, 0, 0, 0, 0, 0, 0, 0,0, 0],
                    [   3_20, 25_62_99, 1_48_69, 2_81, 22_34, 2_89, 22_75, 3_33,6_13_91, 2_89, 25_62_98, 5_43, 25_62_97, 16_87_14, 3_29, 25_62_96,2_74, 1],
                ] )
            # fmt: on
            torch.testing.assert_allclose(UpperCamelCase__       ,  UpperCamelCase__ )

            UpperCAmelCase					=			model.generate(input_ids.to(UpperCamelCase__ ) )
            UpperCAmelCase					=			[
                "<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>",
                "<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>",
                "<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>",
                "<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>",
                "<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>",
            ]
            UpperCAmelCase					=			tokenizer.batch_decode(UpperCamelCase__ )
            self.assertEqual(UpperCamelCase__       ,  UpperCamelCase__ )










"""simple docstring"""


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 				A_      (					SCREAMING_SNAKE_CASE_    ):



						"""simple docstring"""






						def __init__( self			:Any       ,  lowercase_			:Optional[Any]       ,  lowercase_			:int=13       ,  lowercase_			:Optional[Any]=7       ,  lowercase_			:List[str]=True       ,  lowercase_			:Dict=True       ,  lowercase_			:str=True       ,  lowercase_			:Optional[Any]=True       ,  lowercase_			:Dict=99       ,  lowercase_			:int=32       ,  lowercase_			:str=5       ,  lowercase_			:Dict=4       ,  lowercase_			:Tuple=37       ,  lowercase_			:Dict="gelu"       ,  lowercase_			:List[str]=0.1       ,  lowercase_			:int=0.1       ,  lowercase_			:Any=5_12       ,  lowercase_			:Optional[Any]=16       ,  lowercase_			:Optional[int]=2       ,  lowercase_			:Union[str, Any]=0.02       ,  lowercase_			:Dict=False       ,  lowercase_			:Tuple=True       ,  lowercase_			:Optional[Any]="None"       ,  lowercase_			:int=3       ,  lowercase_			:Tuple=4       ,  lowercase_			:Optional[int]=None       ,  )    ->      Tuple:
												UpperCAmelCase					=			parent
												UpperCAmelCase					=			batch_size
												UpperCAmelCase					=			seq_length
												UpperCAmelCase					=			is_training
												UpperCAmelCase					=			use_input_mask
												UpperCAmelCase					=			use_token_type_ids
												UpperCAmelCase					=			use_labels
												UpperCAmelCase					=			vocab_size
												UpperCAmelCase					=			hidden_size
												UpperCAmelCase					=			num_hidden_layers
												UpperCAmelCase					=			num_attention_heads
												UpperCAmelCase					=			intermediate_size
												UpperCAmelCase					=			hidden_act
												UpperCAmelCase					=			hidden_dropout_prob
												UpperCAmelCase					=			attention_probs_dropout_prob
												UpperCAmelCase					=			max_position_embeddings
												UpperCAmelCase					=			type_vocab_size
												UpperCAmelCase					=			type_sequence_label_size
												UpperCAmelCase					=			initializer_range
												UpperCAmelCase					=			num_labels
												UpperCAmelCase					=			num_choices
												UpperCAmelCase					=			relative_attention
												UpperCAmelCase					=			position_biased_input
												UpperCAmelCase					=			pos_att_type
												UpperCAmelCase					=			scope






						def      UpperCAmelCase__					( self			:Any )    ->      Tuple:
												UpperCAmelCase					=			ids_tensor([self.batch_size, self.seq_length]       ,  self.vocab_size )

												UpperCAmelCase					=			None
												if self.use_input_mask:
																		UpperCAmelCase					=			ids_tensor([self.batch_size, self.seq_length]       ,  vocab_size=2 )

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

												UpperCAmelCase					=			None
												UpperCAmelCase					=			None
												UpperCAmelCase					=			None
												if self.use_labels:
																		UpperCAmelCase					=			ids_tensor([self.batch_size]       ,  self.type_sequence_label_size )
																		UpperCAmelCase					=			ids_tensor([self.batch_size, self.seq_length]       ,  self.num_labels )
																		UpperCAmelCase					=			ids_tensor([self.batch_size]       ,  self.num_choices )

												UpperCAmelCase					=			self.get_config()

												return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






						def      UpperCAmelCase__					( self			:Tuple )    ->      Tuple:
												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			:Optional[int]       ,  lowercase_			:str )    ->      List[str]:
												self.parent.assertListEqual(list(result.loss.size() )       ,  [] )






						def      UpperCAmelCase__					( self			:Optional[int]       ,  lowercase_			:str       ,  lowercase_			:Tuple       ,  lowercase_			:str       ,  lowercase_			:int       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:List[str]       ,  lowercase_			:Optional[int] )    ->      Optional[int]:
												UpperCAmelCase					=			DebertaVaModel(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_ )[0]
												UpperCAmelCase					=			model(lowercase_       ,  token_type_ids=lowercase_ )[0]
												UpperCAmelCase					=			model(lowercase_ )[0]

												self.parent.assertListEqual(list(sequence_output.size() )       ,  [self.batch_size, self.seq_length, self.hidden_size] )






						def      UpperCAmelCase__					( self			:Optional[Any]       ,  lowercase_			:Dict       ,  lowercase_			:List[str]       ,  lowercase_			:Any       ,  lowercase_			:List[str]       ,  lowercase_			:Tuple       ,  lowercase_			:List[Any]       ,  lowercase_			:int )    ->      Any:
												UpperCAmelCase					=			DebertaVaForMaskedLM(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_ )

												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.vocab_size) )






						def      UpperCAmelCase__					( self			:Union[str, Any]       ,  lowercase_			:Any       ,  lowercase_			:List[Any]       ,  lowercase_			:Any       ,  lowercase_			:Dict       ,  lowercase_			:str       ,  lowercase_			:List[Any]       ,  lowercase_			:Dict )    ->      Union[str, Any]:
												UpperCAmelCase					=			self.num_labels
												UpperCAmelCase					=			DebertaVaForSequenceClassification(lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_ )
												self.parent.assertListEqual(list(result.logits.size() )       ,  [self.batch_size, self.num_labels] )
												self.check_loss_output(lowercase_ )






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






						def      UpperCAmelCase__					( self			:Any       ,  lowercase_			:Any       ,  lowercase_			:List[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Dict       ,  lowercase_			:List[Any]       ,  lowercase_			:Optional[int] )    ->      Dict:
												UpperCAmelCase					=			DebertaVaForQuestionAnswering(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(
												    lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  start_positions=lowercase_       ,  end_positions=lowercase_       ,  )
												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			:Optional[int]       ,  lowercase_			:str       ,  lowercase_			:List[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:List[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Any       ,  lowercase_			:Any )    ->      List[Any]:
												UpperCAmelCase					=			DebertaVaForMultipleChoice(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			input_ids.unsqueeze(1 ).expand(-1       ,  self.num_choices       ,  -1 ).contiguous()
												UpperCAmelCase					=			token_type_ids.unsqueeze(1 ).expand(-1       ,  self.num_choices       ,  -1 ).contiguous()
												UpperCAmelCase					=			input_mask.unsqueeze(1 ).expand(-1       ,  self.num_choices       ,  -1 ).contiguous()
												UpperCAmelCase					=			model(
												    lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_       ,  )
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_choices) )






						def      UpperCAmelCase__					( self			:Dict )    ->      int:
												UpperCAmelCase					=			self.prepare_config_and_inputs()
												(
												    (
												    UpperCAmelCase
												)				,   (
												    UpperCAmelCase
												)				,   (
												    UpperCAmelCase
												)				,   (
												    UpperCAmelCase
												)				,   (
												    UpperCAmelCase
												)				,   (
												    UpperCAmelCase
												)				,   (
												    UpperCAmelCase
												)				,   
												)					=			config_and_inputs
												UpperCAmelCase					=			{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
												return config, inputs_dict







@require_torch
class 				A_      (					SCREAMING_SNAKE_CASE_     ,       SCREAMING_SNAKE_CASE_     ,       unittest.TestCase    ):



						"""simple docstring"""
						__UpperCamelCase		    =							(
						    (
						        DebertaVaModel,
						        DebertaVaForMaskedLM,
						        DebertaVaForSequenceClassification,
						        DebertaVaForTokenClassification,
						        DebertaVaForQuestionAnswering,
						        DebertaVaForMultipleChoice,
						    )
						    if is_torch_available()
						    else ()
						)
						__UpperCamelCase		    =							(
						    {
						        """feature-extraction""": DebertaVaModel,
						        """fill-mask""": DebertaVaForMaskedLM,
						        """question-answering""": DebertaVaForQuestionAnswering,
						        """text-classification""": DebertaVaForSequenceClassification,
						        """token-classification""": DebertaVaForTokenClassification,
						        """zero-shot""": DebertaVaForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)

						__UpperCamelCase		    =							True
						__UpperCamelCase		    =							False
						__UpperCamelCase		    =							False
						__UpperCamelCase		    =							False
						__UpperCamelCase		    =							False






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[int]:
												UpperCAmelCase					=			DebertaVaModelTester(self )
												UpperCAmelCase					=			ConfigTester(self       ,  config_class=lowercase_       ,  hidden_size=37 )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[Any]:
												self.config_tester.run_common_tests()






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Tuple:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_model(*lowercase_ )






						def      UpperCAmelCase__					( self			:Any )    ->      List[str]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_sequence_classification(*lowercase_ )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      List[Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_masked_lm(*lowercase_ )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[int]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_question_answering(*lowercase_ )






						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      Tuple:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_token_classification(*lowercase_ )






						def      UpperCAmelCase__					( self			:Any )    ->      Union[str, Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_multiple_choice(*lowercase_ )






						@slow
						def      UpperCAmelCase__					( self			:Any )    ->      Optional[int]:
												for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		UpperCAmelCase					=			DebertaVaModel.from_pretrained(lowercase_ )
																		self.assertIsNotNone(lowercase_ )







@require_torch
@require_sentencepiece
@require_tokenizers
class 				A_      (					unittest.TestCase    ):



						"""simple docstring"""






						@unittest.skip(reason='Model not available yet' )
						def      UpperCAmelCase__					( self			:str )    ->      Tuple:
												pass






						@slow
						def      UpperCAmelCase__					( self			:List[Any] )    ->      Any:
												UpperCAmelCase					=			DebertaVaModel.from_pretrained('microsoft/deberta-v2-xlarge' )

												UpperCAmelCase					=			torch.tensor([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]] )
												UpperCAmelCase					=			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
												with torch.no_grad():
																		UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_ )[0]
												# compare the actual values for a slice.
												UpperCAmelCase					=			torch.tensor(
												    [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]] )
												self.assertTrue(torch.allclose(output[:, 1:4, 1:4]       ,  lowercase_       ,  atol=1E-4 )       ,  f"""{output[:, 1:4, 1:4]}""" )





