






import inspect
import unittest

from transformers import SwinaSRConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch
   from torch import nn

   from transformers import SwinaSRForImageSuperResolution, SwinaSRModel
   from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
   from PIL import Image

   from transformers import SwinaSRImageProcessor




class        _lowerCAmelCase:





       """simple docstring"""







       def __init__(      self						,    _lowerCamelCase						,    _lowerCamelCase=1_3						,    _lowerCamelCase=3_2						,    _lowerCamelCase=1						,    _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=False						,    _lowerCamelCase=2						,    ):
         UpperCamelCase_:      Any					   =       parent
         UpperCamelCase_:      Tuple					   =       batch_size
         UpperCamelCase_:      Dict					   =       image_size
         UpperCamelCase_:      int					   =       patch_size
         UpperCamelCase_:      Any					   =       num_channels
         UpperCamelCase_:      List[str]					   =       embed_dim
         UpperCamelCase_:      Union[str, Any]					   =       depths
         UpperCamelCase_:      int					   =       num_heads
         UpperCamelCase_:      List[str]					   =       window_size
         UpperCamelCase_:      int					   =       mlp_ratio
         UpperCamelCase_:      Union[str, Any]					   =       qkv_bias
         UpperCamelCase_:      Dict					   =       hidden_dropout_prob
         UpperCamelCase_:      List[Any]					   =       attention_probs_dropout_prob
         UpperCamelCase_:      Optional[Any]					   =       drop_path_rate
         UpperCamelCase_:      Dict					   =       hidden_act
         UpperCamelCase_:      Tuple					   =       use_absolute_embeddings
         UpperCamelCase_:      str					   =       patch_norm
         UpperCamelCase_:      int					   =       layer_norm_eps
         UpperCamelCase_:      Union[str, Any]					   =       initializer_range
         UpperCamelCase_:      Optional[Any]					   =       is_training
         UpperCamelCase_:      Union[str, Any]					   =       scope
         UpperCamelCase_:      Dict					   =       use_labels
         UpperCamelCase_:      Optional[Any]					   =       upscale

         # here we set some attributes to make tests pass
         UpperCamelCase_:      List[str]					   =       len(lowerCamelCase__							)
         UpperCamelCase_:      List[str]					   =       embed_dim
         UpperCamelCase_:      Optional[int]					   =       (image_size // patch_size) ** 2





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

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

         UpperCamelCase_:      Union[str, Any]					   =       self.get_config()

         return config, pixel_values, labels





       def     _a					(      self							):
         return SwinaSRConfig(
             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						,    upscale=self.upscale						,    )





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase							):
         UpperCamelCase_:      List[Any]					   =       SwinaSRModel(config=lowerCamelCase__							)
         model.to(lowerCamelCase__							)
         model.eval()
         UpperCamelCase_:      Tuple					   =       model(lowerCamelCase__							)

         self.parent.assertEqual(
             result.last_hidden_state.shape						,    (self.batch_size, self.embed_dim, self.image_size, self.image_size)							)





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase						,    _lowerCamelCase							):
         UpperCamelCase_:      List[Any]					   =       SwinaSRForImageSuperResolution(lowerCamelCase__							)
         model.to(lowerCamelCase__							)
         model.eval()
         UpperCamelCase_:      str					   =       model(lowerCamelCase__							)

         UpperCamelCase_:      List[str]					   =       self.image_size * self.upscale
         self.parent.assertEqual(
             result.reconstruction.shape						,    (self.batch_size, self.num_channels, expected_image_size, expected_image_size)							)





       def     _a					(      self							):
         UpperCamelCase_:      str					   =       self.prepare_config_and_inputs()
         UpperCamelCase_:      Optional[Any]					   =       config_and_inputs
         UpperCamelCase_:      Union[str, Any]					   =       {"pixel_values": pixel_values}
         return config, inputs_dict







@require_torch
class        _lowerCAmelCase( UpperCAmelCase__							,			UpperCAmelCase__							,			unittest.TestCase      ):





       """simple docstring"""







       a       :	int								=(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
       a       :	List[str]								={'feature-extraction': SwinaSRModel} if is_torch_available() else {}

       a       :	Tuple								=False
       a       :	Any								=False
       a       :	List[str]								=False
       a       :	Tuple								=False
       a       :	Any								=False





       def     _a					(      self							):
         UpperCamelCase_:      List[Any]					   =       SwinaSRModelTester(self							)
         UpperCamelCase_:      Tuple					   =       ConfigTester(self						,    config_class=lowerCamelCase__						,    embed_dim=3_7							)





       def     _a					(      self							):
         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							):
         UpperCamelCase_:      List[str]					   =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCamelCase__							)





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





       @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'							)
       def     _a					(      self							):
         pass





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





       @unittest.skip(reason='Swin2SR does not support training yet'							)
       def     _a					(      self							):
         pass





       @unittest.skip(reason='Swin2SR does not support training yet'							)
       def     _a					(      self							):
         pass





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

         for model_class in self.all_model_classes:
           UpperCamelCase_:      Optional[Any]					   =       model_class(lowerCamelCase__							)
           self.assertIsInstance(model.get_input_embeddings()						,    (nn.Module)							)
           UpperCamelCase_:      List[Any]					   =       model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(lowerCamelCase__						,    nn.Linear							)							)





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

         for model_class in self.all_model_classes:
           UpperCamelCase_:      Tuple					   =       model_class(lowerCamelCase__							)
           UpperCamelCase_:      Any					   =       inspect.signature(model.forward							)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           UpperCamelCase_:      Tuple					   =       [*signature.parameters.keys()]

           UpperCamelCase_:      Optional[int]					   =       ["pixel_values"]
           self.assertListEqual(arg_names[:1]						,    lowerCamelCase__							)





       @slow
       def     _a					(      self							):
         for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase_:      str					   =       SwinaSRModel.from_pretrained(lowerCamelCase__							)
           self.assertIsNotNone(lowerCamelCase__							)





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

         UpperCamelCase_:      List[Any]					   =       _config_zero_init(lowerCamelCase__							)
         for model_class in self.all_model_classes:
           UpperCamelCase_:      List[str]					   =       model_class(config=lowerCamelCase__							)
           for name, param in model.named_parameters():
             if "logit_scale" in name:
               continue
             if param.requires_grad:
               self.assertIn(
                   ((param.data.mean() * 1e9).round() / 1e9).item()						,    [0.0, 1.0]						,    msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''						,    )





       def     _a					(      self							):
         UpperCamelCase_:      List[Any]					   =       self.model_tester.prepare_config_and_inputs_for_common()
         UpperCamelCase_:      Tuple					   =       True

         for model_class in self.all_model_classes:
           UpperCamelCase_:      str					   =       True
           UpperCamelCase_:      Any					   =       False
           UpperCamelCase_:      Union[str, Any]					   =       True
           UpperCamelCase_:      Any					   =       model_class(lowerCamelCase__							)
           model.to(lowerCamelCase__							)
           model.eval()
           with torch.no_grad():
             UpperCamelCase_:      int					   =       model(**self._prepare_for_class(lowerCamelCase__						,    lowerCamelCase__							)							)
           UpperCamelCase_:      str					   =       outputs.attentions
           UpperCamelCase_:      Any					   =       len(self.model_tester.depths							)
           self.assertEqual(len(lowerCamelCase__							)						,    lowerCamelCase__							)

           # check that output_attentions also work using config
           del inputs_dict["output_attentions"]
           UpperCamelCase_:      Dict					   =       True
           UpperCamelCase_:      Tuple					   =       config.window_size**2
           UpperCamelCase_:      List[Any]					   =       model_class(lowerCamelCase__							)
           model.to(lowerCamelCase__							)
           model.eval()
           with torch.no_grad():
             UpperCamelCase_:      Union[str, Any]					   =       model(**self._prepare_for_class(lowerCamelCase__						,    lowerCamelCase__							)							)
           UpperCamelCase_:      int					   =       outputs.attentions
           self.assertEqual(len(lowerCamelCase__							)						,    lowerCamelCase__							)

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

           # Check attention is always last and order is fine
           UpperCamelCase_:      Tuple					   =       True
           UpperCamelCase_:      Optional[Any]					   =       True
           UpperCamelCase_:      Union[str, Any]					   =       model_class(lowerCamelCase__							)
           model.to(lowerCamelCase__							)
           model.eval()
           with torch.no_grad():
             UpperCamelCase_:      List[Any]					   =       model(**self._prepare_for_class(lowerCamelCase__						,    lowerCamelCase__							)							)

           self.assertEqual(out_len + 1						,    len(lowerCamelCase__							)							)

           UpperCamelCase_:      Optional[Any]					   =       outputs.attentions

           self.assertEqual(len(lowerCamelCase__							)						,    lowerCamelCase__							)

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







@require_vision
@require_torch
@slow
class        _lowerCAmelCase( unittest.TestCase      ):





       """simple docstring"""







       def     _a					(      self							):
         UpperCamelCase_:      Any					   =       SwinaSRImageProcessor()
         UpperCamelCase_:      Union[str, Any]					   =       SwinaSRForImageSuperResolution.from_pretrained('caidas/swin2SR-classical-sr-x2-64'							).to(lowerCamelCase__							)

         UpperCamelCase_:      List[Any]					   =       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
         UpperCamelCase_:      Union[str, Any]					   =       processor(images=lowerCamelCase__						,    return_tensors='pt'							).to(lowerCamelCase__							)

         # forward pass
         with torch.no_grad():
           UpperCamelCase_:      int					   =       model(**lowerCamelCase__							)

         # verify the logits
         UpperCamelCase_:      str					   =       torch.Size([1, 3, 9_7_6, 1_2_9_6]							)
         self.assertEqual(outputs.reconstruction.shape						,    lowerCamelCase__							)
         UpperCamelCase_:      List[Any]					   =       torch.tensor(
             [[0.5_4_5_8, 0.5_5_4_6, 0.5_6_3_8], [0.5_5_2_6, 0.5_5_6_5, 0.5_6_5_1], [0.5_3_9_6, 0.5_4_2_6, 0.5_6_2_1]]							).to(lowerCamelCase__							)
         self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]						,    lowerCamelCase__						,    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							)