



"""simple docstring"""


import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, PLBartTokenizer, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


snake_case_    					=	get_tests_dir("""fixtures/test_sentencepiece.model""")


if is_torch_available():
				from transformers.models.plbart.modeling_plbart import shift_tokens_right

snake_case_    					=	5_0003
snake_case_    					=	5_0002







@require_sentencepiece
@require_tokenizers
class 				A_      (					SCREAMING_SNAKE_CASE_     ,       unittest.TestCase    ):



						"""simple docstring"""
						__UpperCamelCase		    =							PLBartTokenizer
						__UpperCamelCase		    =							None
						__UpperCamelCase		    =							False






						def      UpperCAmelCase__					( self			:Any )    ->      List[Any]:
												super().setUp()

												# We have a SentencePiece fixture for testing
												UpperCAmelCase					=			PLBartTokenizer(lowercase_       ,  language_codes='base'       ,  keep_accents=lowercase_ )
												tokenizer.save_pretrained(self.tmpdirname )






						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      Dict:
												UpperCAmelCase					=			PLBartTokenizer(lowercase_       ,  language_codes='base'       ,  keep_accents=lowercase_ )

												UpperCAmelCase					=			tokenizer.tokenize('This is a test' )
												self.assertListEqual(lowercase_       ,  ['▁This', '▁is', '▁a', '▁t', 'est'] )

												self.assertListEqual(
												    tokenizer.convert_tokens_to_ids(lowercase_ )       ,  [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]       ,  )

												UpperCAmelCase					=			tokenizer.tokenize('I was born in 92000, and this is falsé.' )
												self.assertListEqual(
												    lowercase_       ,  [
												        SPIECE_UNDERLINE + 'I',
												        SPIECE_UNDERLINE + 'was',
												        SPIECE_UNDERLINE + 'b',
												        'or',
												        'n',
												        SPIECE_UNDERLINE + 'in',
												        SPIECE_UNDERLINE + '',
												        '9',
												        '2',
												        '0',
												        '0',
												        '0',
												        ',',
												        SPIECE_UNDERLINE + 'and',
												        SPIECE_UNDERLINE + 'this',
												        SPIECE_UNDERLINE + 'is',
												        SPIECE_UNDERLINE + 'f',
												        'al',
												        's',
												        'é',
												        '.',
												    ]       ,  )
												UpperCAmelCase					=			tokenizer.convert_tokens_to_ids(lowercase_ )
												self.assertListEqual(
												    lowercase_       ,  [
												        value + tokenizer.fairseq_offset
												        for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
												    ]       ,  )

												UpperCAmelCase					=			tokenizer.convert_ids_to_tokens(lowercase_ )
												self.assertListEqual(
												    lowercase_       ,  [
												        SPIECE_UNDERLINE + 'I',
												        SPIECE_UNDERLINE + 'was',
												        SPIECE_UNDERLINE + 'b',
												        'or',
												        'n',
												        SPIECE_UNDERLINE + 'in',
												        SPIECE_UNDERLINE + '',
												        '<unk>',
												        '2',
												        '0',
												        '0',
												        '0',
												        ',',
												        SPIECE_UNDERLINE + 'and',
												        SPIECE_UNDERLINE + 'this',
												        SPIECE_UNDERLINE + 'is',
												        SPIECE_UNDERLINE + 'f',
												        'al',
												        's',
												        '<unk>',
												        '.',
												    ]       ,  )

												UpperCAmelCase					=			tokenizer.vocab_size
												UpperCAmelCase					=			[tokenizer.convert_ids_to_tokens(lowercase_ ) for x in range(end - 4       ,  lowercase_ )]

												self.assertListEqual(lowercase_       ,  ['__java__', '__python__', '__en_XX__', '<mask>'] )

												UpperCAmelCase					=			'java.lang.Exception, python.lang.Exception, javascript, php, ruby, go'
												UpperCAmelCase					=			tokenizer(lowercase_ ).input_ids
												self.assertEqual(
												    tokenizer.decode(lowercase_       ,  skip_special_tokens=lowercase_       ,  clean_up_tokenization_spaces=lowercase_ )       ,  lowercase_       ,  )






						def      UpperCAmelCase__					( self			:Tuple )    ->      int:
												UpperCAmelCase					=			PLBartTokenizer(lowercase_       ,  language_codes='multi'       ,  keep_accents=lowercase_ )

												UpperCAmelCase					=			tokenizer.tokenize('This is a test' )
												self.assertListEqual(lowercase_       ,  ['▁This', '▁is', '▁a', '▁t', 'est'] )

												self.assertListEqual(
												    tokenizer.convert_tokens_to_ids(lowercase_ )       ,  [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]       ,  )

												UpperCAmelCase					=			tokenizer.tokenize('I was born in 92000, and this is falsé.' )
												self.assertListEqual(
												    lowercase_       ,  [
												        SPIECE_UNDERLINE + 'I',
												        SPIECE_UNDERLINE + 'was',
												        SPIECE_UNDERLINE + 'b',
												        'or',
												        'n',
												        SPIECE_UNDERLINE + 'in',
												        SPIECE_UNDERLINE + '',
												        '9',
												        '2',
												        '0',
												        '0',
												        '0',
												        ',',
												        SPIECE_UNDERLINE + 'and',
												        SPIECE_UNDERLINE + 'this',
												        SPIECE_UNDERLINE + 'is',
												        SPIECE_UNDERLINE + 'f',
												        'al',
												        's',
												        'é',
												        '.',
												    ]       ,  )
												UpperCAmelCase					=			tokenizer.convert_tokens_to_ids(lowercase_ )
												self.assertListEqual(
												    lowercase_       ,  [
												        value + tokenizer.fairseq_offset
												        for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
												    ]       ,  )

												UpperCAmelCase					=			tokenizer.convert_ids_to_tokens(lowercase_ )
												self.assertListEqual(
												    lowercase_       ,  [
												        SPIECE_UNDERLINE + 'I',
												        SPIECE_UNDERLINE + 'was',
												        SPIECE_UNDERLINE + 'b',
												        'or',
												        'n',
												        SPIECE_UNDERLINE + 'in',
												        SPIECE_UNDERLINE + '',
												        '<unk>',
												        '2',
												        '0',
												        '0',
												        '0',
												        ',',
												        SPIECE_UNDERLINE + 'and',
												        SPIECE_UNDERLINE + 'this',
												        SPIECE_UNDERLINE + 'is',
												        SPIECE_UNDERLINE + 'f',
												        'al',
												        's',
												        '<unk>',
												        '.',
												    ]       ,  )
												UpperCAmelCase					=			tokenizer.vocab_size
												UpperCAmelCase					=			[tokenizer.convert_ids_to_tokens(lowercase_ ) for x in range(end - 7       ,  lowercase_ )]

												self.assertListEqual(
												    lowercase_       ,  ['__java__', '__python__', '__en_XX__', '__javascript__', '__php__', '__ruby__', '__go__'] )
												UpperCAmelCase					=			'java.lang.Exception, python.lang.Exception, javascript, php, ruby, go'
												UpperCAmelCase					=			tokenizer(lowercase_ ).input_ids
												self.assertEqual(
												    tokenizer.decode(lowercase_       ,  skip_special_tokens=lowercase_       ,  clean_up_tokenization_spaces=lowercase_ )       ,  lowercase_       ,  )







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



						"""simple docstring"""
						__UpperCamelCase		    =							"""uclanlp/plbart-python-en_XX"""
						__UpperCamelCase		    =							[
						    """def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])""",
						    """def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])""",
						]
						__UpperCamelCase		    =							[
						    """Returns the maximum value of a b c.""",
						    """Sums the values of a b c.""",
						]
						__UpperCamelCase		    =							[
						    1_34,
						    54_52,
						    3_34_60,
						    3_34_41,
						    3_34_63,
						    3_34_65,
						    3_34_63,
						    3_34_49,
						    9_88,
						    20,
						    3_34_56,
						    19,
						    3_34_56,
						    7_71,
						    39,
						    42_58,
						    8_89,
						    33_18,
						    3_34_41,
						    3_34_63,
						    3_34_65,
						    3_34_63,
						    3_34_49,
						    24_71,
						    2,
						    PYTHON_CODE,
						]






						@classmethod
						def      UpperCAmelCase__					( cls			:Any )    ->      Tuple:
												UpperCAmelCase					=			PLBartTokenizer.from_pretrained(
												    cls.checkpoint_name       ,  language_codes='base'       ,  src_lang='python'       ,  tgt_lang='en_XX' )
												UpperCAmelCase					=			1
												return cls






						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      List[Any]:
												self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['__java__']       ,  5_00_01 )
												self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['__python__']       ,  5_00_02 )
												self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['__en_XX__']       ,  5_00_03 )






						def      UpperCAmelCase__					( self			:Any )    ->      Dict:
												UpperCAmelCase					=			self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0]
												self.assertListEqual(self.expected_src_tokens       ,  lowercase_ )






						def      UpperCAmelCase__					( self			:int )    ->      Dict:
												self.assertIn(lowercase_       ,  self.tokenizer.all_special_ids )
												UpperCAmelCase					=			[EN_CODE, 90_37, 3_34_42, 57, 7_52, 1_53, 14, 56, 18, 9, 2]
												UpperCAmelCase					=			self.tokenizer.decode(lowercase_       ,  skip_special_tokens=lowercase_ )
												UpperCAmelCase					=			self.tokenizer.decode(generated_ids[1:]       ,  skip_special_tokens=lowercase_ )
												self.assertEqual(lowercase_       ,  lowercase_ )
												self.assertNotIn(self.tokenizer.eos_token       ,  lowercase_ )






						def      UpperCAmelCase__					( self			:Tuple )    ->      Any:
												UpperCAmelCase					=			['def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])' * 20]
												self.assertIsInstance(src_text[0]       ,  lowercase_ )
												UpperCAmelCase					=			10
												UpperCAmelCase					=			self.tokenizer(lowercase_       ,  max_length=lowercase_       ,  truncation=lowercase_ ).input_ids[0]
												self.assertEqual(ids[-2]       ,  2 )
												self.assertEqual(ids[-1]       ,  lowercase_ )
												self.assertEqual(len(lowercase_ )       ,  lowercase_ )






						def      UpperCAmelCase__					( self			:int )    ->      int:
												self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', '__java__'] )       ,  [5_00_04, 5_00_01] )






						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      Tuple:
												UpperCAmelCase					=			tempfile.mkdtemp()
												UpperCAmelCase					=			self.tokenizer.fairseq_tokens_to_ids
												self.tokenizer.save_pretrained(lowercase_ )
												UpperCAmelCase					=			PLBartTokenizer.from_pretrained(lowercase_ )
												self.assertDictEqual(new_tok.fairseq_tokens_to_ids       ,  lowercase_ )






						@require_torch
						def      UpperCAmelCase__					( self			:int )    ->      List[Any]:
												UpperCAmelCase					=			self.tokenizer(self.src_text       ,  text_target=self.tgt_text       ,  padding=lowercase_       ,  return_tensors='pt' )
												UpperCAmelCase					=			shift_tokens_right(batch['labels']       ,  self.tokenizer.pad_token_id )

												# fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
												self.assertEqual(batch.input_ids[1][-2:].tolist()       ,  [2, PYTHON_CODE] )
												self.assertEqual(batch.decoder_input_ids[1][0]       ,  lowercase_ )
												self.assertEqual(batch.decoder_input_ids[1][-1]       ,  2 )
												self.assertEqual(batch.labels[1][-2:].tolist()       ,  [2, EN_CODE] )






						@require_torch
						def      UpperCAmelCase__					( self			:str )    ->      int:
												UpperCAmelCase					=			self.tokenizer(
												    self.src_text       ,  text_target=self.tgt_text       ,  padding=lowercase_       ,  truncation=lowercase_       ,  max_length=len(self.expected_src_tokens )       ,  return_tensors='pt'       ,  )
												UpperCAmelCase					=			shift_tokens_right(batch['labels']       ,  self.tokenizer.pad_token_id )

												self.assertIsInstance(lowercase_       ,  lowercase_ )

												self.assertEqual((2, 26)       ,  batch.input_ids.shape )
												self.assertEqual((2, 26)       ,  batch.attention_mask.shape )
												UpperCAmelCase					=			batch.input_ids.tolist()[0]
												self.assertListEqual(self.expected_src_tokens       ,  lowercase_ )
												self.assertEqual(2       ,  batch.decoder_input_ids[0, -1] )  # EOS
												# Test that special tokens are reset
												self.assertEqual(self.tokenizer.prefix_tokens       ,  [] )
												self.assertEqual(self.tokenizer.suffix_tokens       ,  [self.tokenizer.eos_token_id, PYTHON_CODE] )






						def      UpperCAmelCase__					( self			:int )    ->      List[Any]:
												UpperCAmelCase					=			self.tokenizer(self.src_text       ,  padding=lowercase_       ,  truncation=lowercase_       ,  max_length=3       ,  return_tensors='pt' )
												UpperCAmelCase					=			self.tokenizer(
												    text_target=self.tgt_text       ,  padding=lowercase_       ,  truncation=lowercase_       ,  max_length=10       ,  return_tensors='pt' )
												UpperCAmelCase					=			targets['input_ids']
												UpperCAmelCase					=			shift_tokens_right(lowercase_       ,  self.tokenizer.pad_token_id )

												self.assertEqual(batch.input_ids.shape[1]       ,  3 )
												self.assertEqual(batch.decoder_input_ids.shape[1]       ,  10 )






						@require_torch
						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      List[Any]:
												UpperCAmelCase					=			self.tokenizer._build_translation_inputs(
												    'A test'       ,  return_tensors='pt'       ,  src_lang='en_XX'       ,  tgt_lang='java' )

												self.assertEqual(
												    nested_simplify(lowercase_ )       ,  {
												        # A, test, EOS, en_XX
												        'input_ids': [[1_50, 2_42, 2, 5_00_03]],
												        'attention_mask': [[1, 1, 1, 1]],
												        # java
												        'forced_bos_token_id': 5_00_01,
												    }       ,  )










"""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]}""" )





