
'''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      ):
								_SCREAMING_SNAKE_CASE				= tf.convert_to_tensor(
								    [
								        [
								            8.2_22_09_91,  # 3rd highest value; idx. 0
								            -0.5_62_00_44,
								            5.23_22_97_52,
								            4.0_38_63_93,
								            -6.8_79_83_78,
								            -0.54_78_58_02,
								            -3.2_01_21_53,
								            2.92_77_71_76,
								            1.88_17_19_53,
								            7.35_34_12_76,  # 5th highest value; idx. 9
								            8.43_20_78_33,  # 2nd highest value; idx. 10
								            -9.85_71_18_36,
								            -5.96_20_92_36,
								            -1.13_03_91_61,
								            -7.1_11_52_94,
								            -0.8_36_96_33,
								            -5.3_18_64_08,
								            7.06_42_74_07,
								            0.81_36_93_44,
								            -0.82_02_38_17,
								            -5.9_17_97_96,
								            0.58_81_34_43,
								            -6.99_77_84_38,
								            4.71_55_11_89,
								            -0.18_77_16_37,
								            7.44_02_07_59,  # 4th highest value; idx. 25
								            9.38_45_09_87,  # 1st highest value; idx. 26
								            2.12_66_29_41,
								            -9.32_56_20_38,
								            2.35_65_25_22,
								        ],  # cummulative prob of 5 highest values <= 0.6
								        [
								            0.58_42_55_18,
								            4.53_13_92_38,
								            -5.57_51_04_64,
								            -6.28_03_06_99,
								            -7.19_52_95_03,
								            -4.02_12_25_51,
								            1.39_33_70_37,
								            -6.06_70_70_57,
								            1.59_48_05_17,
								            -9.64_31_19,
								            0.03_90_77_99,
								            0.67_23_17_62,
								            -8.88_20_67_26,
								            6.27_11_59_22,  # 4th highest value; idx. 13
								            2.28_52_07_23,
								            4.82_76_75_06,
								            4.30_42_13_68,
								            8.8_27_53_13,  # 2nd highest value; idx. 17
								            5.44_02_99_58,  # 5th highest value; idx. 18
								            -4.4_73_57_94,
								            7.38_57_95_36,  # 3rd highest value; idx. 20
								            -2.91_05_16_63,
								            2.61_94_60_77,
								            -2.5_67_47_62,
								            -9.48_95_93_02,
								            -4.02_92_26_45,
								            -1.35_41_69_18,
								            9.67_70_23_23,  # 1st highest value; idx. 27
								            -5.89_47_85_53,
								            1.85_37_04_67,
								        ],  # cummulative prob of 5 highest values <= 0.6
								    ]					,						dtype=tf.floataa					,						)

								_SCREAMING_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

								_SCREAMING_SNAKE_CASE				= tf.convert_to_tensor(
								    [8.22_20_99, 7.3_53_41_26, 8.43_20_78, 7.4_40_20_75, 9.3_84_51, 6.27_11_59, 8.82_75_31, 5.4_40_29_95, 7.3_85_79_56, 9.67_70_23]					,						dtype=tf.floataa					,						)  # expected non filtered values as noted above

								_SCREAMING_SNAKE_CASE				= tf_top_k_top_p_filtering(UpperCamelCase					,						top_k=10					,						top_p=0.6					,						min_tokens_to_keep=4      )

								_SCREAMING_SNAKE_CASE				= output[output != -float("inf"      )]
								_SCREAMING_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 			lowerCAmelCase (				unittest.TestCase		,     __UpperCAmelCase			):
		# setting framework_dependent_parameters needs to be gated, just like its contents' imports
		if is_tf_available():
				a							:					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
								_SCREAMING_SNAKE_CASE				= TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"      )
								_SCREAMING_SNAKE_CASE				= 2
								_SCREAMING_SNAKE_CASE				= 2


								class 			lowerCAmelCase (				tf.Module			):




										def __init__(				self					,						UpperCamelCase      ):
																super(UpperCamelCase					,						self      ).__init__()
																_SCREAMING_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     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase      ):
																_SCREAMING_SNAKE_CASE				= self.model.generate(
																    input_ids=UpperCamelCase					,						attention_mask=UpperCamelCase					,						max_new_tokens=UpperCamelCase					,						return_dict_in_generate=UpperCamelCase					,						)
																return {"sequences": outputs["sequences"]}
								_SCREAMING_SNAKE_CASE				= [[2, 0], [102, 103]]
								_SCREAMING_SNAKE_CASE				= [[1, 0], [1, 1]]
								_SCREAMING_SNAKE_CASE				= DummyModel(model=UpperCamelCase      )
								with tempfile.TemporaryDirectory() as tmp_dir:
														tf.saved_model.save(UpperCamelCase					,						UpperCamelCase					,						signatures={"serving_default": dummy_model.serving}      )
														_SCREAMING_SNAKE_CASE				= tf.saved_model.load(UpperCamelCase      ).signatures["serving_default"]
														for batch_size in range(1					,						len(UpperCamelCase      ) + 1      ):
																				_SCREAMING_SNAKE_CASE				= {
																				    "input_ids": tf.constant(dummy_input_ids[:batch_size]      ),
																				    "attention_mask": tf.constant(dummy_attention_masks[:batch_size]      ),
																				}
																				_SCREAMING_SNAKE_CASE				= serving_func(**UpperCamelCase      )["sequences"]
																				_SCREAMING_SNAKE_CASE				= test_model.generate(**UpperCamelCase					,						max_new_tokens=UpperCamelCase      )
																				tf.debugging.assert_equal(UpperCamelCase					,						UpperCamelCase      )




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


								class 			lowerCAmelCase (				tf.Module			):




										def __init__(				self					,						UpperCamelCase      ):
																super(UpperCamelCase					,						self      ).__init__()
																_SCREAMING_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     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase      ):
																_SCREAMING_SNAKE_CASE				= self.model.generate(
																    input_ids=UpperCamelCase					,						attention_mask=UpperCamelCase					,						max_new_tokens=UpperCamelCase					,						return_dict_in_generate=UpperCamelCase					,						)
																return {"sequences": outputs["sequences"]}
								_SCREAMING_SNAKE_CASE				= [[2], [102, 103]]
								_SCREAMING_SNAKE_CASE				= [[1], [1, 1]]
								_SCREAMING_SNAKE_CASE				= DummyModel(model=UpperCamelCase      )
								with tempfile.TemporaryDirectory() as tmp_dir:
														tf.saved_model.save(UpperCamelCase					,						UpperCamelCase					,						signatures={"serving_default": dummy_model.serving}      )
														_SCREAMING_SNAKE_CASE				= tf.saved_model.load(UpperCamelCase      ).signatures["serving_default"]
														for input_row in range(len(UpperCamelCase      )      ):
																				_SCREAMING_SNAKE_CASE				= {
																				    "input_ids": tf.constant([dummy_input_ids[input_row]]      ),
																				    "attention_mask": tf.constant([dummy_attention_masks[input_row]]      ),
																				}
																				_SCREAMING_SNAKE_CASE				= serving_func(**UpperCamelCase      )["sequences"]
																				_SCREAMING_SNAKE_CASE				= test_model.generate(**UpperCamelCase					,						max_new_tokens=UpperCamelCase      )
																				tf.debugging.assert_equal(UpperCamelCase					,						UpperCamelCase      )




		@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=UpperCamelCase      )


														class 			lowerCAmelCase (				tf.keras.layers.Layer			):




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




																def     lowercase       (				self					,						UpperCamelCase					,						*UpperCamelCase					,						**UpperCamelCase      ):
																						_SCREAMING_SNAKE_CASE				= self.tokenizer.tokenize(UpperCamelCase      )
																						_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= text.pad_model_inputs(
																						    UpperCamelCase					,						max_seq_length=64					,						pad_value=self.model.config.pad_token_id      )
																						_SCREAMING_SNAKE_CASE				= self.model.generate(input_ids=UpperCamelCase					,						attention_mask=UpperCamelCase      )
																						return self.tokenizer.detokenize(UpperCamelCase      )
														_SCREAMING_SNAKE_CASE				= CompleteSentenceTransformer()
														_SCREAMING_SNAKE_CASE				= tf.keras.layers.Input(shape=(1,)					,						dtype=tf.string					,						name="inputs"      )
														_SCREAMING_SNAKE_CASE				= complete_model(UpperCamelCase      )
														_SCREAMING_SNAKE_CASE				= tf.keras.Model(UpperCamelCase					,						UpperCamelCase      )
														keras_model.save(UpperCamelCase      )




		def     lowercase       (				self      ):
								# Has PT equivalent: this test relies on random sampling
								_SCREAMING_SNAKE_CASE				= {
								    "do_sample": True,
								    "num_beams": 1,
								    "top_p": 0.7,
								    "top_k": 10,
								    "temperature": 0.7,
								}
								_SCREAMING_SNAKE_CASE				= 14

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

								_SCREAMING_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      )
														_SCREAMING_SNAKE_CASE				= model.generate(**UpperCamelCase					,						eos_token_id=UpperCamelCase					,						**UpperCamelCase      )
								self.assertTrue(expectation == len(generated_tokens[0]      )      )

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




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


								class 			lowerCAmelCase (				__UpperCAmelCase			):




										def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase=None					,						**UpperCamelCase      ):
																return super().call(UpperCamelCase					,						**UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= FakeBart.from_pretrained("hf-internal-testing/tiny-random-bart"      )
								_SCREAMING_SNAKE_CASE				= bart_model.generate(UpperCamelCase					,						foo="bar"      ).numpy()
								self.assertTrue(np.array_equal(UpperCamelCase					,						UpperCamelCase      )      )


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




										def     lowercase       (				self					,						UpperCamelCase					,						**UpperCamelCase      ):
																return super().call(UpperCamelCase					,						**UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= FakeEncoder(bart_model.config					,						bart_model.model.shared      )
								_SCREAMING_SNAKE_CASE				= fake_encoder

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







from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_snake_case				:   List[Any]     =				logging.get_logger(__name__)

_snake_case				:   int     =				{
    """YituTech/conv-bert-base""": """https://huggingface.co/YituTech/conv-bert-base/resolve/main/config.json""",
    """YituTech/conv-bert-medium-small""": (
        """https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/config.json"""
    ),
    """YituTech/conv-bert-small""": """https://huggingface.co/YituTech/conv-bert-small/resolve/main/config.json""",
    # See all ConvBERT models at https://huggingface.co/models?filter=convbert
}


class 			lowerCAmelCase (				__UpperCAmelCase			):
		a							:					Tuple       =					"""convbert"""




		def __init__(				self					,						UpperCamelCase=30_522					,						UpperCamelCase=768					,						UpperCamelCase=12					,						UpperCamelCase=12					,						UpperCamelCase=3_072					,						UpperCamelCase="gelu"					,						UpperCamelCase=0.1					,						UpperCamelCase=0.1					,						UpperCamelCase=512					,						UpperCamelCase=2					,						UpperCamelCase=0.02					,						UpperCamelCase=1e-12					,						UpperCamelCase=1					,						UpperCamelCase=0					,						UpperCamelCase=2					,						UpperCamelCase=768					,						UpperCamelCase=2					,						UpperCamelCase=9					,						UpperCamelCase=1					,						UpperCamelCase=None					,						**UpperCamelCase					,						):
								super().__init__(
								    pad_token_id=UpperCamelCase					,						bos_token_id=UpperCamelCase					,						eos_token_id=UpperCamelCase					,						**UpperCamelCase					,						)

								_SCREAMING_SNAKE_CASE				= vocab_size
								_SCREAMING_SNAKE_CASE				= hidden_size
								_SCREAMING_SNAKE_CASE				= num_hidden_layers
								_SCREAMING_SNAKE_CASE				= num_attention_heads
								_SCREAMING_SNAKE_CASE				= intermediate_size
								_SCREAMING_SNAKE_CASE				= hidden_act
								_SCREAMING_SNAKE_CASE				= hidden_dropout_prob
								_SCREAMING_SNAKE_CASE				= attention_probs_dropout_prob
								_SCREAMING_SNAKE_CASE				= max_position_embeddings
								_SCREAMING_SNAKE_CASE				= type_vocab_size
								_SCREAMING_SNAKE_CASE				= initializer_range
								_SCREAMING_SNAKE_CASE				= layer_norm_eps
								_SCREAMING_SNAKE_CASE				= embedding_size
								_SCREAMING_SNAKE_CASE				= head_ratio
								_SCREAMING_SNAKE_CASE				= conv_kernel_size
								_SCREAMING_SNAKE_CASE				= num_groups
								_SCREAMING_SNAKE_CASE				= classifier_dropout


class 			lowerCAmelCase (				__UpperCAmelCase			):




		@property
		def     lowercase       (				self      ):
								if self.task == "multiple-choice":
														_SCREAMING_SNAKE_CASE				= {0: "batch", 1: "choice", 2: "sequence"}
								else:
														_SCREAMING_SNAKE_CASE				= {0: "batch", 1: "sequence"}
								return OrderedDict(
								    [
								        ("input_ids", dynamic_axis),
								        ("attention_mask", dynamic_axis),
								        ("token_type_ids", dynamic_axis),
								    ]      )