'''simple docstring'''





from __future__ import annotations

import unittest

import numpy as np

from transformers import OPTConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, slow

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


if is_tf_available():
					import tensorflow as tf

					from transformers import GPTaTokenizer, TFOPTForCausalLM, TFOPTModel
def    A			(					_lowercase	,						_lowercase	,						_lowercase=None	,						_lowercase=None		):



						if attention_mask is None:
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							tf.cast(tf.math.not_equal(_lowercase	,						config.pad_token_id		)	,						tf.inta		)
						return {"input_ids": input_ids, "attention_mask": attention_mask}





@require_tf
class       lowercase__		:
						UpperCamelCase_  =	OPTConfig
						UpperCamelCase_  =	{}
						UpperCamelCase_  =	"""gelu"""


						def __init__( self			:       Optional[Any]					,	UpperCamelCase__			:       str					,	UpperCamelCase__			:       Dict=13					,	UpperCamelCase__			:       Tuple=7					,	UpperCamelCase__			:       Tuple=True					,	UpperCamelCase__			:       List[Any]=False					,	UpperCamelCase__			:       Optional[Any]=99					,	UpperCamelCase__			:       Dict=16					,	UpperCamelCase__			:       Union[str, Any]=2					,	UpperCamelCase__			:       str=4					,	UpperCamelCase__			:       Dict=4					,	UpperCamelCase__			:       int="gelu"					,	UpperCamelCase__			:       Dict=0.1					,	UpperCamelCase__			:       List[str]=0.1					,	UpperCamelCase__			:       List[str]=20					,	UpperCamelCase__			:       Optional[int]=2					,	UpperCamelCase__			:       str=1					,	UpperCamelCase__			:       Optional[Any]=0					,	UpperCamelCase__			:       Union[str, Any]=16					,	UpperCamelCase__			:       Union[str, Any]=16					,	):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							parent
												SCREAMING_SNAKE_CASE							:					int           =							batch_size
												SCREAMING_SNAKE_CASE							:					int           =							seq_length
												SCREAMING_SNAKE_CASE							:					str           =							is_training
												SCREAMING_SNAKE_CASE							:					int           =							use_labels
												SCREAMING_SNAKE_CASE							:					List[str]           =							vocab_size
												SCREAMING_SNAKE_CASE							:					Dict           =							hidden_size
												SCREAMING_SNAKE_CASE							:					int           =							num_hidden_layers
												SCREAMING_SNAKE_CASE							:					str           =							num_attention_heads
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							intermediate_size
												SCREAMING_SNAKE_CASE							:					List[str]           =							hidden_act
												SCREAMING_SNAKE_CASE							:					Dict           =							hidden_dropout_prob
												SCREAMING_SNAKE_CASE							:					str           =							attention_probs_dropout_prob
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							max_position_embeddings
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							eos_token_id
												SCREAMING_SNAKE_CASE							:					Any           =							pad_token_id
												SCREAMING_SNAKE_CASE							:					List[str]           =							bos_token_id
												SCREAMING_SNAKE_CASE							:					str           =							embed_dim
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							word_embed_proj_dim
												SCREAMING_SNAKE_CASE							:					int           =							False


						def  __A ( self			:       Optional[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					int           =							ids_tensor([self.batch_size, self.seq_length - 1]					,	self.vocab_size		)
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size		)					,	1		)
												SCREAMING_SNAKE_CASE							:					List[str]           =							tf.concat([input_ids, eos_tensor]					,	axis=1		)

												SCREAMING_SNAKE_CASE							:					str           =							self.config_cls(
												    vocab_size=self.vocab_size					,	hidden_size=self.hidden_size					,	num_hidden_layers=self.num_hidden_layers					,	num_attention_heads=self.num_attention_heads					,	ffn_dim=self.intermediate_size					,	dropout=self.hidden_dropout_prob					,	attention_dropout=self.attention_probs_dropout_prob					,	max_position_embeddings=self.max_position_embeddings					,	eos_token_id=self.eos_token_id					,	bos_token_id=self.bos_token_id					,	pad_token_id=self.pad_token_id					,	embed_dim=self.embed_dim					,	word_embed_proj_dim=self.word_embed_proj_dim					,	is_encoder_decoder=snake_case__					,	**self.config_updates					,	)
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							prepare_opt_inputs_dict(snake_case__					,	snake_case__		)
												return config, inputs_dict



						def  __A ( self			:       Optional[Any]					,	UpperCamelCase__			:       Dict					,	UpperCamelCase__			:       Any		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							TFOPTModel(config=snake_case__		)
												SCREAMING_SNAKE_CASE							:					Any           =							inputs_dict["input_ids"]

												SCREAMING_SNAKE_CASE							:					Optional[int]           =							input_ids[:1, :]
												SCREAMING_SNAKE_CASE							:					Dict           =							inputs_dict["attention_mask"][:1, :]
												SCREAMING_SNAKE_CASE							:					int           =							1

												# first forward pass
												SCREAMING_SNAKE_CASE							:					int           =							model(snake_case__					,	attention_mask=snake_case__					,	use_cache=snake_case__		)

												SCREAMING_SNAKE_CASE							:					str           =							outputs.to_tuple()

												# create hypothetical next token and extent to next_input_ids
												SCREAMING_SNAKE_CASE							:					int           =							ids_tensor((self.batch_size, 3)					,	config.vocab_size		)
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							tf.cast(ids_tensor((self.batch_size, 3)					,	2		)					,	tf.inta		)

												# append to next input_ids and
												SCREAMING_SNAKE_CASE							:					List[Any]           =							tf.concat([input_ids, next_tokens]					,	axis=-1		)
												SCREAMING_SNAKE_CASE							:					List[Any]           =							tf.concat([attention_mask, next_attn_mask]					,	axis=-1		)

												SCREAMING_SNAKE_CASE							:					List[str]           =							model(snake_case__					,	attention_mask=snake_case__		)[0]
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							model(snake_case__					,	attention_mask=snake_case__					,	past_key_values=snake_case__		)[0]

												self.parent.assertEqual(next_tokens.shape[1]					,	output_from_past.shape[1]		)

												# select random slice
												SCREAMING_SNAKE_CASE							:					List[Any]           =							int(ids_tensor((1,)					,	output_from_past.shape[-1]		)		)
												SCREAMING_SNAKE_CASE							:					Any           =							output_from_no_past[:, -3:, random_slice_idx]
												SCREAMING_SNAKE_CASE							:					Any           =							output_from_past[:, :, random_slice_idx]

												# test that outputs are equal for slice
												tf.debugging.assert_near(snake_case__					,	snake_case__					,	rtol=1E-3		)






@require_tf
class       lowercase__		(     SCREAMING_SNAKE_CASE__			,							SCREAMING_SNAKE_CASE__			,							unittest.TestCase):
						UpperCamelCase_  =	(TFOPTModel, TFOPTForCausalLM) if is_tf_available() else ()
						UpperCamelCase_  =	(TFOPTForCausalLM,) if is_tf_available() else ()
						UpperCamelCase_  =	(
						    {"""feature-extraction""": TFOPTModel, """text-generation""": TFOPTForCausalLM} if is_tf_available() else {}
						)
						UpperCamelCase_  =	False
						UpperCamelCase_  =	False
						UpperCamelCase_  =	False
						UpperCamelCase_  =	10


						def  __A ( self			:       str		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					List[str]           =							TFOPTModelTester(self		)
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							ConfigTester(self					,	config_class=snake_case__		)


						def  __A ( self			:       Dict		):





												'''simple docstring'''





												self.config_tester.run_common_tests()


						def  __A ( self			:       int		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Optional[int]           =							self.model_tester.prepare_config_and_inputs_for_common()
												self.model_tester.check_decoder_model_past_large_inputs(*snake_case__		)



						def  __A ( self			:       Optional[int]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					int           =							self.model_tester.prepare_config_and_inputs_for_common()

												def _get_word_embedding_weight(UpperCamelCase__			:       Optional[Any]					,	UpperCamelCase__			:       List[str]		):
																		if hasattr(snake_case__					,	'''weight'''		):
																								return embedding_layer.weight
																		else:
																								# Here we build the word embeddings weights if not exists.
																								# And then we retry to get the attribute once built.
																								model.build()
																								if hasattr(snake_case__					,	'''weight'''		):
																														return embedding_layer.weight
																								else:
																														return None

												for model_class in self.all_model_classes:
																		for size in [config.vocab_size - 10, config.vocab_size + 10]:
																								# build the embeddings
																								SCREAMING_SNAKE_CASE							:					List[Any]           =							model_class(config=snake_case__		)
																								SCREAMING_SNAKE_CASE							:					Optional[int]           =							_get_word_embedding_weight(snake_case__					,	model.get_input_embeddings()		)
																								SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							_get_word_embedding_weight(snake_case__					,	model.get_output_embeddings()		)

																								# reshape the embeddings
																								model.resize_token_embeddings(snake_case__		)
																								SCREAMING_SNAKE_CASE							:					List[str]           =							_get_word_embedding_weight(snake_case__					,	model.get_input_embeddings()		)
																								SCREAMING_SNAKE_CASE							:					List[Any]           =							_get_word_embedding_weight(snake_case__					,	model.get_output_embeddings()		)

																								# check that the resized embeddings size matches the desired size.
																								SCREAMING_SNAKE_CASE							:					str           =							size if size is not None else config.vocab_size

																								self.assertEqual(new_input_embeddings.shape[0]					,	snake_case__		)

																								# check that weights remain the same after resizing
																								SCREAMING_SNAKE_CASE							:					Any           =							True
																								for pa, pa in zip(old_input_embeddings.value()					,	new_input_embeddings.value()		):
																														if tf.math.reduce_sum(tf.math.abs(pa - pa		)		) > 0:
																																				SCREAMING_SNAKE_CASE							:					Dict           =							False
																								self.assertTrue(snake_case__		)

																								if old_output_embeddings is not None and new_output_embeddings is not None:
																														self.assertEqual(new_output_embeddings.shape[0]					,	snake_case__		)

																														SCREAMING_SNAKE_CASE							:					List[str]           =							True
																														for pa, pa in zip(old_output_embeddings.value()					,	new_output_embeddings.value()		):
																																				if tf.math.reduce_sum(tf.math.abs(pa - pa		)		) > 0:
																																										SCREAMING_SNAKE_CASE							:					str           =							False
																														self.assertTrue(snake_case__		)






def    A			(					_lowercase		):
						return tf.constant(_lowercase	,						dtype=tf.intaa		)





@require_tf
class       lowercase__		(     unittest.TestCase):
						UpperCamelCase_  =	99


						def  __A ( self			:       List[str]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					str           =							tf.ones((4, 1)					,	dtype=tf.intaa		) * 2
												SCREAMING_SNAKE_CASE							:					Dict           =							tf.concat([ids_tensor((4, 6)					,	self.vocab_size - 3		) + 3, eos_column_vector]					,	axis=1		)
												SCREAMING_SNAKE_CASE							:					str           =							input_ids.shape[0]
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							OPTConfig(
												    vocab_size=self.vocab_size					,	hidden_size=24					,	num_hidden_layers=2					,	num_attention_heads=2					,	ffn_dim=32					,	max_position_embeddings=48					,	eos_token_id=2					,	pad_token_id=1					,	bos_token_id=0					,	)
												return config, input_ids, batch_size






@require_sentencepiece
@require_tf
class       lowercase__		(     unittest.TestCase):


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Tuple           =							TFOPTModel.from_pretrained('''facebook/opt-350m'''		)
												SCREAMING_SNAKE_CASE							:					str           =							_long_tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]		)
												SCREAMING_SNAKE_CASE							:					Tuple           =							tf.not_equal(snake_case__					,	model.config.pad_token_id		)
												with tf.GradientTape():
																		SCREAMING_SNAKE_CASE							:					Tuple           =							model(input_ids=snake_case__					,	attention_mask=snake_case__		).last_hidden_state
												SCREAMING_SNAKE_CASE							:					List[str]           =							(1, 11, 512)
												self.assertEqual(output.shape					,	snake_case__		)
												SCREAMING_SNAKE_CASE							:					Dict           =							tf.constant(
												    [[-0.2873, -1.9218, -0.3033], [-1.2710, -0.1338, -0.1902], [0.4095, 0.1214, -1.3121]]		)
												self.assertTrue(np.allclose(output[:, :3, :3]					,	snake_case__					,	atol=4E-3		)		)

												SCREAMING_SNAKE_CASE							:					int           =							tf.function(snake_case__					,	jit_compile=snake_case__		)
												SCREAMING_SNAKE_CASE							:					List[str]           =							xla_generate(snake_case__					,	snake_case__		)[0]
												self.assertTrue(np.allclose(output[:, :3, :3]					,	snake_case__					,	atol=4E-2		)		)






@require_tf
@slow
class       lowercase__		(     unittest.TestCase):


						def  __A ( self			:       Dict		):





												'''simple docstring'''





												super().setUp()
												SCREAMING_SNAKE_CASE							:					List[str]           =							"facebook/opt-350m"



						def  __A ( self			:       Any		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Optional[int]           =							TFOPTForCausalLM.from_pretrained(self.path_model		)
												SCREAMING_SNAKE_CASE							:					str           =							GPTaTokenizer.from_pretrained(self.path_model		)

												SCREAMING_SNAKE_CASE							:					Tuple           =							[
												    "Today is a beautiful day and I want to",
												    "In the city of",
												    "Paris is the capital of France and",
												    "Computers and mobile phones have taken",
												]
												# verify that prompt without BOS token is identical to Metaseq -> add_special_tokens=False
												SCREAMING_SNAKE_CASE							:					int           =							tokenizer(snake_case__					,	return_tensors='''tf'''					,	padding=snake_case__					,	add_special_tokens=snake_case__		)
												SCREAMING_SNAKE_CASE							:					int           =							tf.math.reduce_mean(model(inputs.input_ids					,	attention_mask=inputs.attention_mask		)[0]					,	axis=-1		)
												SCREAMING_SNAKE_CASE							:					int           =							tf.constant(
												    [
												        [1.3851, -13.8923, -10.5229, -10.7533, -0.2309, -10.2384, -0.5365, -9.0947, -5.1670],
												        [-4.7073, -10.6276, -3.9415, -21.5242, -0.2822, -0.2822, -0.2822, -0.2822, -0.2822],
												        [0.6247, -3.4229, -8.9179, -1.4297, -14.1650, 1.4146, -9.0218, -0.2703, -0.2703],
												        [6.4783, -1.9913, -10.7926, -2.3336, 1.5092, -0.9974, -6.8213, 1.3477, 1.3477],
												    ]		)
												self.assertTrue(np.allclose(snake_case__					,	snake_case__					,	atol=1E-4		)		)

												SCREAMING_SNAKE_CASE							:					int           =							tf.function(snake_case__					,	jit_compile=snake_case__		)
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							tf.math.reduce_mean(xla_generate(inputs.input_ids					,	attention_mask=inputs.attention_mask		)[0]					,	axis=-1		)
												self.assertTrue(np.allclose(snake_case__					,	snake_case__					,	atol=1E-4		)		)






@require_tf
@slow
class       lowercase__		(     unittest.TestCase):


						@property
						def  __A ( self			:       int		):





												'''simple docstring'''





												return [
												    "Today is a beautiful day and I want",
												    "In the city of",
												    "Paris is the capital of France and",
												    "Computers and mobile phones have taken",
												]


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Tuple           =							"facebook/opt-125m"

												SCREAMING_SNAKE_CASE							:					List[str]           =							[
												    "Today is a beautiful day and I want to",
												    "In the city of New York, the city",
												    "Paris is the capital of France and the capital",
												    "Computers and mobile phones have taken over the",
												]

												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							[]
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							GPTaTokenizer.from_pretrained(snake_case__		)
												SCREAMING_SNAKE_CASE							:					Any           =							TFOPTForCausalLM.from_pretrained(snake_case__		)

												for prompt in self.prompts:
																		SCREAMING_SNAKE_CASE							:					Optional[int]           =							tokenizer(snake_case__					,	return_tensors='''tf'''		).input_ids

																		SCREAMING_SNAKE_CASE							:					List[str]           =							model.generate(snake_case__					,	max_length=10		)

																		SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							tokenizer.batch_decode(snake_case__					,	skip_special_tokens=snake_case__		)
																		predicted_outputs += generated_string

												self.assertListEqual(snake_case__					,	snake_case__		)


						def  __A ( self			:       Optional[int]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					List[str]           =							"facebook/opt-350m"

												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							GPTaTokenizer.from_pretrained(snake_case__		)
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							TFOPTForCausalLM.from_pretrained(snake_case__		)

												SCREAMING_SNAKE_CASE							:					List[str]           =							"left"

												# use different length sentences to test batching
												SCREAMING_SNAKE_CASE							:					Dict           =							[
												    "Hello, my dog is a little",
												    "Today, I",
												]

												SCREAMING_SNAKE_CASE							:					Optional[int]           =							tokenizer(snake_case__					,	return_tensors='''tf'''					,	padding=snake_case__		)
												SCREAMING_SNAKE_CASE							:					int           =							inputs["input_ids"]

												SCREAMING_SNAKE_CASE							:					int           =							model.generate(input_ids=snake_case__					,	attention_mask=inputs['''attention_mask''']		)

												SCREAMING_SNAKE_CASE							:					Dict           =							tokenizer(sentences[0]					,	return_tensors='''tf'''		).input_ids
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							model.generate(input_ids=snake_case__		)

												SCREAMING_SNAKE_CASE							:					Tuple           =							inputs_non_padded.shape[-1] - tf.math.reduce_sum(
												    tf.cast(inputs['''attention_mask'''][-1]					,	tf.intaa		)		)
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							tokenizer(sentences[1]					,	return_tensors='''tf'''		).input_ids
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							model.generate(input_ids=snake_case__					,	max_length=model.config.max_length - num_paddings		)

												SCREAMING_SNAKE_CASE							:					Tuple           =							tokenizer.batch_decode(snake_case__					,	skip_special_tokens=snake_case__		)
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							tokenizer.decode(output_non_padded[0]					,	skip_special_tokens=snake_case__		)
												SCREAMING_SNAKE_CASE							:					int           =							tokenizer.decode(output_padded[0]					,	skip_special_tokens=snake_case__		)

												SCREAMING_SNAKE_CASE							:					List[Any]           =							[
												    "Hello, my dog is a little bit of a dork.\nI'm a little bit",
												    "Today, I was in the middle of a conversation with a friend about the",
												]
												self.assertListEqual(snake_case__					,	snake_case__		)
												self.assertListEqual(snake_case__					,	[non_padded_sentence, padded_sentence]		)



						def  __A ( self			:       str		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					List[str]           =							"facebook/opt-350m"

												SCREAMING_SNAKE_CASE							:					Optional[int]           =							[
												    "Today is a beautiful day and I want to",
												    "In the city of San Francisco, the city",
												    "Paris is the capital of France and the capital",
												    "Computers and mobile phones have taken over the",
												]

												SCREAMING_SNAKE_CASE							:					Dict           =							[]
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							GPTaTokenizer.from_pretrained(snake_case__		)
												SCREAMING_SNAKE_CASE							:					int           =							TFOPTForCausalLM.from_pretrained(snake_case__		)

												for prompt in self.prompts:
																		SCREAMING_SNAKE_CASE							:					Dict           =							tokenizer(snake_case__					,	return_tensors='''tf'''		).input_ids

																		SCREAMING_SNAKE_CASE							:					Any           =							model.generate(snake_case__					,	max_length=10		)

																		SCREAMING_SNAKE_CASE							:					Tuple           =							tokenizer.batch_decode(snake_case__					,	skip_special_tokens=snake_case__		)
																		predicted_outputs += generated_string

												self.assertListEqual(snake_case__					,	snake_case__		)






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__UpperCamelCase	: Tuple    		=  {
    'configuration_ctrl': ['CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'CTRLConfig'],
    'tokenization_ctrl': ['CTRLTokenizer'],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__UpperCamelCase	: Dict    		=  [
					    'CTRL_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'CTRLForSequenceClassification',
					    'CTRLLMHeadModel',
					    'CTRLModel',
					    'CTRLPreTrainedModel',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__UpperCamelCase	: Any    		=  [
					    'TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFCTRLForSequenceClassification',
					    'TFCTRLLMHeadModel',
					    'TFCTRLModel',
					    'TFCTRLPreTrainedModel',
					]


if TYPE_CHECKING:
					from .configuration_ctrl import CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRLConfig
					from .tokenization_ctrl import CTRLTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_ctrl import (
										    CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CTRLForSequenceClassification,
										    CTRLLMHeadModel,
										    CTRLModel,
										    CTRLPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_ctrl import (
										    TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFCTRLForSequenceClassification,
										    TFCTRLLMHeadModel,
										    TFCTRLModel,
										    TFCTRLPreTrainedModel,
										)

else:
					import sys

					__UpperCamelCase	: Optional[Any]    		=  _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





