

'''simple docstring'''

import unittest
from unittest.util import safe_repr

from transformers import AutoTokenizer, RwkvConfig, 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, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import (
						    RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
						    RwkvForCausalLM,
						    RwkvModel,
						)
						from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_0
else:
						lowerCAmelCase_     =      False







class lowerCamelCase   :

				def __init__(       self,						lowercase_,						lowercase_=14,						lowercase_=7,						lowercase_=True,						lowercase_=False,						lowercase_=True,						lowercase_=True,						lowercase_=True,						lowercase_=99,						lowercase_=32,						lowercase_=5,						lowercase_=37,						lowercase_="gelu",						lowercase_=0.1,						lowercase_=0.1,						lowercase_=512,						lowercase_=16,						lowercase_=2,						lowercase_=3,						lowercase_=4,						lowercase_=None,						)    ->							str:
					snake_case							=					parent
					snake_case							=					batch_size
					snake_case							=					seq_length
					snake_case							=					is_training
					snake_case							=					use_token_type_ids
					snake_case							=					use_input_mask
					snake_case							=					use_labels
					snake_case							=					use_mc_token_ids
					snake_case							=					vocab_size
					snake_case							=					hidden_size
					snake_case							=					num_hidden_layers
					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							=					num_labels
					snake_case							=					num_choices
					snake_case							=					scope
					snake_case							=					vocab_size - 1
					snake_case							=					vocab_size - 1
					snake_case							=					vocab_size - 1

				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					return RwkvConfig.from_pretrained('sgugger/rwkv-4-pile-7b' )

				def 					_lowerCamelCase    (       self,						lowercase_=False,						lowercase_=False,						lowercase_=False )    ->							Any:
					snake_case							=					ids_tensor([self.batch_size, self.seq_length],						self.vocab_size )

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

					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
					if self.use_mc_token_ids:
						snake_case							=					ids_tensor([self.batch_size, self.num_choices],						self.seq_length )

					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(
					    gradient_checkpointing=lowercase_,						scale_attn_by_inverse_layer_idx=lowercase_,						reorder_and_upcast_attn=lowercase_,						)

					return (
					    config,
					    input_ids,
					    input_mask,
					    None,
					    token_type_ids,
					    mc_token_ids,
					    sequence_labels,
					    token_labels,
					    choice_labels,
					)

				def 					_lowerCamelCase    (       self,						lowercase_=False,						lowercase_=False,						lowercase_=False )    ->							Optional[Any]:
					return RwkvConfig(
					    vocab_size=self.vocab_size,						hidden_size=self.hidden_size,						num_hidden_layers=self.num_hidden_layers,						intermediate_size=self.intermediate_size,						activation_function=self.hidden_act,						resid_pdrop=self.hidden_dropout_prob,						attn_pdrop=self.attention_probs_dropout_prob,						n_positions=self.max_position_embeddings,						type_vocab_size=self.type_vocab_size,						use_cache=lowercase_,						bos_token_id=self.bos_token_id,						eos_token_id=self.eos_token_id,						pad_token_id=self.pad_token_id,						gradient_checkpointing=lowercase_,						scale_attn_by_inverse_layer_idx=lowercase_,						reorder_and_upcast_attn=lowercase_,						)

				def 					_lowerCamelCase    (       self )    ->							int:
					snake_case							=					self.get_config()
					snake_case							=					300
					return config

				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					(
					    (
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			
					)							=					self.prepare_config_and_inputs()

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

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

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_,						lowercase_,						lowercase_,						*lowercase_ )    ->							int:
					snake_case							=					True
					snake_case							=					RwkvModel(config=lowercase_ )
					model.to(lowercase_ )
					model.eval()

					snake_case							=					model(lowercase_ )

					self.parent.assertEqual(result.last_hidden_state.shape,						(self.batch_size, self.seq_length, self.hidden_size) )
					self.parent.assertEqual(len(result.hidden_states ),						config.num_hidden_layers + 1 )

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_,						lowercase_,						lowercase_,						*lowercase_ )    ->							Dict:
					snake_case							=					RwkvForCausalLM(lowercase_ )
					model.to(lowercase_ )
					model.eval()

					snake_case							=					model(lowercase_,						labels=lowercase_ )
					self.parent.assertEqual(result.loss.shape,						() )
					self.parent.assertEqual(result.logits.shape,						(self.batch_size, self.seq_length, self.vocab_size) )

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_,						lowercase_,						lowercase_,						*lowercase_ )    ->							int:
					snake_case							=					RwkvModel(config=lowercase_ )
					model.to(lowercase_ )
					model.eval()

					snake_case							=					model(lowercase_ )
					snake_case							=					outputs.last_hidden_state

					snake_case							=					model(input_ids[:, :2] )
					snake_case							=					outputs.last_hidden_state

					# Using the state computed on the first inputs, we will get the same output
					snake_case							=					model(input_ids[:, 2:],						state=outputs.state )
					snake_case							=					outputs.last_hidden_state

					self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two],						dim=1 ),						lowercase_,						atol=1E-5 ) )

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_,						lowercase_,						lowercase_,						*lowercase_,						lowercase_=False )    ->							List[str]:
					snake_case							=					RwkvForCausalLM(lowercase_ )
					model.to(lowercase_ )
					if gradient_checkpointing:
						model.gradient_checkpointing_enable()

					snake_case							=					model(lowercase_,						labels=lowercase_ )
					self.parent.assertEqual(result.loss.shape,						() )
					self.parent.assertEqual(result.logits.shape,						(self.batch_size, self.seq_length, self.vocab_size) )
					result.loss.backward()






				def 					_lowerCamelCase    (       self )    ->							Any:
					snake_case							=					self.prepare_config_and_inputs()

					(
					    (
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			(
					    snake_case
					)			,			
					)							=					config_and_inputs

					snake_case							=					{'input_ids': input_ids}

					return config, inputs_dict







@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0				,				reason='''See https://github.com/huggingface/transformers/pull/24204'''				)
@require_torch
class lowerCamelCase   (    __lowerCAmelCase				,				__lowerCAmelCase				,				__lowerCAmelCase				,				unittest.TestCase				):
				snake_case_							     = (RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
				snake_case_							     = (
				    {'''feature-extraction''': RwkvModel, '''text-generation''': RwkvForCausalLM} if is_torch_available() else {}
				)
				# all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False  # Rwkv does not support head masking

				def 					_lowerCamelCase    (       self )    ->							Any:
					snake_case							=					RwkvModelTester(self )
					snake_case							=					ConfigTester(
					    self,						config_class=lowercase_,						n_embd=37,						common_properties=['hidden_size', 'num_hidden_layers'] )

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_=None )    ->							Union[str, Any]:
					if isinstance(lowercase_,						torch.Tensor ):
						snake_case			,			snake_case							=					member.max().item(), member.min().item()
					elif isinstance(lowercase_,						lowercase_ ) or isinstance(lowercase_,						lowercase_ ):
						snake_case			,			snake_case							=					max(lowercase_ ), min(lowercase_ )

					if not isinstance(lowercase_,						lowercase_ ):
						raise TypeError('container should be a list or tuple' )
					elif len(lowercase_ ) != 2:
						raise ValueError('container should have 2 elements' )

					snake_case			,			snake_case							=					container

					snake_case							=					(min_value >= expected_min) and (max_value <= expected_max)

					if not is_inside_interval:
						snake_case							=					'%s not found in %s' % (safe_repr(lowercase_ ), safe_repr(lowercase_ ))
						self.fail(self._formatMessage(lowercase_,						lowercase_ ) )

				def 					_lowerCamelCase    (       self )    ->							Any:
					self.config_tester.run_common_tests()

				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_rwkv_model(*lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							int:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_causl_lm(*lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Any:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_state_equivalency(*lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Optional[Any]:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						snake_case							=					model_class(config=lowercase_ )
						for name, param in model.named_parameters():
							if "time_decay" in name:
								if param.requires_grad:
									self.assertTrue(param.data.max().item() == 3.0 )
									self.assertTrue(param.data.min().item() == -5.0 )
							elif "time_first" in name:
								if param.requires_grad:
									# check if it's a ones like
									self.assertTrue(torch.allclose(param.data,						torch.ones_like(param.data ),						atol=1E-5,						rtol=1E-5 ) )
							elif any(x in name for x in ['time_mix_key', 'time_mix_receptance'] ):
								if param.requires_grad:
									self.assertInterval(
									    param.data,						[0.0, 1.0],						msg=F'''Parameter {name} of model {model_class} seems not properly initialized''',						)
							elif "time_mix_value" in name:
								if param.requires_grad:
									self.assertInterval(
									    param.data,						[0.0, 1.3],						msg=F'''Parameter {name} of model {model_class} seems not properly initialized''',						)

				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()
					snake_case							=					True

					snake_case							=					getattr(self.model_tester,						'seq_length',						lowercase_ )

					for model_class in self.all_model_classes:
						snake_case							=					True
						snake_case							=					False
						snake_case							=					True
						snake_case							=					model_class(lowercase_ )
						model.to(lowercase_ )
						model.eval()

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						snake_case							=					inputs['input_ids'].shape[0]
						with torch.no_grad():
							snake_case							=					model(**lowercase_ )
						snake_case							=					outputs.attentions
						self.assertEqual(len(lowercase_ ),						self.model_tester.num_hidden_layers )

						# check that output_attentions also work using config
						del inputs_dict["output_attentions"]
						snake_case							=					True
						snake_case							=					model_class(lowercase_ )
						model.to(lowercase_ )
						model.eval()

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						snake_case							=					inputs['input_ids'].shape[0]
						with torch.no_grad():
							snake_case							=					model(**lowercase_ )
						snake_case							=					outputs.attentions
						self.assertEqual(len(lowercase_ ),						self.model_tester.num_hidden_layers )

						self.assertListEqual(
						    list(attentions[0].shape[-3:] ),						[batch_size, seq_len, config.hidden_size],						)
						snake_case							=					len(lowercase_ )

						# Check attention is always last and order is fine
						snake_case							=					True
						snake_case							=					True
						snake_case							=					model_class(lowercase_ )
						model.to(lowercase_ )
						model.eval()

						snake_case							=					self._prepare_for_class(lowercase_,						lowercase_ )
						snake_case							=					inputs['input_ids'].shape[0]
						with torch.no_grad():
							snake_case							=					model(**lowercase_ )

						snake_case							=					1
						self.assertEqual(out_len + added_hidden_states,						len(lowercase_ ) )

						snake_case							=					outputs.attentions

						self.assertEqual(len(lowercase_ ),						self.model_tester.num_hidden_layers )
						self.assertListEqual(
						    list(self_attentions[0].shape[-3:] ),						[batch_size, seq_len, config.hidden_size],						)






				@slow
				def 					_lowerCamelCase    (       self )    ->							str:
					for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						snake_case							=					RwkvModel.from_pretrained(lowercase_ )
						self.assertIsNotNone(lowercase_ )







@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0				,				reason='''See https://github.com/huggingface/transformers/pull/24204'''				)
@slow
class lowerCamelCase   (    unittest.TestCase				):

				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					snake_case							=					'RWKV/rwkv-4-169m-pile'
					snake_case							=					AutoTokenizer.from_pretrained(self.model_id )

				def 					_lowerCamelCase    (       self )    ->							List[str]:
					snake_case							=					'Hello my name is Jasmine and I am a newbie to the'
					snake_case							=					RwkvForCausalLM.from_pretrained(self.model_id ).to(lowercase_ )

					snake_case							=					self.tokenizer('Hello my name is',						return_tensors='pt' ).input_ids.to(lowercase_ )
					snake_case							=					model.generate(lowercase_,						max_new_tokens=10 )
					snake_case							=					self.tokenizer.decode(output[0].tolist() )

					self.assertEqual(lowercase_,						lowercase_ )






				def 					_lowerCamelCase    (       self )    ->							List[Any]:
					snake_case							=					'Hello my name is Jasmine and I am a newbie to the'

					snake_case							=					self.tokenizer('Hello my name is',						return_tensors='pt' ).input_ids.to(lowercase_ )
					snake_case							=					RwkvForCausalLM.from_pretrained(self.model_id,						torch_dtype=torch.bfloataa ).to(lowercase_ )

					snake_case							=					model.generate(lowercase_,						max_new_tokens=10 )
					snake_case							=					self.tokenizer.decode(output[0].tolist() )

					self.assertEqual(lowercase_,						lowercase_ )






"""simple docstring"""


from __future__ import annotations

import unittest

from transformers import OpenAIGPTConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers.models.openai.modeling_tf_openai import (
      TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFOpenAIGPTDoubleHeadsModel,
      TFOpenAIGPTForSequenceClassification,
      TFOpenAIGPTLMHeadModel,
      TFOpenAIGPTModel,
  )
class   UpperCAmelCase_	:
    def __init__(	self			:       Tuple   ,						_lowercase			:       List[str]   ,						)						->    Tuple:
       _lowercase							     =       parent
       _lowercase							     =       1_3
       _lowercase							     =       7
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       9_9
       _lowercase							     =       3_2
       _lowercase							     =       2
       _lowercase							     =       4
       _lowercase							     =       3_7
       _lowercase							     =       "gelu"
       _lowercase							     =       0.1
       _lowercase							     =       0.1
       _lowercase							     =       5_1_2
       _lowercase							     =       1_6
       _lowercase							     =       2
       _lowercase							     =       0.02
       _lowercase							     =       3
       _lowercase							     =       4
       _lowercase							     =       None
       _lowercase							     =       self.vocab_size - 1
    def 		_lowerCamelCase      (	self			:       int		)						->    List[Any]:
       _lowercase							     =       ids_tensor([self.batch_size, self.seq_length]   ,						self.vocab_size		)

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

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

       _lowercase							     =       None
       if self.use_mc_token_ids:
          _lowercase							     =       ids_tensor([self.batch_size, self.num_choices]   ,						self.seq_length		)

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

       _lowercase							     =       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   ,						)

       _lowercase							     =       ids_tensor([self.num_hidden_layers, self.num_attention_heads]   ,						2		)

       return (
           config,
           input_ids,
           input_mask,
           head_mask,
           token_type_ids,
           mc_token_ids,
           sequence_labels,
           token_labels,
           choice_labels,
       )
    def 		_lowerCamelCase      (	self			:       Union[str, Any]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       str   ,						_lowercase			:       Dict   ,						_lowercase			:       List[Any]   ,						_lowercase			:       int   ,						*_lowercase			:       List[str]		)						->    Optional[int]:
       _lowercase							     =       TFOpenAIGPTModel(config=_lowercase		)
       _lowercase							     =       {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
       _lowercase							     =       model(_lowercase		)

       _lowercase							     =       [input_ids, input_mask]
       _lowercase							     =       model(_lowercase		)

       _lowercase							     =       model(_lowercase		)

       self.parent.assertEqual(result.last_hidden_state.shape   ,						(self.batch_size, self.seq_length, self.hidden_size)		)
    def 		_lowerCamelCase      (	self			:       Any   ,						_lowercase			:       Optional[Any]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       str   ,						_lowercase			:       Dict   ,						_lowercase			:       List[str]   ,						*_lowercase			:       Optional[Any]		)						->    Dict:
       _lowercase							     =       TFOpenAIGPTLMHeadModel(config=_lowercase		)
       _lowercase							     =       {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
       _lowercase							     =       model(_lowercase		)
       self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.seq_length, self.vocab_size)		)
    def 		_lowerCamelCase      (	self			:       Union[str, Any]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       int   ,						_lowercase			:       str   ,						_lowercase			:       int   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       List[Any]   ,						*_lowercase			:       Tuple		)						->    Optional[int]:
       _lowercase							     =       TFOpenAIGPTDoubleHeadsModel(config=_lowercase		)

       _lowercase							     =       tf.tile(tf.expand_dims(_lowercase   ,						1		)   ,						(1, self.num_choices, 1)		)
       _lowercase							     =       tf.tile(tf.expand_dims(_lowercase   ,						1		)   ,						(1, self.num_choices, 1)		)
       _lowercase							     =       tf.tile(tf.expand_dims(_lowercase   ,						1		)   ,						(1, self.num_choices, 1)		)

       _lowercase							     =       {
           "input_ids": multiple_choice_inputs_ids,
           "mc_token_ids": mc_token_ids,
           "attention_mask": multiple_choice_input_mask,
           "token_type_ids": multiple_choice_token_type_ids,
       }
       _lowercase							     =       model(_lowercase		)
       self.parent.assertEqual(
           result.logits.shape   ,						(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)		)
       self.parent.assertEqual(result.mc_logits.shape   ,						(self.batch_size, self.num_choices)		)
    def 		_lowerCamelCase      (	self			:       Union[str, Any]   ,						_lowercase			:       List[Any]   ,						_lowercase			:       Tuple   ,						_lowercase			:       Any   ,						_lowercase			:       Optional[Any]   ,						_lowercase			:       List[Any]   ,						*_lowercase			:       str		)						->    str:
       _lowercase							     =       self.num_labels
       _lowercase							     =       ids_tensor([self.batch_size]   ,						self.type_sequence_label_size		)
       _lowercase							     =       {
           "input_ids": input_ids,
           "attention_mask": input_mask,
           "token_type_ids": token_type_ids,
           "labels": sequence_labels,
       }
       _lowercase							     =       TFOpenAIGPTForSequenceClassification(_lowercase		)
       _lowercase							     =       model(_lowercase		)
       self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.num_labels)		)




    def 		_lowerCamelCase      (	self			:       str		)						->    Tuple:
       _lowercase							     =       self.prepare_config_and_inputs()

       (
           (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  
       )							     =       config_and_inputs

       _lowercase							     =       {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
       return config, inputs_dict
@require_tf
class   UpperCAmelCase_	(				lowercase__,    lowercase__,    unittest.TestCase   ):
    snake_case_											=      (
        (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
        if is_tf_available()
        else ()
    )
    snake_case_											=      (
        (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
    )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
    snake_case_											=      (
        {
            """feature-extraction""": TFOpenAIGPTModel,
            """text-classification""": TFOpenAIGPTForSequenceClassification,
            """text-generation""": TFOpenAIGPTLMHeadModel,
            """zero-shot""": TFOpenAIGPTForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    snake_case_											=      False
    snake_case_											=      False
    def 		_lowerCamelCase      (	self			:       Optional[int]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       List[str]   ,						_lowercase			:       Tuple   ,						_lowercase			:       Union[str, Any]   ,						_lowercase			:       Any		)						->    List[str]:
       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 		_lowerCamelCase      (	self			:       Union[str, Any]		)						->    str:
       _lowercase							     =       TFOpenAIGPTModelTester(self		)
       _lowercase							     =       ConfigTester(self   ,						config_class=_lowercase   ,						n_embd=3_7		)
    def 		_lowerCamelCase      (	self			:       List[Any]		)						->    Optional[int]:
       self.config_tester.run_common_tests()
    def 		_lowerCamelCase      (	self			:       Any		)						->    List[str]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_model(*_lowercase		)
    def 		_lowerCamelCase      (	self			:       Optional[int]		)						->    List[Any]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_lm_head(*_lowercase		)
    def 		_lowerCamelCase      (	self			:       Optional[Any]		)						->    List[Any]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_double_head(*_lowercase		)
    def 		_lowerCamelCase      (	self			:       int		)						->    Union[str, Any]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_lowercase		)




    @slow
    def 		_lowerCamelCase      (	self			:       Tuple		)						->    Dict:
       for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          _lowercase							     =       TFOpenAIGPTModel.from_pretrained(_lowercase		)
          self.assertIsNotNone(_lowercase		)
@require_tf
class   UpperCAmelCase_	(				unittest.TestCase   ):
    @slow
    def 		_lowerCamelCase      (	self			:       Optional[Any]		)						->    Union[str, Any]:
       _lowercase							     =       TFOpenAIGPTLMHeadModel.from_pretrained("openai-gpt"		)
       _lowercase							     =       tf.convert_to_tensor([[4_8_1, 4_7_3_5, 5_4_4]]   ,						dtype=tf.intaa		)  # the president is
       _lowercase							     =       [
           4_8_1,
           4_7_3_5,
           5_4_4,
           2_4_6,
           9_6_3,
           8_7_0,
           7_6_2,
           2_3_9,
           2_4_4,
           4_0_4_7_7,
           2_4_4,
           2_4_9,
           7_1_9,
           8_8_1,
           4_8_7,
           5_4_4,
           2_4_0,
           2_4_4,
           6_0_3,
           4_8_1,
       ]  # the president is a very good man. " \n " i\'m sure he is, " said the

       _lowercase							     =       model.generate(_lowercase   ,						do_sample=_lowercase		)
       self.assertListEqual(output_ids[0].numpy().tolist()   ,						_lowercase		)