


'''simple docstring'''


import unittest

from transformers import MraConfig, 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


if is_torch_available():
     import torch

     from transformers import (
         MraForMaskedLM,
         MraForMultipleChoice,
         MraForQuestionAnswering,
         MraForSequenceClassification,
         MraForTokenClassification,
         MraModel,
     )
     from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST



class 	__lowerCAmelCase		:


       '''simple docstring'''







       def __init__(							self :       Optional[int]	,_a :       Dict	,_a :       Any=2	,_a :       Dict=8	,_a :       str=True	,_a :       List[Any]=True	,_a :       int=True	,_a :       Union[str, Any]=True	,_a :       List[str]=99	,_a :       Any=16	,_a :       Optional[Any]=5	,_a :       Any=2	,_a :       List[Any]=36	,_a :       Any="gelu"	,_a :       str=0.0	,_a :       List[str]=0.0	,_a :       Union[str, Any]=512	,_a :       Dict=16	,_a :       str=2	,_a :       Any=0.02	,_a :       Union[str, Any]=3	,_a :       List[str]=4	,_a :       Optional[int]=None	,):

             '''simple docstring'''




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






       def        _a							(							self :       Tuple ):

             '''simple docstring'''




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

             A_						:  int          =				None
             if self.use_input_mask:
                   A_						:  Dict          =				random_attention_mask([self.batch_size, self.seq_length] )

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

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

             A_						:  Optional[Any]          =				self.get_config()

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






       def        _a							(							self :       Optional[Any] ):

             '''simple docstring'''




             return MraConfig(
                 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=_a	,initializer_range=self.initializer_range	,)






       def        _a							(							self :       Tuple ):

             '''simple docstring'''




             A_						:  Union[str, Any]          =				self.get_config()
             A_						:  Dict          =				300
             return config






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

             '''simple docstring'''




             (
                 A_					
             )						:  Union[str, Any]          =				self.prepare_config_and_inputs()

             A_						:  Optional[int]          =				True
             A_						:  Tuple          =				floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
             A_						:  Tuple          =				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        _a							(							self :       Tuple	,_a :       str	,_a :       Optional[int]	,_a :       List[Any]	,_a :       Optional[int]	,_a :       str	,_a :       str	,_a :       List[Any] ):

             '''simple docstring'''




             A_						:  List[Any]          =				MraModel(config=_a )
             model.to(_a )
             model.eval()
             A_						:  Any          =				model(_a	,attention_mask=_a	,token_type_ids=_a )
             A_						:  List[str]          =				model(_a	,token_type_ids=_a )
             A_						:  str          =				model(_a )
             self.parent.assertEqual(result.last_hidden_state.shape	,(self.batch_size, self.seq_length, self.hidden_size) )






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

             '''simple docstring'''




             A_						:  Optional[int]          =				True
             A_						:  Any          =				MraModel(_a )
             model.to(_a )
             model.eval()
             A_						:  List[Any]          =				model(
                 _a	,attention_mask=_a	,token_type_ids=_a	,encoder_hidden_states=_a	,encoder_attention_mask=_a	,)
             A_						:  str          =				model(
                 _a	,attention_mask=_a	,token_type_ids=_a	,encoder_hidden_states=_a	,)
             A_						:  Union[str, Any]          =				model(_a	,attention_mask=_a	,token_type_ids=_a )
             self.parent.assertEqual(result.last_hidden_state.shape	,(self.batch_size, self.seq_length, self.hidden_size) )






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

             '''simple docstring'''




             A_						:  Optional[Any]          =				MraForMaskedLM(config=_a )
             model.to(_a )
             model.eval()
             A_						:  Optional[int]          =				model(_a	,attention_mask=_a	,token_type_ids=_a	,labels=_a )
             self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.vocab_size) )






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

             '''simple docstring'''




             A_						:  str          =				MraForQuestionAnswering(config=_a )
             model.to(_a )
             model.eval()
             A_						:  Any          =				model(
                 _a	,attention_mask=_a	,token_type_ids=_a	,start_positions=_a	,end_positions=_a	,)
             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 :       str	,_a :       int	,_a :       str	,_a :       Optional[int]	,_a :       Any	,_a :       Optional[Any]	,_a :       str	,_a :       int ):

             '''simple docstring'''




             A_						:  Optional[Any]          =				self.num_labels
             A_						:  Dict          =				MraForSequenceClassification(_a )
             model.to(_a )
             model.eval()
             A_						:  List[str]          =				model(_a	,attention_mask=_a	,token_type_ids=_a	,labels=_a )
             self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.num_labels) )






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

             '''simple docstring'''




             A_						:  Any          =				self.num_labels
             A_						:  Union[str, Any]          =				MraForTokenClassification(config=_a )
             model.to(_a )
             model.eval()
             A_						:  Any          =				model(_a	,attention_mask=_a	,token_type_ids=_a	,labels=_a )
             self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.num_labels) )






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

             '''simple docstring'''




             A_						:  Any          =				self.num_choices
             A_						:  int          =				MraForMultipleChoice(config=_a )
             model.to(_a )
             model.eval()
             A_						:  Optional[int]          =				input_ids.unsqueeze(1 ).expand(-1	,self.num_choices	,-1 ).contiguous()
             A_						:  Optional[int]          =				token_type_ids.unsqueeze(1 ).expand(-1	,self.num_choices	,-1 ).contiguous()
             A_						:  Any          =				input_mask.unsqueeze(1 ).expand(-1	,self.num_choices	,-1 ).contiguous()
             A_						:  Optional[int]          =				model(
                 _a	,attention_mask=_a	,token_type_ids=_a	,labels=_a	,)
             self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.num_choices) )






       def        _a							(							self :       str ):

             '''simple docstring'''




             A_						:  Any          =				self.prepare_config_and_inputs()
             (
                 A_					
             )						:  Optional[Any]          =				config_and_inputs
             A_						:  Dict          =				{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
             return config, inputs_dict







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


       '''simple docstring'''







       a_  					=							(
           (
               MraModel,
               MraForMaskedLM,
               MraForMultipleChoice,
               MraForQuestionAnswering,
               MraForSequenceClassification,
               MraForTokenClassification,
           )
           if is_torch_available()
           else ()
       )
       a_  					=							False
       a_  					=							False
       a_  					=							False
       a_  					=							False

       a_  					=							()






       def        _a							(							self :       Optional[Any] ):

             '''simple docstring'''




             A_						:  List[str]          =				MraModelTester(self )
             A_						:  Optional[int]          =				ConfigTester(self	,config_class=_a	,hidden_size=37 )






       def        _a							(							self :       Any ):

             '''simple docstring'''




             self.config_tester.run_common_tests()






       def        _a							(							self :       List[Any] ):

             '''simple docstring'''




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






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

             '''simple docstring'''




             A_						:  Any          =				self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                   A_						:  List[Any]          =				type
                   self.model_tester.create_and_check_model(*_a )






       def        _a							(							self :       Tuple ):

             '''simple docstring'''




             A_						:  Optional[Any]          =				self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_lm(*_a )






       def        _a							(							self :       Tuple ):

             '''simple docstring'''




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






       def        _a							(							self :       List[str] ):

             '''simple docstring'''




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






       def        _a							(							self :       Tuple ):

             '''simple docstring'''




             A_						:  Optional[int]          =				self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_sequence_classification(*_a )






       def        _a							(							self :       int ):

             '''simple docstring'''




             A_						:  Optional[int]          =				self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_token_classification(*_a )






       @slow
       def        _a							(							self :       Tuple ):

             '''simple docstring'''




             for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   A_						:  Dict          =				MraModel.from_pretrained(_a )
                   self.assertIsNotNone(_a )






       @unittest.skip(reason="""MRA does not output attentions""" )
       def        _a							(							self :       Tuple ):

             '''simple docstring'''




             return







@require_torch
class 	__lowerCAmelCase		(							unittest.TestCase    ):


       '''simple docstring'''







       @slow
       def        _a							(							self :       str ):

             '''simple docstring'''




             A_						:  Any          =				MraModel.from_pretrained("""uw-madison/mra-base-512-4""" )
             A_						:  Dict          =				torch.arange(256 ).unsqueeze(0 )

             with torch.no_grad():
                   A_						:  Any          =				model(_a )[0]

             A_						:  str          =				torch.Size((1, 256, 768) )
             self.assertEqual(output.shape	,_a )

             A_						:  List[Any]          =				torch.tensor(
                 [[[-0.0140, 0.0830, -0.0381], [0.1546, 0.1402, 0.0220], [0.1162, 0.0851, 0.0165]]] )

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






       @slow
       def        _a							(							self :       Tuple ):

             '''simple docstring'''




             A_						:  Optional[int]          =				MraForMaskedLM.from_pretrained("""uw-madison/mra-base-512-4""" )
             A_						:  Union[str, Any]          =				torch.arange(256 ).unsqueeze(0 )

             with torch.no_grad():
                   A_						:  Tuple          =				model(_a )[0]

             A_						:  str          =				50265

             A_						:  Dict          =				torch.Size((1, 256, vocab_size) )
             self.assertEqual(output.shape	,_a )

             A_						:  Tuple          =				torch.tensor(
                 [[[9.2595, -3.6038, 11.8819], [9.3869, -3.2693, 11.0956], [11.8524, -3.4938, 13.1210]]] )

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






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

             '''simple docstring'''




             A_						:  str          =				MraForMaskedLM.from_pretrained("""uw-madison/mra-base-4096-8-d3""" )
             A_						:  Optional[int]          =				torch.arange(4096 ).unsqueeze(0 )

             with torch.no_grad():
                   A_						:  List[Any]          =				model(_a )[0]

             A_						:  List[str]          =				50265

             A_						:  Union[str, Any]          =				torch.Size((1, 4096, vocab_size) )
             self.assertEqual(output.shape	,_a )

             A_						:  Optional[int]          =				torch.tensor(
                 [[[5.4789, -2.3564, 7.5064], [7.9067, -1.3369, 9.9668], [9.0712, -1.8106, 7.0380]]] )

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




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