





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



     '''simple docstring'''






     def 	UpperCamelCase(					self	):
       _snake_case     		=				tf.convert_to_tensor(
           [
               [
                   8.2220991,  # 3rd highest value; idx. 0
                   -0.5620044,
                   5.23229752,
                   4.0386393,
                   -6.8798378,
                   -0.54785802,
                   -3.2012153,
                   2.92777176,
                   1.88171953,
                   7.35341276,  # 5th highest value; idx. 9
                   8.43207833,  # 2nd highest value; idx. 10
                   -9.85711836,
                   -5.96209236,
                   -1.13039161,
                   -7.1115294,
                   -0.8369633,
                   -5.3186408,
                   7.06427407,
                   0.81369344,
                   -0.82023817,
                   -5.9179796,
                   0.58813443,
                   -6.99778438,
                   4.71551189,
                   -0.18771637,
                   7.44020759,  # 4th highest value; idx. 25
                   9.38450987,  # 1st highest value; idx. 26
                   2.12662941,
                   -9.32562038,
                   2.35652522,
               ],  # cummulative prob of 5 highest values <= 0.6
               [
                   0.58425518,
                   4.53139238,
                   -5.57510464,
                   -6.28030699,
                   -7.19529503,
                   -4.02122551,
                   1.39337037,
                   -6.06707057,
                   1.59480517,
                   -9.643119,
                   0.03907799,
                   0.67231762,
                   -8.88206726,
                   6.27115922,  # 4th highest value; idx. 13
                   2.28520723,
                   4.82767506,
                   4.30421368,
                   8.8275313,  # 2nd highest value; idx. 17
                   5.44029958,  # 5th highest value; idx. 18
                   -4.4735794,
                   7.38579536,  # 3rd highest value; idx. 20
                   -2.91051663,
                   2.61946077,
                   -2.5674762,
                   -9.48959302,
                   -4.02922645,
                   -1.35416918,
                   9.67702323,  # 1st highest value; idx. 27
                   -5.89478553,
                   1.85370467,
               ],  # cummulative prob of 5 highest values <= 0.6
           ]						,   dtype=tf.floataa						,   )

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

       _snake_case     		=				tf.convert_to_tensor(
           [8.222099, 7.3534126, 8.432078, 7.4402075, 9.38451, 6.271159, 8.827531, 5.4402995, 7.3857956, 9.677023]						,   dtype=tf.floataa						,   )  # expected non filtered values as noted above

       _snake_case     		=				tf_top_k_top_p_filtering(UpperCamelCase_						,   top_k=10						,   top_p=0.6						,   min_tokens_to_keep=4	)

       _snake_case     		=				output[output != -float("inf"	)]
       _snake_case     		=				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 					__SCREAMING_SNAKE_CASE	(						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 	UpperCamelCase(					self	):
       _snake_case     		=				TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"	)
       _snake_case     		=				2
       _snake_case     		=				2


       class 					__SCREAMING_SNAKE_CASE	(						tf.Module			):



            '''simple docstring'''






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







       _snake_case     		=				[[2, 0], [102, 103]]
       _snake_case     		=				[[1, 0], [1, 1]]
       _snake_case     		=				DummyModel(model=UpperCamelCase_	)
       with tempfile.TemporaryDirectory() as tmp_dir:
         tf.saved_model.save(UpperCamelCase_						,   UpperCamelCase_						,   signatures={"serving_default": dummy_model.serving}	)
         _snake_case     		=				tf.saved_model.load(UpperCamelCase_	).signatures['serving_default']
         for batch_size in range(1						,   len(UpperCamelCase_	) + 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(**UpperCamelCase_	)['sequences']
           _snake_case     		=				test_model.generate(**UpperCamelCase_						,   max_new_tokens=UpperCamelCase_	)
           tf.debugging.assert_equal(UpperCamelCase_						,   UpperCamelCase_	)

     @slow
     def 	UpperCamelCase(					self	):
       _snake_case     		=				TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"	)
       _snake_case     		=				1
       _snake_case     		=				2


       class 					__SCREAMING_SNAKE_CASE	(						tf.Module			):



            '''simple docstring'''






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







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

     @slow
     @require_tensorflow_text
     def 	UpperCamelCase(					self	):





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



              '''simple docstring'''






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






              def 	UpperCamelCase(					self						,   lowerCamelCase						,   *lowerCamelCase						,   **lowerCamelCase	):
                _snake_case     		=				self.tokenizer.tokenize(UpperCamelCase_	)
                _snake_case     		=				text.pad_model_inputs(
                    UpperCamelCase_						,   max_seq_length=64						,   pad_value=self.model.config.pad_token_id	)
                _snake_case     		=				self.model.generate(input_ids=UpperCamelCase_						,   attention_mask=UpperCamelCase_	)
                return self.tokenizer.detokenize(UpperCamelCase_	)







         _snake_case     		=				CompleteSentenceTransformer()
         _snake_case     		=				tf.keras.layers.Input(shape=(1,)						,   dtype=tf.string						,   name="inputs"	)
         _snake_case     		=				complete_model(UpperCamelCase_	)
         _snake_case     		=				tf.keras.Model(UpperCamelCase_						,   UpperCamelCase_	)
         keras_model.save(UpperCamelCase_	)

     def 	UpperCamelCase(					self	):
       _snake_case     		=				{
           'do_sample': True,
           'num_beams': 1,
           'top_p': 0.7,
           'top_k': 10,
           'temperature': 0.7,
       }
       _snake_case     		=				14

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

       _snake_case     		=				638
       # 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(**UpperCamelCase_						,   eos_token_id=UpperCamelCase_						,   **UpperCamelCase_	)
       self.assertTrue(expectation == len(generated_tokens[0]	)	)

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






     def 	UpperCamelCase(					self	):
       _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(UpperCamelCase_						,   return_tensors="tf"	).input_ids
       _snake_case     		=				TFBartForConditionalGeneration.from_pretrained("hf-internal-testing/tiny-random-bart"	)
       _snake_case     		=				bart_model.generate(UpperCamelCase_	).numpy()


       class 					__SCREAMING_SNAKE_CASE	(						__UpperCamelCase			):



            '''simple docstring'''






            def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase=None						,   **lowerCamelCase	):
              return super().call(UpperCamelCase_						,   **UpperCamelCase_	)







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


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



            '''simple docstring'''






            def 	UpperCamelCase(					self						,   lowerCamelCase						,   **lowerCamelCase	):
              return super().call(UpperCamelCase_						,   **UpperCamelCase_	)







       _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(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"	)









'''simple docstring'''



import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.layers import LSTM, Dense
from tensorflow.keras.models import Sequential

if __name__ == "__main__":
 __magic_name__   :						Union[str, Any]    =			pd.read_csv("""sample_data.csv""", header=None)
 __magic_name__   :						Optional[Any]    =			df.shape[:1][0]
 # If you're using some other dataset input the target column
 __magic_name__   :						str    =			df.iloc[:, 1:2]
 __magic_name__   :						Dict    =			actual_data.values.reshape(len_data, 1)
 __magic_name__   :						Tuple    =			MinMaxScaler().fit_transform(actual_data)
 __magic_name__   :						Union[str, Any]    =			10
 __magic_name__   :						Optional[int]    =			5
 __magic_name__   :						Any    =			20
 __magic_name__   :						int    =			len_data - periods * look_back
 __magic_name__   :						Union[str, Any]    =			actual_data[:division]
 __magic_name__   :						int    =			actual_data[division - look_back :]
 __magic_name__   ,    __magic_name__   :						List[str]    =			[], []
 __magic_name__   ,    __magic_name__   :						Tuple    =			[], []

 for i in range(0, len(train_data) - forward_days - look_back + 1):
  train_x.append(train_data[i : i + look_back])
  train_y.append(train_data[i + look_back : i + look_back + forward_days])
 for i in range(0, len(test_data) - forward_days - look_back + 1):
  test_x.append(test_data[i : i + look_back])
  test_y.append(test_data[i + look_back : i + look_back + forward_days])
 __magic_name__   :						List[str]    =			np.array(train_x)
 __magic_name__   :						List[str]    =			np.array(test_x)
 __magic_name__   :						int    =			np.array([list(i.ravel()) for i in train_y])
 __magic_name__   :						int    =			np.array([list(i.ravel()) for i in test_y])

 __magic_name__   :						Tuple    =			Sequential()
 model.add(LSTM(128, input_shape=(look_back, 1), return_sequences=True))
 model.add(LSTM(64, input_shape=(128, 1)))
 model.add(Dense(forward_days))
 model.compile(loss="""mean_squared_error""", optimizer="""adam""")
 __magic_name__   :						int    =			model.fit(
     x_train, y_train, epochs=150, verbose=1, shuffle=True, batch_size=4
 )
 __magic_name__   :						int    =			model.predict(x_test)


