



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






					def     _a							(     self					:       Union[str, Any]					):






								"""simple docstring"""


								A__       =    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				,					)

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

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

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

								A__       =    output[output != -float('inf'					)]
								A__       =    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      __lowerCAmelCase     (		unittest.TestCase							,     UpperCAmelCase_      ):
					"""simple docstring"""






					if is_tf_available():
										A__				:		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     _a							(     self					:       str					):






								"""simple docstring"""


								A__       =    TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'					)
								A__       =    2
								A__       =    2


								class      __lowerCAmelCase     (		tf.Module      ):
													"""simple docstring"""






													def __init__(     self					:       Any				,					_snake_case					:       str					):






																"""simple docstring"""


																super(_snake_case				,					self					).__init__()
																A__       =    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					:       Optional[int]				,					_snake_case					:       Dict				,					_snake_case					:       List[str]					):






																"""simple docstring"""


																A__       =    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"]}







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



					@slow
					def     _a							(     self					:       Tuple					):






								"""simple docstring"""


								A__       =    TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'					)
								A__       =    1
								A__       =    2


								class      __lowerCAmelCase     (		tf.Module      ):
													"""simple docstring"""






													def __init__(     self					:       Optional[int]				,					_snake_case					:       Tuple					):






																"""simple docstring"""


																super(_snake_case				,					self					).__init__()
																A__       =    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					:       Tuple				,					_snake_case					:       Any				,					_snake_case					:       List[Any]					):






																"""simple docstring"""


																A__       =    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"]}







								A__       =    [[2], [1_02, 1_03]]
								A__       =    [[1], [1, 1]]
								A__       =    DummyModel(model=_snake_case					)
								with tempfile.TemporaryDirectory() as tmp_dir:
											tf.saved_model.save(_snake_case				,					_snake_case				,					signatures={'serving_default': dummy_model.serving}					)
											A__       =    tf.saved_model.load(_snake_case					).signatures['serving_default']
											for input_row in range(len(_snake_case					)					):
														A__       =    {
														    'input_ids': tf.constant([dummy_input_ids[input_row]]					),
														    'attention_mask': tf.constant([dummy_attention_masks[input_row]]					),
														}
														A__       =    serving_func(**_snake_case					)['sequences']
														A__       =    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					:       Optional[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=_snake_case					)


											class      __lowerCAmelCase     (		tf.keras.layers.Layer      ):
																"""simple docstring"""






																def __init__(     self					:       Dict					):






																			"""simple docstring"""


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



																def     _a							(     self					:       Any				,					_snake_case					:       Tuple				,					*_snake_case					:       Optional[Any]				,					**_snake_case					:       Union[str, Any]					):






																			"""simple docstring"""


																			A__       =    self.tokenizer.tokenize(_snake_case					)
																			A__     , A__       =    text.pad_model_inputs(
																			    _snake_case				,					max_seq_length=64				,					pad_value=self.model.config.pad_token_id					)
																			A__       =    self.model.generate(input_ids=_snake_case				,					attention_mask=_snake_case					)
																			return self.tokenizer.detokenize(_snake_case					)







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



					def     _a							(     self					:       List[str]					):






								"""simple docstring"""


								A__       =    {
								    'do_sample': True,
								    'num_beams': 1,
								    'top_p': 0.7,
								    'top_k': 10,
								    'temperature': 0.7,
								}
								A__       =    14

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

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

								A__       =    [6_38, 1_98]
								with tf.device(':/CPU:0'					):
											tf.random.set_seed(0					)
											A__       =    model.generate(**_snake_case				,					eos_token_id=_snake_case				,					**_snake_case					)
								self.assertTrue(expectation == len(generated_tokens[0]					)					)



					def     _a							(     self					:       Union[str, Any]					):






								"""simple docstring"""


								A__       =    AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart'					)
								A__       =    'Hugging Face is a technology company based in New York and Paris.'
								A__       =    bart_tokenizer(_snake_case				,					return_tensors='tf'					).input_ids
								A__       =    TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'					)
								A__       =    bart_model.generate(_snake_case					).numpy()


								class      __lowerCAmelCase     (		UpperCAmelCase_      ):
													"""simple docstring"""






													def     _a							(     self					:       List[str]				,					_snake_case					:       List[Any]				,					_snake_case					:       Dict=None				,					**_snake_case					:       int					):






																"""simple docstring"""


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







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


								class      __lowerCAmelCase     (		bart_model.model.encoder.__class__      ):
													"""simple docstring"""






													def     _a							(     self					:       str				,					_snake_case					:       Tuple				,					**_snake_case					:       str					):






																"""simple docstring"""


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







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

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









import tempfile
import unittest

from make_student import create_student_by_copying_alternating_layers

from transformers import AutoConfig
from transformers.file_utils import cached_property
from transformers.testing_utils import require_torch


SCREAMING_SNAKE_CASE__       =      '''sshleifer/bart-tiny-random'''
SCREAMING_SNAKE_CASE__       =      '''patrickvonplaten/t5-tiny-random'''


@require_torch
class      __lowerCAmelCase     (		unittest.TestCase      ):
					"""simple docstring"""






					@cached_property
					def     _a							(     self					:       Optional[int]					):






								"""simple docstring"""


								return AutoConfig.from_pretrained(_snake_case					)



					def     _a							(     self					:       Optional[Any]					):






								"""simple docstring"""


								A__     , *A__       =    create_student_by_copying_alternating_layers(_snake_case				,					tempfile.mkdtemp()				,					e=1				,					d=1					)
								self.assertEqual(student.config.num_hidden_layers				,					1					)



					def     _a							(     self					:       Optional[int]					):






								"""simple docstring"""


								A__     , *A__       =    create_student_by_copying_alternating_layers(_snake_case				,					tempfile.mkdtemp()				,					e=1				,					d=_snake_case					)



					def     _a							(     self					:       int					):






								"""simple docstring"""


								A__     , *A__       =    create_student_by_copying_alternating_layers(_snake_case				,					tempfile.mkdtemp()				,					e=1				,					d=_snake_case					)
								self.assertEqual(student.config.encoder_layers				,					1					)
								self.assertEqual(student.config.decoder_layers				,					self.teacher_config.encoder_layers					)



					def     _a							(     self					:       str					):






								"""simple docstring"""


								A__     , *A__       =    create_student_by_copying_alternating_layers(_snake_case				,					tempfile.mkdtemp()				,					e=1				,					d=1					)
								self.assertEqual(student.config.encoder_layers				,					1					)
								self.assertEqual(student.config.decoder_layers				,					1					)



					def     _a							(     self					:       str					):






								"""simple docstring"""


								with self.assertRaises(_snake_case					):
											create_student_by_copying_alternating_layers(_snake_case				,					tempfile.mkdtemp()				,					e=_snake_case				,					d=_snake_case					)




