
"""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    _snake_case  (						_lowercase       ):






							def __init__(					self						:			List[Any]						, snake_case__						:			str						, ):






												"""simple docstring"""



												__a:						Union[str, Any]		    =					parent
												__a:						Dict		    =					1_3
												__a:						Union[str, Any]		    =					7
												__a:						List[str]		    =					True
												__a:						Tuple		    =					True
												__a:						Tuple		    =					True
												__a:						str		    =					True
												__a:						Tuple		    =					True
												__a:						Optional[int]		    =					9_9
												__a:						Optional[Any]		    =					3_2
												__a:						List[str]		    =					2
												__a:						str		    =					4
												__a:						List[str]		    =					3_7
												__a:						Dict		    =					"""gelu"""
												__a:						Dict		    =					0.1
												__a:						List[str]		    =					0.1
												__a:						Optional[int]		    =					5_1_2
												__a:						Tuple		    =					1_6
												__a:						List[str]		    =					2
												__a:						Union[str, Any]		    =					0.02
												__a:						Optional[Any]		    =					3
												__a:						int		    =					4
												__a:						Any		    =					None
												__a:						Dict		    =					self.vocab_size - 1






							def 							__lowercase  (					self						:			Optional[Any]    ):






												"""simple docstring"""



												__a:						Dict		    =					ids_tensor([self.batch_size, self.seq_length]						, self.vocab_size    )

												__a:						int		    =					None
												if self.use_input_mask:
																	__a:						Tuple		    =					random_attention_mask([self.batch_size, self.seq_length]    )

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

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

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

												__a:						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						, )

												__a:						Optional[int]		    =					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 							__lowercase  (					self						:			Any						, snake_case__						:			int						, snake_case__						:			int						, snake_case__						:			Optional[Any]						, snake_case__						:			Optional[Any]						, snake_case__						:			Optional[int]						, *snake_case__						:			List[Any]    ):






												"""simple docstring"""



												__a:						Tuple		    =					TFCTRLModel(config=snake_case__    )
												__a:						Optional[Any]		    =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
												__a:						Tuple		    =					model(snake_case__    )

												__a:						List[str]		    =					[input_ids, None, input_mask]  # None is the input for 'past'
												__a:						Optional[int]		    =					model(snake_case__    )

												__a:						Dict		    =					model(snake_case__    )

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






							def 							__lowercase  (					self						:			List[str]						, snake_case__						:			Union[str, Any]						, snake_case__						:			str						, snake_case__						:			Optional[Any]						, snake_case__						:			str						, snake_case__						:			int						, *snake_case__						:			int    ):






												"""simple docstring"""



												__a:						Any		    =					TFCTRLLMHeadModel(config=snake_case__    )
												__a:						Dict		    =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
												__a:						str		    =					model(snake_case__    )
												self.parent.assertEqual(result.logits.shape						, (self.batch_size, self.seq_length, self.vocab_size)    )






							def 							__lowercase  (					self						:			Optional[Any]						, snake_case__						:			List[str]						, snake_case__						:			Optional[Any]						, snake_case__						:			List[str]						, snake_case__						:			Tuple						, snake_case__						:			str						, *snake_case__						:			Dict    ):






												"""simple docstring"""



												__a:						Any		    =					self.num_labels
												__a:						str		    =					ids_tensor([self.batch_size]						, self.type_sequence_label_size    )
												__a:						List[Any]		    =					{
												    """input_ids""": input_ids,
												    """token_type_ids""": token_type_ids,
												    """labels""": sequence_labels,
												}
												__a:						Any		    =					TFCTRLForSequenceClassification(snake_case__    )
												__a:						Optional[Any]		    =					model(snake_case__    )
												self.parent.assertEqual(result.logits.shape						, (self.batch_size, self.num_labels)    )






							def 							__lowercase  (					self						:			Tuple    ):






												"""simple docstring"""



												__a:						Tuple		    =					self.prepare_config_and_inputs()

												(
												    __a				
												):						str		    =					config_and_inputs

												__a:						Dict		    =					{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
												return config, inputs_dict






@require_tf
class    _snake_case  (						_lowercase ,				_lowercase ,				unittest.TestCase       ):
							SCREAMING_SNAKE_CASE		     =						(TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
							SCREAMING_SNAKE_CASE		     =						(TFCTRLLMHeadModel,) if is_tf_available() else ()
							SCREAMING_SNAKE_CASE		     =						(
							    {
							        '''feature-extraction''': TFCTRLModel,
							        '''text-classification''': TFCTRLForSequenceClassification,
							        '''text-generation''': TFCTRLLMHeadModel,
							        '''zero-shot''': TFCTRLForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)
							SCREAMING_SNAKE_CASE		     =						False
							SCREAMING_SNAKE_CASE		     =						False






							def 							__lowercase  (					self						:			List[Any]						, snake_case__						:			Optional[int]						, snake_case__						:			List[str]						, snake_case__						:			Optional[int]						, snake_case__						:			Optional[Any]						, snake_case__						:			Tuple    ):






												"""simple docstring"""



												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 							__lowercase  (					self						:			Tuple    ):






												"""simple docstring"""



												__a:						List[Any]		    =					TFCTRLModelTester(self    )
												__a:						Any		    =					ConfigTester(self						, config_class=snake_case__						, n_embd=3_7    )






							def 							__lowercase  (					self						:			int    ):






												"""simple docstring"""



												self.config_tester.run_common_tests()






							def 							__lowercase  (					self						:			Optional[Any]    ):






												"""simple docstring"""



												__a:						Dict		    =					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_ctrl_model(*snake_case__    )






							def 							__lowercase  (					self						:			Tuple    ):






												"""simple docstring"""



												__a:						Any		    =					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_ctrl_lm_head(*snake_case__    )






							def 							__lowercase  (					self						:			Tuple    ):






												"""simple docstring"""



												__a:						str		    =					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_ctrl_for_sequence_classification(*snake_case__    )






							def 							__lowercase  (					self						:			Tuple    ):






												"""simple docstring"""



												__a:						List[Any]		    =					self.model_tester.prepare_config_and_inputs_for_common()
												__a:						Union[str, Any]		    =					[TFCTRLLMHeadModel]
												__a:						Dict		    =					[TFCTRLForSequenceClassification]

												for model_class in self.all_model_classes:
																	__a:						List[str]		    =					model_class(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:
																						__a:						str		    =					model.get_output_embeddings()
																						assert isinstance(snake_case__						, tf.keras.layers.Layer    )
																						__a:						List[Any]		    =					model.get_bias()
																						assert isinstance(snake_case__						, snake_case__    )
																						for k, v in name.items():
																											assert isinstance(snake_case__						, tf.Variable    )
																	elif model_class in list_other_models_with_output_ebd:
																						__a:						Tuple		    =					model.get_output_embeddings()
																						assert isinstance(snake_case__						, tf.keras.layers.Layer    )
																						__a:						int		    =					model.get_bias()
																						assert name is None
																	else:
																						__a:						Any		    =					model.get_output_embeddings()
																						assert x is None
																						__a:						Union[str, Any]		    =					model.get_bias()
																						assert name is None






							@slow
							def 							__lowercase  (					self						:			int    ):






												"""simple docstring"""



												for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	__a:						int		    =					TFCTRLModel.from_pretrained(snake_case__    )
																	self.assertIsNotNone(snake_case__    )






@require_tf
class    _snake_case  (						unittest.TestCase       ):






							@slow
							def 							__lowercase  (					self						:			Union[str, Any]    ):






												"""simple docstring"""



												__a:						Optional[Any]		    =					TFCTRLLMHeadModel.from_pretrained("""ctrl"""    )
												__a:						int		    =					tf.convert_to_tensor([[1_1_8_5_9, 0, 1_6_1_1, 8]]						, dtype=tf.intaa    )  # Legal the president is
												__a:						List[Any]		    =					[
												    1_1_8_5_9,
												    0,
												    1_6_1_1,
												    8,
												    5,
												    1_5_0,
												    2_6_4_4_9,
												    2,
												    1_9,
												    3_4_8,
												    4_6_9,
												    3,
												    2_5_9_5,
												    4_8,
												    2_0_7_4_0,
												    2_4_6_5_3_3,
												    2_4_6_5_3_3,
												    1_9,
												    3_0,
												    5,
												]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

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


"""simple docstring"""
import torch
import torch.nn as nn
from transformers.modeling_utils import ModuleUtilsMixin
from transformers.models.ta.modeling_ta import (
    TaBlock,
    TaConfig,
    TaLayerNorm,
)

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin




class    _snake_case  (						_lowercase ,				_lowercase ,				_lowercase       ):






							@register_to_config
							def __init__(					self						:			str						, snake_case__						:			int						, snake_case__						:			int						, snake_case__						:			int						, snake_case__						:			float						, snake_case__						:			int						, snake_case__						:			int						, snake_case__						:			int						, snake_case__						:			int						, snake_case__						:			str						, snake_case__						:			bool = False						, ):






												"""simple docstring"""



												super().__init__()

												__a:						Optional[Any]		    =					nn.Linear(snake_case__						, snake_case__						, bias=snake_case__    )

												__a:						Optional[Any]		    =					nn.Embedding(snake_case__						, snake_case__    )
												__a:						Any		    =					False

												__a:						Any		    =					nn.Dropout(p=snake_case__    )

												__a:						List[str]		    =					TaConfig(
												    d_model=snake_case__						, num_heads=snake_case__						, d_kv=snake_case__						, d_ff=snake_case__						, feed_forward_proj=snake_case__						, dropout_rate=snake_case__						, is_decoder=snake_case__						, is_encoder_decoder=snake_case__						, )
												__a:						Optional[int]		    =					nn.ModuleList()
												for lyr_num in range(snake_case__    ):
																	__a:						Union[str, Any]		    =					TaBlock(snake_case__    )
																	self.encoders.append(snake_case__    )

												__a:						List[str]		    =					TaLayerNorm(snake_case__    )
												__a:						Optional[int]		    =					nn.Dropout(p=snake_case__    )






							def 							__lowercase  (					self						:			str						, snake_case__						:			Optional[Any]						, snake_case__						:			int    ):






												"""simple docstring"""



												__a:						str		    =					self.input_proj(snake_case__    )

												# terminal relative positional encodings
												__a:						Optional[int]		    =					encoder_inputs.shape[1]
												__a:						List[Any]		    =					torch.arange(snake_case__						, device=encoder_inputs.device    )

												__a:						Union[str, Any]		    =					encoder_inputs_mask.sum(-1    )
												__a:						str		    =					torch.roll(input_positions.unsqueeze(0    )						, tuple(seq_lens.tolist()    )						, dims=0    )
												x += self.position_encoding(snake_case__    )

												__a:						Any		    =					self.dropout_pre(snake_case__    )

												# inverted the attention mask
												__a:						Any		    =					encoder_inputs.size()
												__a:						str		    =					self.get_extended_attention_mask(snake_case__						, snake_case__    )

												for lyr in self.encoders:
																	__a:						Any		    =					lyr(snake_case__						, snake_case__    )[0]
												__a:						int		    =					self.layer_norm(snake_case__    )

												return self.dropout_post(snake_case__    ), encoder_inputs_mask
