





from typing import TYPE_CHECKING

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


__A       : Dict						    = {
    "configuration_deberta_v2": ["DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP", "DebertaV2Config", "DebertaV2OnnxConfig"],
    "tokenization_deberta_v2": ["DebertaV2Tokenizer"],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A       : Dict						    = ["DebertaV2TokenizerFast"]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A       : List[Any]						    = [
     "TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST",
     "TFDebertaV2ForMaskedLM",
     "TFDebertaV2ForQuestionAnswering",
     "TFDebertaV2ForSequenceClassification",
     "TFDebertaV2ForTokenClassification",
     "TFDebertaV2Model",
     "TFDebertaV2PreTrainedModel",
 ]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A       : Tuple						    = [
     "DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST",
     "DebertaV2ForMaskedLM",
     "DebertaV2ForMultipleChoice",
     "DebertaV2ForQuestionAnswering",
     "DebertaV2ForSequenceClassification",
     "DebertaV2ForTokenClassification",
     "DebertaV2Model",
     "DebertaV2PreTrainedModel",
 ]


if TYPE_CHECKING:
 from .configuration_deberta_va import (
     DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP,
     DebertaVaConfig,
     DebertaVaOnnxConfig,
 )
 from .tokenization_deberta_va import DebertaVaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_deberta_va_fast import DebertaVaTokenizerFast

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_deberta_va import (
      TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFDebertaVaForMaskedLM,
      TFDebertaVaForQuestionAnswering,
      TFDebertaVaForSequenceClassification,
      TFDebertaVaForTokenClassification,
      TFDebertaVaModel,
      TFDebertaVaPreTrainedModel,
  )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_deberta_va import (
      DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
      DebertaVaForMaskedLM,
      DebertaVaForMultipleChoice,
      DebertaVaForQuestionAnswering,
      DebertaVaForSequenceClassification,
      DebertaVaForTokenClassification,
      DebertaVaModel,
      DebertaVaPreTrainedModel,
  )

else:
 import sys

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












import unittest

from transformers import YosoConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     YosoForMaskedLM,
     YosoForMultipleChoice,
     YosoForQuestionAnswering,
     YosoForSequenceClassification,
     YosoForTokenClassification,
     YosoModel,
 )
 from transformers.models.yoso.modeling_yoso import YOSO_PRETRAINED_MODEL_ARCHIVE_LIST







class     lowerCamelCase:
     '''simple docstring'''


     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_=3							,    snake_case_=4							,    snake_case_=None							,    ):
         _A    =       parent
         _A    =       batch_size
         _A    =       seq_length
         _A    =       is_training
         _A    =       use_input_mask
         _A    =       use_token_type_ids
         _A    =       use_labels
         _A    =       vocab_size
         _A    =       hidden_size
         _A    =       num_hidden_layers
         _A    =       num_attention_heads
         _A    =       intermediate_size
         _A    =       hidden_act
         _A    =       hidden_dropout_prob
         _A    =       attention_probs_dropout_prob
         _A    =       max_position_embeddings
         _A    =       type_vocab_size
         _A    =       type_sequence_label_size
         _A    =       initializer_range
         _A    =       num_labels
         _A    =       num_choices
         _A    =       scope




     def 					lowerCAmelCase__		(						self       ):
         _A    =       ids_tensor([self.batch_size, self.seq_length]							,    self.vocab_size       )

         _A    =       None
         if self.use_input_mask:
             _A    =       random_attention_mask([self.batch_size, self.seq_length]       )

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

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

         _A    =       self.get_config()

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




     def 					lowerCAmelCase__		(						self       ):
         return YosoConfig(
             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							,    is_decoder=snake_case_							,    initializer_range=self.initializer_range							,    )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.get_config()
         _A    =       300
         return config




     def 					lowerCAmelCase__		(						self       ):
         (
             (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), 
         )    =       self.prepare_config_and_inputs()

         _A    =       True
         _A    =       floats_tensor([self.batch_size, self.seq_length, self.hidden_size]       )
         _A    =       ids_tensor([self.batch_size, self.seq_length]							,    vocab_size=2       )

         return (
             config,
             input_ids,
             token_type_ids,
             input_mask,
             sequence_labels,
             token_labels,
             choice_labels,
             encoder_hidden_states,
             encoder_attention_mask,
         )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       YosoModel(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_       )
         _A    =       model(snake_case_							,    token_type_ids=snake_case_       )
         _A    =       model(snake_case_       )
         self.parent.assertEqual(result.last_hidden_state.shape							,    (self.batch_size, self.seq_length, self.hidden_size)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    ):
         _A    =       True
         _A    =       YosoModel(snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(
             snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    encoder_hidden_states=snake_case_							,    encoder_attention_mask=snake_case_							,    )
         _A    =       model(
             snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    encoder_hidden_states=snake_case_							,    )
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_       )
         self.parent.assertEqual(result.last_hidden_state.shape							,    (self.batch_size, self.seq_length, self.hidden_size)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       YosoForMaskedLM(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       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 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       YosoForQuestionAnswering(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       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 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       self.num_labels
         _A    =       YosoForSequenceClassification(snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       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_labels)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       self.num_labels
         _A    =       YosoForTokenClassification(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       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 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       self.num_choices
         _A    =       YosoForMultipleChoice(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       input_ids.unsqueeze(1       ).expand(-1							,    self.num_choices							,    -1       ).contiguous()
         _A    =       token_type_ids.unsqueeze(1       ).expand(-1							,    self.num_choices							,    -1       ).contiguous()
         _A    =       input_mask.unsqueeze(1       ).expand(-1							,    self.num_choices							,    -1       ).contiguous()
         _A    =       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 					lowerCAmelCase__		(						self       ):
         _A    =       self.prepare_config_and_inputs()
         (
             (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), 
         )    =       config_and_inputs
         _A    =       {'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'''


     __magic_name__        = (
         (
             YosoModel,
             YosoForMaskedLM,
             YosoForMultipleChoice,
             YosoForQuestionAnswering,
             YosoForSequenceClassification,
             YosoForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     __magic_name__        = False
     __magic_name__        = False
     __magic_name__        = False

     __magic_name__        = ()
     __magic_name__        = (
         {
             'feature-extraction': YosoModel,
             'fill-mask': YosoForMaskedLM,
             'question-answering': YosoForQuestionAnswering,
             'text-classification': YosoForSequenceClassification,
             'token-classification': YosoForTokenClassification,
             'zero-shot': YosoForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoModelTester(self       )
         _A    =       ConfigTester(self							,    config_class=snake_case_							,    hidden_size=37       )




     def 					lowerCAmelCase__		(						self       ):
         self.config_tester.run_common_tests()




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
             _A    =       type
             self.model_tester.create_and_check_model(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*snake_case_       )




     @slow
     def 					lowerCAmelCase__		(						self       ):
         for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _A    =       YosoModel.from_pretrained(snake_case_       )
             self.assertIsNotNone(snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         return







@require_torch
class     lowerCamelCase(	unittest.TestCase  ):
     '''simple docstring'''


     @slow
     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoModel.from_pretrained('uw-madison/yoso-4096'       )
         _A    =       torch.tensor([[0, 1, 2, 3, 4, 5]]       )

         with torch.no_grad():
             _A    =       model(snake_case_       )[0]

         _A    =       torch.Size((1, 6, 768)       )
         self.assertEqual(output.shape							,    snake_case_       )

         _A    =       torch.tensor(
             [[[-0.0611, 0.1242, 0.0840], [0.0280, -0.0048, 0.1125], [0.0106, 0.0226, 0.0751]]]       )

         self.assertTrue(torch.allclose(output[:, :3, :3]							,    snake_case_							,    atol=1E-4       )       )




     @slow
     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoForMaskedLM.from_pretrained('uw-madison/yoso-4096'       )
         _A    =       torch.tensor([[0, 1, 2, 3, 4, 5]]       )

         with torch.no_grad():
             _A    =       model(snake_case_       )[0]

         _A    =       5_0265

         _A    =       torch.Size((1, 6, vocab_size)       )
         self.assertEqual(output.shape							,    snake_case_       )

         _A    =       torch.tensor(
             [[[-2.1313, -3.7285, -2.2407], [-2.7047, -3.3314, -2.6408], [0.0629, -2.5166, -0.3356]]]       )

         self.assertTrue(torch.allclose(output[:, :3, :3]							,    snake_case_							,    atol=1E-4       )       )




     @slow
     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoForMaskedLM.from_pretrained('uw-madison/yoso-4096'       )
         _A    =       torch.arange(4096       ).unsqueeze(0       )

         with torch.no_grad():
             _A    =       model(snake_case_       )[0]

         _A    =       5_0265

         _A    =       torch.Size((1, 4096, vocab_size)       )
         self.assertEqual(output.shape							,    snake_case_       )

         _A    =       torch.tensor(
             [[[-2.3914, -4.3742, -5.0956], [-4.0988, -4.2384, -7.0406], [-3.1427, -3.7192, -6.6800]]]       )

         self.assertTrue(torch.allclose(output[:, :3, :3]							,    snake_case_							,    atol=1E-4       )       )





