






from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
from transformers.utils import cached_property, is_tf_available, is_vision_available

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


if is_tf_available():
   import tensorflow as tf

   from transformers.models.swin.modeling_tf_swin import (
       TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFSwinForImageClassification,
       TFSwinForMaskedImageModeling,
       TFSwinModel,
   )


if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor




class        _lowerCAmelCase:





       """simple docstring"""







       def __init__(      self						,    _lowerCamelCase						,    _lowerCamelCase=1_3						,    _lowerCamelCase=3_2						,    _lowerCamelCase=2						,    _lowerCamelCase=3						,    _lowerCamelCase=1_6						,    _lowerCamelCase=[1, 2, 1]						,    _lowerCamelCase=[2, 2, 4]						,    _lowerCamelCase=2						,    _lowerCamelCase=2.0						,    _lowerCamelCase=True						,    _lowerCamelCase=0.0						,    _lowerCamelCase=0.0						,    _lowerCamelCase=0.1						,    _lowerCamelCase="gelu"						,    _lowerCamelCase=False						,    _lowerCamelCase=True						,    _lowerCamelCase=0.0_2						,    _lowerCamelCase=1e-5						,    _lowerCamelCase=True						,    _lowerCamelCase=None						,    _lowerCamelCase=True						,    _lowerCamelCase=1_0						,    _lowerCamelCase=8						,    ):
         UpperCamelCase_:      Dict					   =       parent
         UpperCamelCase_:      int					   =       batch_size
         UpperCamelCase_:      str					   =       image_size
         UpperCamelCase_:      List[Any]					   =       patch_size
         UpperCamelCase_:      Any					   =       num_channels
         UpperCamelCase_:      int					   =       embed_dim
         UpperCamelCase_:      Optional[Any]					   =       depths
         UpperCamelCase_:      Optional[Any]					   =       num_heads
         UpperCamelCase_:      List[Any]					   =       window_size
         UpperCamelCase_:      Dict					   =       mlp_ratio
         UpperCamelCase_:      Any					   =       qkv_bias
         UpperCamelCase_:      Any					   =       hidden_dropout_prob
         UpperCamelCase_:      Union[str, Any]					   =       attention_probs_dropout_prob
         UpperCamelCase_:      str					   =       drop_path_rate
         UpperCamelCase_:      Dict					   =       hidden_act
         UpperCamelCase_:      List[str]					   =       use_absolute_embeddings
         UpperCamelCase_:      str					   =       patch_norm
         UpperCamelCase_:      List[str]					   =       layer_norm_eps
         UpperCamelCase_:      Optional[Any]					   =       initializer_range
         UpperCamelCase_:      str					   =       is_training
         UpperCamelCase_:      Any					   =       scope
         UpperCamelCase_:      Union[str, Any]					   =       use_labels
         UpperCamelCase_:      Optional[int]					   =       type_sequence_label_size
         UpperCamelCase_:      Optional[Any]					   =       encoder_stride





       def     _a					(      self							):
         UpperCamelCase_:      str					   =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

         UpperCamelCase_:      List[Any]					   =       None
         if self.use_labels:
           UpperCamelCase_:      str					   =       ids_tensor([self.batch_size]						,    self.type_sequence_label_size							)

         UpperCamelCase_:      int					   =       self.get_config()

         return config, pixel_values, labels





       def     _a					(      self							):
         return SwinConfig(
             image_size=self.image_size						,    patch_size=self.patch_size						,    num_channels=self.num_channels						,    embed_dim=self.embed_dim						,    depths=self.depths						,    num_heads=self.num_heads						,    window_size=self.window_size						,    mlp_ratio=self.mlp_ratio						,    qkv_bias=self.qkv_bias						,    hidden_dropout_prob=self.hidden_dropout_prob						,    attention_probs_dropout_prob=self.attention_probs_dropout_prob						,    drop_path_rate=self.drop_path_rate						,    hidden_act=self.hidden_act						,    use_absolute_embeddings=self.use_absolute_embeddings						,    path_norm=self.patch_norm						,    layer_norm_eps=self.layer_norm_eps						,    initializer_range=self.initializer_range						,    encoder_stride=self.encoder_stride						,    )





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase							):
         UpperCamelCase_:      Any					   =       TFSwinModel(config=__a							)
         UpperCamelCase_:      List[str]					   =       model(__a							)

         UpperCamelCase_:      Dict					   =       ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths							) - 1))
         UpperCamelCase_:      Any					   =       int(config.embed_dim * 2 ** (len(config.depths							) - 1)							)

         self.parent.assertEqual(result.last_hidden_state.shape						,    (self.batch_size, expected_seq_len, expected_dim)							)





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase							):
         UpperCamelCase_:      Any					   =       TFSwinForMaskedImageModeling(config=__a							)
         UpperCamelCase_:      Tuple					   =       model(__a							)
         self.parent.assertEqual(
             result.logits.shape						,    (self.batch_size, self.num_channels, self.image_size, self.image_size)							)

         # test greyscale images
         UpperCamelCase_:      str					   =       1
         UpperCamelCase_:      Union[str, Any]					   =       TFSwinForMaskedImageModeling(__a							)

         UpperCamelCase_:      Optional[int]					   =       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
         UpperCamelCase_:      Any					   =       model(__a							)
         self.parent.assertEqual(result.logits.shape						,    (self.batch_size, 1, self.image_size, self.image_size)							)





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase							):
         UpperCamelCase_:      Dict					   =       self.type_sequence_label_size
         UpperCamelCase_:      Tuple					   =       TFSwinForImageClassification(__a							)
         UpperCamelCase_:      Any					   =       model(__a						,    labels=__a							)
         self.parent.assertEqual(result.logits.shape						,    (self.batch_size, self.type_sequence_label_size)							)

         # test greyscale images
         UpperCamelCase_:      Tuple					   =       1
         UpperCamelCase_:      str					   =       TFSwinForImageClassification(__a							)
         UpperCamelCase_:      List[Any]					   =       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
         UpperCamelCase_:      List[str]					   =       model(__a							)
         self.parent.assertEqual(result.logits.shape						,    (self.batch_size, self.type_sequence_label_size)							)





       def     _a					(      self							):
         UpperCamelCase_:      List[Any]					   =       self.prepare_config_and_inputs()
         UpperCamelCase_:      Tuple					   =       config_and_inputs
         UpperCamelCase_:      Dict					   =       {'pixel_values': pixel_values}
         return config, inputs_dict







@require_tf
class        _lowerCAmelCase( lowerCAmelCase_							,			lowerCAmelCase_							,			unittest.TestCase      ):





       """simple docstring"""







       a       :	Tuple								=(
           (
               TFSwinModel,
               TFSwinForImageClassification,
               TFSwinForMaskedImageModeling,
           )
           if is_tf_available()
           else ()
       )
       a       :	Optional[int]								=(
           {'''feature-extraction''': TFSwinModel, '''image-classification''': TFSwinForImageClassification}
           if is_tf_available()
           else {}
       )

       a       :	Tuple								=False
       a       :	Union[str, Any]								=False
       a       :	Optional[int]								=False
       a       :	int								=False





       def     _a					(      self							):
         UpperCamelCase_:      Optional[int]					   =       TFSwinModelTester(self							)
         UpperCamelCase_:      Union[str, Any]					   =       ConfigTester(self						,    config_class=__a						,    embed_dim=3_7							)





       def     _a					(      self							):
         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()





       def     _a					(      self							):
         return





       def     _a					(      self							):
         UpperCamelCase_:      List[str]					   =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__a							)





       def     _a					(      self							):
         UpperCamelCase_:      List[Any]					   =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*__a							)





       def     _a					(      self							):
         UpperCamelCase_:      Optional[Any]					   =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__a							)





       @unittest.skip(reason='Swin does not use inputs_embeds'							)
       def     _a					(      self							):
         pass





       def     _a					(      self							):
         UpperCamelCase_:      int					   =       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           UpperCamelCase_:      Dict					   =       model_class(__a							)
           self.assertIsInstance(model.get_input_embeddings()						,    tf.keras.layers.Layer							)
           UpperCamelCase_:      str					   =       model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(__a						,    tf.keras.layers.Dense							)							)





       def     _a					(      self							):
         UpperCamelCase_:      Dict					   =       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           UpperCamelCase_:      Optional[int]					   =       model_class(__a							)
           UpperCamelCase_:      Union[str, Any]					   =       inspect.signature(model.call							)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           UpperCamelCase_:      Optional[int]					   =       [*signature.parameters.keys()]

           UpperCamelCase_:      str					   =       ['pixel_values']
           self.assertListEqual(arg_names[:1]						,    __a							)





       def     _a					(      self							):
         UpperCamelCase_:      Any					   =       self.model_tester.prepare_config_and_inputs_for_common()
         UpperCamelCase_:      Optional[int]					   =       True

         for model_class in self.all_model_classes:
           UpperCamelCase_:      Optional[int]					   =       True
           UpperCamelCase_:      Dict					   =       False
           UpperCamelCase_:      Any					   =       True
           UpperCamelCase_:      Tuple					   =       model_class(__a							)
           UpperCamelCase_:      List[str]					   =       model(**self._prepare_for_class(__a						,    __a							)							)
           UpperCamelCase_:      int					   =       outputs.attentions
           UpperCamelCase_:      List[Any]					   =       len(self.model_tester.depths							)
           self.assertEqual(len(__a							)						,    __a							)

           # check that output_attentions also work using config
           del inputs_dict["output_attentions"]
           UpperCamelCase_:      Any					   =       True
           UpperCamelCase_:      List[Any]					   =       config.window_size**2
           UpperCamelCase_:      Optional[Any]					   =       model_class(__a							)
           UpperCamelCase_:      Tuple					   =       model(**self._prepare_for_class(__a						,    __a							)							)
           UpperCamelCase_:      str					   =       outputs.attentions
           self.assertEqual(len(__a							)						,    __a							)

           self.assertListEqual(
               list(attentions[0].shape[-3:]							)						,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]						,    )
           UpperCamelCase_:      Any					   =       len(__a							)

           # Check attention is always last and order is fine
           UpperCamelCase_:      int					   =       True
           UpperCamelCase_:      Any					   =       True
           UpperCamelCase_:      str					   =       model_class(__a							)
           UpperCamelCase_:      str					   =       model(**self._prepare_for_class(__a						,    __a							)							)

           if hasattr(self.model_tester						,    'num_hidden_states_types'							):
             UpperCamelCase_:      Optional[int]					   =       self.model_tester.num_hidden_states_types
           else:
             # also another +1 for reshaped_hidden_states
             UpperCamelCase_:      Union[str, Any]					   =       2
           self.assertEqual(out_len + added_hidden_states						,    len(__a							)							)

           UpperCamelCase_:      Dict					   =       outputs.attentions

           self.assertEqual(len(__a							)						,    __a							)

           self.assertListEqual(
               list(self_attentions[0].shape[-3:]							)						,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]						,    )





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase							):
         UpperCamelCase_:      Optional[Any]					   =       model_class(__a							)
         UpperCamelCase_:      int					   =       model(**self._prepare_for_class(__a						,    __a							)							)
         UpperCamelCase_:      Tuple					   =       outputs.hidden_states

         UpperCamelCase_:      Any					   =       getattr(
             self.model_tester						,    'expected_num_hidden_layers'						,    len(self.model_tester.depths							) + 1							)
         self.assertEqual(len(__a							)						,    __a							)

         # Swin has a different seq_length
         UpperCamelCase_:      Optional[int]					   =       to_atuple(config.patch_size							)

         UpperCamelCase_:      List[str]					   =       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

         self.assertListEqual(
             list(hidden_states[0].shape[-2:]							)						,    [num_patches, self.model_tester.embed_dim]						,    )

         UpperCamelCase_:      str					   =       outputs.reshaped_hidden_states
         self.assertEqual(len(__a							)						,    __a							)

         UpperCamelCase_:      str					   =       reshaped_hidden_states[0].shape

         UpperCamelCase_:      int					   =       tf.reshape(reshaped_hidden_states[0]						,    (batch_size, num_channels, height * width)							)
         UpperCamelCase_:      List[str]					   =       tf.transpose(__a						,    (0, 2, 1)							)

         self.assertListEqual(
             list(reshaped_hidden_states.shape[-2:]							)						,    [num_patches, self.model_tester.embed_dim]						,    )





       def     _a					(      self							):
         UpperCamelCase_:      Optional[Any]					   =       self.model_tester.prepare_config_and_inputs_for_common()

         UpperCamelCase_:      Union[str, Any]					   =       to_atuple(self.model_tester.image_size							)

         for model_class in self.all_model_classes:
           UpperCamelCase_:      Optional[int]					   =       True
           self.check_hidden_states_output(__a						,    __a						,    __a						,    __a							)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           UpperCamelCase_:      Tuple					   =       True

           self.check_hidden_states_output(__a						,    __a						,    __a						,    __a							)





       def     _a					(      self							):
         UpperCamelCase_:      List[str]					   =       self.model_tester.prepare_config_and_inputs_for_common()
         UpperCamelCase_:      List[str]					   =       3

         UpperCamelCase_:      Any					   =       to_atuple(self.model_tester.image_size							)
         UpperCamelCase_:      Any					   =       to_atuple(config.patch_size							)

         UpperCamelCase_:      Any					   =       image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
         UpperCamelCase_:      Optional[int]					   =       image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

         for model_class in self.all_model_classes:
           UpperCamelCase_:      Union[str, Any]					   =       True
           self.check_hidden_states_output(__a						,    __a						,    __a						,    (padded_height, padded_width)							)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           UpperCamelCase_:      int					   =       True
           self.check_hidden_states_output(__a						,    __a						,    __a						,    (padded_height, padded_width)							)





       @slow
       def     _a					(      self							):





         for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase_:      List[Any]					   =       TFSwinModel.from_pretrained(__a							)
           self.assertIsNotNone(__a							)







@require_vision
@require_tf
class        _lowerCAmelCase( unittest.TestCase      ):





       """simple docstring"""







       @cached_property
       def     _a					(      self							):
         return (
             AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'							)
             if is_vision_available()
             else None
         )





       @slow
       def     _a					(      self							):
         UpperCamelCase_:      Optional[Any]					   =       TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'							)
         UpperCamelCase_:      str					   =       self.default_image_processor

         UpperCamelCase_:      Optional[Any]					   =       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
         UpperCamelCase_:      Optional[Any]					   =       image_processor(images=__a						,    return_tensors='tf'							)

         # forward pass
         UpperCamelCase_:      List[Any]					   =       model(__a							)

         # verify the logits
         UpperCamelCase_:      List[str]					   =       tf.TensorShape((1, 1_0_0_0)							)
         self.assertEqual(outputs.logits.shape						,    __a							)
         UpperCamelCase_:      Optional[Any]					   =       tf.constant([-0.0_9_4_8, -0.6_4_5_4, -0.0_9_2_1]							)
         self.assertTrue(np.allclose(outputs.logits[0, :3]						,    __a						,    atol=1e-4							)							)







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        _lowerCAmelCase( UpperCAmelCase_      ):





       """simple docstring"""







       def __init__(      self						,    _lowerCamelCase						,    ):
         UpperCamelCase_:      Tuple					   =       parent
         UpperCamelCase_:      Optional[Any]					   =       1_3
         UpperCamelCase_:      Any					   =       7
         UpperCamelCase_:      Any					   =       True
         UpperCamelCase_:      List[Any]					   =       True
         UpperCamelCase_:      Dict					   =       True
         UpperCamelCase_:      Optional[Any]					   =       True
         UpperCamelCase_:      Tuple					   =       True
         UpperCamelCase_:      Any					   =       9_9
         UpperCamelCase_:      Dict					   =       3_2
         UpperCamelCase_:      Dict					   =       2
         UpperCamelCase_:      List[Any]					   =       4
         UpperCamelCase_:      int					   =       3_7
         UpperCamelCase_:      List[str]					   =       'gelu'
         UpperCamelCase_:      Union[str, Any]					   =       0.1
         UpperCamelCase_:      int					   =       0.1
         UpperCamelCase_:      int					   =       5_1_2
         UpperCamelCase_:      str					   =       1_6
         UpperCamelCase_:      List[str]					   =       2
         UpperCamelCase_:      Optional[int]					   =       0.0_2
         UpperCamelCase_:      int					   =       3
         UpperCamelCase_:      Tuple					   =       4
         UpperCamelCase_:      List[Any]					   =       None
         UpperCamelCase_:      Union[str, Any]					   =       self.vocab_size - 1





       def     _a					(      self							):
         UpperCamelCase_:      Optional[Any]					   =       ids_tensor([self.batch_size, self.seq_length]						,    self.vocab_size							)

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

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

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

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

         UpperCamelCase_:      List[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     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase						,    *_lowerCamelCase							):
         UpperCamelCase_:      Dict					   =       TFCTRLModel(config=_lowerCamelCase							)
         UpperCamelCase_:      int					   =       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         UpperCamelCase_:      Optional[int]					   =       model(_lowerCamelCase							)

         UpperCamelCase_:      Optional[int]					   =       [input_ids, None, input_mask]  # None is the input for 'past'
         UpperCamelCase_:      Dict					   =       model(_lowerCamelCase							)

         UpperCamelCase_:      List[str]					   =       model(_lowerCamelCase							)

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





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





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





       def     _a					(      self							):
         UpperCamelCase_:      int					   =       self.prepare_config_and_inputs()

         (
             (
             UpperCamelCase_
         )   ,(
             UpperCamelCase_
         )   ,(
             UpperCamelCase_
         )   ,(
             UpperCamelCase_
         )   ,(
             UpperCamelCase_
         )   ,(
             UpperCamelCase_
         )   ,(
             UpperCamelCase_
         )   ,(
             UpperCamelCase_
         )   ,(
             UpperCamelCase_
         )   ,
         ):      str					   =       config_and_inputs

         UpperCamelCase_:      List[str]					   =       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
         return config, inputs_dict







@require_tf
class        _lowerCAmelCase( UpperCAmelCase_							,			UpperCAmelCase_							,			unittest.TestCase      ):





       """simple docstring"""







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





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase							):
         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							):
         UpperCamelCase_:      List[str]					   =       TFCTRLModelTester(self							)
         UpperCamelCase_:      List[Any]					   =       ConfigTester(self						,    config_class=_lowerCamelCase						,    n_embd=3_7							)





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





       def     _a					(      self							):
         UpperCamelCase_:      Dict					   =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_model(*_lowerCamelCase							)





       def     _a					(      self							):
         UpperCamelCase_:      Optional[int]					   =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_lm_head(*_lowerCamelCase							)





       def     _a					(      self							):
         UpperCamelCase_:      Union[str, Any]					   =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_for_sequence_classification(*_lowerCamelCase							)





       def     _a					(      self							):
         UpperCamelCase_   ,UpperCamelCase_:      Union[str, Any]					   =       self.model_tester.prepare_config_and_inputs_for_common()
         UpperCamelCase_:      Optional[Any]					   =       [TFCTRLLMHeadModel]
         UpperCamelCase_:      Optional[Any]					   =       [TFCTRLForSequenceClassification]

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





       @slow
       def     _a					(      self							):
         for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase_:      Optional[Any]					   =       TFCTRLModel.from_pretrained(_lowerCamelCase							)
           self.assertIsNotNone(_lowerCamelCase							)







@require_tf
class        _lowerCAmelCase( unittest.TestCase      ):





       """simple docstring"""







       @slow
       def     _a					(      self							):
         UpperCamelCase_:      Optional[int]					   =       TFCTRLLMHeadModel.from_pretrained('ctrl'							)
         UpperCamelCase_:      Any					   =       tf.convert_to_tensor([[1_1_8_5_9, 0, 1_6_1_1, 8]]						,    dtype=tf.intaa							)  # Legal the president is
         UpperCamelCase_:      Dict					   =       [
             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

         UpperCamelCase_:      List[str]					   =       model.generate(_lowerCamelCase						,    do_sample=_lowerCamelCase							)
         self.assertListEqual(output_ids[0].numpy().tolist()						,    _lowerCamelCase							)