


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







    """simple docstring"""

    def 		a_      (	self   ):
         snake_case					=    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      , )

         snake_case					=    tf.convert_to_tensor(
             [[0, 0], [0, 9], [0, 1_0], [0, 2_5], [0, 2_6], [1, 1_3], [1, 1_7], [1, 1_8], [1, 2_0], [1, 2_7]]      , dtype=tf.intaa      , )  # expected non filtered idx as noted above

         snake_case					=    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

         snake_case					=    tf_top_k_top_p_filtering(__snake_case      , top_k=1_0      , top_p=0.6      , min_tokens_to_keep=4   )

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

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






@require_tf
class   A__ (   unittest.TestCase	, snake_case__     ):







    """simple docstring"""

    if is_tf_available():
        __magic_name__        =		{
            '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 		a_      (	self   ):
         # TF-only test: tf.saved_model export
         snake_case					=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''   )
         snake_case					=    2
         snake_case					=    2

         class   A__ (   tf.Module     ):







             """simple docstring"""

             def __init__(	self      , __snake_case   ):
                  super(__snake_case      , self   ).__init__()
                  snake_case					=    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=__snake_case      , )
             def 		a_      (	self      , __snake_case      , __snake_case   ):
                  snake_case					=    self.model.generate(
                      input_ids=__snake_case      , attention_mask=__snake_case      , max_new_tokens=__snake_case      , return_dict_in_generate=__snake_case      , )
                  return {"sequences": outputs["sequences"]}






         snake_case					=    [[2, 0], [1_0_2, 1_0_3]]
         snake_case					=    [[1, 0], [1, 1]]
         snake_case					=    DummyModel(model=__snake_case   )
         with tempfile.TemporaryDirectory() as tmp_dir:
              tf.saved_model.save(__snake_case      , __snake_case      , signatures={'''serving_default''': dummy_model.serving}   )
              snake_case					=    tf.saved_model.load(__snake_case   ).signatures['''serving_default''']
              for batch_size in range(1      , len(__snake_case   ) + 1   ):
                   snake_case					=    {
                       '''input_ids''': tf.constant(dummy_input_ids[:batch_size]   ),
                       '''attention_mask''': tf.constant(dummy_attention_masks[:batch_size]   ),
                   }
                   snake_case					=    serving_func(**__snake_case   )['''sequences''']
                   snake_case					=    test_model.generate(**__snake_case      , max_new_tokens=__snake_case   )
                   tf.debugging.assert_equal(__snake_case      , __snake_case   )
    @slow
    def 		a_      (	self   ):
         # TF-only test: tf.saved_model export
         snake_case					=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''   )
         snake_case					=    1
         snake_case					=    2

         class   A__ (   tf.Module     ):







             """simple docstring"""

             def __init__(	self      , __snake_case   ):
                  super(__snake_case      , self   ).__init__()
                  snake_case					=    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=__snake_case      , )
             def 		a_      (	self      , __snake_case      , __snake_case   ):
                  snake_case					=    self.model.generate(
                      input_ids=__snake_case      , attention_mask=__snake_case      , max_new_tokens=__snake_case      , return_dict_in_generate=__snake_case      , )
                  return {"sequences": outputs["sequences"]}






         snake_case					=    [[2], [1_0_2, 1_0_3]]
         snake_case					=    [[1], [1, 1]]
         snake_case					=    DummyModel(model=__snake_case   )
         with tempfile.TemporaryDirectory() as tmp_dir:
              tf.saved_model.save(__snake_case      , __snake_case      , signatures={'''serving_default''': dummy_model.serving}   )
              snake_case					=    tf.saved_model.load(__snake_case   ).signatures['''serving_default''']
              for input_row in range(len(__snake_case   )   ):
                   snake_case					=    {
                       '''input_ids''': tf.constant([dummy_input_ids[input_row]]   ),
                       '''attention_mask''': tf.constant([dummy_attention_masks[input_row]]   ),
                   }
                   snake_case					=    serving_func(**__snake_case   )['''sequences''']
                   snake_case					=    test_model.generate(**__snake_case      , max_new_tokens=__snake_case   )
                   tf.debugging.assert_equal(__snake_case      , __snake_case   )
    @slow
    @require_tensorflow_text
    def 		a_      (	self   ):
         # 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=__snake_case   )

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







                  """simple docstring"""

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




                  def 		a_      (	self      , __snake_case      , *__snake_case      , **__snake_case   ):
                       snake_case					=    self.tokenizer.tokenize(__snake_case   )
                       snake_case			,  snake_case					=    text.pad_model_inputs(
                           __snake_case      , max_seq_length=6_4      , pad_value=self.model.config.pad_token_id   )
                       snake_case					=    self.model.generate(input_ids=__snake_case      , attention_mask=__snake_case   )
                       return self.tokenizer.detokenize(__snake_case   )






              snake_case					=    CompleteSentenceTransformer()
              snake_case					=    tf.keras.layers.Input(shape=(1,)      , dtype=tf.string      , name='''inputs'''   )
              snake_case					=    complete_model(__snake_case   )
              snake_case					=    tf.keras.Model(__snake_case      , __snake_case   )
              keras_model.save(__snake_case   )
    def 		a_      (	self   ):
         # Has PT equivalent: this test relies on random sampling
         snake_case					=    {
             '''do_sample''': True,
             '''num_beams''': 1,
             '''top_p''': 0.7,
             '''top_k''': 1_0,
             '''temperature''': 0.7,
         }
         snake_case					=    1_4

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

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

         snake_case					=    [6_3_8, 1_9_8]
         with tf.device(''':/CPU:0'''   ):
              tf.random.set_seed(0   )
              snake_case					=    model.generate(**__snake_case      , eos_token_id=__snake_case      , **__snake_case   )
         self.assertTrue(expectation == len(generated_tokens[0]   )   )




    def 		a_      (	self   ):
         # Has PT equivalent: ample use of framework-specific code
         snake_case					=    AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bart'''   )
         snake_case					=    '''Hugging Face is a technology company based in New York and Paris.'''
         snake_case					=    bart_tokenizer(__snake_case      , return_tensors='''tf'''   ).input_ids
         snake_case					=    TFBartForConditionalGeneration.from_pretrained('''hf-internal-testing/tiny-random-bart'''   )
         snake_case					=    bart_model.generate(__snake_case   ).numpy()

         class   A__ (   snake_case__     ):







             """simple docstring"""

             def 		a_      (	self      , __snake_case      , __snake_case=None      , **__snake_case   ):
                  return super().call(__snake_case      , **__snake_case   )






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

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







             """simple docstring"""

             def 		a_      (	self      , __snake_case      , **__snake_case   ):
                  return super().call(__snake_case      , **__snake_case   )






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

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








def       UpperCAmelCase__						(UpperCamelCase_							,UpperCamelCase_							,UpperCamelCase_    ):



     """simple docstring"""






     snake_case					=    len(UpperCamelCase_    )
     snake_case					=    [[0] * n for i in range(UpperCamelCase_    )]
     for i in range(UpperCamelCase_    ):
          snake_case					=    y_points[i]

     for i in range(2							,UpperCamelCase_    ):
          for j in range(UpperCamelCase_							,UpperCamelCase_    ):
               snake_case					=    (
                   (xa - x_points[j - i + 1]) * q[j][i - 1]
                   - (xa - x_points[j]) * q[j - 1][i - 1]
               ) / (x_points[j] - x_points[j - i + 1])

     return [q[n - 1][n - 1], q]


if __name__ == "__main__":
 import doctest

 doctest.testmod()




