






"""simple docstring"""





import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

import transformers
from transformers.testing_utils import require_tf, require_torch, slow


A__					: Union[str, Any]=	logging.getLogger()
@unittest.skip("""Temporarily disable the doc tests."""  )
@require_torch
@require_tf
@slow
class    __lowerCamelCase    (  unittest.TestCase  ):

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ = None ,				snake_case_ = None ,				snake_case_ = None ,				snake_case_ = True ,				)		->       Tuple:
       UpperCamelCase__         =    [file for file in os.listdir(snake_case_      ) if os.path.isfile(os.path.join(snake_case_ ,				snake_case_      )      )]

       if identifier is not None:
           UpperCamelCase__         =    [file for file in files if identifier in file]

       if n_identifier is not None:
           if isinstance(snake_case_ ,				snake_case_      ):
               for n_ in n_identifier:
                   UpperCamelCase__         =    [file for file in files if n_ not in file]
           else:
               UpperCamelCase__         =    [file for file in files if n_identifier not in file]

       UpperCamelCase__         =    ignore_files or []
       ignore_files.append('__init__.py'      )
       UpperCamelCase__         =    [file for file in files if file not in ignore_files]

       for file in files:
           # Open all files
           print('Testing' ,				snake_case_      )

           if only_modules:
               UpperCamelCase__         =    file.split('.'      )[0]
               try:
                   UpperCamelCase__         =    getattr(snake_case_ ,				snake_case_      )
                   UpperCamelCase__         =    doctest.DocTestSuite(snake_case_      )
                   UpperCamelCase__         =    unittest.TextTestRunner().run(snake_case_      )
                   self.assertIs(len(result.failures      ) ,				0      )
               except AttributeError:
                   logger.info(F'{module_identifier} is not a module.'      )
           else:
               UpperCamelCase__         =    doctest.testfile(str('..' / directory / file      ) ,				optionflags=doctest.ELLIPSIS      )
               self.assertIs(result.failed ,				0      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    Path('src/transformers'      )
       UpperCamelCase__         =    'modeling'
       UpperCamelCase__         =    [
           'modeling_ctrl.py',
           'modeling_tf_ctrl.py',
       ]
       self.analyze_directory(snake_case_ ,				identifier=snake_case_ ,				ignore_files=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    Path('src/transformers'      )
       UpperCamelCase__         =    'tokenization'
       self.analyze_directory(snake_case_ ,				identifier=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[Any]:
       UpperCamelCase__         =    Path('src/transformers'      )
       UpperCamelCase__         =    'configuration'
       self.analyze_directory(snake_case_ ,				identifier=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__         =    Path('src/transformers'      )
       UpperCamelCase__         =    ['configuration', 'modeling', 'tokenization']
       self.analyze_directory(snake_case_ ,				n_identifier=snake_case_      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    Path('docs/source'      )
       UpperCamelCase__         =    ['favicon.ico']
       self.analyze_directory(snake_case_ ,				ignore_files=snake_case_ ,				only_modules=snake_case_      )












"""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    __lowerCamelCase    (  _a  ):

   def __init__(					self ,				snake_case_ ,				snake_case_=13 ,				snake_case_=7 ,				snake_case_=True ,				snake_case_=True ,				snake_case_=True ,				snake_case_=True ,				snake_case_=99 ,				snake_case_=32 ,				snake_case_=5 ,				snake_case_=4 ,				snake_case_=37 ,				snake_case_="gelu" ,				snake_case_=0.1 ,				snake_case_=0.1 ,				snake_case_=512 ,				snake_case_=16 ,				snake_case_=2 ,				snake_case_=0.02 ,				snake_case_=False ,				snake_case_=True ,				snake_case_="None" ,				snake_case_=3 ,				snake_case_=4 ,				snake_case_=None ,				)		->       str:
       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 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       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 						SCREAMING_SNAKE_CASE__ (					self      )		->       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 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_      )		->       Any:
       self.parent.assertListEqual(list(result.loss.size()      ) ,				[]      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       str:
       UpperCamelCase__         =    DebertaVaModel(config=snake_case_      )
       model.to(snake_case_      )
       model.eval()
       UpperCamelCase__         =    model(snake_case_ ,				attention_mask=snake_case_ ,				token_type_ids=snake_case_      )[0]
       UpperCamelCase__         =    model(snake_case_ ,				token_type_ids=snake_case_      )[0]
       UpperCamelCase__         =    model(snake_case_      )[0]

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

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       Optional[Any]:
       UpperCamelCase__         =    DebertaVaForMaskedLM(config=snake_case_      )
       model.to(snake_case_      )
       model.eval()
       UpperCamelCase__         =    model(snake_case_ ,				attention_mask=snake_case_ ,				token_type_ids=snake_case_ ,				labels=snake_case_      )

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

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       Dict:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    DebertaVaForSequenceClassification(snake_case_      )
       model.to(snake_case_      )
       model.eval()
       UpperCamelCase__         =    model(snake_case_ ,				attention_mask=snake_case_ ,				token_type_ids=snake_case_ ,				labels=snake_case_      )
       self.parent.assertListEqual(list(result.logits.size()      ) ,				[self.batch_size, self.num_labels]      )
       self.check_loss_output(snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       Optional[int]:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    DebertaVaForTokenClassification(config=snake_case_      )
       model.to(snake_case_      )
       model.eval()
       UpperCamelCase__         =    model(snake_case_ ,				attention_mask=snake_case_ ,				token_type_ids=snake_case_ ,				labels=snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.num_labels)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       Tuple:
       UpperCamelCase__         =    DebertaVaForQuestionAnswering(config=snake_case_      )
       model.to(snake_case_      )
       model.eval()
       UpperCamelCase__         =    model(
           snake_case_ ,				attention_mask=snake_case_ ,				token_type_ids=snake_case_ ,				start_positions=snake_case_ ,				end_positions=snake_case_ ,				)
       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 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       int:
       UpperCamelCase__         =    DebertaVaForMultipleChoice(config=snake_case_      )
       model.to(snake_case_      )
       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(
           snake_case_ ,				attention_mask=snake_case_ ,				token_type_ids=snake_case_ ,				labels=snake_case_ ,				)
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_choices)      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       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    __lowerCamelCase    (  _a							,	_a							,	unittest.TestCase  ):
   a      :				Any 						=(
       (
           DebertaVaModel,
           DebertaVaForMaskedLM,
           DebertaVaForSequenceClassification,
           DebertaVaForTokenClassification,
           DebertaVaForQuestionAnswering,
           DebertaVaForMultipleChoice,
       )
       if is_torch_available()
       else ()
   )
   a      :				Dict 						=(
       {
           """feature-extraction""": DebertaVaModel,
           """fill-mask""": DebertaVaForMaskedLM,
           """question-answering""": DebertaVaForQuestionAnswering,
           """text-classification""": DebertaVaForSequenceClassification,
           """token-classification""": DebertaVaForTokenClassification,
           """zero-shot""": DebertaVaForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )

   a      :				Tuple 						=True
   a      :				Union[str, Any] 						=False
   a      :				Tuple 						=False
   a      :				Union[str, Any] 						=False
   a      :				Dict 						=False

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       UpperCamelCase__         =    DebertaVaModelTester(self      )
       UpperCamelCase__         =    ConfigTester(self ,				config_class=snake_case_ ,				hidden_size=37      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       self.config_tester.run_common_tests()

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_model(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_sequence_classification(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_masked_lm(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_question_answering(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_token_classification(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_multiple_choice(*snake_case_      )







   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase__         =    DebertaVaModel.from_pretrained(snake_case_      )
           self.assertIsNotNone(snake_case_      )







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

   @unittest.skip(reason='Model not available yet'      )
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[Any]:
       pass







   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[Any]:
       UpperCamelCase__         =    DebertaVaModel.from_pretrained('microsoft/deberta-v2-xlarge'      )

       UpperCamelCase__         =    torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]      )
       UpperCamelCase__         =    torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]      )
       with torch.no_grad():
           UpperCamelCase__         =    model(snake_case_ ,				attention_mask=snake_case_      )[0]
       # compare the actual values for a slice.
       UpperCamelCase__         =    torch.tensor(
           [[[0.2_356, 0.1_948, 0.0_369], [-0.1_063, 0.3_586, -0.5_152], [-0.6_399, -0.0_259, -0.2_525]]]      )
       self.assertTrue(torch.allclose(output[:, 1:4, 1:4] ,				snake_case_ ,				atol=1E-4      ) ,				F'{output[:, 1:4, 1:4]}'      )




