



"""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       SCREAMING_SNAKE_CASE__  :

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=13      ,     _SCREAMING_SNAKE_CASE=7      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=99      ,     _SCREAMING_SNAKE_CASE=32      ,     _SCREAMING_SNAKE_CASE=5      ,     _SCREAMING_SNAKE_CASE=4      ,     _SCREAMING_SNAKE_CASE=37      ,     _SCREAMING_SNAKE_CASE="gelu"      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=512      ,     _SCREAMING_SNAKE_CASE=16      ,     _SCREAMING_SNAKE_CASE=2      ,     _SCREAMING_SNAKE_CASE=0.02      ,     _SCREAMING_SNAKE_CASE=3      ,     _SCREAMING_SNAKE_CASE=4      ,     _SCREAMING_SNAKE_CASE=None      ,     )  ->      Optional[Any]:





    '''simple docstring'''




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

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.vocab_size						)

    UpperCAmelCase	:					Any	=	None
    if self.use_token_type_ids:
     UpperCAmelCase	:					Union[str, Any]	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.type_vocab_size						)

    UpperCAmelCase	:					Union[str, Any]	=	None
    UpperCAmelCase	:					Dict	=	None
    UpperCAmelCase	:					Tuple	=	None
    if self.use_labels:
     UpperCAmelCase	:					Any	=	ids_tensor([self.batch_size]      ,     self.type_sequence_label_size						)
     UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.num_labels						)
     UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size]      ,     self.num_choices						)

    UpperCAmelCase	:					Union[str, 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      ,     )

    UpperCAmelCase	:					str	=	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 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	OpenAIGPTModel(config=_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					List[str]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     head_mask=_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					List[Any]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Tuple	=	model(_SCREAMING_SNAKE_CASE						)

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

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	OpenAIGPTLMHeadModel(_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					Dict	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     labels=_SCREAMING_SNAKE_CASE						)
    self.parent.assertEqual(result.loss.shape      ,     ()						)
    self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.seq_length, self.vocab_size)						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	OpenAIGPTDoubleHeadsModel(_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

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

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	self.num_labels
    UpperCAmelCase	:					Optional[int]	=	OpenAIGPTForSequenceClassification(_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size]      ,     self.type_sequence_label_size						)
    UpperCAmelCase	:					Optional[int]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     labels=_SCREAMING_SNAKE_CASE						)
    self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.num_labels)						)




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.prepare_config_and_inputs()
    (
        (
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		
    )	:					Any	=	config_and_inputs
    UpperCAmelCase	:					Dict	=	{
        """input_ids""": input_ids,
        """token_type_ids""": token_type_ids,
        """head_mask""": head_mask,
    }

    return config, inputs_dict



@require_torch
class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			UpperCAmelCase__      ,			UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   Union[str, Any]						=						(
       (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
       if is_torch_available()
       else ()
   )
   __lowerCAmelCase  :   Union[str, Any]						=						(
       (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
   )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
   __lowerCAmelCase  :   int						=						(
       {
           'feature-extraction': OpenAIGPTModel,
           'text-classification': OpenAIGPTForSequenceClassification,
           'text-generation': OpenAIGPTLMHeadModel,
           'zero-shot': OpenAIGPTForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      List[str]:





    '''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 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=False						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	super()._prepare_for_class(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     return_labels=_SCREAMING_SNAKE_CASE						)

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

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	OpenAIGPTModelTester(self						)
    UpperCAmelCase	:					Any	=	ConfigTester(self      ,     config_class=_SCREAMING_SNAKE_CASE      ,     n_embd=37						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    self.config_tester.run_common_tests()

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_openai_gpt_model(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_lm_head_model(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[str]:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_double_lm_head_model(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_SCREAMING_SNAKE_CASE						)




   @slow
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[Any]:





    '''simple docstring'''




    for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     UpperCAmelCase	:					Optional[Any]	=	OpenAIGPTModel.from_pretrained(_SCREAMING_SNAKE_CASE						)
     self.assertIsNotNone(_SCREAMING_SNAKE_CASE						)



@require_torch
class       SCREAMING_SNAKE_CASE__  (					unittest.TestCase ):

   @slow
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Union[str, Any]	=	OpenAIGPTLMHeadModel.from_pretrained("""openai-gpt"""						)
    model.to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Dict	=	torch.tensor([[481, 4735, 544]]      ,     dtype=torch.long      ,     device=_SCREAMING_SNAKE_CASE						)  # the president is
    UpperCAmelCase	:					Optional[int]	=	[
        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

    UpperCAmelCase	:					List[Any]	=	model.generate(_SCREAMING_SNAKE_CASE      ,     do_sample=_SCREAMING_SNAKE_CASE						)
    self.assertListEqual(output_ids[0].tolist()      ,     _SCREAMING_SNAKE_CASE						)


'''simple docstring'''







from __future__ import annotations

from collections.abc import Iterator
from typing import Generic, TypeVar

__lowerCAmelCase         =    TypeVar("""T""")







class UpperCAmelCase__	( Generic[T]	):





  """simple docstring"""

  def __init__(		self      :     Tuple							,_a      :     T       ):


     '''simple docstring'''






     _a				:	List[str]			=   data
     _a				:	Node[T] | None			=   None


  def __str__(		self      :     Dict       ):


     '''simple docstring'''






     return F"""{self.data}"""







class UpperCAmelCase__	( Generic[T]	):





  """simple docstring"""

  def __init__(		self      :     Optional[int]       ):


     '''simple docstring'''






     _a				:	Node[T] | None			=   None


  def __iter__(		self      :     str       ):


     '''simple docstring'''






     _a				:	Tuple			=   self.top
     while node:
        yield node.data
        _a				:	int			=   node.next


  def __str__(		self      :     str       ):


     '''simple docstring'''






     return "->".join([str(_a       ) for item in self]       )


  def __len__(		self      :     Optional[Any]       ):


     '''simple docstring'''






     return len(tuple(iter(self       )       )       )


  def   __lowercase		(		self      :     str       ):


     '''simple docstring'''






     return self.top is None


  def   __lowercase		(		self      :     List[Any]							,_a      :     T       ):


     '''simple docstring'''






     _a				:	int			=   Node(_a       )
     if not self.is_empty():
        _a				:	Optional[Any]			=   self.top
     _a				:	List[str]			=   node


  def   __lowercase		(		self      :     Tuple       ):


     '''simple docstring'''






     if self.is_empty():
        raise IndexError('pop from empty stack'       )
     assert isinstance(self.top							,_a       )
     _a				:	List[Any]			=   self.top
     _a				:	int			=   self.top.next
     return pop_node.data


  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     if self.is_empty():
        raise IndexError('peek from empty stack'       )

     assert self.top is not None
     return self.top.data


  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     _a				:	Optional[int]			=   None


if __name__ == "__main__":
  from doctest import testmod

  testmod()



