


"""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	:	Tuple      ,       A_	:	str      ,       A_	:	int=1_3      ,       A_	:	Tuple=7      ,       A_	:	List[Any]=True      ,       A_	:	List[Any]=True      ,       A_	:	List[Any]=True      ,       A_	:	List[Any]=True      ,       A_	:	Any=9_9      ,       A_	:	int=3_2      ,       A_	:	Union[str, Any]=5      ,       A_	:	str=4      ,       A_	:	int=3_7      ,       A_	:	int="gelu"      ,       A_	:	List[Any]=0.1      ,       A_	:	Tuple=0.1      ,       A_	:	List[Any]=5_1_2      ,       A_	:	List[str]=1_6      ,       A_	:	Any=2      ,       A_	:	List[str]=0.02      ,       A_	:	Union[str, Any]=False      ,       A_	:	Dict=True      ,       A_	:	Any="None"      ,       A_	:	Optional[int]=3      ,       A_	:	Tuple=4      ,       A_	:	Tuple=None      ,       ):






       '''simple docstring'''


       __lowercase									=	parent
       __lowercase									=	batch_size
       __lowercase									=	seq_length
       __lowercase									=	is_training
       __lowercase									=	use_input_mask
       __lowercase									=	use_token_type_ids
       __lowercase									=	use_labels
       __lowercase									=	vocab_size
       __lowercase									=	hidden_size
       __lowercase									=	num_hidden_layers
       __lowercase									=	num_attention_heads
       __lowercase									=	intermediate_size
       __lowercase									=	hidden_act
       __lowercase									=	hidden_dropout_prob
       __lowercase									=	attention_probs_dropout_prob
       __lowercase									=	max_position_embeddings
       __lowercase									=	type_vocab_size
       __lowercase									=	type_sequence_label_size
       __lowercase									=	initializer_range
       __lowercase									=	num_labels
       __lowercase									=	num_choices
       __lowercase									=	relative_attention
       __lowercase									=	position_biased_input
       __lowercase									=	pos_att_type
       __lowercase									=	scope
      def SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       __lowercase									=	ids_tensor([self.batch_size, self.seq_length]      ,       self.vocab_size							)

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

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

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

       __lowercase									=	self.get_config()

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]							):






       '''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 SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]      ,       A_	:	int							):






       '''simple docstring'''


       self.parent.assertListEqual(list(result.loss.size()							)      ,       []							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[str]      ,       A_	:	int      ,       A_	:	Optional[Any]      ,       A_	:	Dict      ,       A_	:	Optional[int]      ,       A_	:	Union[str, Any]      ,       A_	:	str      ,       A_	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	DebertaVaModel(config=_A							)
       model.to(_A							)
       model.eval()
       __lowercase									=	model(_A      ,       attention_mask=_A      ,       token_type_ids=_A							)[0]
       __lowercase									=	model(_A      ,       token_type_ids=_A							)[0]
       __lowercase									=	model(_A							)[0]

       self.parent.assertListEqual(list(sequence_output.size()							)      ,       [self.batch_size, self.seq_length, self.hidden_size]							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[str]      ,       A_	:	Tuple      ,       A_	:	Optional[Any]      ,       A_	:	Union[str, Any]      ,       A_	:	Optional[int]      ,       A_	:	Tuple      ,       A_	:	int      ,       A_	:	List[str]							):






       '''simple docstring'''


       __lowercase									=	DebertaVaForMaskedLM(config=_A							)
       model.to(_A							)
       model.eval()
       __lowercase									=	model(_A      ,       attention_mask=_A      ,       token_type_ids=_A      ,       labels=_A							)

       self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.seq_length, self.vocab_size)							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Any      ,       A_	:	Optional[int]      ,       A_	:	Tuple      ,       A_	:	Tuple      ,       A_	:	Optional[Any]      ,       A_	:	int      ,       A_	:	str      ,       A_	:	Any							):






       '''simple docstring'''


       __lowercase									=	self.num_labels
       __lowercase									=	DebertaVaForSequenceClassification(_A							)
       model.to(_A							)
       model.eval()
       __lowercase									=	model(_A      ,       attention_mask=_A      ,       token_type_ids=_A      ,       labels=_A							)
       self.parent.assertListEqual(list(result.logits.size()							)      ,       [self.batch_size, self.num_labels]							)
       self.check_loss_output(_A							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[str]      ,       A_	:	List[str]      ,       A_	:	int      ,       A_	:	Optional[Any]      ,       A_	:	str      ,       A_	:	Dict      ,       A_	:	Dict      ,       A_	:	Dict							):






       '''simple docstring'''


       __lowercase									=	self.num_labels
       __lowercase									=	DebertaVaForTokenClassification(config=_A							)
       model.to(_A							)
       model.eval()
       __lowercase									=	model(_A      ,       attention_mask=_A      ,       token_type_ids=_A      ,       labels=_A							)
       self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.seq_length, self.num_labels)							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[Any]      ,       A_	:	List[str]      ,       A_	:	Tuple      ,       A_	:	Union[str, Any]      ,       A_	:	str      ,       A_	:	Union[str, Any]      ,       A_	:	Union[str, Any]      ,       A_	:	Dict							):






       '''simple docstring'''


       __lowercase									=	DebertaVaForQuestionAnswering(config=_A							)
       model.to(_A							)
       model.eval()
       __lowercase									=	model(
           _A      ,       attention_mask=_A      ,       token_type_ids=_A      ,       start_positions=_A      ,       end_positions=_A      ,       )
       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	:	List[Any]      ,       A_	:	Any      ,       A_	:	Any      ,       A_	:	Tuple      ,       A_	:	int      ,       A_	:	Dict      ,       A_	:	Tuple      ,       A_	:	Dict							):






       '''simple docstring'''


       __lowercase									=	DebertaVaForMultipleChoice(config=_A							)
       model.to(_A							)
       model.eval()
       __lowercase									=	input_ids.unsqueeze(1							).expand(-1      ,       self.num_choices      ,       -1							).contiguous()
       __lowercase									=	token_type_ids.unsqueeze(1							).expand(-1      ,       self.num_choices      ,       -1							).contiguous()
       __lowercase									=	input_mask.unsqueeze(1							).expand(-1      ,       self.num_choices      ,       -1							).contiguous()
       __lowercase									=	model(
           _A      ,       attention_mask=_A      ,       token_type_ids=_A      ,       labels=_A      ,       )
       self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.num_choices)							)






      def SCREAMING_SNAKE_CASE_	(		self	:	List[str]							):






       '''simple docstring'''


       __lowercase									=	self.prepare_config_and_inputs()
       (
           __lowercase					
       )									=	config_and_inputs
       __lowercase									=	{'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 :     List[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 :     Optional[int]											=		True
      a :     Tuple											=		False
      a :     Any											=		False
      a :     Dict											=		False
      a :     Union[str, Any]											=		False
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	DebertaVaModelTester(self							)
       __lowercase									=	ConfigTester(self      ,       config_class=_A      ,       hidden_size=3_7							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Any							):






       '''simple docstring'''


       self.config_tester.run_common_tests()
      def SCREAMING_SNAKE_CASE_	(		self	:	int							):






       '''simple docstring'''


       __lowercase									=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_model(*_A							)
      def SCREAMING_SNAKE_CASE_	(		self	:	List[Any]							):






       '''simple docstring'''


       __lowercase									=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_sequence_classification(*_A							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Optional[int]							):






       '''simple docstring'''


       __lowercase									=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_masked_lm(*_A							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Tuple							):






       '''simple docstring'''


       __lowercase									=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_question_answering(*_A							)
      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


       __lowercase									=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_token_classification(*_A							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]							):






       '''simple docstring'''


       __lowercase									=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_multiple_choice(*_A							)






      @slow
      def SCREAMING_SNAKE_CASE_	(		self	:	str							):






       '''simple docstring'''


       for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        __lowercase									=	DebertaVaModel.from_pretrained(_A							)
        self.assertIsNotNone(_A							)






@require_torch
@require_sentencepiece
@require_tokenizers
class    lowerCamelCase__						(		unittest.TestCase    ):
      @unittest.skip(reason="""Model not available yet"""							)
      def SCREAMING_SNAKE_CASE_	(		self	:	Union[str, Any]							):






       '''simple docstring'''


       pass






      @slow
      def SCREAMING_SNAKE_CASE_	(		self	:	Any							):






       '''simple docstring'''


       __lowercase									=	DebertaVaModel.from_pretrained("""microsoft/deberta-v2-xlarge"""							)

       __lowercase									=	torch.tensor([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]]							)
       __lowercase									=	torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]							)
       with torch.no_grad():
        __lowercase									=	model(_A      ,       attention_mask=_A							)[0]
       # compare the actual values for a slice.
       __lowercase									=	torch.tensor(
           [[[0.23_56, 0.19_48, 0.03_69], [-0.10_63, 0.35_86, -0.51_52], [-0.63_99, -0.02_59, -0.25_25]]]							)
       self.assertTrue(torch.allclose(output[:, 1:4, 1:4]      ,       _A      ,       atol=1e-4							)      ,       F'''{output[:, 1:4, 1:4]}'''							)




"""simple docstring"""

from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCAmelCase__  							={"configuration_van": ["VAN_PRETRAINED_CONFIG_ARCHIVE_MAP", "VanConfig"]}


try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase__  							=[
           "VAN_PRETRAINED_MODEL_ARCHIVE_LIST",
           "VanForImageClassification",
           "VanModel",
           "VanPreTrainedModel",
       ]

if TYPE_CHECKING:
       from .configuration_van import VAN_PRETRAINED_CONFIG_ARCHIVE_MAP, VanConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_van import (
                  VAN_PRETRAINED_MODEL_ARCHIVE_LIST,
                  VanForImageClassification,
                  VanModel,
                  VanPreTrainedModel,
              )

else:
       import sys

       UpperCAmelCase__  							=_LazyModule(__name__, globals()["__file__"], _import_structure)
