
'''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      _lowerCAmelCase       (       __snake_case ):







							'''simple docstring'''

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

							def 			lowercase				(self    )	->  Optional[Any]:
														_snake_case  =    ids_tensor([self.batch_size, self.seq_length]    ,    self.vocab_size    )

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

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

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

														_snake_case  =    self.get_config()

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

							def 			lowercase				(self    )	->  Any:
														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 			lowercase				(self    )	->  Optional[Any]:
														_snake_case  =    self.get_config()
														_snake_case  =    300
														return config

							def 			lowercase				(self    ,    UpperCAmelCase    )	->  Union[str, Any]:
														self.parent.assertListEqual(list(result.loss.size()    )    ,    []    )

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  Union[str, Any]:
														_snake_case  =    DebertaModel(config=__UpperCAmelCase    )
														model.to(__UpperCAmelCase    )
														model.eval()
														_snake_case  =    model(__UpperCAmelCase    ,    attention_mask=__UpperCAmelCase    ,    token_type_ids=__UpperCAmelCase    )[0]
														_snake_case  =    model(__UpperCAmelCase    ,    token_type_ids=__UpperCAmelCase    )[0]
														_snake_case  =    model(__UpperCAmelCase    )[0]

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

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  Optional[int]:
														_snake_case  =    DebertaForMaskedLM(config=__UpperCAmelCase    )
														model.to(__UpperCAmelCase    )
														model.eval()
														_snake_case  =    model(__UpperCAmelCase    ,    attention_mask=__UpperCAmelCase    ,    token_type_ids=__UpperCAmelCase    ,    labels=__UpperCAmelCase    )

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

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  List[str]:
														_snake_case  =    self.num_labels
														_snake_case  =    DebertaForSequenceClassification(__UpperCAmelCase    )
														model.to(__UpperCAmelCase    )
														model.eval()
														_snake_case  =    model(__UpperCAmelCase    ,    attention_mask=__UpperCAmelCase    ,    token_type_ids=__UpperCAmelCase    ,    labels=__UpperCAmelCase    )
														self.parent.assertListEqual(list(result.logits.size()    )    ,    [self.batch_size, self.num_labels]    )
														self.check_loss_output(__UpperCAmelCase    )

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  str:
														_snake_case  =    self.num_labels
														_snake_case  =    DebertaForTokenClassification(config=__UpperCAmelCase    )
														model.to(__UpperCAmelCase    )
														model.eval()
														_snake_case  =    model(__UpperCAmelCase    ,    attention_mask=__UpperCAmelCase    ,    token_type_ids=__UpperCAmelCase    ,    labels=__UpperCAmelCase    )
														self.parent.assertEqual(result.logits.shape    ,    (self.batch_size, self.seq_length, self.num_labels)    )

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  Any:
														_snake_case  =    DebertaForQuestionAnswering(config=__UpperCAmelCase    )
														model.to(__UpperCAmelCase    )
														model.eval()
														_snake_case  =    model(
														    __UpperCAmelCase    ,    attention_mask=__UpperCAmelCase    ,    token_type_ids=__UpperCAmelCase    ,    start_positions=__UpperCAmelCase    ,    end_positions=__UpperCAmelCase    ,    )
														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 			lowercase				(self    )	->  Optional[Any]:
														_snake_case  =    self.prepare_config_and_inputs()
														(
														    _snake_case							
														)  =    config_and_inputs
														_snake_case  =    {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
														return config, inputs_dict


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







							'''simple docstring'''

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

							lowerCAmelCase_   		=		True
							lowerCAmelCase_   		=		False
							lowerCAmelCase_   		=		False
							lowerCAmelCase_   		=		False
							lowerCAmelCase_   		=		False

							def 			lowercase				(self    )	->  Optional[int]:
														_snake_case  =    DebertaModelTester(self    )
														_snake_case  =    ConfigTester(self    ,    config_class=__UpperCAmelCase    ,    hidden_size=37    )

							def 			lowercase				(self    )	->  Tuple:
														self.config_tester.run_common_tests()

							def 			lowercase				(self    )	->  int:
														_snake_case  =    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_model(*__UpperCAmelCase    )

							def 			lowercase				(self    )	->  Tuple:
														_snake_case  =    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_for_sequence_classification(*__UpperCAmelCase    )

							def 			lowercase				(self    )	->  Dict:
														_snake_case  =    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_for_masked_lm(*__UpperCAmelCase    )

							def 			lowercase				(self    )	->  Tuple:
														_snake_case  =    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_for_question_answering(*__UpperCAmelCase    )

							def 			lowercase				(self    )	->  List[str]:
														_snake_case  =    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_for_token_classification(*__UpperCAmelCase    )





							@slow
							def 			lowercase				(self    )	->  int:

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


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







							'''simple docstring'''

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





							@slow
							def 			lowercase				(self    )	->  str:
														_snake_case  =    DebertaModel.from_pretrained("""microsoft/deberta-base"""    )

														_snake_case  =    torch.tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]    )
														_snake_case  =    torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]    )
														with torch.no_grad():
																					_snake_case  =    model(__UpperCAmelCase    ,    attention_mask=__UpperCAmelCase    )[0]
														# compare the actual values for a slice.
														_snake_case  =    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]    ,    __UpperCAmelCase    ,    atol=1e-4    )    ,    f"""{output[:, 1:4, 1:4]}"""    )






"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


__A											=						{}


try:
  if not is_sentencepiece_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __A											=						["""MLukeTokenizer"""]

if TYPE_CHECKING:
  try:
    if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_mluke import MLukeTokenizer


else:
  import sys

  __A											=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
