

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 		__magic_name__ (				snake_case							):






     def __init__(							self						,		_lowercase						,		)->			Tuple:
         UpperCamelCase_          =		parent
         UpperCamelCase_          =		13
         UpperCamelCase_          =		7
         UpperCamelCase_          =		True
         UpperCamelCase_          =		True
         UpperCamelCase_          =		True
         UpperCamelCase_          =		True
         UpperCamelCase_          =		True
         UpperCamelCase_          =		99
         UpperCamelCase_          =		32
         UpperCamelCase_          =		2
         UpperCamelCase_          =		4
         UpperCamelCase_          =		37
         UpperCamelCase_          =		"gelu"
         UpperCamelCase_          =		0.1
         UpperCamelCase_          =		0.1
         UpperCamelCase_          =		512
         UpperCamelCase_          =		16
         UpperCamelCase_          =		2
         UpperCamelCase_          =		0.02
         UpperCamelCase_          =		3
         UpperCamelCase_          =		4
         UpperCamelCase_          =		None
         UpperCamelCase_          =		self.vocab_size - 1






     def      UpperCAmelCase_							(							self     )->			int:
         UpperCamelCase_          =		ids_tensor([self.batch_size, self.seq_length]						,		self.vocab_size     )

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

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

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

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

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

         UpperCamelCase_          =		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      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		*_lowercase     )->			int:
         UpperCamelCase_          =		TFCTRLModel(config=_lowercase     )
         UpperCamelCase_          =		{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
         UpperCamelCase_          =		model(_lowercase     )

         UpperCamelCase_          =		[input_ids, None, input_mask]  # None is the input for 'past'
         UpperCamelCase_          =		model(_lowercase     )

         UpperCamelCase_          =		model(_lowercase     )

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






     def      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		*_lowercase     )->			str:
         UpperCamelCase_          =		TFCTRLLMHeadModel(config=_lowercase     )
         UpperCamelCase_          =		{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
         UpperCamelCase_          =		model(_lowercase     )
         self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.seq_length, self.vocab_size)     )






     def      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		*_lowercase     )->			Dict:
         UpperCamelCase_          =		self.num_labels
         UpperCamelCase_          =		ids_tensor([self.batch_size]						,		self.type_sequence_label_size     )
         UpperCamelCase_          =		{
             "input_ids": input_ids,
             "token_type_ids": token_type_ids,
             "labels": sequence_labels,
         }
         UpperCamelCase_          =		TFCTRLForSequenceClassification(_lowercase     )
         UpperCamelCase_          =		model(_lowercase     )
         self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.num_labels)     )






     def      UpperCAmelCase_							(							self     )->			Dict:
         UpperCamelCase_          =		self.prepare_config_and_inputs()

         (
             (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    (
             UpperCamelCase_
         )   ,    
         )          =		config_and_inputs

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






@require_tf
class 		__magic_name__ (				snake_case       ,	snake_case       ,	unittest.TestCase							):
     UpperCamelCase_     :int									=	(TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
     UpperCamelCase_     :int									=	(TFCTRLLMHeadModel,) if is_tf_available() else ()
     UpperCamelCase_     :List[str]									=	(
         {
             """feature-extraction""": TFCTRLModel,
             """text-classification""": TFCTRLForSequenceClassification,
             """text-generation""": TFCTRLLMHeadModel,
             """zero-shot""": TFCTRLForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     UpperCamelCase_     :Union[str, Any]									=	False
     UpperCamelCase_     :List[Any]									=	False






     def      UpperCAmelCase_							(							self						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase						,		_lowercase     )->			int:
         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      UpperCAmelCase_							(							self     )->			List[Any]:
         UpperCamelCase_          =		TFCTRLModelTester(self     )
         UpperCamelCase_          =		ConfigTester(self						,		config_class=_lowercase						,		n_embd=37     )






     def      UpperCAmelCase_							(							self     )->			Tuple:
         self.config_tester.run_common_tests()






     def      UpperCAmelCase_							(							self     )->			Optional[Any]:
         UpperCamelCase_          =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_model(*_lowercase     )






     def      UpperCAmelCase_							(							self     )->			List[Any]:
         UpperCamelCase_          =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_lm_head(*_lowercase     )






     def      UpperCAmelCase_							(							self     )->			Any:
         UpperCamelCase_          =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_for_sequence_classification(*_lowercase     )






     def      UpperCAmelCase_							(							self     )->			List[Any]:
         UpperCamelCase_   ,    UpperCamelCase_          =		self.model_tester.prepare_config_and_inputs_for_common()
         UpperCamelCase_          =		[TFCTRLLMHeadModel]
         UpperCamelCase_          =		[TFCTRLForSequenceClassification]

         for model_class in self.all_model_classes:
             UpperCamelCase_          =		model_class(_lowercase     )
             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:
                 UpperCamelCase_          =		model.get_output_embeddings()
                 assert isinstance(_lowercase						,		tf.keras.layers.Layer     )
                 UpperCamelCase_          =		model.get_bias()
                 assert isinstance(_lowercase						,		_lowercase     )
                 for k, v in name.items():
                     assert isinstance(_lowercase						,		tf.Variable     )
             elif model_class in list_other_models_with_output_ebd:
                 UpperCamelCase_          =		model.get_output_embeddings()
                 assert isinstance(_lowercase						,		tf.keras.layers.Layer     )
                 UpperCamelCase_          =		model.get_bias()
                 assert name is None
             else:
                 UpperCamelCase_          =		model.get_output_embeddings()
                 assert x is None
                 UpperCamelCase_          =		model.get_bias()
                 assert name is None






     @slow
     def      UpperCAmelCase_							(							self     )->			Any:
         for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase_          =		TFCTRLModel.from_pretrained(_lowercase     )
             self.assertIsNotNone(_lowercase     )






@require_tf
class 		__magic_name__ (				unittest.TestCase							):






     @slow
     def      UpperCAmelCase_							(							self     )->			str:
         UpperCamelCase_          =		TFCTRLLMHeadModel.from_pretrained("ctrl"     )
         UpperCamelCase_          =		tf.convert_to_tensor([[11_859, 0, 1_611, 8]]						,		dtype=tf.intaa     )  # Legal the president is
         UpperCamelCase_          =		[
             11_859,
             0,
             1_611,
             8,
             5,
             150,
             26_449,
             2,
             19,
             348,
             469,
             3,
             2_595,
             48,
             20_740,
             246_533,
             246_533,
             19,
             30,
             5,
         ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

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





'''simple docstring'''

from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


UpperCAmelCase			=    logging.get_logger(__name__)

UpperCAmelCase			=    {
    'google/bigbird-pegasus-large-arxiv': (
        'https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json'
    ),
    'google/bigbird-pegasus-large-pubmed': (
        'https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json'
    ),
    'google/bigbird-pegasus-large-bigpatent': (
        'https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json'
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}

class __snake_case(      _lowerCAmelCase					):


						'''simple docstring'''



						UpperCAmelCase							:    Union[str, Any]           =		"bigbird_pegasus"
						UpperCAmelCase							:    Optional[Any]           =		["past_key_values"]
						UpperCAmelCase							:    Optional[Any]           =		{
						    "num_attention_heads": "encoder_attention_heads",
						    "hidden_size": "d_model",
						    "attention_probs_dropout_prob": "attention_dropout",
						}


						def __init__(					self	,       A_=9_6103	,       A_=4096	,       A_=16	,       A_=4096	,       A_=16	,       A_=16	,       A_=4096	,       A_=16	,       A_=0.0	,       A_=0.0	,       A_=True	,       A_=True	,       A_="gelu_new"	,       A_=1024	,       A_=0.1	,       A_=0.0	,       A_=0.0	,       A_=0.0_2	,       A_=2	,       A_=0.0	,       A_=True	,       A_=0	,       A_=2	,       A_=1	,       A_="block_sparse"	,       A_=64	,       A_=3	,       A_=False	,       **A_	,       )	->	List[str]:
							lowerCAmelCase    =	vocab_size
							lowerCAmelCase    =	max_position_embeddings
							lowerCAmelCase    =	d_model
							lowerCAmelCase    =	encoder_ffn_dim
							lowerCAmelCase    =	encoder_layers
							lowerCAmelCase    =	encoder_attention_heads
							lowerCAmelCase    =	decoder_ffn_dim
							lowerCAmelCase    =	decoder_layers
							lowerCAmelCase    =	decoder_attention_heads
							lowerCAmelCase    =	dropout
							lowerCAmelCase    =	attention_dropout
							lowerCAmelCase    =	activation_dropout
							lowerCAmelCase    =	activation_function
							lowerCAmelCase    =	init_std
							lowerCAmelCase    =	encoder_layerdrop
							lowerCAmelCase    =	decoder_layerdrop
							lowerCAmelCase    =	classifier_dropout
							lowerCAmelCase    =	use_cache
							lowerCAmelCase    =	encoder_layers
							lowerCAmelCase    =	scale_embedding  # scale factor will be sqrt(d_model) if True

							# extra config
							lowerCAmelCase    =	attention_type
							lowerCAmelCase    =	block_size
							lowerCAmelCase    =	num_random_blocks
							lowerCAmelCase    =	use_bias

							super().__init__(
							    pad_token_id=A_	,       bos_token_id=A_	,       eos_token_id=A_	,       is_encoder_decoder=A_	,       decoder_start_token_id=A_	,       **A_	,       )







class __snake_case(      _lowerCAmelCase					):


						'''simple docstring'''



						@property
						def 				__snake_case    (					self      )	->	Mapping[str, Mapping[int, str]]:
							if self.task in ["default", "seq2seq-lm"]:
								lowerCAmelCase    =	OrderedDict(
								    [
								        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
								        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
								    ]      )

								if self.use_past:
									lowerCAmelCase    =	{0: """batch"""}
									lowerCAmelCase    =	{0: """batch""", 1: """past_decoder_sequence + sequence"""}
								else:
									lowerCAmelCase    =	{0: """batch""", 1: """decoder_sequence"""}
									lowerCAmelCase    =	{0: """batch""", 1: """decoder_sequence"""}

								if self.use_past:
									self.fill_with_past_key_values_(A_	,       direction="""inputs"""      )
							elif self.task == "causal-lm":
								# TODO: figure this case out.
								lowerCAmelCase    =	OrderedDict(
								    [
								        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
								        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
								    ]      )
								if self.use_past:
									lowerCAmelCase,   lowerCAmelCase    =	self.num_layers
									for i in range(A_      ):
										lowerCAmelCase    =	{0: """batch""", 2: """past_sequence + sequence"""}
										lowerCAmelCase    =	{0: """batch""", 2: """past_sequence + sequence"""}
							else:
								lowerCAmelCase    =	OrderedDict(
								    [
								        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
								        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
								        ("""decoder_input_ids""", {0: """batch""", 1: """decoder_sequence"""}),
								        ("""decoder_attention_mask""", {0: """batch""", 1: """decoder_sequence"""}),
								    ]      )

							return common_inputs


						@property
						def 				__snake_case    (					self      )	->	Mapping[str, Mapping[int, str]]:
							if self.task in ["default", "seq2seq-lm"]:
								lowerCAmelCase    =	super().outputs
							else:
								lowerCAmelCase    =	super(A_	,       self      ).outputs
								if self.use_past:
									lowerCAmelCase,   lowerCAmelCase    =	self.num_layers
									for i in range(A_      ):
										lowerCAmelCase    =	{0: """batch""", 2: """past_sequence + sequence"""}
										lowerCAmelCase    =	{0: """batch""", 2: """past_sequence + sequence"""}
							return common_outputs


						def 				__snake_case    (					self	,       A_	,       A_ = -1	,       A_ = -1	,       A_ = False	,       A_ = None	,       )	->	Mapping[str, Any]:
							lowerCAmelCase    =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    A_	,       A_	,       A_	,       A_	,       A_      )

							# Generate decoder inputs
							lowerCAmelCase    =	seq_length if not self.use_past else 1
							lowerCAmelCase    =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    A_	,       A_	,       A_	,       A_	,       A_      )
							lowerCAmelCase    =	{f'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
							lowerCAmelCase    =	dict(**A_	,       **A_      )

							if self.use_past:
								if not is_torch_available():
									raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""      )
								else:
									import torch
								lowerCAmelCase,   lowerCAmelCase    =	common_inputs["""input_ids"""].shape
								lowerCAmelCase    =	common_inputs["""decoder_input_ids"""].shape[1]
								lowerCAmelCase,   lowerCAmelCase    =	self.num_attention_heads
								lowerCAmelCase    =	(
								    batch,
								    num_encoder_attention_heads,
								    encoder_seq_length,
								    self._config.hidden_size // num_encoder_attention_heads,
								)
								lowerCAmelCase    =	decoder_seq_length + 3
								lowerCAmelCase    =	(
								    batch,
								    num_decoder_attention_heads,
								    decoder_past_length,
								    self._config.hidden_size // num_decoder_attention_heads,
								)

								lowerCAmelCase    =	torch.cat(
								    [common_inputs["""decoder_attention_mask"""], torch.ones(A_	,       A_      )]	,       dim=1      )

								lowerCAmelCase    =	[]
								# If the number of encoder and decoder layers are present in the model configuration, both are considered
								lowerCAmelCase,   lowerCAmelCase    =	self.num_layers
								lowerCAmelCase    =	min(A_	,       A_      )
								lowerCAmelCase    =	max(A_	,       A_      ) - min_num_layers
								lowerCAmelCase    =	"""encoder""" if num_encoder_layers > num_decoder_layers else """decoder"""

								for _ in range(A_      ):
									common_inputs["past_key_values"].append(
									    (
									        torch.zeros(A_      ),
									        torch.zeros(A_      ),
									        torch.zeros(A_      ),
									        torch.zeros(A_      ),
									    )      )
								# TODO: test this.
								lowerCAmelCase    =	encoder_shape if remaining_side_name == """encoder""" else decoder_shape
								for _ in range(A_	,       A_      ):
									common_inputs["past_key_values"].append((torch.zeros(A_      ), torch.zeros(A_      ))      )
							return common_inputs


						def 				__snake_case    (					self	,       A_	,       A_ = -1	,       A_ = -1	,       A_ = False	,       A_ = None	,       )	->	Mapping[str, Any]:
							lowerCAmelCase    =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    A_	,       A_	,       A_	,       A_	,       A_      )

							if self.use_past:
								if not is_torch_available():
									raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""      )
								else:
									import torch
								lowerCAmelCase,   lowerCAmelCase    =	common_inputs["""input_ids"""].shape
								# Not using the same length for past_key_values
								lowerCAmelCase    =	seqlen + 2
								lowerCAmelCase,   lowerCAmelCase    =	self.num_layers
								lowerCAmelCase,   lowerCAmelCase    =	self.num_attention_heads
								lowerCAmelCase    =	(
								    batch,
								    num_encoder_attention_heads,
								    past_key_values_length,
								    self._config.hidden_size // num_encoder_attention_heads,
								)

								lowerCAmelCase    =	common_inputs["""attention_mask"""].dtype
								lowerCAmelCase    =	torch.cat(
								    [common_inputs["""attention_mask"""], torch.ones(A_	,       A_	,       dtype=A_      )]	,       dim=1      )
								lowerCAmelCase    =	[
								    (torch.zeros(A_      ), torch.zeros(A_      )) for _ in range(A_      )
								]
							return common_inputs


						def 				__snake_case    (					self	,       A_	,       A_ = -1	,       A_ = -1	,       A_ = False	,       A_ = None	,       )	->	Mapping[str, Any]:
							# Copied from OnnxConfig.generate_dummy_inputs
							# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
							# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
							lowerCAmelCase    =	compute_effective_axis_dimension(
							    A_	,       fixed_dimension=OnnxConfig.default_fixed_batch	,       num_token_to_add=0      )

							# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
							lowerCAmelCase    =	tokenizer.num_special_tokens_to_add(A_      )
							lowerCAmelCase    =	compute_effective_axis_dimension(
							    A_	,       fixed_dimension=OnnxConfig.default_fixed_sequence	,       num_token_to_add=A_      )

							# Generate dummy inputs according to compute batch and sequence
							lowerCAmelCase    =	[""" """.join([tokenizer.unk_token]      ) * seq_length] * batch_size
							lowerCAmelCase    =	dict(tokenizer(A_	,       return_tensors=A_      )      )
							return common_inputs


						def 				__snake_case    (					self	,       A_	,       A_ = -1	,       A_ = -1	,       A_ = False	,       A_ = None	,       )	->	Mapping[str, Any]:
							if self.task in ["default", "seq2seq-lm"]:
								lowerCAmelCase    =	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
								    A_	,       batch_size=A_	,       seq_length=A_	,       is_pair=A_	,       framework=A_      )

							elif self.task == "causal-lm":
								lowerCAmelCase    =	self._generate_dummy_inputs_for_causal_lm(
								    A_	,       batch_size=A_	,       seq_length=A_	,       is_pair=A_	,       framework=A_      )
							else:
								lowerCAmelCase    =	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
								    A_	,       batch_size=A_	,       seq_length=A_	,       is_pair=A_	,       framework=A_      )

							return common_inputs




						def 				__snake_case    (					self	,       A_	,       A_	,       A_	,       A_      )	->	Tuple:
							if self.task in ["default", "seq2seq-lm"]:
								lowerCAmelCase    =	super()._flatten_past_key_values_(A_	,       A_	,       A_	,       A_      )
							else:
								lowerCAmelCase    =	super(A_	,       self      )._flatten_past_key_values_(
								    A_	,       A_	,       A_	,       A_      )