




'''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 __magic_name__:






						def __init__(   self						:						Optional[int]					,   __UpperCamelCase						:						Optional[Any]					,   ):



									'''simple docstring'''






									snake_case__          =						parent
									snake_case__          =						1_3
									snake_case__          =						7
									snake_case__          =						True
									snake_case__          =						True
									snake_case__          =						True
									snake_case__          =						True
									snake_case__          =						True
									snake_case__          =						9_9
									snake_case__          =						3_2
									snake_case__          =						2
									snake_case__          =						4
									snake_case__          =						3_7
									snake_case__          =						"""gelu"""
									snake_case__          =						0.1
									snake_case__          =						0.1
									snake_case__          =						5_1_2
									snake_case__          =						1_6
									snake_case__          =						2
									snake_case__          =						0.02
									snake_case__          =						3
									snake_case__          =						4
									snake_case__          =						None
									snake_case__          =						self.vocab_size - 1






						def       __lowerCAmelCase(   self						:						List[Any]       ):



									'''simple docstring'''






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

									snake_case__          =						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						:						List[str]					,   __UpperCamelCase						:						Tuple					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						Optional[int]					,   __UpperCamelCase						:						List[Any]					,   *__UpperCamelCase						:						Any       ):



									'''simple docstring'''






									snake_case__          =						TFOpenAIGPTModel(config=__UpperCamelCase       )
									snake_case__          =						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
									snake_case__          =						model(__UpperCamelCase       )

									snake_case__          =						[input_ids, input_mask]
									snake_case__          =						model(__UpperCamelCase       )

									snake_case__          =						model(__UpperCamelCase       )

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






						def       __lowerCAmelCase(   self						:						Optional[Any]					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						Union[str, Any]					,   __UpperCamelCase						:						Optional[Any]					,   __UpperCamelCase						:						int					,   *__UpperCamelCase						:						Union[str, Any]       ):



									'''simple docstring'''






									snake_case__          =						TFOpenAIGPTLMHeadModel(config=__UpperCamelCase       )
									snake_case__          =						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
									snake_case__          =						model(__UpperCamelCase       )
									self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.seq_length, self.vocab_size)       )






						def       __lowerCAmelCase(   self						:						List[Any]					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						Optional[int]					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						int					,   __UpperCamelCase						:						str					,   *__UpperCamelCase						:						str       ):



									'''simple docstring'''






									snake_case__          =						TFOpenAIGPTDoubleHeadsModel(config=__UpperCamelCase       )

									snake_case__          =						tf.tile(tf.expand_dims(__UpperCamelCase					,   1       )					,   (1, self.num_choices, 1)       )
									snake_case__          =						tf.tile(tf.expand_dims(__UpperCamelCase					,   1       )					,   (1, self.num_choices, 1)       )
									snake_case__          =						tf.tile(tf.expand_dims(__UpperCamelCase					,   1       )					,   (1, self.num_choices, 1)       )

									snake_case__          =						{
									    """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,
									}
									snake_case__          =						model(__UpperCamelCase       )
									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						:						Tuple					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						List[str]					,   *__UpperCamelCase						:						Tuple       ):



									'''simple docstring'''






									snake_case__          =						self.num_labels
									snake_case__          =						ids_tensor([self.batch_size]					,   self.type_sequence_label_size       )
									snake_case__          =						{
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									    """labels""": sequence_labels,
									}
									snake_case__          =						TFOpenAIGPTForSequenceClassification(__UpperCamelCase       )
									snake_case__          =						model(__UpperCamelCase       )
									self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.num_labels)       )







						def       __lowerCAmelCase(   self						:						Optional[int]       ):



									'''simple docstring'''






									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, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
									return config, inputs_dict







@require_tf
class __magic_name__(						__lowerCAmelCase    ,		__lowerCAmelCase    ,		unittest.TestCase      ):
						UpperCAmelCase_		:					List[Any]    =  (
						    (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
						    if is_tf_available()
						    else ()
						)
						UpperCAmelCase_		:					Optional[Any]    =  (
						    (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
						)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
						UpperCAmelCase_		:					Union[str, Any]    =  (
						    {
						        """feature-extraction""": TFOpenAIGPTModel,
						        """text-classification""": TFOpenAIGPTForSequenceClassification,
						        """text-generation""": TFOpenAIGPTLMHeadModel,
						        """zero-shot""": TFOpenAIGPTForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						UpperCAmelCase_		:					Optional[Any]    =  False
						UpperCAmelCase_		:					int    =  False






						def       __lowerCAmelCase(   self						:						Optional[int]					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						int					,   __UpperCamelCase						:						Union[str, Any]					,   __UpperCamelCase						:						Union[str, 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       __lowerCAmelCase(   self						:						int       ):



									'''simple docstring'''






									snake_case__          =						TFOpenAIGPTModelTester(self       )
									snake_case__          =						ConfigTester(self					,   config_class=__UpperCamelCase					,   n_embd=3_7       )






						def       __lowerCAmelCase(   self						:						Any       ):



									'''simple docstring'''






									self.config_tester.run_common_tests()






						def       __lowerCAmelCase(   self						:						Optional[int]       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_openai_gpt_model(*__UpperCamelCase       )






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



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_openai_gpt_lm_head(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						int       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_openai_gpt_double_head(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						Tuple       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*__UpperCamelCase       )







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



									'''simple docstring'''






									for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												snake_case__          =						TFOpenAIGPTModel.from_pretrained(__UpperCamelCase       )
												self.assertIsNotNone(__UpperCamelCase       )







@require_tf
class __magic_name__(						unittest.TestCase      ):






						@slow
						def       __lowerCAmelCase(   self						:						Dict       ):



									'''simple docstring'''






									snake_case__          =						TFOpenAIGPTLMHeadModel.from_pretrained("""openai-gpt"""       )
									snake_case__          =						tf.convert_to_tensor([[4_8_1, 4_7_3_5, 5_4_4]]					,   dtype=tf.intaa       )  # the president is
									snake_case__          =						[
									    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

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





'''simple docstring'''

class __magic_name__:






						def __init__(   self						:						List[Any]       ):



									'''simple docstring'''






									snake_case__          =						[]
									snake_case__          =						0
									snake_case__          =						0






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



									'''simple docstring'''






									snake_case__          =						"""<""" + str(self.entries       )[1:-1] + """>"""
									return printed






						def       __lowerCAmelCase(   self						:						List[Any]					,   __UpperCamelCase						:						List[Any]       ):



									'''simple docstring'''






									self.entries.append(__UpperCamelCase       )
									snake_case__          =						self.length + 1






						def       __lowerCAmelCase(   self						:						int       ):



									'''simple docstring'''






									snake_case__          =						self.length - 1
									snake_case__          =						self.entries[self.front]
									# self.front-=1
									# self.entries = self.entries[self.front:]
									snake_case__          =						self.entries[1:]
									return dequeued






						def       __lowerCAmelCase(   self						:						str					,   __UpperCamelCase						:						Optional[Any]       ):



									'''simple docstring'''






									for _ in range(__UpperCamelCase       ):
												self.put(self.get()       )






						def       __lowerCAmelCase(   self						:						List[Any]       ):



									'''simple docstring'''






									return self.entries[0]






						def       __lowerCAmelCase(   self						:						str       ):



									'''simple docstring'''






									return self.length