

from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import tensorflow as tf

		from transformers import (
		    TFConvBertForMaskedLM,
		    TFConvBertForMultipleChoice,
		    TFConvBertForQuestionAnswering,
		    TFConvBertForSequenceClassification,
		    TFConvBertForTokenClassification,
		    TFConvBertModel,
		)


class SCREAMING_SNAKE_CASE  :






			"""simple docstring"""




			def __init__(    self ,				__UpperCamelCase ,				__UpperCamelCase=13 ,				__UpperCamelCase=7 ,				__UpperCamelCase=True ,				__UpperCamelCase=True ,				__UpperCamelCase=True ,				__UpperCamelCase=True ,				__UpperCamelCase=99 ,				__UpperCamelCase=32 ,				__UpperCamelCase=2 ,				__UpperCamelCase=4 ,				__UpperCamelCase=37 ,				__UpperCamelCase="gelu" ,				__UpperCamelCase=0.1 ,				__UpperCamelCase=0.1 ,				__UpperCamelCase=5_12 ,				__UpperCamelCase=16 ,				__UpperCamelCase=2 ,				__UpperCamelCase=0.02 ,				__UpperCamelCase=3 ,				__UpperCamelCase=4 ,				__UpperCamelCase=None ,				):

				"""simple docstring"""


				snake_case_      		= parent
				snake_case_      		= 13
				snake_case_      		= 7
				snake_case_      		= True
				snake_case_      		= True
				snake_case_      		= True
				snake_case_      		= True
				snake_case_      		= 99
				snake_case_      		= 3_84
				snake_case_      		= 2
				snake_case_      		= 4
				snake_case_      		= 37
				snake_case_      		= 'gelu'
				snake_case_      		= 0.1
				snake_case_      		= 0.1
				snake_case_      		= 5_12
				snake_case_      		= 16
				snake_case_      		= 2
				snake_case_      		= 0.02
				snake_case_      		= 3
				snake_case_      		= 4
				snake_case_      		= 1_28
				snake_case_      		= 2
				snake_case_      		= 9
				snake_case_      		= 1
				snake_case_      		= None


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size							)

				snake_case_      		= None
				if self.use_input_mask:
					snake_case_      		= random_attention_mask([self.batch_size, self.seq_length]							)

				snake_case_      		= None
				if self.use_token_type_ids:
					snake_case_      		= ids_tensor([self.batch_size, self.seq_length] ,				self.type_vocab_size							)

				snake_case_      		= None
				snake_case_      		= None
				snake_case_      		= None
				if self.use_labels:
					snake_case_      		= ids_tensor([self.batch_size] ,				self.type_sequence_label_size							)
					snake_case_      		= ids_tensor([self.batch_size, self.seq_length] ,				self.num_labels							)
					snake_case_      		= ids_tensor([self.batch_size] ,				self.num_choices							)

				snake_case_      		= ConvBertConfig(
				    vocab_size=self.vocab_size ,				hidden_size=self.hidden_size ,				num_hidden_layers=self.num_hidden_layers ,				num_attention_heads=self.num_attention_heads ,				intermediate_size=self.intermediate_size ,				hidden_act=self.hidden_act ,				hidden_dropout_prob=self.hidden_dropout_prob ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob ,				max_position_embeddings=self.max_position_embeddings ,				type_vocab_size=self.type_vocab_size ,				initializer_range=self.initializer_range ,				return_dict=snake_case_ ,				)

				return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= TFConvBertModel(config=snake_case_							)
				snake_case_      		= {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

				snake_case_      		= [input_ids, input_mask]
				snake_case_      		= model(snake_case_							)

				snake_case_      		= model(snake_case_							)

				self.parent.assertEqual(result.last_hidden_state.shape ,				(self.batch_size, self.seq_length, self.hidden_size)							)


			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= TFConvBertForMaskedLM(config=snake_case_							)
				snake_case_      		= {
				    'input_ids': input_ids,
				    'attention_mask': input_mask,
				    'token_type_ids': token_type_ids,
				}
				snake_case_      		= model(snake_case_							)
				self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.vocab_size)							)


			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= self.num_labels
				snake_case_      		= TFConvBertForSequenceClassification(config=snake_case_							)
				snake_case_      		= {
				    'input_ids': input_ids,
				    'attention_mask': input_mask,
				    'token_type_ids': token_type_ids,
				}

				snake_case_      		= model(snake_case_							)
				self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_labels)							)


			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= self.num_choices
				snake_case_      		= TFConvBertForMultipleChoice(config=snake_case_							)
				snake_case_      		= tf.tile(tf.expand_dims(snake_case_ ,				1							) ,				(1, self.num_choices, 1)							)
				snake_case_      		= tf.tile(tf.expand_dims(snake_case_ ,				1							) ,				(1, self.num_choices, 1)							)
				snake_case_      		= tf.tile(tf.expand_dims(snake_case_ ,				1							) ,				(1, self.num_choices, 1)							)
				snake_case_      		= {
				    'input_ids': multiple_choice_inputs_ids,
				    'attention_mask': multiple_choice_input_mask,
				    'token_type_ids': multiple_choice_token_type_ids,
				}
				snake_case_      		= model(snake_case_							)
				self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_choices)							)


			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= self.num_labels
				snake_case_      		= TFConvBertForTokenClassification(config=snake_case_							)
				snake_case_      		= {
				    'input_ids': input_ids,
				    'attention_mask': input_mask,
				    'token_type_ids': token_type_ids,
				}
				snake_case_      		= model(snake_case_							)
				self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.num_labels)							)


			def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase ,				__UpperCamelCase							):

				"""simple docstring"""


				snake_case_      		= TFConvBertForQuestionAnswering(config=snake_case_							)
				snake_case_      		= {
				    'input_ids': input_ids,
				    'attention_mask': input_mask,
				    'token_type_ids': token_type_ids,
				}

				snake_case_      		= model(snake_case_							)
				self.parent.assertEqual(result.start_logits.shape ,				(self.batch_size, self.seq_length)							)
				self.parent.assertEqual(result.end_logits.shape ,				(self.batch_size, self.seq_length)							)







			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= self.prepare_config_and_inputs()
				(
				    (
				    snake_case_						
				)		,       (
				    snake_case_						
				)		,       (
				    snake_case_						
				)		,       (
				    snake_case_						
				)		,       (
				    snake_case_						
				)		,       (
				    snake_case_						
				)		,       (
				    snake_case_						
				)		,       						
				)      		= config_and_inputs
				snake_case_      		= {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
				return config, inputs_dict







@require_tf
class SCREAMING_SNAKE_CASE  (		_a							,						_a							,						unittest.TestCase							):






			"""simple docstring"""




			__A     :   Any						  =  (
			    (
			        TFConvBertModel,
			        TFConvBertForMaskedLM,
			        TFConvBertForQuestionAnswering,
			        TFConvBertForSequenceClassification,
			        TFConvBertForTokenClassification,
			        TFConvBertForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			__A     :   str						  =  (
			    {
			        """feature-extraction""": TFConvBertModel,
			        """fill-mask""": TFConvBertForMaskedLM,
			        """question-answering""": TFConvBertForQuestionAnswering,
			        """text-classification""": TFConvBertForSequenceClassification,
			        """token-classification""": TFConvBertForTokenClassification,
			        """zero-shot""": TFConvBertForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			__A     :   Any						  =  False
			__A     :   Dict						  =  False
			__A     :   str						  =  False


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= TFConvBertModelTester(self							)
				snake_case_      		= ConfigTester(self ,				config_class=snake_case_ ,				hidden_size=37							)


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				self.config_tester.run_common_tests()


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*snake_case_							)


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_lm(*snake_case_							)


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_multiple_choice(*snake_case_							)


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_question_answering(*snake_case_							)


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_sequence_classification(*snake_case_							)


			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_token_classification(*snake_case_							)


			@slow
			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_		,       snake_case_      		= self.model_tester.prepare_config_and_inputs_for_common()
				snake_case_      		= True
				snake_case_      		= True

				if hasattr(snake_case_ ,				'use_cache'							):
					snake_case_      		= True

				snake_case_      		= getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length							)
				snake_case_      		= getattr(self.model_tester ,				'key_length' ,				snake_case_							)

				for model_class in self.all_model_classes:
					snake_case_      		= self._prepare_for_class(snake_case_ ,				snake_case_							)
					snake_case_      		= model_class(snake_case_							)
					snake_case_      		= len(model(snake_case_							)							)

					with tempfile.TemporaryDirectory() as tmpdirname:
						model.save_pretrained(snake_case_ ,				saved_model=snake_case_							)
						snake_case_      		= os.path.join(snake_case_ ,				'saved_model' ,				'1'							)
						snake_case_      		= tf.keras.models.load_model(snake_case_							)
						snake_case_      		= model(snake_case_							)

						if self.is_encoder_decoder:
							snake_case_      		= outputs['encoder_hidden_states']
							snake_case_      		= outputs['encoder_attentions']
						else:
							snake_case_      		= outputs['hidden_states']
							snake_case_      		= outputs['attentions']

						self.assertEqual(len(snake_case_							) ,				snake_case_							)

						snake_case_      		= getattr(
						    self.model_tester ,				'expected_num_hidden_layers' ,				self.model_tester.num_hidden_layers + 1							)

						self.assertEqual(len(snake_case_							) ,				snake_case_							)
						self.assertListEqual(
						    list(output_hidden_states[0].shape[-2:]							) ,				[self.model_tester.seq_length, self.model_tester.hidden_size] ,				)

						self.assertEqual(len(snake_case_							) ,				self.model_tester.num_hidden_layers							)
						self.assertListEqual(
						    list(output_attentions[0].shape[-3:]							) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)


			@slow
			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= TFConvBertModel.from_pretrained('YituTech/conv-bert-base'							)
				self.assertIsNotNone(snake_case_							)







			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_		,       snake_case_      		= self.model_tester.prepare_config_and_inputs_for_common()
				snake_case_      		= True
				snake_case_      		= getattr(self.model_tester ,				'decoder_seq_length' ,				self.model_tester.seq_length							)
				snake_case_      		= getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length							)
				snake_case_      		= getattr(self.model_tester ,				'key_length' ,				snake_case_							)
				snake_case_      		= getattr(self.model_tester ,				'key_length' ,				snake_case_							)

				def check_decoder_attentions_output(__UpperCamelCase							):
					snake_case_      		= len(snake_case_							)
					self.assertEqual(out_len % 2 ,				0							)
					snake_case_      		= outputs.decoder_attentions
					self.assertEqual(len(snake_case_							) ,				self.model_tester.num_hidden_layers							)
					self.assertListEqual(
					    list(decoder_attentions[0].shape[-3:]							) ,				[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length] ,				)

				def check_encoder_attentions_output(__UpperCamelCase							):
					snake_case_      		= [
					    t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
					]
					self.assertEqual(len(snake_case_							) ,				self.model_tester.num_hidden_layers							)
					self.assertListEqual(
					    list(attentions[0].shape[-3:]							) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)

				for model_class in self.all_model_classes:
					snake_case_      		= True
					snake_case_      		= False
					snake_case_      		= model_class(snake_case_							)
					snake_case_      		= model(self._prepare_for_class(snake_case_ ,				snake_case_							)							)
					snake_case_      		= len(snake_case_							)
					self.assertEqual(config.output_hidden_states ,				snake_case_							)
					check_encoder_attentions_output(snake_case_							)

					if self.is_encoder_decoder:
						snake_case_      		= model_class(snake_case_							)
						snake_case_      		= model(self._prepare_for_class(snake_case_ ,				snake_case_							)							)
						self.assertEqual(config.output_hidden_states ,				snake_case_							)
						check_decoder_attentions_output(snake_case_							)

					# Check that output attentions can also be changed via the config
					del inputs_dict["output_attentions"]
					snake_case_      		= True
					snake_case_      		= model_class(snake_case_							)
					snake_case_      		= model(self._prepare_for_class(snake_case_ ,				snake_case_							)							)
					self.assertEqual(config.output_hidden_states ,				snake_case_							)
					check_encoder_attentions_output(snake_case_							)

					# Check attention is always last and order is fine
					snake_case_      		= True
					snake_case_      		= True
					snake_case_      		= model_class(snake_case_							)
					snake_case_      		= model(self._prepare_for_class(snake_case_ ,				snake_case_							)							)

					self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1) ,				len(snake_case_							)							)
					self.assertEqual(model.config.output_hidden_states ,				snake_case_							)
					check_encoder_attentions_output(snake_case_							)







@require_tf
class SCREAMING_SNAKE_CASE  (		unittest.TestCase							):






			"""simple docstring"""




			@slow
			def 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				snake_case_      		= TFConvBertModel.from_pretrained('YituTech/conv-bert-base'							)
				snake_case_      		= tf.constant([[0, 1, 2, 3, 4, 5]]							)
				snake_case_      		= model(snake_case_							)[0]

				snake_case_      		= [1, 6, 7_68]
				self.assertEqual(output.shape ,				snake_case_							)

				snake_case_      		= tf.constant(
				    [
				        [
				            [-0.0347_5493, -0.468_6034, -0.3063_8832],
				            [0.2263_7248, -0.2698_8646, -0.742_3424],
				            [0.1032_4868, -0.4501_3508, -0.5828_0784],
				        ]
				    ]							)
				tf.debugging.assert_near(output[:, :3, :3] ,				snake_case_ ,				atol=1E-4							)



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 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				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, 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.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(__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							,						__snake_case							):






			"""simple docstring"""




			if is_tf_available():
						__A						  =  {
						    """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							):

				"""simple docstring"""


				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 ,				__UpperCamelCase							):

								"""simple docstring"""


								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 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase							):

								"""simple docstring"""


								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], [1_02, 1_03]]
				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 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				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 ,				__UpperCamelCase							):

								"""simple docstring"""


								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 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase							):

								"""simple docstring"""


								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], [1_02, 1_03]]
				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 			__lowerCAmelCase (    self							):

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






								"""simple docstring"""




								def __init__(    self							):

									"""simple docstring"""


									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 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				*__UpperCamelCase ,				**__UpperCamelCase							):

									"""simple docstring"""


									snake_case_      		= self.tokenizer.tokenize(__UpperCamelCase							)
									snake_case_		,       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 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				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_      		= 6_38
				# 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_      		= [6_38, 1_98]
				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 			__lowerCAmelCase (    self							):

				"""simple docstring"""


				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  (		__snake_case							):






							"""simple docstring"""




							def 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				__UpperCamelCase=None ,				**__UpperCamelCase							):

								"""simple docstring"""


								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 			__lowerCAmelCase (    self ,				__UpperCamelCase ,				**__UpperCamelCase							):

								"""simple docstring"""


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