



"""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 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							def        lowerCamelCase_   (  self						)			->							int:
														_UpperCAmelCase							 =		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	,       )

														_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.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

														_UpperCAmelCase							 =		tf_top_k_top_p_filtering(snake_case	,       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(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 			lowercase__			(      unittest.TestCase,					A    ):
							'''simple docstring'''







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




														class 			lowercase__			(      tf.Module    ):
																					'''simple docstring'''







																					def __init__(  self	,       snake_case						)			->							Optional[Any]:
																												super(snake_case	,       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=snake_case	,       )
																					def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							Optional[Any]:
																												_UpperCAmelCase							 =		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"]}







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






							@slow
							def        lowerCamelCase_   (  self						)			->							int:
														# TF-only test: tf.saved_model export
														_UpperCAmelCase							 =		TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'						)
														_UpperCAmelCase							 =		1
														_UpperCAmelCase							 =		2




														class 			lowercase__			(      tf.Module    ):
																					'''simple docstring'''







																					def __init__(  self	,       snake_case						)			->							str:
																												super(snake_case	,       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=snake_case	,       )
																					def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							int:
																												_UpperCAmelCase							 =		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"]}







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






							@slow
							@require_tensorflow_text
							def        lowerCamelCase_   (  self						)			->							Any:
														# 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 			lowercase__			(      tf.keras.layers.Layer    ):
																												'''simple docstring'''







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






																												def        lowerCamelCase_   (  self	,       snake_case	,       *snake_case	,       **snake_case						)			->							str:
																																			_UpperCAmelCase							 =		self.tokenizer.tokenize(snake_case						)
																																			_UpperCAmelCase ,					_UpperCAmelCase							 =		text.pad_model_inputs(
																																			    snake_case	,       max_seq_length=64	,       pad_value=self.model.config.pad_token_id						)
																																			_UpperCAmelCase							 =		self.model.generate(input_ids=snake_case	,       attention_mask=snake_case						)
																																			return self.tokenizer.detokenize(snake_case						)







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






							def        lowerCamelCase_   (  self						)			->							List[Any]:
														# 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(snake_case	,       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(**snake_case	,       eos_token_id=snake_case	,       **snake_case						)
														self.assertTrue(expectation == len(generated_tokens[0]						)						)

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






							def        lowerCamelCase_   (  self						)			->							Dict:
														# 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(snake_case	,       return_tensors='tf'						).input_ids
														_UpperCAmelCase							 =		TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'						)
														_UpperCAmelCase							 =		bart_model.generate(snake_case						).numpy()




														class 			lowercase__			(      A    ):
																					'''simple docstring'''







																					def        lowerCamelCase_   (  self	,       snake_case	,       snake_case=None	,       **snake_case						)			->							str:
																												return super().call(snake_case	,       **snake_case						)







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




														class 			lowercase__			(      bart_model.model.encoder.__class__    ):
																					'''simple docstring'''







																					def        lowerCamelCase_   (  self	,       snake_case	,       **snake_case						)			->							int:
																												return super().call(snake_case	,       **snake_case						)







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







"""simple docstring"""





import logging
import os
import sys
from pathlib import Path
from unittest.mock import patch

from parameterized import parameterized
from run_eval import run_generate
from run_eval_search import run_search

from transformers.testing_utils import CaptureStdout, TestCasePlus, slow
from utils import ROUGE_KEYS


logging.basicConfig(level=logging.DEBUG)
lowercase  							=					logging.getLogger()




def 	UpperCAmelCase     (		A	:						Path     ,				A	:						list       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		'\n'.join(A       )
		Path(A       ).open('w'       ).writelines(A       )


lowercase  							=					'''patrickvonplaten/t5-tiny-random'''
lowercase  							=					'''sshleifer/bart-tiny-random'''
lowercase  							=					'''sshleifer/tiny-mbart'''

lowercase  							=					logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)
logging.disable(logging.CRITICAL)  # remove noisy download output from tracebacks






class 			lowercase__			(      A    ):
							'''simple docstring'''







							def        lowerCamelCase_   (  self	,       snake_case						)			->							str:
									_UpperCAmelCase							 =		Path(self.get_auto_remove_tmp_dir()						) / 'utest_input.source'
									_UpperCAmelCase							 =		input_file_name.parent / 'utest_output.txt'
									assert not output_file_name.exists()
									_UpperCAmelCase							 =		[' New York (CNN)When Liana Barrientos was 23 years old, she got married in Westchester County.']
									_dump_articles(snake_case	,       snake_case						)

									_UpperCAmelCase							 =		str(Path(self.get_auto_remove_tmp_dir()						) / 'scores.json'						)
									_UpperCAmelCase							 =		'translation_en_to_de' if model == T5_TINY else 'summarization'
									_UpperCAmelCase							 =		f'\n            run_eval_search.py\n            {model}\n            {input_file_name}\n            {output_file_name}\n            --score_path {score_path}\n            --task {task}\n            --num_beams 2\n            --length_penalty 2.0\n            '.split()

									with patch.object(snake_case	,       'argv'	,       snake_case						):
											run_generate()
											assert Path(snake_case						).exists()
											# os.remove(Path(output_file_name))






							def        lowerCamelCase_   (  self						)			->							str:
									self.run_eval_tester(snake_case						)






							@parameterized.expand([BART_TINY, MBART_TINY]						)
							@slow
							def        lowerCamelCase_   (  self	,       snake_case						)			->							List[Any]:
									self.run_eval_tester(snake_case						)






							@parameterized.expand([T5_TINY, MBART_TINY]						)
							@slow
							def        lowerCamelCase_   (  self	,       snake_case						)			->							Dict:
									_UpperCAmelCase							 =		Path(self.get_auto_remove_tmp_dir()						) / 'utest_input.source'
									_UpperCAmelCase							 =		input_file_name.parent / 'utest_output.txt'
									assert not output_file_name.exists()

									_UpperCAmelCase							 =		{
									    'en': ['Machine learning is great, isn\'t it?', 'I like to eat bananas', 'Tomorrow is another great day!'],
									    'de': [
									        'Maschinelles Lernen ist großartig, oder?',
									        'Ich esse gerne Bananen',
									        'Morgen ist wieder ein toller Tag!',
									    ],
									}

									_UpperCAmelCase							 =		Path(self.get_auto_remove_tmp_dir()						)
									_UpperCAmelCase							 =		str(tmp_dir / 'scores.json'						)
									_UpperCAmelCase							 =		str(tmp_dir / 'val.target'						)
									_dump_articles(snake_case	,       text['en']						)
									_dump_articles(snake_case	,       text['de']						)
									_UpperCAmelCase							 =		'translation_en_to_de' if model == T5_TINY else 'summarization'
									_UpperCAmelCase							 =		f'\n            run_eval_search.py\n            {model}\n            {str(snake_case						)}\n            {str(snake_case						)}\n            --score_path {score_path}\n            --reference_path {reference_path}\n            --task {task}\n            '.split()
									testargs.extend(['--search', 'num_beams=1:2 length_penalty=0.9:1.0']						)

									with patch.object(snake_case	,       'argv'	,       snake_case						):
											with CaptureStdout() as cs:
													run_search()
											_UpperCAmelCase							 =		[' num_beams | length_penalty', model, 'Best score args']
											_UpperCAmelCase							 =		['Info']
											if "translation" in task:
													expected_strings.append('bleu'						)
											else:
													expected_strings.extend(snake_case						)
											for w in expected_strings:
													assert w in cs.out
											for w in un_expected_strings:
													assert w not in cs.out
											assert Path(snake_case						).exists()
											os.remove(Path(snake_case						)						)


