


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     A__   (       snake_case__      ):







    """simple docstring"""

    def __init__(			self     ,   __snake_case     ,   __snake_case=1_3     ,   __snake_case=7     ,   __snake_case=True     ,   __snake_case=True     ,   __snake_case=True     ,   __snake_case=True     ,   __snake_case=9_9     ,   __snake_case=3_2     ,   __snake_case=5     ,   __snake_case=4     ,   __snake_case=3_7     ,   __snake_case="gelu"     ,   __snake_case=0.1     ,   __snake_case=0.1     ,   __snake_case=5_1_2     ,   __snake_case=1_6     ,   __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     ,   ):
         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 						a_     (			self       ):
         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 						a_     (			self       ):
         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 						a_     (			self       ):
         snake_case											=							self.get_config()
         snake_case											=							3_0_0
         return config
    def 						a_     (			self     ,   __snake_case       ):
         self.parent.assertListEqual(list(result.loss.size()       )     ,   []       )
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							DebertaModel(config=__snake_case       )
         model.to(__snake_case       )
         model.eval()
         snake_case											=							model(__snake_case     ,   attention_mask=__snake_case     ,   token_type_ids=__snake_case       )[0]
         snake_case											=							model(__snake_case     ,   token_type_ids=__snake_case       )[0]
         snake_case											=							model(__snake_case       )[0]

         self.parent.assertListEqual(list(sequence_output.size()       )     ,   [self.batch_size, self.seq_length, self.hidden_size]       )
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							DebertaForMaskedLM(config=__snake_case       )
         model.to(__snake_case       )
         model.eval()
         snake_case											=							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 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							self.num_labels
         snake_case											=							DebertaForSequenceClassification(__snake_case       )
         model.to(__snake_case       )
         model.eval()
         snake_case											=							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 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							self.num_labels
         snake_case											=							DebertaForTokenClassification(config=__snake_case       )
         model.to(__snake_case       )
         model.eval()
         snake_case											=							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 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							DebertaForQuestionAnswering(config=__snake_case       )
         model.to(__snake_case       )
         model.eval()
         snake_case											=							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 						a_     (			self       ):
         snake_case											=							self.prepare_config_and_inputs()
         (
             (
             snake_case
         )					,    (
             snake_case
         )					,    (
             snake_case
         )					,    (
             snake_case
         )					,    (
             snake_case
         )					,    (
             snake_case
         )					,    (
             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     A__   (       snake_case__			,   snake_case__			,   unittest.TestCase      ):







    """simple docstring"""

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

    __magic_name__         =						True
    __magic_name__         =						False
    __magic_name__         =						False
    __magic_name__         =						False
    __magic_name__         =						False
    def 						a_     (			self       ):
         snake_case											=							DebertaModelTester(self       )
         snake_case											=							ConfigTester(self     ,   config_class=__snake_case     ,   hidden_size=3_7       )
    def 						a_     (			self       ):
         self.config_tester.run_common_tests()
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_deberta_model(*__snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_deberta_for_sequence_classification(*__snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_deberta_for_masked_lm(*__snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_deberta_for_question_answering(*__snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_deberta_for_token_classification(*__snake_case       )




    @slow
    def 						a_     (			self       ):
         for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case											=							DebertaModel.from_pretrained(__snake_case       )
              self.assertIsNotNone(__snake_case       )






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







    """simple docstring"""

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




    @slow
    def 						a_     (			self       ):
         snake_case											=							DebertaModel.from_pretrained('''microsoft/deberta-base'''       )

         snake_case											=							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]]       )
         snake_case											=							torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]       )
         with torch.no_grad():
              snake_case											=							model(__snake_case     ,   attention_mask=__snake_case       )[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]     ,   __snake_case     ,   atol=1E-4       )     ,   F'''{output[:, 1:4, 1:4]}'''       )








from ...utils import is_torch_available, is_transformers_available


if is_transformers_available() and is_torch_available():
 from .pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings, VQDiffusionPipeline




