'''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       UpperCAmelCase  (						unittest.TestCase ):





       '''simple docstring'''



       def _lowerCAmelCase(						self			)  ->  Dict:
        lowercase__    :   Optional[Any]						= tf.convert_to_tensor(
            [
                [
                    8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
                    -0.5_6_2_0_0_4_4,
                    5.2_3_2_2_9_7_5_2,
                    4.0_3_8_6_3_9_3,
                    -6.8_7_9_8_3_7_8,
                    -0.5_4_7_8_5_8_0_2,
                    -3.2_0_1_2_1_5_3,
                    2.9_2_7_7_7_1_7_6,
                    1.8_8_1_7_1_9_5_3,
                    7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
                    8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
                    -9.8_5_7_1_1_8_3_6,
                    -5.9_6_2_0_9_2_3_6,
                    -1.1_3_0_3_9_1_6_1,
                    -7.1_1_1_5_2_9_4,
                    -0.8_3_6_9_6_3_3,
                    -5.3_1_8_6_4_0_8,
                    7.0_6_4_2_7_4_0_7,
                    0.8_1_3_6_9_3_4_4,
                    -0.8_2_0_2_3_8_1_7,
                    -5.9_1_7_9_7_9_6,
                    0.5_8_8_1_3_4_4_3,
                    -6.9_9_7_7_8_4_3_8,
                    4.7_1_5_5_1_1_8_9,
                    -0.1_8_7_7_1_6_3_7,
                    7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
                    9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
                    2.1_2_6_6_2_9_4_1,
                    -9.3_2_5_6_2_0_3_8,
                    2.3_5_6_5_2_5_2_2,
                ],  # cummulative prob of 5 highest values <= 0.6
                [
                    0.5_8_4_2_5_5_1_8,
                    4.5_3_1_3_9_2_3_8,
                    -5.5_7_5_1_0_4_6_4,
                    -6.2_8_0_3_0_6_9_9,
                    -7.1_9_5_2_9_5_0_3,
                    -4.0_2_1_2_2_5_5_1,
                    1.3_9_3_3_7_0_3_7,
                    -6.0_6_7_0_7_0_5_7,
                    1.5_9_4_8_0_5_1_7,
                    -9.6_4_3_1_1_9,
                    0.0_3_9_0_7_7_9_9,
                    0.6_7_2_3_1_7_6_2,
                    -8.8_8_2_0_6_7_2_6,
                    6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
                    2.2_8_5_2_0_7_2_3,
                    4.8_2_7_6_7_5_0_6,
                    4.3_0_4_2_1_3_6_8,
                    8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
                    5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
                    -4.4_7_3_5_7_9_4,
                    7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
                    -2.9_1_0_5_1_6_6_3,
                    2.6_1_9_4_6_0_7_7,
                    -2.5_6_7_4_7_6_2,
                    -9.4_8_9_5_9_3_0_2,
                    -4.0_2_9_2_2_6_4_5,
                    -1.3_5_4_1_6_9_1_8,
                    9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
                    -5.8_9_4_7_8_5_5_3,
                    1.8_5_3_7_0_4_6_7,
                ],  # cummulative prob of 5 highest values <= 0.6
            ]     ,       dtype=tf.floataa     ,       )

        lowercase__    :   str						= 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

        lowercase__    :   str						= tf.convert_to_tensor(
            [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3]     ,       dtype=tf.floataa     ,       )  # expected non filtered values as noted above

        lowercase__    :   List[Any]						= tf_top_k_top_p_filtering(__lowerCAmelCase     ,       top_k=10     ,       top_p=0.6     ,       min_tokens_to_keep=4			)

        lowercase__    :   Optional[int]						= output[output != -float('''inf'''			)]
        lowercase__    :   Union[str, Any]						= tf.cast(
            tf.where(tf.not_equal(__lowerCAmelCase     ,       tf.constant(-float('''inf'''			)     ,       dtype=tf.floataa			)			)			)     ,       dtype=tf.intaa     ,       )

        tf.debugging.assert_near(__lowerCAmelCase     ,       __lowerCAmelCase     ,       rtol=1E-12			)
        tf.debugging.assert_equal(__lowerCAmelCase     ,       __lowerCAmelCase			)



@require_tf
class       UpperCAmelCase  (						unittest.TestCase   ,						a__ ):





       '''simple docstring'''



       if is_tf_available():
              SCREAMING_SNAKE_CASE 		=   {
                  "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			)  ->  Optional[int]:
        # TF-only test: tf.saved_model export
        lowercase__    :   Dict						= TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''			)
        lowercase__    :   int						= 2
        lowercase__    :   List[str]						= 2



        class       UpperCAmelCase  (						tf.Module ):





               '''simple docstring'''



               def __init__(						self     ,       __lowerCAmelCase			)  ->  Optional[int]:
                super(__lowerCAmelCase     ,       self			).__init__()
                lowercase__    :   Tuple						= 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=__lowerCAmelCase     ,       )
               def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase			)  ->  List[Any]:
                lowercase__    :   Tuple						= self.model.generate(
                    input_ids=__lowerCAmelCase     ,       attention_mask=__lowerCAmelCase     ,       max_new_tokens=__lowerCAmelCase     ,       return_dict_in_generate=__lowerCAmelCase     ,       )
                return {"sequences": outputs["sequences"]}


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

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



        class       UpperCAmelCase  (						tf.Module ):





               '''simple docstring'''



               def __init__(						self     ,       __lowerCAmelCase			)  ->  str:
                super(__lowerCAmelCase     ,       self			).__init__()
                lowercase__    :   str						= 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=__lowerCAmelCase     ,       )
               def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase			)  ->  List[Any]:
                lowercase__    :   List[str]						= self.model.generate(
                    input_ids=__lowerCAmelCase     ,       attention_mask=__lowerCAmelCase     ,       max_new_tokens=__lowerCAmelCase     ,       return_dict_in_generate=__lowerCAmelCase     ,       )
                return {"sequences": outputs["sequences"]}


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

       @slow
       @require_tensorflow_text
       def _lowerCAmelCase(						self			)  ->  Dict:
        # 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=__lowerCAmelCase			)



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





                '''simple docstring'''



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


                def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       *__lowerCAmelCase     ,       **__lowerCAmelCase			)  ->  Optional[int]:
                 lowercase__    :   Tuple						= self.tokenizer.tokenize(__lowerCAmelCase			)
                 lowercase__			,							lowercase__    :   Optional[int]						= text.pad_model_inputs(
                     __lowerCAmelCase     ,       max_seq_length=64     ,       pad_value=self.model.config.pad_token_id			)
                 lowercase__    :   int						= self.model.generate(input_ids=__lowerCAmelCase     ,       attention_mask=__lowerCAmelCase			)
                 return self.tokenizer.detokenize(__lowerCAmelCase			)


         lowercase__    :   int						= CompleteSentenceTransformer()
         lowercase__    :   Dict						= tf.keras.layers.Input(shape=(1,)     ,       dtype=tf.string     ,       name='''inputs'''			)
         lowercase__    :   Dict						= complete_model(__lowerCAmelCase			)
         lowercase__    :   Dict						= tf.keras.Model(__lowerCAmelCase     ,       __lowerCAmelCase			)
         keras_model.save(__lowerCAmelCase			)

       def _lowerCAmelCase(						self			)  ->  Tuple:
        # Has PT equivalent: this test relies on random sampling
        lowercase__    :   Union[str, Any]						= {
            '''do_sample''': True,
            '''num_beams''': 1,
            '''top_p''': 0.7,
            '''top_k''': 10,
            '''temperature''': 0.7,
        }
        lowercase__    :   List[str]						= 14

        lowercase__    :   Any						= AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''			)
        lowercase__    :   List[str]						= '''Hello, my dog is cute and'''
        lowercase__    :   Optional[int]						= tokenizer(__lowerCAmelCase     ,       return_tensors='''tf'''			)
        lowercase__    :   Optional[Any]						= TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''			)

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

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


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



        class       UpperCAmelCase  (						a__ ):





               '''simple docstring'''



               def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase=None     ,       **__lowerCAmelCase			)  ->  Any:
                return super().call(__lowerCAmelCase     ,       **__lowerCAmelCase			)


        lowercase__    :   str						= FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart'''			)
        lowercase__    :   Dict						= bart_model.generate(__lowerCAmelCase     ,       foo='''bar'''			).numpy()
        self.assertTrue(np.array_equal(__lowerCAmelCase     ,       __lowerCAmelCase			)			)



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





               '''simple docstring'''



               def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       **__lowerCAmelCase			)  ->  int:
                return super().call(__lowerCAmelCase     ,       **__lowerCAmelCase			)


        lowercase__    :   Union[str, Any]						= FakeEncoder(bart_model.config     ,       bart_model.model.shared			)
        lowercase__    :   str						= fake_encoder

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


'''simple docstring'''

import unittest

from datasets import load_dataset

from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow



@is_pipeline_test
@require_torch
class       UpperCAmelCase  (						unittest.TestCase ):





       '''simple docstring'''



       @require_torch
       def _lowerCAmelCase(						self			)  ->  int:
        lowercase__    :   str						= pipeline(
            task='''zero-shot-audio-classification'''     ,       model='''hf-internal-testing/tiny-clap-htsat-unfused'''			)
        lowercase__    :   Optional[Any]						= load_dataset('''ashraq/esc50'''			)
        lowercase__    :   Tuple						= dataset['''train''']['''audio'''][-1]['''array''']
        lowercase__    :   Optional[Any]						= audio_classifier(__lowerCAmelCase     ,       candidate_labels=['''Sound of a dog''', '''Sound of vaccum cleaner''']			)
        self.assertEqual(
            nested_simplify(__lowerCAmelCase			)     ,       [{'''score''': 0.5_0_1, '''label''': '''Sound of a dog'''}, {'''score''': 0.4_9_9, '''label''': '''Sound of vaccum cleaner'''}]     ,       )

       @unittest.skip('''No models are available in TF'''			)
       def _lowerCAmelCase(						self			)  ->  str:
        pass

       @slow
       @require_torch
       def _lowerCAmelCase(						self			)  ->  Tuple:
        lowercase__    :   List[str]						= pipeline(
            task='''zero-shot-audio-classification'''     ,       model='''laion/clap-htsat-unfused'''     ,       )
        # This is an audio of a dog
        lowercase__    :   int						= load_dataset('''ashraq/esc50'''			)
        lowercase__    :   str						= dataset['''train''']['''audio'''][-1]['''array''']
        lowercase__    :   Any						= audio_classifier(__lowerCAmelCase     ,       candidate_labels=['''Sound of a dog''', '''Sound of vaccum cleaner''']			)

        self.assertEqual(
            nested_simplify(__lowerCAmelCase			)     ,       [
                {'''score''': 0.9_9_9, '''label''': '''Sound of a dog'''},
                {'''score''': 0.0_0_1, '''label''': '''Sound of vaccum cleaner'''},
            ]     ,       )

        lowercase__    :   Dict						= audio_classifier([audio] * 5     ,       candidate_labels=['''Sound of a dog''', '''Sound of vaccum cleaner''']			)
        self.assertEqual(
            nested_simplify(__lowerCAmelCase			)     ,       [
                [
                    {'''score''': 0.9_9_9, '''label''': '''Sound of a dog'''},
                    {'''score''': 0.0_0_1, '''label''': '''Sound of vaccum cleaner'''},
                ],
            ]
            * 5     ,       )
        lowercase__    :   Any						= audio_classifier(
            [audio] * 5     ,       candidate_labels=['''Sound of a dog''', '''Sound of vaccum cleaner''']     ,       batch_size=5			)
        self.assertEqual(
            nested_simplify(__lowerCAmelCase			)     ,       [
                [
                    {'''score''': 0.9_9_9, '''label''': '''Sound of a dog'''},
                    {'''score''': 0.0_0_1, '''label''': '''Sound of vaccum cleaner'''},
                ],
            ]
            * 5     ,       )


       @unittest.skip('''No models are available in TF'''			)
       def _lowerCAmelCase(						self			)  ->  Union[str, Any]:
        pass

