
"""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


_a	 =							logging.get_logger(__name__)

_a	 =							{
    '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 A_			(lowercase__   ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__    :		Optional[int]						  =	"""bigbird_pegasus"""
  SCREAMING_SNAKE_CASE__    :		Any						  =	["""past_key_values"""]
  SCREAMING_SNAKE_CASE__    :		Tuple						  =	{
      """num_attention_heads""": """encoder_attention_heads""",
      """hidden_size""": """d_model""",
      """attention_probs_dropout_prob""": """attention_dropout""",
  }







  def __init__(	self       ,     lowercase_=9_6103       ,     lowercase_=4096       ,     lowercase_=16       ,     lowercase_=4096       ,     lowercase_=16       ,     lowercase_=16       ,     lowercase_=4096       ,     lowercase_=16       ,     lowercase_=0.0       ,     lowercase_=0.0       ,     lowercase_=True       ,     lowercase_=True       ,     lowercase_="gelu_new"       ,     lowercase_=1024       ,     lowercase_=0.1       ,     lowercase_=0.0       ,     lowercase_=0.0       ,     lowercase_=0.02       ,     lowercase_=2       ,     lowercase_=0.0       ,     lowercase_=True       ,     lowercase_=0       ,     lowercase_=2       ,     lowercase_=1       ,     lowercase_="block_sparse"       ,     lowercase_=64       ,     lowercase_=3       ,     lowercase_=False       ,     **lowercase_       ,     ):

     """simple docstring"""
     UpperCAmelCase_      :      Union[str, Any]      =					vocab_size
     UpperCAmelCase_      :      Optional[Any]      =					max_position_embeddings
     UpperCAmelCase_      :      List[str]      =					d_model
     UpperCAmelCase_      :      str      =					encoder_ffn_dim
     UpperCAmelCase_      :      Optional[Any]      =					encoder_layers
     UpperCAmelCase_      :      Optional[Any]      =					encoder_attention_heads
     UpperCAmelCase_      :      str      =					decoder_ffn_dim
     UpperCAmelCase_      :      Optional[Any]      =					decoder_layers
     UpperCAmelCase_      :      Optional[int]      =					decoder_attention_heads
     UpperCAmelCase_      :      Dict      =					dropout
     UpperCAmelCase_      :      Optional[int]      =					attention_dropout
     UpperCAmelCase_      :      Any      =					activation_dropout
     UpperCAmelCase_      :      str      =					activation_function
     UpperCAmelCase_      :      Tuple      =					init_std
     UpperCAmelCase_      :      Optional[int]      =					encoder_layerdrop
     UpperCAmelCase_      :      Union[str, Any]      =					decoder_layerdrop
     UpperCAmelCase_      :      int      =					classifier_dropout
     UpperCAmelCase_      :      Union[str, Any]      =					use_cache
     UpperCAmelCase_      :      List[str]      =					encoder_layers
     UpperCAmelCase_      :      str      =					scale_embedding  # scale factor will be sqrt(d_model) if True

     # extra config
     UpperCAmelCase_      :      List[Any]      =					attention_type
     UpperCAmelCase_      :      Any      =					block_size
     UpperCAmelCase_      :      str      =					num_random_blocks
     UpperCAmelCase_      :      Optional[Any]      =					use_bias

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




class A_			(lowercase__   ):




  '''simple docstring'''







  @property
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     if self.task in ["default", "seq2seq-lm"]:
        UpperCAmelCase_      :      List[str]      =					OrderedDict(
            [
                ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
            ]						)

        if self.use_past:
           UpperCAmelCase_      :      List[str]      =					{0: "batch"}
           UpperCAmelCase_      :      Any      =					{0: "batch", 1: "past_decoder_sequence + sequence"}
        else:
           UpperCAmelCase_      :      List[str]      =					{0: "batch", 1: "decoder_sequence"}
           UpperCAmelCase_      :      Optional[Any]      =					{0: "batch", 1: "decoder_sequence"}

        if self.use_past:
           self.fill_with_past_key_values_(lowercase_       ,     direction="inputs"						)
     elif self.task == "causal-lm":
        # TODO: figure this case out.
        UpperCAmelCase_      :      str      =					OrderedDict(
            [
                ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
            ]						)
        if self.use_past:
           UpperCAmelCase_  ,     UpperCAmelCase_      :      Dict      =					self.num_layers
           for i in range(lowercase_						):
              UpperCAmelCase_      :      Tuple      =					{0: "batch", 2: "past_sequence + sequence"}
              UpperCAmelCase_      :      List[str]      =					{0: "batch", 2: "past_sequence + sequence"}
     else:
        UpperCAmelCase_      :      Optional[Any]      =					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  UpperCamelCase__      (	self						):

     """simple docstring"""
     if self.task in ["default", "seq2seq-lm"]:
        UpperCAmelCase_      :      Union[str, Any]      =					super().outputs
     else:
        UpperCAmelCase_      :      Optional[Any]      =					super(lowercase_       ,     self						).outputs
        if self.use_past:
           UpperCAmelCase_  ,     UpperCAmelCase_      :      str      =					self.num_layers
           for i in range(lowercase_						):
              UpperCAmelCase_      :      Any      =					{0: "batch", 2: "past_sequence + sequence"}
              UpperCAmelCase_      :      int      =					{0: "batch", 2: "past_sequence + sequence"}
     return common_outputs







  def  UpperCamelCase__      (	self       ,     lowercase_       ,     lowercase_ = -1       ,     lowercase_ = -1       ,     lowercase_ = False       ,     lowercase_ = None       ,     ):

     """simple docstring"""
     UpperCAmelCase_      :      str      =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_						)

     # Generate decoder inputs
     UpperCAmelCase_      :      Union[str, Any]      =					seq_length if not self.use_past else 1
     UpperCAmelCase_      :      str      =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_						)
     UpperCAmelCase_      :      List[Any]      =					{F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
     UpperCAmelCase_      :      Optional[Any]      =					dict(**lowercase_       ,     **lowercase_						)

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

        UpperCAmelCase_      :      List[str]      =					torch.cat(
            [common_inputs["decoder_attention_mask"], torch.ones(lowercase_       ,     lowercase_						)]       ,     dim=1						)

        UpperCAmelCase_      :      Dict      =					[]
        # If the number of encoder and decoder layers are present in the model configuration, both are considered
        UpperCAmelCase_  ,     UpperCAmelCase_      :      Union[str, Any]      =					self.num_layers
        UpperCAmelCase_      :      List[str]      =					min(lowercase_       ,     lowercase_						)
        UpperCAmelCase_      :      Optional[int]      =					max(lowercase_       ,     lowercase_						) - min_num_layers
        UpperCAmelCase_      :      List[Any]      =					"encoder" if num_encoder_layers > num_decoder_layers else "decoder"

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







  def  UpperCamelCase__      (	self       ,     lowercase_       ,     lowercase_ = -1       ,     lowercase_ = -1       ,     lowercase_ = False       ,     lowercase_ = None       ,     ):

     """simple docstring"""
     UpperCAmelCase_      :      Optional[Any]      =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_						)

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

        UpperCAmelCase_      :      str      =					common_inputs["attention_mask"].dtype
        UpperCAmelCase_      :      Union[str, Any]      =					torch.cat(
            [common_inputs["attention_mask"], torch.ones(lowercase_       ,     lowercase_       ,     dtype=lowercase_						)]       ,     dim=1						)
        UpperCAmelCase_      :      List[str]      =					[
            (torch.zeros(lowercase_						), torch.zeros(lowercase_						)) for _ in range(lowercase_						)
        ]
     return common_inputs







  def  UpperCamelCase__      (	self       ,     lowercase_       ,     lowercase_ = -1       ,     lowercase_ = -1       ,     lowercase_ = False       ,     lowercase_ = None       ,     ):

     """simple docstring"""
     # 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
     UpperCAmelCase_      :      Any      =					compute_effective_axis_dimension(
         lowercase_       ,     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
     UpperCAmelCase_      :      List[str]      =					tokenizer.num_special_tokens_to_add(lowercase_						)
     UpperCAmelCase_      :      Union[str, Any]      =					compute_effective_axis_dimension(
         lowercase_       ,     fixed_dimension=OnnxConfig.default_fixed_sequence       ,     num_token_to_add=lowercase_						)

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







  def  UpperCamelCase__      (	self       ,     lowercase_       ,     lowercase_ = -1       ,     lowercase_ = -1       ,     lowercase_ = False       ,     lowercase_ = None       ,     ):

     """simple docstring"""
     if self.task in ["default", "seq2seq-lm"]:
        UpperCAmelCase_      :      Dict      =					self._generate_dummy_inputs_for_default_and_seqaseq_lm(
            lowercase_       ,     batch_size=lowercase_       ,     seq_length=lowercase_       ,     is_pair=lowercase_       ,     framework=lowercase_						)

     elif self.task == "causal-lm":
        UpperCAmelCase_      :      List[str]      =					self._generate_dummy_inputs_for_causal_lm(
            lowercase_       ,     batch_size=lowercase_       ,     seq_length=lowercase_       ,     is_pair=lowercase_       ,     framework=lowercase_						)
     else:
        UpperCAmelCase_      :      int      =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            lowercase_       ,     batch_size=lowercase_       ,     seq_length=lowercase_       ,     is_pair=lowercase_       ,     framework=lowercase_						)

     return common_inputs







  def  UpperCamelCase__      (	self       ,     lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_						):

     """simple docstring"""
     if self.task in ["default", "seq2seq-lm"]:
        UpperCAmelCase_      :      Union[str, Any]      =					super()._flatten_past_key_values_(lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_						)
     else:
        UpperCAmelCase_      :      Dict      =					super(lowercase_       ,     self						)._flatten_past_key_values_(
            lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_						)




"""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_			(lowercase__   ):




  '''simple docstring'''







  def __init__(	self       ,     lowercase_       ,     ):

     """simple docstring"""
     UpperCAmelCase_      :      List[str]      =					parent
     UpperCAmelCase_      :      List[Any]      =					13
     UpperCAmelCase_      :      Dict      =					7
     UpperCAmelCase_      :      Optional[int]      =					True
     UpperCAmelCase_      :      List[Any]      =					True
     UpperCAmelCase_      :      Optional[int]      =					True
     UpperCAmelCase_      :      int      =					True
     UpperCAmelCase_      :      Any      =					True
     UpperCAmelCase_      :      Any      =					99
     UpperCAmelCase_      :      Dict      =					32
     UpperCAmelCase_      :      Dict      =					2
     UpperCAmelCase_      :      str      =					4
     UpperCAmelCase_      :      int      =					37
     UpperCAmelCase_      :      Union[str, Any]      =					"gelu"
     UpperCAmelCase_      :      List[str]      =					0.1
     UpperCAmelCase_      :      List[str]      =					0.1
     UpperCAmelCase_      :      int      =					512
     UpperCAmelCase_      :      str      =					16
     UpperCAmelCase_      :      Union[str, Any]      =					2
     UpperCAmelCase_      :      Dict      =					0.02
     UpperCAmelCase_      :      Tuple      =					3
     UpperCAmelCase_      :      Tuple      =					4
     UpperCAmelCase_      :      int      =					None
     UpperCAmelCase_      :      Dict      =					self.vocab_size - 1







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Dict      =					ids_tensor([self.batch_size, self.seq_length]       ,     self.vocab_size						)

     UpperCAmelCase_      :      Optional[int]      =					None
     if self.use_input_mask:
        UpperCAmelCase_      :      Optional[Any]      =					random_attention_mask([self.batch_size, self.seq_length]						)

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

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

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

     UpperCAmelCase_      :      str      =					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_      :      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  UpperCamelCase__      (	self       ,     lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_       ,     *lowercase_						):

     """simple docstring"""
     UpperCAmelCase_      :      int      =					TFCTRLModel(config=lowercase_						)
     UpperCAmelCase_      :      Optional[Any]      =					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
     UpperCAmelCase_      :      Union[str, Any]      =					model(lowercase_						)

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

     UpperCAmelCase_      :      str      =					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_						):

     """simple docstring"""
     UpperCAmelCase_      :      Optional[int]      =					TFCTRLLMHeadModel(config=lowercase_						)
     UpperCAmelCase_      :      List[Any]      =					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
     UpperCAmelCase_      :      List[str]      =					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_						):

     """simple docstring"""
     UpperCAmelCase_      :      List[str]      =					self.num_labels
     UpperCAmelCase_      :      str      =					ids_tensor([self.batch_size]       ,     self.type_sequence_label_size						)
     UpperCAmelCase_      :      Union[str, Any]      =					{
         "input_ids": input_ids,
         "token_type_ids": token_type_ids,
         "labels": sequence_labels,
     }
     UpperCAmelCase_      :      Union[str, Any]      =					TFCTRLForSequenceClassification(lowercase_						)
     UpperCAmelCase_      :      Tuple      =					model(lowercase_						)
     self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.num_labels)						)







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Dict      =					self.prepare_config_and_inputs()

     (
         (
         UpperCAmelCase_
     )  ,     (
         UpperCAmelCase_
     )  ,     (
         UpperCAmelCase_
     )  ,     (
         UpperCAmelCase_
     )  ,     (
         UpperCAmelCase_
     )  ,     (
         UpperCAmelCase_
     )  ,     (
         UpperCAmelCase_
     )  ,     (
         UpperCAmelCase_
     )  ,     (
         UpperCAmelCase_
     )  ,     
     )      :      Tuple      =					config_and_inputs

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




@require_tf
class A_			(lowercase__       ,lowercase__       ,unittest.TestCase   ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__    :		Dict						  =	(TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
  SCREAMING_SNAKE_CASE__    :		str						  =	(TFCTRLLMHeadModel,) if is_tf_available() else ()
  SCREAMING_SNAKE_CASE__    :		Any						  =	(
      {
          """feature-extraction""": TFCTRLModel,
          """text-classification""": TFCTRLForSequenceClassification,
          """text-generation""": TFCTRLLMHeadModel,
          """zero-shot""": TFCTRLForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  SCREAMING_SNAKE_CASE__    :		Dict						  =	False
  SCREAMING_SNAKE_CASE__    :		List[Any]						  =	False







  def  UpperCamelCase__      (	self       ,     lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_       ,     lowercase_						):

     """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  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      str      =					TFCTRLModelTester(self						)
     UpperCAmelCase_      :      Dict      =					ConfigTester(self       ,     config_class=lowercase_       ,     n_embd=37						)







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     self.config_tester.run_common_tests()







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      str      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_ctrl_model(*lowercase_						)







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Union[str, Any]      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_ctrl_lm_head(*lowercase_						)







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Optional[Any]      =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_ctrl_for_sequence_classification(*lowercase_						)







  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_  ,     UpperCAmelCase_      :      List[Any]      =					self.model_tester.prepare_config_and_inputs_for_common()
     UpperCAmelCase_      :      Tuple      =					[TFCTRLLMHeadModel]
     UpperCAmelCase_      :      Dict      =					[TFCTRLForSequenceClassification]

     for model_class in self.all_model_classes:
        UpperCAmelCase_      :      Optional[int]      =					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_      :      List[str]      =					model.get_output_embeddings()
           assert isinstance(lowercase_       ,     tf.keras.layers.Layer						)
           UpperCAmelCase_      :      List[Any]      =					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_      :      int      =					model.get_output_embeddings()
           assert isinstance(lowercase_       ,     tf.keras.layers.Layer						)
           UpperCAmelCase_      :      Any      =					model.get_bias()
           assert name is None
        else:
           UpperCAmelCase_      :      Dict      =					model.get_output_embeddings()
           assert x is None
           UpperCAmelCase_      :      Tuple      =					model.get_bias()
           assert name is None







  @slow
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        UpperCAmelCase_      :      List[Any]      =					TFCTRLModel.from_pretrained(lowercase_						)
        self.assertIsNotNone(lowercase_						)




@require_tf
class A_			(unittest.TestCase   ):




  '''simple docstring'''







  @slow
  def  UpperCamelCase__      (	self						):

     """simple docstring"""
     UpperCAmelCase_      :      Union[str, Any]      =					TFCTRLLMHeadModel.from_pretrained("ctrl"						)
     UpperCAmelCase_      :      Union[str, Any]      =					tf.convert_to_tensor([[1_1859, 0, 1611, 8]]       ,     dtype=tf.intaa						)  # Legal the president is
     UpperCAmelCase_      :      int      =					[
         1_1859,
         0,
         1611,
         8,
         5,
         150,
         2_6449,
         2,
         19,
         348,
         469,
         3,
         2595,
         48,
         2_0740,
         24_6533,
         24_6533,
         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_      :      List[str]      =					model.generate(lowercase_       ,     do_sample=lowercase_						)
     self.assertListEqual(output_ids[0].numpy().tolist()       ,     lowercase_						)


