

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  _lowercase      (			self    : Optional[Any]		)					->Dict:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      int       =   tf.convert_to_tensor(
            [
                [
                    8.2_22_09_91,  # 3rd highest value; idx. 0
                    -0.5_62_00_44,
                    5.23_22_97_52,
                    4.0_38_63_93,
                    -6.8_79_83_78,
                    -0.54_78_58_02,
                    -3.2_01_21_53,
                    2.92_77_71_76,
                    1.88_17_19_53,
                    7.35_34_12_76,  # 5th highest value; idx. 9
                    8.43_20_78_33,  # 2nd highest value; idx. 10
                    -9.85_71_18_36,
                    -5.96_20_92_36,
                    -1.13_03_91_61,
                    -7.1_11_52_94,
                    -0.8_36_96_33,
                    -5.3_18_64_08,
                    7.06_42_74_07,
                    0.81_36_93_44,
                    -0.82_02_38_17,
                    -5.9_17_97_96,
                    0.58_81_34_43,
                    -6.99_77_84_38,
                    4.71_55_11_89,
                    -0.18_77_16_37,
                    7.44_02_07_59,  # 4th highest value; idx. 25
                    9.38_45_09_87,  # 1st highest value; idx. 26
                    2.12_66_29_41,
                    -9.32_56_20_38,
                    2.35_65_25_22,
                ],  # cummulative prob of 5 highest values <= 0.6
                [
                    0.58_42_55_18,
                    4.53_13_92_38,
                    -5.57_51_04_64,
                    -6.28_03_06_99,
                    -7.19_52_95_03,
                    -4.02_12_25_51,
                    1.39_33_70_37,
                    -6.06_70_70_57,
                    1.59_48_05_17,
                    -9.64_31_19,
                    0.03_90_77_99,
                    0.67_23_17_62,
                    -8.88_20_67_26,
                    6.27_11_59_22,  # 4th highest value; idx. 13
                    2.28_52_07_23,
                    4.82_76_75_06,
                    4.30_42_13_68,
                    8.8_27_53_13,  # 2nd highest value; idx. 17
                    5.44_02_99_58,  # 5th highest value; idx. 18
                    -4.4_73_57_94,
                    7.38_57_95_36,  # 3rd highest value; idx. 20
                    -2.91_05_16_63,
                    2.61_94_60_77,
                    -2.5_67_47_62,
                    -9.48_95_93_02,
                    -4.02_92_26_45,
                    -1.35_41_69_18,
                    9.67_70_23_23,  # 1st highest value; idx. 27
                    -5.89_47_85_53,
                    1.85_37_04_67,
                ],  # cummulative prob of 5 highest values <= 0.6
            ]				,				dtype=tf.floataa				,				)

        SCREAMING_SNAKE_CASE :      List[str]       =   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

        SCREAMING_SNAKE_CASE :      Optional[Any]       =   tf.convert_to_tensor(
            [8.22_20_99, 7.3_53_41_26, 8.43_20_78, 7.4_40_20_75, 9.3_84_51, 6.27_11_59, 8.82_75_31, 5.4_40_29_95, 7.3_85_79_56, 9.67_70_23]				,				dtype=tf.floataa				,				)  # expected non filtered values as noted above

        SCREAMING_SNAKE_CASE :      List[str]       =   tf_top_k_top_p_filtering(UpperCAmelCase__				,				top_k=1_0				,				top_p=0.6				,				min_tokens_to_keep=4		)

        SCREAMING_SNAKE_CASE :      List[Any]       =   output[output != -float("""inf"""		)]
        SCREAMING_SNAKE_CASE :      int       =   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        a__       (   unittest.TestCase	,			UpperCAmelCase       ):







  """simple docstring"""




  if is_tf_available():
    UpperCAmelCase__      : List[Any]			       ={
        """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  _lowercase      (			self    : List[str]		)					->Dict:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Any       =   TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""		)
        SCREAMING_SNAKE_CASE :      str       =   2
        SCREAMING_SNAKE_CASE :      Any       =   2







        class        a__       (   tf.Module       ):







          """simple docstring"""




          def __init__(			self    : Dict				,				UpperCAmelCase__    : List[str]		)					->Any:
                """simple docstring"""







                super(UpperCAmelCase__				,				self		).__init__()
                SCREAMING_SNAKE_CASE :      Optional[int]       =   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  _lowercase      (			self    : Optional[Any]				,				UpperCAmelCase__    : Optional[int]				,				UpperCAmelCase__    : Union[str, Any]		)					->Optional[int]:
                """simple docstring"""







                SCREAMING_SNAKE_CASE :      Optional[Any]       =   self.model.generate(
                    input_ids=UpperCAmelCase__				,				attention_mask=UpperCAmelCase__				,				max_new_tokens=UpperCAmelCase__				,				return_dict_in_generate=UpperCAmelCase__				,				)
                return {"sequences": outputs["sequences"]}


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


  @slow
  def  _lowercase      (			self    : Optional[Any]		)					->Optional[int]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      List[str]       =   TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""		)
        SCREAMING_SNAKE_CASE :      int       =   1
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   2







        class        a__       (   tf.Module       ):







          """simple docstring"""




          def __init__(			self    : List[str]				,				UpperCAmelCase__    : Optional[Any]		)					->Optional[Any]:
                """simple docstring"""







                super(UpperCAmelCase__				,				self		).__init__()
                SCREAMING_SNAKE_CASE :      Dict       =   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  _lowercase      (			self    : Optional[Any]				,				UpperCAmelCase__    : Optional[Any]				,				UpperCAmelCase__    : List[str]		)					->Any:
                """simple docstring"""







                SCREAMING_SNAKE_CASE :      Optional[int]       =   self.model.generate(
                    input_ids=UpperCAmelCase__				,				attention_mask=UpperCAmelCase__				,				max_new_tokens=UpperCAmelCase__				,				return_dict_in_generate=UpperCAmelCase__				,				)
                return {"sequences": outputs["sequences"]}


        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   [[2], [1_0_2, 1_0_3]]
        SCREAMING_SNAKE_CASE :      Any       =   [[1], [1, 1]]
        SCREAMING_SNAKE_CASE :      str       =   DummyModel(model=UpperCAmelCase__		)
        with tempfile.TemporaryDirectory() as tmp_dir:
              tf.saved_model.save(UpperCAmelCase__				,				UpperCAmelCase__				,				signatures={"""serving_default""": dummy_model.serving}		)
              SCREAMING_SNAKE_CASE :      Any       =   tf.saved_model.load(UpperCAmelCase__		).signatures["""serving_default"""]
              for input_row in range(len(UpperCAmelCase__		)		):
                    SCREAMING_SNAKE_CASE :      Optional[int]       =   {
                        """input_ids""": tf.constant([dummy_input_ids[input_row]]		),
                        """attention_mask""": tf.constant([dummy_attention_masks[input_row]]		),
                    }
                    SCREAMING_SNAKE_CASE :      List[Any]       =   serving_func(**UpperCAmelCase__		)["""sequences"""]
                    SCREAMING_SNAKE_CASE :      str       =   test_model.generate(**UpperCAmelCase__				,				max_new_tokens=UpperCAmelCase__		)
                    tf.debugging.assert_equal(UpperCAmelCase__				,				UpperCAmelCase__		)


  @slow
  @require_tensorflow_text
  def  _lowercase      (			self    : str		)					->Any:
        """simple docstring"""







        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        a__       (   tf.keras.layers.Layer       ):







                """simple docstring"""




                def __init__(			self    : Tuple		)					->Optional[Any]:
                      """simple docstring"""







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




                def  _lowercase      (			self    : str				,				UpperCAmelCase__    : Union[str, Any]				,				*UpperCAmelCase__    : List[str]				,				**UpperCAmelCase__    : Tuple		)					->Any:
                      """simple docstring"""







                      SCREAMING_SNAKE_CASE :      int       =   self.tokenizer.tokenize(UpperCAmelCase__		)
                      SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      str       =   text.pad_model_inputs(
                          UpperCAmelCase__				,				max_seq_length=6_4				,				pad_value=self.model.config.pad_token_id		)
                      SCREAMING_SNAKE_CASE :      Dict       =   self.model.generate(input_ids=UpperCAmelCase__				,				attention_mask=UpperCAmelCase__		)
                      return self.tokenizer.detokenize(UpperCAmelCase__		)


              SCREAMING_SNAKE_CASE :      Tuple       =   CompleteSentenceTransformer()
              SCREAMING_SNAKE_CASE :      List[str]       =   tf.keras.layers.Input(shape=(1,)				,				dtype=tf.string				,				name="""inputs"""		)
              SCREAMING_SNAKE_CASE :      List[Any]       =   complete_model(UpperCAmelCase__		)
              SCREAMING_SNAKE_CASE :      str       =   tf.keras.Model(UpperCAmelCase__				,				UpperCAmelCase__		)
              keras_model.save(UpperCAmelCase__		)


  def  _lowercase      (			self    : Union[str, Any]		)					->List[str]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      List[Any]       =   {
            """do_sample""": True,
            """num_beams""": 1,
            """top_p""": 0.7,
            """top_k""": 1_0,
            """temperature""": 0.7,
        }
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   1_4

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

        SCREAMING_SNAKE_CASE :      str       =   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		)
              SCREAMING_SNAKE_CASE :      Union[str, Any]       =   model.generate(**UpperCAmelCase__				,				eos_token_id=UpperCAmelCase__				,				**UpperCAmelCase__		)
        self.assertTrue(expectation == len(generated_tokens[0]		)		)

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




  def  _lowercase      (			self    : int		)					->Any:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      List[Any]       =   AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bart"""		)
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   """Hugging Face is a technology company based in New York and Paris."""
        SCREAMING_SNAKE_CASE :      int       =   bart_tokenizer(UpperCAmelCase__				,				return_tensors="""tf"""		).input_ids
        SCREAMING_SNAKE_CASE :      Dict       =   TFBartForConditionalGeneration.from_pretrained("""hf-internal-testing/tiny-random-bart"""		)
        SCREAMING_SNAKE_CASE :      Dict       =   bart_model.generate(UpperCAmelCase__		).numpy()







        class        a__       (   UpperCAmelCase       ):







          """simple docstring"""




          def  _lowercase      (			self    : Dict				,				UpperCAmelCase__    : Dict				,				UpperCAmelCase__    : Union[str, Any]=None				,				**UpperCAmelCase__    : int		)					->str:
                """simple docstring"""







                return super().call(UpperCAmelCase__				,				**UpperCAmelCase__		)


        SCREAMING_SNAKE_CASE :      Tuple       =   FakeBart.from_pretrained("""hf-internal-testing/tiny-random-bart"""		)
        SCREAMING_SNAKE_CASE :      str       =   bart_model.generate(UpperCAmelCase__				,				foo="""bar"""		).numpy()
        self.assertTrue(np.array_equal(UpperCAmelCase__				,				UpperCAmelCase__		)		)







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







          """simple docstring"""




          def  _lowercase      (			self    : Any				,				UpperCAmelCase__    : Tuple				,				**UpperCAmelCase__    : int		)					->List[str]:
                """simple docstring"""







                return super().call(UpperCAmelCase__				,				**UpperCAmelCase__		)


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

        # Normal generation still works (the output will be different because the encoder weights are different)
        SCREAMING_SNAKE_CASE :      Dict       =   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"""		)







from typing import Any

import numpy as np






def 					__lowercase      (     _A			)     ->						bool:
      return np.array_equal(_A						,    matrix.conjugate().T			)






def 					__lowercase      (     _A						,    _A			)     ->						Any:
      SCREAMING_SNAKE_CASE :      Optional[int]       =   v.conjugate().T
      SCREAMING_SNAKE_CASE :      List[Any]       =   v_star.dot(_A			)
      assert isinstance(_A						,    np.ndarray			)
      return (v_star_dot.dot(_A			)) / (v_star.dot(_A			))






def 					__lowercase      (     )     ->						None:
      SCREAMING_SNAKE_CASE :      Any       =   np.array([[2, 2 + 1J, 4], [2 - 1J, 3, 1J], [4, -1J, 1]]			)
      SCREAMING_SNAKE_CASE :      Optional[int]       =   np.array([[1], [2], [3]]			)
      assert is_hermitian(_A			), F"{a} is not hermitian."
      print(rayleigh_quotient(_A						,    _A			)			)

      SCREAMING_SNAKE_CASE :      Any       =   np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]			)
      assert is_hermitian(_A			), F"{a} is not hermitian."
      assert rayleigh_quotient(_A						,    _A			) == float(3			)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  tests()




