


'''simple docstring'''


import unittest

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

from ...generation.test_utils import GenerationTesterMixin
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 (
         OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
         OpenAIGPTConfig,
         OpenAIGPTDoubleHeadsModel,
         OpenAIGPTForSequenceClassification,
         OpenAIGPTLMHeadModel,
         OpenAIGPTModel,
     )



class 	__lowerCAmelCase		:


  '''simple docstring'''







  def __init__(							self :       Optional[int]	,_a :       List[Any]	,_a :       Dict=13	,_a :       List[Any]=7	,_a :       Optional[Any]=True	,_a :       Any=True	,_a :       Optional[int]=True	,_a :       Union[str, Any]=99	,_a :       Union[str, Any]=32	,_a :       List[str]=5	,_a :       List[str]=4	,_a :       Dict=37	,_a :       List[Any]="gelu"	,_a :       int=0.1	,_a :       Optional[int]=0.1	,_a :       Tuple=512	,_a :       Union[str, Any]=16	,_a :       Optional[Any]=2	,_a :       Optional[Any]=0.02	,_a :       Optional[int]=3	,_a :       str=4	,_a :       Optional[Any]=None	,):

        '''simple docstring'''




        A_						:  Optional[Any]          =				parent
        A_						:  str          =				batch_size
        A_						:  int          =				seq_length
        A_						:  Union[str, Any]          =				is_training
        A_						:  Optional[Any]          =				use_token_type_ids
        A_						:  int          =				use_labels
        A_						:  Dict          =				vocab_size
        A_						:  List[Any]          =				hidden_size
        A_						:  Tuple          =				num_hidden_layers
        A_						:  Optional[int]          =				num_attention_heads
        A_						:  int          =				intermediate_size
        A_						:  Tuple          =				hidden_act
        A_						:  int          =				hidden_dropout_prob
        A_						:  Dict          =				attention_probs_dropout_prob
        A_						:  Any          =				max_position_embeddings
        A_						:  Optional[Any]          =				type_vocab_size
        A_						:  Tuple          =				type_sequence_label_size
        A_						:  int          =				initializer_range
        A_						:  Optional[Any]          =				num_labels
        A_						:  str          =				num_choices
        A_						:  Optional[Any]          =				scope
        A_						:  List[Any]          =				self.vocab_size - 1






  def        _a							(							self :       Any ):

        '''simple docstring'''




        A_						:  List[Any]          =				ids_tensor([self.batch_size, self.seq_length]	,self.vocab_size )

        A_						:  List[Any]          =				None
        if self.use_token_type_ids:
              A_						:  Optional[int]          =				ids_tensor([self.batch_size, self.seq_length]	,self.type_vocab_size )

        A_						:  int          =				None
        A_						:  str          =				None
        A_						:  Union[str, Any]          =				None
        if self.use_labels:
              A_						:  Optional[int]          =				ids_tensor([self.batch_size]	,self.type_sequence_label_size )
              A_						:  str          =				ids_tensor([self.batch_size, self.seq_length]	,self.num_labels )
              A_						:  Any          =				ids_tensor([self.batch_size]	,self.num_choices )

        A_						:  List[Any]          =				OpenAIGPTConfig(
            vocab_size=self.vocab_size	,n_embd=self.hidden_size	,n_layer=self.num_hidden_layers	,n_head=self.num_attention_heads	,n_positions=self.max_position_embeddings	,pad_token_id=self.pad_token_id	,)

        A_						:  Tuple          =				ids_tensor([self.num_hidden_layers, self.num_attention_heads]	,2 )

        return (
            config,
            input_ids,
            head_mask,
            token_type_ids,
            sequence_labels,
            token_labels,
            choice_labels,
        )






  def        _a							(							self :       Optional[int]	,_a :       List[str]	,_a :       str	,_a :       int	,_a :       int	,*_a :       Union[str, Any] ):

        '''simple docstring'''




        A_						:  Optional[Any]          =				OpenAIGPTModel(config=_a )
        model.to(_a )
        model.eval()

        A_						:  Optional[int]          =				model(_a	,token_type_ids=_a	,head_mask=_a )
        A_						:  str          =				model(_a	,token_type_ids=_a )
        A_						:  Dict          =				model(_a )

        self.parent.assertEqual(result.last_hidden_state.shape	,(self.batch_size, self.seq_length, self.hidden_size) )






  def        _a							(							self :       Dict	,_a :       Optional[int]	,_a :       Union[str, Any]	,_a :       Dict	,_a :       List[str]	,*_a :       str ):

        '''simple docstring'''




        A_						:  str          =				OpenAIGPTLMHeadModel(_a )
        model.to(_a )
        model.eval()

        A_						:  Any          =				model(_a	,token_type_ids=_a	,labels=_a )
        self.parent.assertEqual(result.loss.shape	,() )
        self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.vocab_size) )






  def        _a							(							self :       Any	,_a :       Dict	,_a :       List[Any]	,_a :       Dict	,_a :       Union[str, Any]	,*_a :       str ):

        '''simple docstring'''




        A_						:  Any          =				OpenAIGPTDoubleHeadsModel(_a )
        model.to(_a )
        model.eval()

        A_						:  Optional[int]          =				model(_a	,token_type_ids=_a	,labels=_a )
        self.parent.assertEqual(result.loss.shape	,() )
        self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.vocab_size) )






  def        _a							(							self :       List[str]	,_a :       str	,_a :       Tuple	,_a :       Dict	,_a :       Tuple	,*_a :       Dict ):

        '''simple docstring'''




        A_						:  List[str]          =				self.num_labels
        A_						:  int          =				OpenAIGPTForSequenceClassification(_a )
        model.to(_a )
        model.eval()

        A_						:  Dict          =				ids_tensor([self.batch_size]	,self.type_sequence_label_size )
        A_						:  Optional[Any]          =				model(_a	,token_type_ids=_a	,labels=_a )
        self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.num_labels) )






  def        _a							(							self :       Tuple ):

        '''simple docstring'''




        A_						:  Union[str, Any]          =				self.prepare_config_and_inputs()
        (
            (
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					(
            A_
        )   ,					
        )						:  str          =				config_and_inputs
        A_						:  int          =				{
            """input_ids""": input_ids,
            """token_type_ids""": token_type_ids,
            """head_mask""": head_mask,
        }

        return config, inputs_dict







@require_torch
class 	__lowerCAmelCase		(							__SCREAMING_SNAKE_CASE  , __SCREAMING_SNAKE_CASE  , __SCREAMING_SNAKE_CASE  , unittest.TestCase    ):


  '''simple docstring'''







  a_  					=							(
      (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
      if is_torch_available()
      else ()
  )
  a_  					=							(
      (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
  )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
  a_  					=							(
      {
          """feature-extraction""": OpenAIGPTModel,
          """text-classification""": OpenAIGPTForSequenceClassification,
          """text-generation""": OpenAIGPTLMHeadModel,
          """zero-shot""": OpenAIGPTForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )






  def        _a							(							self :       Tuple	,_a :       Optional[int]	,_a :       str	,_a :       List[str]	,_a :       List[str]	,_a :       Any ):

        '''simple docstring'''




        if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
              # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
              # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
              # tiny config could not be created.
              return True

        return False






  def        _a							(							self :       Optional[int]	,_a :       str	,_a :       Dict	,_a :       Optional[int]=False ):

        '''simple docstring'''




        A_						:  Any          =				super()._prepare_for_class(_a	,_a	,return_labels=_a )

        if return_labels:
              if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
                    A_						:  Union[str, Any]          =				torch.zeros(
                        (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)	,dtype=torch.long	,device=_a	,)
                    A_						:  Any          =				inputs_dict["""labels"""]
                    A_						:  Any          =				inputs_dict["""labels"""]
                    A_						:  Tuple          =				torch.zeros(
                        (self.model_tester.batch_size, self.model_tester.num_choices)	,dtype=torch.long	,device=_a	,)
                    A_						:  int          =				torch.zeros(
                        self.model_tester.batch_size	,dtype=torch.long	,device=_a )
        return inputs_dict






  def        _a							(							self :       Union[str, Any] ):

        '''simple docstring'''




        A_						:  Tuple          =				OpenAIGPTModelTester(self )
        A_						:  Optional[int]          =				ConfigTester(self	,config_class=_a	,n_embd=37 )






  def        _a							(							self :       Any ):

        '''simple docstring'''




        self.config_tester.run_common_tests()






  def        _a							(							self :       Optional[Any] ):

        '''simple docstring'''




        A_						:  int          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_model(*_a )






  def        _a							(							self :       Tuple ):

        '''simple docstring'''




        A_						:  Dict          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_lm_head_model(*_a )






  def        _a							(							self :       List[Any] ):

        '''simple docstring'''




        A_						:  str          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_double_lm_head_model(*_a )






  def        _a							(							self :       Union[str, Any] ):

        '''simple docstring'''




        A_						:  List[Any]          =				self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_a )






  @slow
  def        _a							(							self :       List[Any] ):

        '''simple docstring'''




        for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              A_						:  Union[str, Any]          =				OpenAIGPTModel.from_pretrained(_a )
              self.assertIsNotNone(_a )







@require_torch
class 	__lowerCAmelCase		(							unittest.TestCase    ):


  '''simple docstring'''







  @slow
  def        _a							(							self :       List[str] ):

        '''simple docstring'''




        A_						:  Dict          =				OpenAIGPTLMHeadModel.from_pretrained("""openai-gpt""" )
        model.to(_a )
        A_						:  Dict          =				torch.tensor([[481, 4735, 544]]	,dtype=torch.long	,device=_a )  # the president is
        A_						:  Dict          =				[
            481,
            4735,
            544,
            246,
            963,
            870,
            762,
            239,
            244,
            40477,
            244,
            249,
            719,
            881,
            487,
            544,
            240,
            244,
            603,
            481,
        ]  # the president is a very good man. " \n " i\'m sure he is, " said the

        A_						:  int          =				model.generate(_a	,do_sample=_a )
        self.assertListEqual(output_ids[0].tolist()	,_a )




'''simple docstring'''


from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
     from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


__magic_name__			=      logging.get_logger(__name__)

__magic_name__			=      {
    'microsoft/deberta-v2-xlarge': 'https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json',
    'microsoft/deberta-v2-xxlarge': 'https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json',
    'microsoft/deberta-v2-xlarge-mnli': (
        'https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json'
    ),
    'microsoft/deberta-v2-xxlarge-mnli': (
        'https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json'
    ),
}



class 	__lowerCAmelCase		(							__SCREAMING_SNAKE_CASE    ):


  '''simple docstring'''







  a_  					=							"""deberta-v2"""






  def __init__(							self :       Optional[Any]	,_a :       Union[str, Any]=128100	,_a :       Optional[int]=1536	,_a :       Dict=24	,_a :       int=24	,_a :       Tuple=6144	,_a :       Union[str, Any]="gelu"	,_a :       List[Any]=0.1	,_a :       Dict=0.1	,_a :       int=512	,_a :       int=0	,_a :       int=0.02	,_a :       int=1e-7	,_a :       List[str]=False	,_a :       Union[str, Any]=-1	,_a :       List[Any]=0	,_a :       Optional[Any]=True	,_a :       Tuple=None	,_a :       Any=0	,_a :       int="gelu"	,**_a :       Any	,):

        '''simple docstring'''




        super().__init__(**_a )

        A_						:  Union[str, Any]          =				hidden_size
        A_						:  Dict          =				num_hidden_layers
        A_						:  Union[str, Any]          =				num_attention_heads
        A_						:  List[Any]          =				intermediate_size
        A_						:  List[Any]          =				hidden_act
        A_						:  Optional[int]          =				hidden_dropout_prob
        A_						:  Dict          =				attention_probs_dropout_prob
        A_						:  int          =				max_position_embeddings
        A_						:  Any          =				type_vocab_size
        A_						:  List[Any]          =				initializer_range
        A_						:  int          =				relative_attention
        A_						:  Tuple          =				max_relative_positions
        A_						:  int          =				pad_token_id
        A_						:  Tuple          =				position_biased_input

        # Backwards compatibility
        if type(_a ) == str:
              A_						:  str          =				[x.strip() for x in pos_att_type.lower().split("""|""" )]

        A_						:  Any          =				pos_att_type
        A_						:  Optional[int]          =				vocab_size
        A_						:  Tuple          =				layer_norm_eps

        A_						:  Any          =				kwargs.get("""pooler_hidden_size"""	,_a )
        A_						:  Union[str, Any]          =				pooler_dropout
        A_						:  List[Any]          =				pooler_hidden_act







class 	__lowerCAmelCase		(							__SCREAMING_SNAKE_CASE    ):


  '''simple docstring'''







  @property
  def        _a							(							self :       Any ):

        '''simple docstring'''




        if self.task == "multiple-choice":
              A_						:  Any          =				{0: """batch""", 1: """choice""", 2: """sequence"""}
        else:
              A_						:  Any          =				{0: """batch""", 1: """sequence"""}
        if self._config.type_vocab_size > 0:
              return OrderedDict(
                  [("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis)] )
        else:
              return OrderedDict([("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis)] )






  @property
  def        _a							(							self :       Optional[int] ):

        '''simple docstring'''




        return 12






  def        _a							(							self :       int	,_a :       Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]	,_a :       int = -1	,_a :       int = -1	,_a :       int = -1	,_a :       bool = False	,_a :       Optional["TensorType"] = None	,_a :       int = 3	,_a :       int = 40	,_a :       int = 40	,_a :       "PreTrainedTokenizerBase" = None	,):

        '''simple docstring'''




        A_						:  Any          =				super().generate_dummy_inputs(preprocessor=_a	,framework=_a )
        if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
              del dummy_inputs["token_type_ids"]
        return dummy_inputs
