'''simple docstring'''
from __future__ import annotations

import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import require_tf, require_vision, slow
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 import TFViTForImageClassification, TFViTModel


if is_vision_available():
      from PIL import Image

      from transformers import ViTImageProcessor







class lowerCamelCase							:




  '''simple docstring'''



  def __init__(      self			:       Tuple  ,							UpperCAmelCase__			:       List[Any]  ,							UpperCAmelCase__			:       Optional[Any]=13  ,							UpperCAmelCase__			:       List[str]=30  ,							UpperCAmelCase__			:       Dict=2  ,							UpperCAmelCase__			:       int=3  ,							UpperCAmelCase__			:       List[str]=True  ,							UpperCAmelCase__			:       List[Any]=True  ,							UpperCAmelCase__			:       Tuple=32  ,							UpperCAmelCase__			:       Tuple=2  ,							UpperCAmelCase__			:       Optional[Any]=4  ,							UpperCAmelCase__			:       Tuple=37  ,							UpperCAmelCase__			:       Optional[int]="gelu"  ,							UpperCAmelCase__			:       Tuple=0.1  ,							UpperCAmelCase__			:       Optional[int]=0.1  ,							UpperCAmelCase__			:       Optional[int]=10  ,							UpperCAmelCase__			:       int=0.02  ,							UpperCAmelCase__			:       int=3  ,							UpperCAmelCase__			:       str=None  ,							)				->Optional[int]:
        UpperCAmelCase_            =  parent
        UpperCAmelCase_            =  batch_size
        UpperCAmelCase_            =  image_size
        UpperCAmelCase_            =  patch_size
        UpperCAmelCase_            =  num_channels
        UpperCAmelCase_            =  is_training
        UpperCAmelCase_            =  use_labels
        UpperCAmelCase_            =  hidden_size
        UpperCAmelCase_            =  num_hidden_layers
        UpperCAmelCase_            =  num_attention_heads
        UpperCAmelCase_            =  intermediate_size
        UpperCAmelCase_            =  hidden_act
        UpperCAmelCase_            =  hidden_dropout_prob
        UpperCAmelCase_            =  attention_probs_dropout_prob
        UpperCAmelCase_            =  type_sequence_label_size
        UpperCAmelCase_            =  initializer_range
        UpperCAmelCase_            =  scope

        # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
        UpperCAmelCase_            =  (image_size // patch_size) ** 2
        UpperCAmelCase_            =  num_patches + 1






  def  lowerCAmelCase__ (      self			:       List[Any]  )				->str:
        UpperCAmelCase_            =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

        UpperCAmelCase_            =  None
        if self.use_labels:
              UpperCAmelCase_            =  ids_tensor([self.batch_size]  ,							self.type_sequence_label_size  )

        UpperCAmelCase_            =  self.get_config()

        return config, pixel_values, labels






  def  lowerCAmelCase__ (      self			:       Any  )				->Any:
        return ViTConfig(
            image_size=self.image_size  ,							patch_size=self.patch_size  ,							num_channels=self.num_channels  ,							hidden_size=self.hidden_size  ,							num_hidden_layers=self.num_hidden_layers  ,							num_attention_heads=self.num_attention_heads  ,							intermediate_size=self.intermediate_size  ,							hidden_act=self.hidden_act  ,							hidden_dropout_prob=self.hidden_dropout_prob  ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,							is_decoder=UpperCAmelCase__  ,							initializer_range=self.initializer_range  ,							)






  def  lowerCAmelCase__ (      self			:       Union[str, Any]  ,							UpperCAmelCase__			:       Tuple  ,							UpperCAmelCase__			:       List[Any]  ,							UpperCAmelCase__			:       Optional[Any]  )				->List[str]:
        UpperCAmelCase_            =  TFViTModel(config=UpperCAmelCase__  )
        UpperCAmelCase_            =  model(UpperCAmelCase__  ,							training=UpperCAmelCase__  )
        self.parent.assertEqual(result.last_hidden_state.shape  ,							(self.batch_size, self.seq_length, self.hidden_size)  )

        # Test with an image with different size than the one specified in config.
        UpperCAmelCase_            =  self.image_size // 2
        UpperCAmelCase_            =  pixel_values[:, :, :image_size, :image_size]
        UpperCAmelCase_            =  model(UpperCAmelCase__  ,							interpolate_pos_encoding=UpperCAmelCase__  ,							training=UpperCAmelCase__  )
        UpperCAmelCase_            =  (image_size // self.patch_size) ** 2 + 1
        self.parent.assertEqual(result.last_hidden_state.shape  ,							(self.batch_size, seq_length, self.hidden_size)  )






  def  lowerCAmelCase__ (      self			:       int  ,							UpperCAmelCase__			:       int  ,							UpperCAmelCase__			:       List[Any]  ,							UpperCAmelCase__			:       Optional[int]  )				->Tuple:
        UpperCAmelCase_            =  self.type_sequence_label_size
        UpperCAmelCase_            =  TFViTForImageClassification(UpperCAmelCase__  )
        UpperCAmelCase_            =  model(UpperCAmelCase__  ,							labels=UpperCAmelCase__  ,							training=UpperCAmelCase__  )
        self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.type_sequence_label_size)  )

        # Test with an image with different size than the one specified in config.
        UpperCAmelCase_            =  self.image_size // 2
        UpperCAmelCase_            =  pixel_values[:, :, :image_size, :image_size]
        UpperCAmelCase_            =  model(UpperCAmelCase__  ,							interpolate_pos_encoding=UpperCAmelCase__  ,							training=UpperCAmelCase__  )
        self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.type_sequence_label_size)  )

        # test greyscale images
        UpperCAmelCase_            =  1
        UpperCAmelCase_            =  TFViTForImageClassification(UpperCAmelCase__  )
        UpperCAmelCase_            =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
        UpperCAmelCase_            =  model(UpperCAmelCase__  )
        self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.type_sequence_label_size)  )






  def  lowerCAmelCase__ (      self			:       Dict  )				->Dict:
        UpperCAmelCase_            =  self.prepare_config_and_inputs()
        UpperCAmelCase_      ,		UpperCAmelCase_      ,		UpperCAmelCase_            =  config_and_inputs
        UpperCAmelCase_            =  {'''pixel_values''': pixel_values}
        return config, inputs_dict







@require_tf
class lowerCamelCase							(	lowerCamelCase     ,		lowerCamelCase     ,		unittest.TestCase					):




  '''simple docstring'''



  lowerCAmelCase__										=	(TFViTModel, TFViTForImageClassification) if is_tf_available() else ()
  lowerCAmelCase__										=	(
      {'''feature-extraction''': TFViTModel, '''image-classification''': TFViTForImageClassification}
      if is_tf_available()
      else {}
  )

  lowerCAmelCase__										=	False
  lowerCAmelCase__										=	False
  lowerCAmelCase__										=	False






  def  lowerCAmelCase__ (      self			:       Dict  )				->int:
        UpperCAmelCase_            =  TFViTModelTester(self  )
        UpperCAmelCase_            =  ConfigTester(self  ,							config_class=UpperCAmelCase__  ,							has_text_modality=UpperCAmelCase__  ,							hidden_size=37  )






  def  lowerCAmelCase__ (      self			:       List[str]  )				->Optional[Any]:
        self.config_tester.run_common_tests()






  @unittest.skip(reason='''ViT does not use inputs_embeds'''  )
  def  lowerCAmelCase__ (      self			:       Union[str, Any]  )				->Tuple:
        pass






  @unittest.skip(reason='''ViT does not use inputs_embeds'''  )
  def  lowerCAmelCase__ (      self			:       Optional[Any]  )				->List[str]:
        pass






  def  lowerCAmelCase__ (      self			:       int  )				->Tuple:
        UpperCAmelCase_      ,		UpperCAmelCase_            =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              UpperCAmelCase_            =  model_class(UpperCAmelCase__  )
              self.assertIsInstance(model.get_input_embeddings()  ,							(tf.keras.layers.Layer)  )
              UpperCAmelCase_            =  model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(UpperCAmelCase__  ,							tf.keras.layers.Layer  )  )






  def  lowerCAmelCase__ (      self			:       List[str]  )				->int:
        UpperCAmelCase_      ,		UpperCAmelCase_            =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              UpperCAmelCase_            =  model_class(UpperCAmelCase__  )
              UpperCAmelCase_            =  inspect.signature(model.call  )
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              UpperCAmelCase_            =  [*signature.parameters.keys()]

              UpperCAmelCase_            =  ['''pixel_values''']
              self.assertListEqual(arg_names[:1]  ,							UpperCAmelCase__  )






  def  lowerCAmelCase__ (      self			:       Tuple  )				->List[Any]:
        UpperCAmelCase_            =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*UpperCAmelCase__  )






  def  lowerCAmelCase__ (      self			:       List[Any]  )				->Any:
        UpperCAmelCase_            =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__  )






  @slow
  def  lowerCAmelCase__ (      self			:       str  )				->int:
        UpperCAmelCase_            =  TFViTModel.from_pretrained('''google/vit-base-patch16-224'''  )
        self.assertIsNotNone(UpperCAmelCase__  )






def  __lowerCamelCase       (      ):


      '''simple docstring'''


      UpperCAmelCase_            =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					)
      return image







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




  '''simple docstring'''



  @cached_property
  def  lowerCAmelCase__ (      self			:       Union[str, Any]  )				->str:
        return ViTImageProcessor.from_pretrained('''google/vit-base-patch16-224'''  ) if is_vision_available() else None






  @slow
  def  lowerCAmelCase__ (      self			:       Dict  )				->Union[str, Any]:
        UpperCAmelCase_            =  TFViTForImageClassification.from_pretrained('''google/vit-base-patch16-224'''  )

        UpperCAmelCase_            =  self.default_image_processor
        UpperCAmelCase_            =  prepare_img()
        UpperCAmelCase_            =  image_processor(images=UpperCAmelCase__  ,							return_tensors='''tf'''  )

        # forward pass
        UpperCAmelCase_            =  model(**UpperCAmelCase__  )

        # verify the logits
        UpperCAmelCase_            =  tf.TensorShape((1, 1000)  )
        self.assertEqual(outputs.logits.shape  ,							UpperCAmelCase__  )

        UpperCAmelCase_            =  tf.constant([-0.2744, 0.8215, -0.0836]  )

        tf.debugging.assert_near(outputs.logits[0, :3]  ,							UpperCAmelCase__  ,							atol=1e-4  )






'''simple docstring'''
from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
      import tensorflow as tf

      from transformers import (
          AutoTokenizer,
          TFAutoModelForCausalLM,
          TFAutoModelForSeqaSeqLM,
          TFAutoModelForSpeechSeqaSeq,
          TFAutoModelForVisionaSeq,
          TFBartForConditionalGeneration,
          TFLogitsProcessorList,
          TFMinLengthLogitsProcessor,
          tf_top_k_top_p_filtering,
      )

if is_tensorflow_text_available():
      import tensorflow_text as text







@require_tf
class lowerCamelCase							(	unittest.TestCase					):




  '''simple docstring'''



  def  lowerCAmelCase__ (      self			:       Dict  )				->List[str]:
        UpperCAmelCase_            =  tf.convert_to_tensor(
            [
                [
                    8.222_0991,  # 3rd highest value; idx. 0
                    -0.562_0044,
                    5.2322_9752,
                    4.038_6393,
                    -6.879_8378,
                    -0.5478_5802,
                    -3.201_2153,
                    2.9277_7176,
                    1.8817_1953,
                    7.3534_1276,  # 5th highest value; idx. 9
                    8.4320_7833,  # 2nd highest value; idx. 10
                    -9.8571_1836,
                    -5.9620_9236,
                    -1.1303_9161,
                    -7.111_5294,
                    -0.836_9633,
                    -5.318_6408,
                    7.0642_7407,
                    0.8136_9344,
                    -0.8202_3817,
                    -5.917_9796,
                    0.5881_3443,
                    -6.9977_8438,
                    4.7155_1189,
                    -0.1877_1637,
                    7.4402_0759,  # 4th highest value; idx. 25
                    9.3845_0987,  # 1st highest value; idx. 26
                    2.1266_2941,
                    -9.3256_2038,
                    2.3565_2522,
                ],  # cummulative prob of 5 highest values <= 0.6
                [
                    0.5842_5518,
                    4.5313_9238,
                    -5.5751_0464,
                    -6.2803_0699,
                    -7.1952_9503,
                    -4.0212_2551,
                    1.3933_7037,
                    -6.0670_7057,
                    1.5948_0517,
                    -9.64_3119,
                    0.0390_7799,
                    0.6723_1762,
                    -8.8820_6726,
                    6.2711_5922,  # 4th highest value; idx. 13
                    2.2852_0723,
                    4.8276_7506,
                    4.3042_1368,
                    8.827_5313,  # 2nd highest value; idx. 17
                    5.4402_9958,  # 5th highest value; idx. 18
                    -4.473_5794,
                    7.3857_9536,  # 3rd highest value; idx. 20
                    -2.9105_1663,
                    2.6194_6077,
                    -2.567_4762,
                    -9.4895_9302,
                    -4.0292_2645,
                    -1.3541_6918,
                    9.6770_2323,  # 1st highest value; idx. 27
                    -5.8947_8553,
                    1.8537_0467,
                ],  # cummulative prob of 5 highest values <= 0.6
            ]  ,							dtype=tf.floataa  ,							)

        UpperCAmelCase_            =  tf.convert_to_tensor(
            [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]  ,							dtype=tf.intaa  ,							)  # expected non filtered idx as noted above

        UpperCAmelCase_            =  tf.convert_to_tensor(
            [8.22_2099, 7.353_4126, 8.43_2078, 7.440_2075, 9.3_8451, 6.27_1159, 8.82_7531, 5.440_2995, 7.385_7956, 9.67_7023]  ,							dtype=tf.floataa  ,							)  # expected non filtered values as noted above

        UpperCAmelCase_            =  tf_top_k_top_p_filtering(UpperCAmelCase__  ,							top_k=10  ,							top_p=0.6  ,							min_tokens_to_keep=4  )

        UpperCAmelCase_            =  output[output != -float('''inf'''  )]
        UpperCAmelCase_            =  tf.cast(
            tf.where(tf.not_equal(UpperCAmelCase__  ,							tf.constant(-float('''inf'''  )  ,							dtype=tf.floataa  )  )  )  ,							dtype=tf.intaa  ,							)

        tf.debugging.assert_near(UpperCAmelCase__  ,							UpperCAmelCase__  ,							rtol=1e-12  )
        tf.debugging.assert_equal(UpperCAmelCase__  ,							UpperCAmelCase__  )







@require_tf
class lowerCamelCase							(	unittest.TestCase     ,		lowerCamelCase					):




  '''simple docstring'''



  if is_tf_available():
    lowerCAmelCase__										=	{
        '''AutoModelForCausalLM''': TFAutoModelForCausalLM,
        '''AutoModelForSpeechSeq2Seq''': TFAutoModelForSpeechSeqaSeq,
        '''AutoModelForSeq2SeqLM''': TFAutoModelForSeqaSeqLM,
        '''AutoModelForVision2Seq''': TFAutoModelForVisionaSeq,
        '''LogitsProcessorList''': TFLogitsProcessorList,
        '''MinLengthLogitsProcessor''': TFMinLengthLogitsProcessor,
        '''create_tensor_fn''': tf.convert_to_tensor,
        '''floats_tensor''': floats_tensor,
        '''return_tensors''': '''tf''',
    }






  @slow
  def  lowerCAmelCase__ (      self			:       Dict  )				->Optional[Any]:
        # TF-only test: tf.saved_model export
        UpperCAmelCase_            =  TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''  )
        UpperCAmelCase_            =  2
        UpperCAmelCase_            =  2







        class lowerCamelCase							(	tf.Module					):




          '''simple docstring'''



          def __init__(      self			:       List[str]  ,							UpperCAmelCase__			:       List[str]  )				->Dict:
                super(UpperCAmelCase__  ,							self  ).__init__()
                UpperCAmelCase_            =  model






          @tf.function(
              input_signature=(
                  tf.TensorSpec((None, input_length)  ,							tf.intaa  ,							name='''input_ids'''  ),
                  tf.TensorSpec((None, input_length)  ,							tf.intaa  ,							name='''attention_mask'''  ),
              )  ,							jit_compile=UpperCAmelCase__  ,							)
          def  lowerCAmelCase__ (      self			:       Union[str, Any]  ,							UpperCAmelCase__			:       Union[str, Any]  ,							UpperCAmelCase__			:       List[str]  )				->int:
                UpperCAmelCase_            =  self.model.generate(
                    input_ids=UpperCAmelCase__  ,							attention_mask=UpperCAmelCase__  ,							max_new_tokens=UpperCAmelCase__  ,							return_dict_in_generate=UpperCAmelCase__  ,							)
                return {"sequences": outputs["sequences"]}






        UpperCAmelCase_            =  [[2, 0], [102, 103]]
        UpperCAmelCase_            =  [[1, 0], [1, 1]]
        UpperCAmelCase_            =  DummyModel(model=UpperCAmelCase__  )
        with tempfile.TemporaryDirectory() as tmp_dir:
              tf.saved_model.save(UpperCAmelCase__  ,							UpperCAmelCase__  ,							signatures={'''serving_default''': dummy_model.serving}  )
              UpperCAmelCase_            =  tf.saved_model.load(UpperCAmelCase__  ).signatures['''serving_default''']
              for batch_size in range(1  ,							len(UpperCAmelCase__  ) + 1  ):
                    UpperCAmelCase_            =  {
                        '''input_ids''': tf.constant(dummy_input_ids[:batch_size]  ),
                        '''attention_mask''': tf.constant(dummy_attention_masks[:batch_size]  ),
                    }
                    UpperCAmelCase_            =  serving_func(**UpperCAmelCase__  )['''sequences''']
                    UpperCAmelCase_            =  test_model.generate(**UpperCAmelCase__  ,							max_new_tokens=UpperCAmelCase__  )
                    tf.debugging.assert_equal(UpperCAmelCase__  ,							UpperCAmelCase__  )






  @slow
  def  lowerCAmelCase__ (      self			:       Tuple  )				->Optional[int]:
        # TF-only test: tf.saved_model export
        UpperCAmelCase_            =  TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''  )
        UpperCAmelCase_            =  1
        UpperCAmelCase_            =  2







        class lowerCamelCase							(	tf.Module					):




          '''simple docstring'''



          def __init__(      self			:       int  ,							UpperCAmelCase__			:       int  )				->List[str]:
                super(UpperCAmelCase__  ,							self  ).__init__()
                UpperCAmelCase_            =  model






          @tf.function(
              input_signature=(
                  tf.TensorSpec((batch_size, None)  ,							tf.intaa  ,							name='''input_ids'''  ),
                  tf.TensorSpec((batch_size, None)  ,							tf.intaa  ,							name='''attention_mask'''  ),
              )  ,							jit_compile=UpperCAmelCase__  ,							)
          def  lowerCAmelCase__ (      self			:       Dict  ,							UpperCAmelCase__			:       List[str]  ,							UpperCAmelCase__			:       Optional[Any]  )				->int:
                UpperCAmelCase_            =  self.model.generate(
                    input_ids=UpperCAmelCase__  ,							attention_mask=UpperCAmelCase__  ,							max_new_tokens=UpperCAmelCase__  ,							return_dict_in_generate=UpperCAmelCase__  ,							)
                return {"sequences": outputs["sequences"]}






        UpperCAmelCase_            =  [[2], [102, 103]]
        UpperCAmelCase_            =  [[1], [1, 1]]
        UpperCAmelCase_            =  DummyModel(model=UpperCAmelCase__  )
        with tempfile.TemporaryDirectory() as tmp_dir:
              tf.saved_model.save(UpperCAmelCase__  ,							UpperCAmelCase__  ,							signatures={'''serving_default''': dummy_model.serving}  )
              UpperCAmelCase_            =  tf.saved_model.load(UpperCAmelCase__  ).signatures['''serving_default''']
              for input_row in range(len(UpperCAmelCase__  )  ):
                    UpperCAmelCase_            =  {
                        '''input_ids''': tf.constant([dummy_input_ids[input_row]]  ),
                        '''attention_mask''': tf.constant([dummy_attention_masks[input_row]]  ),
                    }
                    UpperCAmelCase_            =  serving_func(**UpperCAmelCase__  )['''sequences''']
                    UpperCAmelCase_            =  test_model.generate(**UpperCAmelCase__  ,							max_new_tokens=UpperCAmelCase__  )
                    tf.debugging.assert_equal(UpperCAmelCase__  ,							UpperCAmelCase__  )






  @slow
  @require_tensorflow_text
  def  lowerCAmelCase__ (      self			:       Optional[Any]  )				->int:
        # TF-only test: tf.saved_model export
        with tempfile.TemporaryDirectory() as tmp_dir:
              # file needed to load the TF tokenizer
              hf_hub_download(repo_id='''google/flan-t5-small'''  ,							filename='''spiece.model'''  ,							local_dir=UpperCAmelCase__  )







              class lowerCamelCase							(	tf.keras.layers.Layer					):




                '''simple docstring'''



                def __init__(      self			:       List[str]  )				->Any:
                      super().__init__()
                      UpperCAmelCase_            =  text.SentencepieceTokenizer(
                          model=tf.io.gfile.GFile(os.path.join(UpperCAmelCase__  ,							'''spiece.model'''  )  ,							'''rb'''  ).read()  )
                      UpperCAmelCase_            =  TFAutoModelForSeqaSeqLM.from_pretrained('''hf-internal-testing/tiny-random-t5'''  )






                def  lowerCAmelCase__ (      self			:       Any  ,							UpperCAmelCase__			:       Union[str, Any]  ,							*UpperCAmelCase__			:       Union[str, Any]  ,							**UpperCAmelCase__			:       str  )				->List[str]:
                      UpperCAmelCase_            =  self.tokenizer.tokenize(UpperCAmelCase__  )
                      UpperCAmelCase_      ,		UpperCAmelCase_            =  text.pad_model_inputs(
                          UpperCAmelCase__  ,							max_seq_length=64  ,							pad_value=self.model.config.pad_token_id  )
                      UpperCAmelCase_            =  self.model.generate(input_ids=UpperCAmelCase__  ,							attention_mask=UpperCAmelCase__  )
                      return self.tokenizer.detokenize(UpperCAmelCase__  )






              UpperCAmelCase_            =  CompleteSentenceTransformer()
              UpperCAmelCase_            =  tf.keras.layers.Input(shape=(1,)  ,							dtype=tf.string  ,							name='''inputs'''  )
              UpperCAmelCase_            =  complete_model(UpperCAmelCase__  )
              UpperCAmelCase_            =  tf.keras.Model(UpperCAmelCase__  ,							UpperCAmelCase__  )
              keras_model.save(UpperCAmelCase__  )






  def  lowerCAmelCase__ (      self			:       Optional[int]  )				->Tuple:
        # Has PT equivalent: this test relies on random sampling
        UpperCAmelCase_            =  {
            '''do_sample''': True,
            '''num_beams''': 1,
            '''top_p''': 0.7,
            '''top_k''': 10,
            '''temperature''': 0.7,
        }
        UpperCAmelCase_            =  14

        UpperCAmelCase_            =  AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''  )
        UpperCAmelCase_            =  '''Hello, my dog is cute and'''
        UpperCAmelCase_            =  tokenizer(UpperCAmelCase__  ,							return_tensors='''tf'''  )
        UpperCAmelCase_            =  TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''  )

        UpperCAmelCase_            =  638
        # forces the generation to happen on CPU, to avoid GPU-related quirks
        with tf.device(''':/CPU:0'''  ):
              tf.random.set_seed(0  )
              UpperCAmelCase_            =  model.generate(**UpperCAmelCase__  ,							eos_token_id=UpperCAmelCase__  ,							**UpperCAmelCase__  )
        self.assertTrue(expectation == len(generated_tokens[0]  )  )

        UpperCAmelCase_            =  [638, 198]
        with tf.device(''':/CPU:0'''  ):
              tf.random.set_seed(0  )
              UpperCAmelCase_            =  model.generate(**UpperCAmelCase__  ,							eos_token_id=UpperCAmelCase__  ,							**UpperCAmelCase__  )
        self.assertTrue(expectation == len(generated_tokens[0]  )  )






  def  lowerCAmelCase__ (      self			:       Optional[int]  )				->List[str]:
        # Has PT equivalent: ample use of framework-specific code
        UpperCAmelCase_            =  AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bart'''  )
        UpperCAmelCase_            =  '''Hugging Face is a technology company based in New York and Paris.'''
        UpperCAmelCase_            =  bart_tokenizer(UpperCAmelCase__  ,							return_tensors='''tf'''  ).input_ids
        UpperCAmelCase_            =  TFBartForConditionalGeneration.from_pretrained('''hf-internal-testing/tiny-random-bart'''  )
        UpperCAmelCase_            =  bart_model.generate(UpperCAmelCase__  ).numpy()







        class lowerCamelCase							(	lowerCamelCase					):




          '''simple docstring'''



          def  lowerCAmelCase__ (      self			:       int  ,							UpperCAmelCase__			:       Dict  ,							UpperCAmelCase__			:       List[Any]=None  ,							**UpperCAmelCase__			:       int  )				->List[str]:
                return super().call(UpperCAmelCase__  ,							**UpperCAmelCase__  )






        UpperCAmelCase_            =  FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart'''  )
        UpperCAmelCase_            =  bart_model.generate(UpperCAmelCase__  ,							foo='''bar'''  ).numpy()
        self.assertTrue(np.array_equal(UpperCAmelCase__  ,							UpperCAmelCase__  )  )







        class lowerCamelCase							(	bart_model.model.encoder.__class__					):




          '''simple docstring'''



          def  lowerCAmelCase__ (      self			:       str  ,							UpperCAmelCase__			:       List[str]  ,							**UpperCAmelCase__			:       Dict  )				->Any:
                return super().call(UpperCAmelCase__  ,							**UpperCAmelCase__  )






        UpperCAmelCase_            =  FakeEncoder(bart_model.config  ,							bart_model.model.shared  )
        UpperCAmelCase_            =  fake_encoder

        # Normal generation still works (the output will be different because the encoder weights are different)
        UpperCAmelCase_            =  bart_model.generate(UpperCAmelCase__  ).numpy()
        with self.assertRaises(UpperCAmelCase__  ):
              # FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
              bart_model.generate(UpperCAmelCase__  ,							foo='''bar'''  )





