


from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
			import numpy as np
			import tensorflow as tf

			from transformers import (
			    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
			    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
			    TF_MODEL_FOR_MASKED_LM_MAPPING,
			    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
			    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
			    TF_MODEL_FOR_PRETRAINING_MAPPING,
			    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
			    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
			    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
			    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
			    TFSharedEmbeddings,
			)

			if _tf_gpu_memory_limit is not None:
						snake_case__  				=			tf.config.list_physical_devices('GPU')
						for gpu in gpus:
									# Restrict TensorFlow to only allocate x GB of memory on the GPUs
									try:
												tf.config.set_logical_device_configuration(
												    gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
												)
												snake_case__  				=			tf.config.list_logical_devices('GPU')
												print('Logical GPUs', logical_gpus)
									except RuntimeError as e:
												# Virtual devices must be set before GPUs have been initialized
												print(e)



@require_tf
class      snake_case__	:
				__lowerCAmelCase		=   None
				__lowerCAmelCase		=   ()
				__lowerCAmelCase		=   ()
				__lowerCAmelCase		=   True
				__lowerCAmelCase		=   True
				__lowerCAmelCase		=   True
				__lowerCAmelCase		=   False
				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase  ,   _UpperCAmelCase  ,   _UpperCAmelCase=False   ):




										"""simple docstring"""




										__magic_name__					:				Dict				=   copy.deepcopy(__SCREAMING_SNAKE_CASE   )

										if model_class in get_values(__SCREAMING_SNAKE_CASE   ):
																__magic_name__					:				List[str]				=   {
																    k: tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE  ,   1   )  ,   (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)   )
																    if isinstance(__SCREAMING_SNAKE_CASE  ,   tf.Tensor   ) and v.ndim > 0
																    else v
																    for k, v in inputs_dict.items()
																}

										if return_labels:
																if model_class in get_values(__SCREAMING_SNAKE_CASE   ):
																						__magic_name__					:				Tuple				=   tf.ones(self.model_tester.batch_size  ,   dtype=tf.intaa   )
																elif model_class in get_values(__SCREAMING_SNAKE_CASE   ):
																						__magic_name__					:				str				=   tf.zeros(self.model_tester.batch_size  ,   dtype=tf.intaa   )
																						__magic_name__					:				List[Any]				=   tf.zeros(self.model_tester.batch_size  ,   dtype=tf.intaa   )
																elif model_class in [
																    *get_values(__SCREAMING_SNAKE_CASE   ),
																    *get_values(__SCREAMING_SNAKE_CASE   ),
																]:
																						__magic_name__					:				Tuple				=   tf.zeros(self.model_tester.batch_size  ,   dtype=tf.intaa   )
																elif model_class in get_values(__SCREAMING_SNAKE_CASE   ):
																						__magic_name__					:				Any				=   tf.zeros(self.model_tester.batch_size  ,   dtype=tf.intaa   )
																elif model_class in [
																    *get_values(__SCREAMING_SNAKE_CASE   ),
																    *get_values(__SCREAMING_SNAKE_CASE   ),
																    *get_values(__SCREAMING_SNAKE_CASE   ),
																    *get_values(__SCREAMING_SNAKE_CASE   ),
																    *get_values(__SCREAMING_SNAKE_CASE   ),
																]:
																						__magic_name__					:				str				=   tf.zeros(
																						    (self.model_tester.batch_size, self.model_tester.seq_length)  ,   dtype=tf.intaa   )
										return inputs_dict
				@slow
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				int				=   self.model_tester.prepare_config_and_inputs_for_common()
										for model_class in self.all_model_classes[:2]:
																__magic_name__					:				Optional[int]				=   self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE   )
																__magic_name__					:				Union[str, Any]				=   model_class(__SCREAMING_SNAKE_CASE   )

																@tf.function
																def run_in_graph_mode():
																						return model(__SCREAMING_SNAKE_CASE   )

																__magic_name__					:				int				=   run_in_graph_mode()
																self.assertIsNotNone(__SCREAMING_SNAKE_CASE   )
				@slow
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				Optional[Any]				=   self.model_tester.prepare_config_and_inputs_for_common()
										for model_class in self.all_model_classes[:2]:
																__magic_name__					:				Union[str, Any]				=   self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE   )
																__magic_name__					:				List[Any]				=   model_class(__SCREAMING_SNAKE_CASE   )

																@tf.function(experimental_compile=__SCREAMING_SNAKE_CASE   )
																def run_in_graph_mode():
																						return model(__SCREAMING_SNAKE_CASE   )

																__magic_name__					:				Any				=   run_in_graph_mode()
																self.assertIsNotNone(__SCREAMING_SNAKE_CASE   )
				@slow
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				List[Any]				=   self.model_tester.prepare_config_and_inputs_for_common()
										for model_class in self.all_model_classes[:2]:
																__magic_name__					:				Dict				=   model_class(__SCREAMING_SNAKE_CASE   )
																if getattr(__SCREAMING_SNAKE_CASE  ,   'hf_compute_loss'  ,   __SCREAMING_SNAKE_CASE   ):
																						# Test that model correctly compute the loss with kwargs
																						__magic_name__					:				Optional[Any]				=   self._prepare_for_class(inputs_dict.copy()  ,   __SCREAMING_SNAKE_CASE  ,   return_labels=__SCREAMING_SNAKE_CASE   )
																						# Is there a better way to remove these decoder inputs?
																						__magic_name__					:				str				=   {
																						    key: val
																						    for key, val in prepared_for_class.items()
																						    if key not in ('head_mask', 'decoder_head_mask', 'cross_attn_head_mask', 'decoder_input_ids')
																						}

																						__magic_name__					:				Tuple				=   {
																						    'labels',
																						    'label',
																						    'label_ids',
																						    'start_positions',
																						    'start_position',
																						    'end_positions',
																						    'end_position',
																						    'next_sentence_label',
																						}
																						__magic_name__					:				Any				=   possible_label_cols.intersection(set(__SCREAMING_SNAKE_CASE   )   )
																						self.assertGreater(len(__SCREAMING_SNAKE_CASE   )  ,   0  ,   msg='No matching label names found!'   )
																						__magic_name__					:				int				=   {key: val for key, val in prepared_for_class.items() if key in label_names}
																						__magic_name__					:				Union[str, Any]				=   {key: val for key, val in prepared_for_class.items() if key not in label_names}
																						self.assertGreater(len(__SCREAMING_SNAKE_CASE   )  ,   0   )

																						# Make sure it works with XLA!
																						model.compile(optimizer=tf.keras.optimizers.SGD(0.0   )  ,   jit_compile=__SCREAMING_SNAKE_CASE   )
																						# Make sure the model fits without crashing regardless of where we pass the labels
																						__magic_name__					:				Optional[Any]				=   model.fit(
																						    __SCREAMING_SNAKE_CASE  ,   validation_data=__SCREAMING_SNAKE_CASE  ,   steps_per_epoch=1  ,   validation_steps=1  ,   shuffle=__SCREAMING_SNAKE_CASE  ,   verbose=0  ,   )
																						__magic_name__					:				Tuple				=   history.history['loss'][0]
																						self.assertTrue(not isnan(__SCREAMING_SNAKE_CASE   )   )
																						__magic_name__					:				Dict				=   history.history['val_loss'][0]
																						self.assertTrue(not isnan(__SCREAMING_SNAKE_CASE   )   )

																						# Now test it with separate labels, to make sure that path works in XLA too.
																						__magic_name__					:				Optional[Any]				=   model_class(__SCREAMING_SNAKE_CASE   )
																						model.compile(optimizer=tf.keras.optimizers.SGD(0.0   )  ,   jit_compile=__SCREAMING_SNAKE_CASE   )
																						__magic_name__					:				List[str]				=   model.fit(
																						    __SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE  ,   validation_data=(inputs_minus_labels, labels)  ,   steps_per_epoch=1  ,   validation_steps=1  ,   shuffle=__SCREAMING_SNAKE_CASE  ,   verbose=0  ,   )

																						__magic_name__					:				List[Any]				=   history.history['loss'][0]
																						self.assertTrue(not isnan(__SCREAMING_SNAKE_CASE   )   )
																						__magic_name__					:				Dict				=   history.history['val_loss'][0]
																						self.assertTrue(not isnan(__SCREAMING_SNAKE_CASE   )   )
				@slow
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				Tuple				=   self.model_tester.prepare_config_and_inputs_for_common()
										__magic_name__					:				Optional[Any]				=   True
										__magic_name__					:				str				=   True

										if hasattr(__SCREAMING_SNAKE_CASE  ,   'use_cache'   ):
																__magic_name__					:				Dict				=   True

										__magic_name__					:				Any				=   getattr(self.model_tester  ,   'encoder_seq_length'  ,   self.model_tester.seq_length   )
										__magic_name__					:				int				=   getattr(self.model_tester  ,   'key_length'  ,   __SCREAMING_SNAKE_CASE   )

										for model_class in self.all_model_classes[:2]:
																__magic_name__					:				Union[str, Any]				=   self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE   )
																__magic_name__					:				Optional[Any]				=   model_class(__SCREAMING_SNAKE_CASE   )
																model.build()
																__magic_name__					:				Dict				=   len(model(__SCREAMING_SNAKE_CASE   )   )

																for key in list(class_inputs_dict.keys()   ):
																						# Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
																						if key not in model.input_signature:
																												del class_inputs_dict[key]
																						# Check it's a tensor, in case the inputs dict has some bools in it too
																						elif isinstance(class_inputs_dict[key]  ,   tf.Tensor   ) and class_inputs_dict[key].dtype.is_integer:
																												__magic_name__					:				int				=   tf.cast(class_inputs_dict[key]  ,   tf.intaa   )

																if set(class_inputs_dict.keys()   ) != set(model.input_signature.keys()   ):
																						continue  # Some models have inputs that the preparation functions don't create, we skip those

																with tempfile.TemporaryDirectory() as tmpdirname:
																						model.save_pretrained(__SCREAMING_SNAKE_CASE  ,   saved_model=__SCREAMING_SNAKE_CASE   )
																						__magic_name__					:				Tuple				=   os.path.join(__SCREAMING_SNAKE_CASE  ,   'saved_model'  ,   '1'   )
																						__magic_name__					:				Any				=   tf.keras.models.load_model(__SCREAMING_SNAKE_CASE   )
																						__magic_name__					:				Any				=   model(__SCREAMING_SNAKE_CASE   )

																						if self.is_encoder_decoder:
																												__magic_name__					:				Any				=   outputs['encoder_hidden_states']
																												__magic_name__					:				List[Any]				=   outputs['encoder_attentions']
																						else:
																												__magic_name__					:				Tuple				=   outputs['hidden_states']
																												__magic_name__					:				int				=   outputs['attentions']

																						self.assertEqual(len(__SCREAMING_SNAKE_CASE   )  ,   __SCREAMING_SNAKE_CASE   )

																						__magic_name__					:				List[Any]				=   getattr(
																						    self.model_tester  ,   'expected_num_hidden_layers'  ,   self.model_tester.num_hidden_layers + 1   )

																						self.assertEqual(len(__SCREAMING_SNAKE_CASE   )  ,   __SCREAMING_SNAKE_CASE   )
																						self.assertListEqual(
																						    list(output_hidden_states[0].shape[-2:]   )  ,   [self.model_tester.seq_length, self.model_tester.hidden_size]  ,   )

																						self.assertEqual(len(__SCREAMING_SNAKE_CASE   )  ,   self.model_tester.num_hidden_layers   )
																						self.assertListEqual(
																						    list(output_attentions[0].shape[-3:]   )  ,   [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]  ,   )
				@slow
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										tf.keras.mixed_precision.set_global_policy('mixed_float16'   )

										# try/finally block to ensure subsequent tests run in float32
										try:
																__magic_name__					:				Optional[int]				=   self.model_tester.prepare_config_and_inputs_for_common()
																for model_class in self.all_model_classes[:2]:
																						__magic_name__					:				Dict				=   self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE   )
																						__magic_name__					:				Optional[int]				=   model_class(__SCREAMING_SNAKE_CASE   )
																						__magic_name__					:				Any				=   model(__SCREAMING_SNAKE_CASE   )

																						self.assertIsNotNone(__SCREAMING_SNAKE_CASE   )
										finally:
																tf.keras.mixed_precision.set_global_policy('float32'   )
				@slow
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				List[Any]				=   self.model_tester.prepare_config_and_inputs_for_common()
										# head_mask and decoder_head_mask has different shapes than other input args
										if "head_mask" in inputs_dict:
																del inputs_dict["head_mask"]
										if "decoder_head_mask" in inputs_dict:
																del inputs_dict["decoder_head_mask"]
										if "cross_attn_head_mask" in inputs_dict:
																del inputs_dict["cross_attn_head_mask"]
										__magic_name__					:				str				=   {
										    module_member
										    for model_class in self.all_model_classes
										    for module in (import_module(model_class.__module__   ),)
										    for module_member_name in dir(__SCREAMING_SNAKE_CASE   )
										    if module_member_name.endswith('MainLayer'   )
										    for module_member in (getattr(__SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE   ),)
										    if isinstance(__SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE   )
										    and tf.keras.layers.Layer in module_member.__bases__
										    and getattr(__SCREAMING_SNAKE_CASE  ,   '_keras_serializable'  ,   __SCREAMING_SNAKE_CASE   )
										}

										for main_layer_class in tf_main_layer_classes:
																# T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
																if "T5" in main_layer_class.__name__:
																						# Take the same values than in TFT5ModelTester for this shared layer
																						__magic_name__					:				Union[str, Any]				=   TFSharedEmbeddings(self.model_tester.vocab_size  ,   self.model_tester.hidden_size  ,   name='shared'   )
																						__magic_name__					:				List[Any]				=   False
																						__magic_name__					:				Optional[int]				=   main_layer_class(__SCREAMING_SNAKE_CASE  ,   embed_tokens=__SCREAMING_SNAKE_CASE   )
																else:
																						__magic_name__					:				Optional[Any]				=   main_layer_class(__SCREAMING_SNAKE_CASE   )

																__magic_name__					:				Optional[Any]				=   {
																    name: tf.keras.Input(tensor.shape[1:]  ,   dtype=tensor.dtype   ) for name, tensor in inputs_dict.items()
																}

																if hasattr(self.model_tester  ,   'num_labels'   ):
																						__magic_name__					:				Union[str, Any]				=   self.model_tester.num_labels
																else:
																						__magic_name__					:				Optional[int]				=   2

																__magic_name__					:				Dict				=   tf.data.Dataset.from_tensor_slices(
																    (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)   ))   ).batch(1   )

																__magic_name__					:				Dict				=   main_layer(__SCREAMING_SNAKE_CASE   )[0]
																__magic_name__					:				int				=   tf.keras.layers.Dense(__SCREAMING_SNAKE_CASE  ,   activation='softmax'  ,   name='outputs'   )(__SCREAMING_SNAKE_CASE   )
																__magic_name__					:				Union[str, Any]				=   tf.keras.models.Model(inputs=__SCREAMING_SNAKE_CASE  ,   outputs=[outputs]   )

																model.compile(loss='binary_crossentropy'  ,   optimizer='adam'  ,   metrics=['binary_accuracy']   )
																model.fit(__SCREAMING_SNAKE_CASE  ,   epochs=1   )

																with tempfile.TemporaryDirectory() as tmpdirname:
																						__magic_name__					:				Optional[int]				=   os.path.join(__SCREAMING_SNAKE_CASE  ,   'keras_model.h5'   )
																						model.save(__SCREAMING_SNAKE_CASE   )
																						if "T5" in main_layer_class.__name__:
																												__magic_name__					:				Tuple				=   tf.keras.models.load_model(
																												    __SCREAMING_SNAKE_CASE  ,   custom_objects={
																												        main_layer_class.__name__: main_layer_class,
																												        'TFSharedEmbeddings': TFSharedEmbeddings,
																												    }  ,   )
																						else:
																												__magic_name__					:				int				=   tf.keras.models.load_model(
																												    __SCREAMING_SNAKE_CASE  ,   custom_objects={main_layer_class.__name__: main_layer_class}   )
																						assert isinstance(__SCREAMING_SNAKE_CASE  ,   tf.keras.Model   )
																						model(__SCREAMING_SNAKE_CASE   )
				@slow
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				str				=   self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes[:2]:
																__magic_name__					:				Any				=   model_class(__SCREAMING_SNAKE_CASE   )

																__magic_name__					:				Dict				=   copy.deepcopy(__SCREAMING_SNAKE_CASE   )

																if not self.is_encoder_decoder:
																						__magic_name__					:				Any				=   inputs['input_ids']
																						del inputs["input_ids"]
																else:
																						__magic_name__					:				Optional[Any]				=   inputs['input_ids']
																						__magic_name__					:				Union[str, Any]				=   inputs.get('decoder_input_ids'  ,   __SCREAMING_SNAKE_CASE   )
																						del inputs["input_ids"]
																						inputs.pop('decoder_input_ids'  ,   __SCREAMING_SNAKE_CASE   )

																if not self.is_encoder_decoder:
																						__magic_name__					:				Tuple				=   model.get_input_embeddings()(__SCREAMING_SNAKE_CASE   )
																else:
																						__magic_name__					:				str				=   model.get_input_embeddings()(__SCREAMING_SNAKE_CASE   )
																						__magic_name__					:				Dict				=   model.get_input_embeddings()(__SCREAMING_SNAKE_CASE   )

																__magic_name__					:				Optional[int]				=   self._prepare_for_class(__SCREAMING_SNAKE_CASE  ,   __SCREAMING_SNAKE_CASE   )

																@tf.function
																def run_in_graph_mode():
																						return model(__SCREAMING_SNAKE_CASE   )

																__magic_name__					:				Union[str, Any]				=   run_in_graph_mode()
																self.assertIsNotNone(__SCREAMING_SNAKE_CASE   )
				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase  ,   _UpperCAmelCase   ):




										"""simple docstring"""




										__magic_name__					:				Optional[Any]				=   []
										if model.config.bos_token_id is not None:
																special_tokens.append(model.config.bos_token_id   )
										if model.config.pad_token_id is not None:
																special_tokens.append(model.config.pad_token_id   )
										if model.config.eos_token_id is not None:
																special_tokens.append(model.config.eos_token_id   )

										# create random bad tokens that are not special tokens
										__magic_name__					:				str				=   []
										while len(__SCREAMING_SNAKE_CASE   ) < num_bad_tokens:
																__magic_name__					:				str				=   tf.squeeze(ids_tensor((1, 1)  ,   self.model_tester.vocab_size   )  ,   0   ).numpy()[0]
																if token not in special_tokens:
																						bad_tokens.append(__SCREAMING_SNAKE_CASE   )
										return bad_tokens
				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase   ):




										"""simple docstring"""




										for token_id in output_ids[0].numpy().tolist():
																self.assertGreaterEqual(__SCREAMING_SNAKE_CASE  ,   0   )
																self.assertLess(__SCREAMING_SNAKE_CASE  ,   self.model_tester.vocab_size   )





				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase  ,   _UpperCAmelCase   ):




										"""simple docstring"""




										for bad_word_ids in bad_words_ids:
																# for all slices in batch
																for generated_ids_slice in generated_ids:
																						# for all word idx
																						for i in range(len(__SCREAMING_SNAKE_CASE   )  ,   len(__SCREAMING_SNAKE_CASE   )   ):
																												# if tokens match
																												if generated_ids_slice[i - len(__SCREAMING_SNAKE_CASE   ) : i] == bad_word_ids:
																																		return True
										return False




'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import CTRLConfig, 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.ctrl.modeling_tf_ctrl import (
       TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFCTRLForSequenceClassification,
       TFCTRLLMHeadModel,
       TFCTRLModel,
   )


class 		_a     (							SCREAMING_SNAKE_CASE  ):







   """simple docstring"""




   def __init__(       self    ,__SCREAMING_SNAKE_CASE    ,):
    SCREAMING_SNAKE_CASE  :  Dict								=		parent
    SCREAMING_SNAKE_CASE  :  int								=		13
    SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		7
    SCREAMING_SNAKE_CASE  :  List[Any]								=		True
    SCREAMING_SNAKE_CASE  :  Dict								=		True
    SCREAMING_SNAKE_CASE  :  Optional[int]								=		True
    SCREAMING_SNAKE_CASE  :  int								=		True
    SCREAMING_SNAKE_CASE  :  str								=		True
    SCREAMING_SNAKE_CASE  :  int								=		99
    SCREAMING_SNAKE_CASE  :  List[str]								=		32
    SCREAMING_SNAKE_CASE  :  List[str]								=		2
    SCREAMING_SNAKE_CASE  :  Optional[Any]								=		4
    SCREAMING_SNAKE_CASE  :  Tuple								=		37
    SCREAMING_SNAKE_CASE  :  str								=		'gelu'
    SCREAMING_SNAKE_CASE  :  Tuple								=		0.1
    SCREAMING_SNAKE_CASE  :  Any								=		0.1
    SCREAMING_SNAKE_CASE  :  List[str]								=		512
    SCREAMING_SNAKE_CASE  :  List[Any]								=		16
    SCREAMING_SNAKE_CASE  :  List[Any]								=		2
    SCREAMING_SNAKE_CASE  :  Any								=		0.02
    SCREAMING_SNAKE_CASE  :  List[str]								=		3
    SCREAMING_SNAKE_CASE  :  Any								=		4
    SCREAMING_SNAKE_CASE  :  List[Any]								=		None
    SCREAMING_SNAKE_CASE  :  Optional[int]								=		self.vocab_size - 1






   def 					__a			(       self      ):
    SCREAMING_SNAKE_CASE  :  Any								=		ids_tensor([self.batch_size, self.seq_length]    ,self.vocab_size      )

    SCREAMING_SNAKE_CASE  :  Dict								=		None
    if self.use_input_mask:
     SCREAMING_SNAKE_CASE  :  List[str]								=		random_attention_mask([self.batch_size, self.seq_length]      )

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

    SCREAMING_SNAKE_CASE  :  int								=		None
    if self.use_mc_token_ids:
     SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		ids_tensor([self.batch_size, self.num_choices]    ,self.seq_length      )

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

    SCREAMING_SNAKE_CASE  :  Dict								=		CTRLConfig(
        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    ,)

    SCREAMING_SNAKE_CASE  :  Tuple								=		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 					__a			(       self    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,*__SCREAMING_SNAKE_CASE      ):
    SCREAMING_SNAKE_CASE  :  int								=		TFCTRLModel(config=__SCREAMING_SNAKE_CASE      )
    SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
    SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		model(__SCREAMING_SNAKE_CASE      )

    SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		[input_ids, None, input_mask]  # None is the input for 'past'
    SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		model(__SCREAMING_SNAKE_CASE      )

    SCREAMING_SNAKE_CASE  :  Tuple								=		model(__SCREAMING_SNAKE_CASE      )

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






   def 					__a			(       self    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,*__SCREAMING_SNAKE_CASE      ):
    SCREAMING_SNAKE_CASE  :  Optional[int]								=		TFCTRLLMHeadModel(config=__SCREAMING_SNAKE_CASE      )
    SCREAMING_SNAKE_CASE  :  Any								=		{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
    SCREAMING_SNAKE_CASE  :  Any								=		model(__SCREAMING_SNAKE_CASE      )
    self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.seq_length, self.vocab_size)      )






   def 					__a			(       self    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,*__SCREAMING_SNAKE_CASE      ):
    SCREAMING_SNAKE_CASE  :  Tuple								=		self.num_labels
    SCREAMING_SNAKE_CASE  :  Any								=		ids_tensor([self.batch_size]    ,self.type_sequence_label_size      )
    SCREAMING_SNAKE_CASE  :  Dict								=		{
        'input_ids': input_ids,
        'token_type_ids': token_type_ids,
        'labels': sequence_labels,
    }
    SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		TFCTRLForSequenceClassification(__SCREAMING_SNAKE_CASE      )
    SCREAMING_SNAKE_CASE  :  str								=		model(__SCREAMING_SNAKE_CASE      )
    self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.num_labels)      )






   def 					__a			(       self      ):
    SCREAMING_SNAKE_CASE  :  str								=		self.prepare_config_and_inputs()

    (
        (
        SCREAMING_SNAKE_CASE
    )				, (
        SCREAMING_SNAKE_CASE
    )				, (
        SCREAMING_SNAKE_CASE
    )				, (
        SCREAMING_SNAKE_CASE
    )				, (
        SCREAMING_SNAKE_CASE
    )				, (
        SCREAMING_SNAKE_CASE
    )				, (
        SCREAMING_SNAKE_CASE
    )				, (
        SCREAMING_SNAKE_CASE
    )				, (
        SCREAMING_SNAKE_CASE
    )				, 
    )  :  List[Any]								=		config_and_inputs

    SCREAMING_SNAKE_CASE  :  int								=		{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
    return config, inputs_dict



@require_tf
class 		_a     (							SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    unittest.TestCase  ):







   """simple docstring"""




   A		= (TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
   A		= (TFCTRLLMHeadModel,) if is_tf_available() else ()
   A		= (
       {
           'feature-extraction': TFCTRLModel,
           'text-classification': TFCTRLForSequenceClassification,
           'text-generation': TFCTRLLMHeadModel,
           'zero-shot': TFCTRLForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   A		= False
   A		= False






   def 					__a			(       self    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE      ):
    if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
     # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
     # `CTRLConfig` 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      ):
    SCREAMING_SNAKE_CASE  :  List[Any]								=		TFCTRLModelTester(self      )
    SCREAMING_SNAKE_CASE  :  Dict								=		ConfigTester(self    ,config_class=__SCREAMING_SNAKE_CASE    ,n_embd=37      )






   def 					__a			(       self      ):
    self.config_tester.run_common_tests()






   def 					__a			(       self      ):
    SCREAMING_SNAKE_CASE  :  Tuple								=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_ctrl_model(*__SCREAMING_SNAKE_CASE      )






   def 					__a			(       self      ):
    SCREAMING_SNAKE_CASE  :  str								=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_ctrl_lm_head(*__SCREAMING_SNAKE_CASE      )






   def 					__a			(       self      ):
    SCREAMING_SNAKE_CASE  :  Optional[Any]								=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_ctrl_for_sequence_classification(*__SCREAMING_SNAKE_CASE      )






   def 					__a			(       self      ):
    SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE  :  Tuple								=		self.model_tester.prepare_config_and_inputs_for_common()
    SCREAMING_SNAKE_CASE  :  Any								=		[TFCTRLLMHeadModel]
    SCREAMING_SNAKE_CASE  :  str								=		[TFCTRLForSequenceClassification]

    for model_class in self.all_model_classes:
     SCREAMING_SNAKE_CASE  :  List[str]								=		model_class(__SCREAMING_SNAKE_CASE      )
     model.build()  # may be needed for the get_bias() call below
     assert isinstance(model.get_input_embeddings()    ,tf.keras.layers.Layer      )

     if model_class in list_lm_models:
      SCREAMING_SNAKE_CASE  :  Dict								=		model.get_output_embeddings()
      assert isinstance(__SCREAMING_SNAKE_CASE    ,tf.keras.layers.Layer      )
      SCREAMING_SNAKE_CASE  :  Any								=		model.get_bias()
      assert isinstance(__SCREAMING_SNAKE_CASE    ,__SCREAMING_SNAKE_CASE      )
      for k, v in name.items():
       assert isinstance(__SCREAMING_SNAKE_CASE    ,tf.Variable      )
     elif model_class in list_other_models_with_output_ebd:
      SCREAMING_SNAKE_CASE  :  Any								=		model.get_output_embeddings()
      assert isinstance(__SCREAMING_SNAKE_CASE    ,tf.keras.layers.Layer      )
      SCREAMING_SNAKE_CASE  :  str								=		model.get_bias()
      assert name is None
     else:
      SCREAMING_SNAKE_CASE  :  List[Any]								=		model.get_output_embeddings()
      assert x is None
      SCREAMING_SNAKE_CASE  :  int								=		model.get_bias()
      assert name is None






   @slow
   def 					__a			(       self      ):
    for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     SCREAMING_SNAKE_CASE  :  List[str]								=		TFCTRLModel.from_pretrained(__SCREAMING_SNAKE_CASE      )
     self.assertIsNotNone(__SCREAMING_SNAKE_CASE      )



@require_tf
class 		_a     (							unittest.TestCase  ):







   """simple docstring"""




   @slow
   def 					__a			(       self      ):
    SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		TFCTRLLMHeadModel.from_pretrained('ctrl'      )
    SCREAMING_SNAKE_CASE  :  Any								=		tf.convert_to_tensor([[11859, 0, 1611, 8]]    ,dtype=tf.intaa      )  # Legal the president is
    SCREAMING_SNAKE_CASE  :  Optional[Any]								=		[
        11859,
        0,
        1611,
        8,
        5,
        150,
        26449,
        2,
        19,
        348,
        469,
        3,
        2595,
        48,
        20740,
        246533,
        246533,
        19,
        30,
        5,
    ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

    SCREAMING_SNAKE_CASE  :  Union[str, Any]								=		model.generate(__SCREAMING_SNAKE_CASE    ,do_sample=__SCREAMING_SNAKE_CASE      )
    self.assertListEqual(output_ids[0].numpy().tolist()    ,__SCREAMING_SNAKE_CASE      )


