


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



	def 				lowercase     (					self    ):
		lowerCAmelCase					:    Dict      							= tf.convert_to_tensor(
		    [
		        [
		            8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
		            -0.5_6_2_0_0_4_4,
		            5.2_3_2_2_9_7_5_2,
		            4.0_3_8_6_3_9_3,
		            -6.8_7_9_8_3_7_8,
		            -0.5_4_7_8_5_8_0_2,
		            -3.2_0_1_2_1_5_3,
		            2.9_2_7_7_7_1_7_6,
		            1.8_8_1_7_1_9_5_3,
		            7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
		            8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
		            -9.8_5_7_1_1_8_3_6,
		            -5.9_6_2_0_9_2_3_6,
		            -1.1_3_0_3_9_1_6_1,
		            -7.1_1_1_5_2_9_4,
		            -0.8_3_6_9_6_3_3,
		            -5.3_1_8_6_4_0_8,
		            7.0_6_4_2_7_4_0_7,
		            0.8_1_3_6_9_3_4_4,
		            -0.8_2_0_2_3_8_1_7,
		            -5.9_1_7_9_7_9_6,
		            0.5_8_8_1_3_4_4_3,
		            -6.9_9_7_7_8_4_3_8,
		            4.7_1_5_5_1_1_8_9,
		            -0.1_8_7_7_1_6_3_7,
		            7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
		            9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
		            2.1_2_6_6_2_9_4_1,
		            -9.3_2_5_6_2_0_3_8,
		            2.3_5_6_5_2_5_2_2,
		        ],  # cummulative prob of 5 highest values <= 0.6
		        [
		            0.5_8_4_2_5_5_1_8,
		            4.5_3_1_3_9_2_3_8,
		            -5.5_7_5_1_0_4_6_4,
		            -6.2_8_0_3_0_6_9_9,
		            -7.1_9_5_2_9_5_0_3,
		            -4.0_2_1_2_2_5_5_1,
		            1.3_9_3_3_7_0_3_7,
		            -6.0_6_7_0_7_0_5_7,
		            1.5_9_4_8_0_5_1_7,
		            -9.6_4_3_1_1_9,
		            0.0_3_9_0_7_7_9_9,
		            0.6_7_2_3_1_7_6_2,
		            -8.8_8_2_0_6_7_2_6,
		            6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
		            2.2_8_5_2_0_7_2_3,
		            4.8_2_7_6_7_5_0_6,
		            4.3_0_4_2_1_3_6_8,
		            8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
		            5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
		            -4.4_7_3_5_7_9_4,
		            7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
		            -2.9_1_0_5_1_6_6_3,
		            2.6_1_9_4_6_0_7_7,
		            -2.5_6_7_4_7_6_2,
		            -9.4_8_9_5_9_3_0_2,
		            -4.0_2_9_2_2_6_4_5,
		            -1.3_5_4_1_6_9_1_8,
		            9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
		            -5.8_9_4_7_8_5_5_3,
		            1.8_5_3_7_0_4_6_7,
		        ],  # cummulative prob of 5 highest values <= 0.6
		    ] ,					dtype=tf.floataa ,					)

		lowerCAmelCase					:    str      							= 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

		lowerCAmelCase					:    Tuple      							= tf.convert_to_tensor(
		    [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3] ,					dtype=tf.floataa ,					)  # expected non filtered values as noted above

		lowerCAmelCase					:    Union[str, Any]      							= tf_top_k_top_p_filtering(snake_case__ ,					top_k=10 ,					top_p=0.6 ,					min_tokens_to_keep=4    )

		lowerCAmelCase					:    List[str]      							= output[output != -float('inf'    )]
		lowerCAmelCase					:    int      							= 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-1_2    )
		tf.debugging.assert_equal(snake_case__ ,					snake_case__    )



@require_tf
class  lowerCAmelCase				(				unittest.TestCase      ,				a							):
	# setting framework_dependent_parameters needs to be gated, just like its contents' imports
	if is_tf_available():
		_lowerCamelCase   :					Optional[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    ):
		# TF-only test: tf.saved_model export
		lowerCAmelCase					:    int      							= TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'    )
		lowerCAmelCase					:    Union[str, Any]      							= 2
		lowerCAmelCase					:    List[str]      							= 2



		class  lowerCAmelCase				(				tf.Module							):



			def __init__(					self ,					snake_case__    ):
				super(snake_case__ ,					self    ).__init__()
				lowerCAmelCase					:    List[Any]      							= 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 				lowercase     (					self ,					snake_case__ ,					snake_case__    ):
				lowerCAmelCase					:    Union[str, Any]      							= 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"]}


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



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



		class  lowerCAmelCase				(				tf.Module							):



			def __init__(					self ,					snake_case__    ):
				super(snake_case__ ,					self    ).__init__()
				lowerCAmelCase					:    List[Any]      							= 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 				lowercase     (					self ,					snake_case__ ,					snake_case__    ):
				lowerCAmelCase					:    int      							= 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"]}


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



	@slow
	@require_tensorflow_text
	def 				lowercase     (					self    ):
		# 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  lowerCAmelCase				(				tf.keras.layers.Layer							):



				def __init__(					self    ):
					super().__init__()
					lowerCAmelCase					:    Optional[int]      							= text.SentencepieceTokenizer(
					    model=tf.io.gfile.GFile(os.path.join(snake_case__ ,					'spiece.model'    ) ,					'rb'    ).read()    )
					lowerCAmelCase					:    str      							= TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5'    )



				def 				lowercase     (					self ,					snake_case__ ,					*snake_case__ ,					**snake_case__    ):
					lowerCAmelCase					:    List[str]      							= self.tokenizer.tokenize(snake_case__    )
					lowerCAmelCase					:    Any      							= text.pad_model_inputs(
					    snake_case__ ,					max_seq_length=64 ,					pad_value=self.model.config.pad_token_id    )
					lowerCAmelCase					:    Optional[int]      							= self.model.generate(input_ids=snake_case__ ,					attention_mask=snake_case__    )
					return self.tokenizer.detokenize(snake_case__    )


			lowerCAmelCase					:    Optional[Any]      							= CompleteSentenceTransformer()
			lowerCAmelCase					:    List[str]      							= tf.keras.layers.Input(shape=(1,) ,					dtype=tf.string ,					name='inputs'    )
			lowerCAmelCase					:    Any      							= complete_model(snake_case__    )
			lowerCAmelCase					:    str      							= tf.keras.Model(snake_case__ ,					snake_case__    )
			keras_model.save(snake_case__    )



	def 				lowercase     (					self    ):
		# Has PT equivalent: this test relies on random sampling
		lowerCAmelCase					:    Optional[Any]      							= {
		    'do_sample': True,
		    'num_beams': 1,
		    'top_p': 0.7,
		    'top_k': 10,
		    'temperature': 0.7,
		}
		lowerCAmelCase					:    Dict      							= 14

		lowerCAmelCase					:    Union[str, Any]      							= AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'    )
		lowerCAmelCase					:    Tuple      							= 'Hello, my dog is cute and'
		lowerCAmelCase					:    Union[str, Any]      							= tokenizer(snake_case__ ,					return_tensors='tf'    )
		lowerCAmelCase					:    int      							= TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'    )

		lowerCAmelCase					:    Union[str, Any]      							= 638
		# forces the generation to happen on CPU, to avoid GPU-related quirks
		with tf.device(':/CPU:0'    ):
			tf.random.set_seed(0    )
			lowerCAmelCase					:    str      							= model.generate(**snake_case__ ,					eos_token_id=snake_case__ ,					**snake_case__    )
		self.assertTrue(expectation == len(generated_tokens[0]    )    )

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



	def 				lowercase     (					self    ):
		# Has PT equivalent: ample use of framework-specific code
		lowerCAmelCase					:    Tuple      							= AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart'    )
		lowerCAmelCase					:    Tuple      							= 'Hugging Face is a technology company based in New York and Paris.'
		lowerCAmelCase					:    Tuple      							= bart_tokenizer(snake_case__ ,					return_tensors='tf'    ).input_ids
		lowerCAmelCase					:    Optional[Any]      							= TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'    )
		lowerCAmelCase					:    Tuple      							= bart_model.generate(snake_case__    ).numpy()



		class  lowerCAmelCase				(				a							):



			def 				lowercase     (					self ,					snake_case__ ,					snake_case__=None ,					**snake_case__    ):
				return super().call(snake_case__ ,					**snake_case__    )


		lowerCAmelCase					:    Optional[Any]      							= FakeBart.from_pretrained('hf-internal-testing/tiny-random-bart'    )
		lowerCAmelCase					:    Union[str, Any]      							= bart_model.generate(snake_case__ ,					foo='bar'    ).numpy()
		self.assertTrue(np.array_equal(snake_case__ ,					snake_case__    )    )



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



			def 				lowercase     (					self ,					snake_case__ ,					**snake_case__    ):
				return super().call(snake_case__ ,					**snake_case__    )


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

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




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


_lowerCAmelCase  :		int		     =	{
    'configuration_nezha': ['NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'NezhaConfig'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowerCAmelCase  :		Tuple		     =	[
				    'NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'NezhaForNextSentencePrediction',
				    'NezhaForMaskedLM',
				    'NezhaForPreTraining',
				    'NezhaForMultipleChoice',
				    'NezhaForQuestionAnswering',
				    'NezhaForSequenceClassification',
				    'NezhaForTokenClassification',
				    'NezhaModel',
				    'NezhaPreTrainedModel',
				]


if TYPE_CHECKING:
				from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_nezha import (
								    NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST,
								    NezhaForMaskedLM,
								    NezhaForMultipleChoice,
								    NezhaForNextSentencePrediction,
								    NezhaForPreTraining,
								    NezhaForQuestionAnswering,
								    NezhaForSequenceClassification,
								    NezhaForTokenClassification,
								    NezhaModel,
								    NezhaPreTrainedModel,
								)


else:
				import sys

				_lowerCAmelCase  :		str		     =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
