
'''simple docstring'''


import unittest

from transformers import DebertaConfig, 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 (
			    DebertaForMaskedLM,
			    DebertaForQuestionAnswering,
			    DebertaForSequenceClassification,
			    DebertaForTokenClassification,
			    DebertaModel,
			)
			from transformers.models.deberta.modeling_deberta import DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST


class 						lowercase__	(  snake_case_   ):






			'''simple docstring'''







			def __init__(			self ,   lowerCamelCase__ ,   lowerCamelCase__=1_3 ,   lowerCamelCase__=7 ,   lowerCamelCase__=True ,   lowerCamelCase__=True ,   lowerCamelCase__=True ,   lowerCamelCase__=True ,   lowerCamelCase__=9_9 ,   lowerCamelCase__=3_2 ,   lowerCamelCase__=5 ,   lowerCamelCase__=4 ,   lowerCamelCase__=3_7 ,   lowerCamelCase__="gelu" ,   lowerCamelCase__=0.1 ,   lowerCamelCase__=0.1 ,   lowerCamelCase__=5_1_2 ,   lowerCamelCase__=1_6 ,   lowerCamelCase__=2 ,   lowerCamelCase__=0.02 ,   lowerCamelCase__=False ,   lowerCamelCase__=True ,   lowerCamelCase__="None" ,   lowerCamelCase__=3 ,   lowerCamelCase__=4 ,   lowerCamelCase__=None ,   ):

						'''simple docstring'''







						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   ):

						'''simple docstring'''







						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   ):

						'''simple docstring'''







						return DebertaConfig(
						    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   ):

						'''simple docstring'''







						UpperCamelCase       =  self.get_config()
						UpperCamelCase       =  3_0_0
						return config







			def       UpperCAmelCase				(			self ,   lowerCamelCase__   ):

						'''simple docstring'''







						self.parent.assertListEqual(list(result.loss.size()   ) ,   []   )







			def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

						'''simple docstring'''







						UpperCamelCase       =  DebertaModel(config=lowerCamelCase__   )
						model.to(lowerCamelCase__   )
						model.eval()
						UpperCamelCase       =  model(lowerCamelCase__ ,   attention_mask=lowerCamelCase__ ,   token_type_ids=lowerCamelCase__   )[0]
						UpperCamelCase       =  model(lowerCamelCase__ ,   token_type_ids=lowerCamelCase__   )[0]
						UpperCamelCase       =  model(lowerCamelCase__   )[0]

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







			def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

						'''simple docstring'''







						UpperCamelCase       =  DebertaForMaskedLM(config=lowerCamelCase__   )
						model.to(lowerCamelCase__   )
						model.eval()
						UpperCamelCase       =  model(lowerCamelCase__ ,   attention_mask=lowerCamelCase__ ,   token_type_ids=lowerCamelCase__ ,   labels=lowerCamelCase__   )

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







			def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

						'''simple docstring'''







						UpperCamelCase       =  self.num_labels
						UpperCamelCase       =  DebertaForSequenceClassification(lowerCamelCase__   )
						model.to(lowerCamelCase__   )
						model.eval()
						UpperCamelCase       =  model(lowerCamelCase__ ,   attention_mask=lowerCamelCase__ ,   token_type_ids=lowerCamelCase__ ,   labels=lowerCamelCase__   )
						self.parent.assertListEqual(list(result.logits.size()   ) ,   [self.batch_size, self.num_labels]   )
						self.check_loss_output(lowerCamelCase__   )







			def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

						'''simple docstring'''







						UpperCamelCase       =  self.num_labels
						UpperCamelCase       =  DebertaForTokenClassification(config=lowerCamelCase__   )
						model.to(lowerCamelCase__   )
						model.eval()
						UpperCamelCase       =  model(lowerCamelCase__ ,   attention_mask=lowerCamelCase__ ,   token_type_ids=lowerCamelCase__ ,   labels=lowerCamelCase__   )
						self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.seq_length, self.num_labels)   )







			def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__ ,   lowerCamelCase__   ):

						'''simple docstring'''







						UpperCamelCase       =  DebertaForQuestionAnswering(config=lowerCamelCase__   )
						model.to(lowerCamelCase__   )
						model.eval()
						UpperCamelCase       =  model(
						    lowerCamelCase__ ,   attention_mask=lowerCamelCase__ ,   token_type_ids=lowerCamelCase__ ,   start_positions=lowerCamelCase__ ,   end_positions=lowerCamelCase__ ,   )
						self.parent.assertEqual(result.start_logits.shape ,   (self.batch_size, self.seq_length)   )
						self.parent.assertEqual(result.end_logits.shape ,   (self.batch_size, self.seq_length)   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						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 						lowercase__	(  snake_case_,					snake_case_,					unittest.TestCase   ):






			'''simple docstring'''







			_snake_case		   =							(
			    (
			        DebertaModel,
			        DebertaForMaskedLM,
			        DebertaForSequenceClassification,
			        DebertaForTokenClassification,
			        DebertaForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			_snake_case		   =							(
			    {
			        '''feature-extraction''': DebertaModel,
			        '''fill-mask''': DebertaForMaskedLM,
			        '''question-answering''': DebertaForQuestionAnswering,
			        '''text-classification''': DebertaForSequenceClassification,
			        '''token-classification''': DebertaForTokenClassification,
			        '''zero-shot''': DebertaForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)

			_snake_case		   =							True
			_snake_case		   =							False
			_snake_case		   =							False
			_snake_case		   =							False
			_snake_case		   =							False







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  DebertaModelTester(self   )
						UpperCamelCase       =  ConfigTester(self ,   config_class=lowerCamelCase__ ,   hidden_size=3_7   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						self.config_tester.run_common_tests()







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_model(*lowerCamelCase__   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_sequence_classification(*lowerCamelCase__   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_masked_lm(*lowerCamelCase__   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_question_answering(*lowerCamelCase__   )







			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_token_classification(*lowerCamelCase__   )







			@slow
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									UpperCamelCase       =  DebertaModel.from_pretrained(lowerCamelCase__   )
									self.assertIsNotNone(lowerCamelCase__   )




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






			'''simple docstring'''







			@unittest.skip(reason='''Model not available yet'''   )
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						pass







			@slow
			def       UpperCAmelCase				(			self   ):

						'''simple docstring'''







						UpperCamelCase       =  DebertaModel.from_pretrained('''microsoft/deberta-base'''   )

						UpperCamelCase       =  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]]   )
						UpperCamelCase       =  torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
						with torch.no_grad():
									UpperCamelCase       =  model(lowerCamelCase__ ,   attention_mask=lowerCamelCase__   )[0]
						# compare the actual values for a slice.
						UpperCamelCase       =  torch.tensor(
						    [[[-0.5986, -0.8055, -0.8462], [1.4484, -0.9348, -0.8059], [0.3123, 0.0032, -1.4131]]]   )
						self.assertTrue(torch.allclose(output[:, 1:4, 1:4] ,   lowerCamelCase__ ,   atol=1e-4   ) ,   f'{output[:, 1:4, 1:4]}'   )







'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


snake_case_ :  Any     =					{
    'configuration_electra': ['ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ElectraConfig', 'ElectraOnnxConfig'],
    'tokenization_electra': ['ElectraTokenizer'],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   snake_case_ :  Union[str, Any]     =					['ElectraTokenizerFast']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   snake_case_ :  Tuple     =					[
       'ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST',
       'ElectraForCausalLM',
       'ElectraForMaskedLM',
       'ElectraForMultipleChoice',
       'ElectraForPreTraining',
       'ElectraForQuestionAnswering',
       'ElectraForSequenceClassification',
       'ElectraForTokenClassification',
       'ElectraModel',
       'ElectraPreTrainedModel',
       'load_tf_weights_in_electra',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   snake_case_ :  int     =					[
       'TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFElectraForMaskedLM',
       'TFElectraForMultipleChoice',
       'TFElectraForPreTraining',
       'TFElectraForQuestionAnswering',
       'TFElectraForSequenceClassification',
       'TFElectraForTokenClassification',
       'TFElectraModel',
       'TFElectraPreTrainedModel',
   ]

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   snake_case_ :  Optional[int]     =					[
       'FlaxElectraForCausalLM',
       'FlaxElectraForMaskedLM',
       'FlaxElectraForMultipleChoice',
       'FlaxElectraForPreTraining',
       'FlaxElectraForQuestionAnswering',
       'FlaxElectraForSequenceClassification',
       'FlaxElectraForTokenClassification',
       'FlaxElectraModel',
       'FlaxElectraPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
   from .tokenization_electra import ElectraTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_electra_fast import ElectraTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_electra import (
          ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
          ElectraForCausalLM,
          ElectraForMaskedLM,
          ElectraForMultipleChoice,
          ElectraForPreTraining,
          ElectraForQuestionAnswering,
          ElectraForSequenceClassification,
          ElectraForTokenClassification,
          ElectraModel,
          ElectraPreTrainedModel,
          load_tf_weights_in_electra,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_electra import (
          TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFElectraForMaskedLM,
          TFElectraForMultipleChoice,
          TFElectraForPreTraining,
          TFElectraForQuestionAnswering,
          TFElectraForSequenceClassification,
          TFElectraForTokenClassification,
          TFElectraModel,
          TFElectraPreTrainedModel,
      )

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_flax_electra import (
          FlaxElectraForCausalLM,
          FlaxElectraForMaskedLM,
          FlaxElectraForMultipleChoice,
          FlaxElectraForPreTraining,
          FlaxElectraForQuestionAnswering,
          FlaxElectraForSequenceClassification,
          FlaxElectraForTokenClassification,
          FlaxElectraModel,
          FlaxElectraPreTrainedModel,
      )

else:
   import sys

   snake_case_ :  Union[str, Any]     =					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





