





"""simple docstring"""
from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
		import numpy as np
		import tensorflow as tf

		from transformers import (
		    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
		    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
		    TF_MODEL_FOR_MASKED_LM_MAPPING,
		    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
		    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
		    TF_MODEL_FOR_PRETRAINING_MAPPING,
		    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
		    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
		    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
		    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
		    TFSharedEmbeddings,
		)

		if _tf_gpu_memory_limit is not None:
				_snake_case					:		Dict							=			tf.config.list_physical_devices('GPU')
				for gpu in gpus:
						# Restrict TensorFlow to only allocate x GB of memory on the GPUs
						try:
								tf.config.set_logical_device_configuration(
								    gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
								)
								_snake_case					:		Optional[Any]							=			tf.config.list_logical_devices('GPU')
								print('Logical GPUs', logical_gpus)
						except RuntimeError as e:
								# Virtual devices must be set before GPUs have been initialized
								print(e)






@require_tf
class  _UpperCAmelCase      :
					UpperCamelCase								=							None
					UpperCamelCase								=							()
					UpperCamelCase								=							()
					UpperCamelCase								=							True
					UpperCamelCase								=							True
					UpperCamelCase								=							True
					UpperCamelCase								=							False


					def      lowerCamelCase	( self      :str					,	__UpperCamelCase      :Optional[int]					,	__UpperCamelCase      :List[Any]					,	__UpperCamelCase      :int=False		):
												A		=  copy.deepcopy(__lowerCamelCase		)

												if model_class in get_values(__lowerCamelCase		):
																			A		=  {
																			    k: tf.tile(tf.expand_dims(__lowerCamelCase					,	1		)					,	(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)		)
																			    if isinstance(__lowerCamelCase					,	tf.Tensor		) and v.ndim > 0
																			    else v
																			    for k, v in inputs_dict.items()
																			}

												if return_labels:
																			if model_class in get_values(__lowerCamelCase		):
																										A		=  tf.ones(self.model_tester.batch_size					,	dtype=tf.intaa		)
																			elif model_class in get_values(__lowerCamelCase		):
																										A		=  tf.zeros(self.model_tester.batch_size					,	dtype=tf.intaa		)
																										A		=  tf.zeros(self.model_tester.batch_size					,	dtype=tf.intaa		)
																			elif model_class in [
																			    *get_values(__lowerCamelCase		),
																			    *get_values(__lowerCamelCase		),
																			]:
																										A		=  tf.zeros(self.model_tester.batch_size					,	dtype=tf.intaa		)
																			elif model_class in get_values(__lowerCamelCase		):
																										A		=  tf.zeros(self.model_tester.batch_size					,	dtype=tf.intaa		)
																			elif model_class in [
																			    *get_values(__lowerCamelCase		),
																			    *get_values(__lowerCamelCase		),
																			    *get_values(__lowerCamelCase		),
																			    *get_values(__lowerCamelCase		),
																			    *get_values(__lowerCamelCase		),
																			]:
																										A		=  tf.zeros(
																										    (self.model_tester.batch_size, self.model_tester.seq_length)					,	dtype=tf.intaa		)
												return inputs_dict


					@slow
					def      lowerCamelCase	( self      :Dict		):
												A		=  self.model_tester.prepare_config_and_inputs_for_common()
												for model_class in self.all_model_classes[:2]:
																			A		=  self._prepare_for_class(__lowerCamelCase					,	__lowerCamelCase		)
																			A		=  model_class(__lowerCamelCase		)

																			@tf.function
																			def run_in_graph_mode():
																										return model(__lowerCamelCase		)

																			A		=  run_in_graph_mode()
																			self.assertIsNotNone(__lowerCamelCase		)


					@slow
					def      lowerCamelCase	( self      :Optional[Any]		):
												A		=  self.model_tester.prepare_config_and_inputs_for_common()
												for model_class in self.all_model_classes[:2]:
																			A		=  self._prepare_for_class(__lowerCamelCase					,	__lowerCamelCase		)
																			A		=  model_class(__lowerCamelCase		)

																			@tf.function(experimental_compile=__lowerCamelCase		)
																			def run_in_graph_mode():
																										return model(__lowerCamelCase		)

																			A		=  run_in_graph_mode()
																			self.assertIsNotNone(__lowerCamelCase		)


					@slow
					def      lowerCamelCase	( self      :Optional[Any]		):
												A		=  self.model_tester.prepare_config_and_inputs_for_common()
												for model_class in self.all_model_classes[:2]:
																			A		=  model_class(__lowerCamelCase		)
																			if getattr(__lowerCamelCase					,	"hf_compute_loss"					,	__lowerCamelCase		):
																										# Test that model correctly compute the loss with kwargs
																										A		=  self._prepare_for_class(inputs_dict.copy()					,	__lowerCamelCase					,	return_labels=__lowerCamelCase		)
																										# Is there a better way to remove these decoder inputs?
																										A		=  {
																										    key: val
																										    for key, val in prepared_for_class.items()
																										    if key not in ("head_mask", "decoder_head_mask", "cross_attn_head_mask", "decoder_input_ids")
																										}

																										A		=  {
																										    "labels",
																										    "label",
																										    "label_ids",
																										    "start_positions",
																										    "start_position",
																										    "end_positions",
																										    "end_position",
																										    "next_sentence_label",
																										}
																										A		=  possible_label_cols.intersection(set(__lowerCamelCase		)		)
																										self.assertGreater(len(__lowerCamelCase		)					,	0					,	msg="No matching label names found!"		)
																										A		=  {key: val for key, val in prepared_for_class.items() if key in label_names}
																										A		=  {key: val for key, val in prepared_for_class.items() if key not in label_names}
																										self.assertGreater(len(__lowerCamelCase		)					,	0		)

																										# Make sure it works with XLA!
																										model.compile(optimizer=tf.keras.optimizers.SGD(0.0		)					,	jit_compile=__lowerCamelCase		)
																										# Make sure the model fits without crashing regardless of where we pass the labels
																										A		=  model.fit(
																										    __lowerCamelCase					,	validation_data=__lowerCamelCase					,	steps_per_epoch=1					,	validation_steps=1					,	shuffle=__lowerCamelCase					,	verbose=0					,	)
																										A		=  history.history["loss"][0]
																										self.assertTrue(not isnan(__lowerCamelCase		)		)
																										A		=  history.history["val_loss"][0]
																										self.assertTrue(not isnan(__lowerCamelCase		)		)

																										# Now test it with separate labels, to make sure that path works in XLA too.
																										A		=  model_class(__lowerCamelCase		)
																										model.compile(optimizer=tf.keras.optimizers.SGD(0.0		)					,	jit_compile=__lowerCamelCase		)
																										A		=  model.fit(
																										    __lowerCamelCase					,	__lowerCamelCase					,	validation_data=(inputs_minus_labels, labels)					,	steps_per_epoch=1					,	validation_steps=1					,	shuffle=__lowerCamelCase					,	verbose=0					,	)

																										A		=  history.history["loss"][0]
																										self.assertTrue(not isnan(__lowerCamelCase		)		)
																										A		=  history.history["val_loss"][0]
																										self.assertTrue(not isnan(__lowerCamelCase		)		)


					@slow
					def      lowerCamelCase	( self      :Union[str, Any]		):
												A		=  self.model_tester.prepare_config_and_inputs_for_common()
												A		=  True
												A		=  True

												if hasattr(__lowerCamelCase					,	"use_cache"		):
																			A		=  True

												A		=  getattr(self.model_tester					,	"encoder_seq_length"					,	self.model_tester.seq_length		)
												A		=  getattr(self.model_tester					,	"key_length"					,	__lowerCamelCase		)

												for model_class in self.all_model_classes[:2]:
																			A		=  self._prepare_for_class(__lowerCamelCase					,	__lowerCamelCase		)
																			A		=  model_class(__lowerCamelCase		)
																			model.build()
																			A		=  len(model(__lowerCamelCase		)		)

																			for key in list(class_inputs_dict.keys()		):
																										# Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
																										if key not in model.input_signature:
																																	del class_inputs_dict[key]
																										# Check it's a tensor, in case the inputs dict has some bools in it too
																										elif isinstance(class_inputs_dict[key]					,	tf.Tensor		) and class_inputs_dict[key].dtype.is_integer:
																																	A		=  tf.cast(class_inputs_dict[key]					,	tf.intaa		)

																			if set(class_inputs_dict.keys()		) != set(model.input_signature.keys()		):
																										continue  # Some models have inputs that the preparation functions don't create, we skip those

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

																										if self.is_encoder_decoder:
																																	A		=  outputs["encoder_hidden_states"]
																																	A		=  outputs["encoder_attentions"]
																										else:
																																	A		=  outputs["hidden_states"]
																																	A		=  outputs["attentions"]

																										self.assertEqual(len(__lowerCamelCase		)					,	__lowerCamelCase		)

																										A		=  getattr(
																										    self.model_tester					,	"expected_num_hidden_layers"					,	self.model_tester.num_hidden_layers + 1		)

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

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


					@slow
					def      lowerCamelCase	( self      :Tuple		):
												tf.keras.mixed_precision.set_global_policy("mixed_float16"		)

												# try/finally block to ensure subsequent tests run in float32
												try:
																			A		=  self.model_tester.prepare_config_and_inputs_for_common()
																			for model_class in self.all_model_classes[:2]:
																										A		=  self._prepare_for_class(__lowerCamelCase					,	__lowerCamelCase		)
																										A		=  model_class(__lowerCamelCase		)
																										A		=  model(__lowerCamelCase		)

																										self.assertIsNotNone(__lowerCamelCase		)
												finally:
																			tf.keras.mixed_precision.set_global_policy("float32"		)


					@slow
					def      lowerCamelCase	( self      :Optional[Any]		):
												A		=  self.model_tester.prepare_config_and_inputs_for_common()
												# head_mask and decoder_head_mask has different shapes than other input args
												if "head_mask" in inputs_dict:
																			del inputs_dict["head_mask"]
												if "decoder_head_mask" in inputs_dict:
																			del inputs_dict["decoder_head_mask"]
												if "cross_attn_head_mask" in inputs_dict:
																			del inputs_dict["cross_attn_head_mask"]
												A		=  {
												    module_member
												    for model_class in self.all_model_classes
												    for module in (import_module(model_class.__module__		),)
												    for module_member_name in dir(__lowerCamelCase		)
												    if module_member_name.endswith("MainLayer"		)
												    for module_member in (getattr(__lowerCamelCase					,	__lowerCamelCase		),)
												    if isinstance(__lowerCamelCase					,	__lowerCamelCase		)
												    and tf.keras.layers.Layer in module_member.__bases__
												    and getattr(__lowerCamelCase					,	"_keras_serializable"					,	__lowerCamelCase		)
												}

												for main_layer_class in tf_main_layer_classes:
																			# T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
																			if "T5" in main_layer_class.__name__:
																										# Take the same values than in TFT5ModelTester for this shared layer
																										A		=  TFSharedEmbeddings(self.model_tester.vocab_size					,	self.model_tester.hidden_size					,	name="shared"		)
																										A		=  False
																										A		=  main_layer_class(__lowerCamelCase					,	embed_tokens=__lowerCamelCase		)
																			else:
																										A		=  main_layer_class(__lowerCamelCase		)

																			A		=  {
																			    name: tf.keras.Input(tensor.shape[1:]					,	dtype=tensor.dtype		) for name, tensor in inputs_dict.items()
																			}

																			if hasattr(self.model_tester					,	"num_labels"		):
																										A		=  self.model_tester.num_labels
																			else:
																										A		=  2

																			A		=  tf.data.Dataset.from_tensor_slices(
																			    (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)		))		).batch(1		)

																			A		=  main_layer(__lowerCamelCase		)[0]
																			A		=  tf.keras.layers.Dense(__lowerCamelCase					,	activation="softmax"					,	name="outputs"		)(__lowerCamelCase		)
																			A		=  tf.keras.models.Model(inputs=__lowerCamelCase					,	outputs=[outputs]		)

																			model.compile(loss="binary_crossentropy"					,	optimizer="adam"					,	metrics=["binary_accuracy"]		)
																			model.fit(__lowerCamelCase					,	epochs=1		)

																			with tempfile.TemporaryDirectory() as tmpdirname:
																										A		=  os.path.join(__lowerCamelCase					,	"keras_model.h5"		)
																										model.save(__lowerCamelCase		)
																										if "T5" in main_layer_class.__name__:
																																	A		=  tf.keras.models.load_model(
																																	    __lowerCamelCase					,	custom_objects={
																																	        main_layer_class.__name__: main_layer_class,
																																	        "TFSharedEmbeddings": TFSharedEmbeddings,
																																	    }					,	)
																										else:
																																	A		=  tf.keras.models.load_model(
																																	    __lowerCamelCase					,	custom_objects={main_layer_class.__name__: main_layer_class}		)
																										assert isinstance(__lowerCamelCase					,	tf.keras.Model		)
																										model(__lowerCamelCase		)


					@slow
					def      lowerCamelCase	( self      :Any		):
												A		=  self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes[:2]:
																			A		=  model_class(__lowerCamelCase		)

																			A		=  copy.deepcopy(__lowerCamelCase		)

																			if not self.is_encoder_decoder:
																										A		=  inputs["input_ids"]
																										del inputs["input_ids"]
																			else:
																										A		=  inputs["input_ids"]
																										A		=  inputs.get("decoder_input_ids"					,	__lowerCamelCase		)
																										del inputs["input_ids"]
																										inputs.pop("decoder_input_ids"					,	__lowerCamelCase		)

																			if not self.is_encoder_decoder:
																										A		=  model.get_input_embeddings()(__lowerCamelCase		)
																			else:
																										A		=  model.get_input_embeddings()(__lowerCamelCase		)
																										A		=  model.get_input_embeddings()(__lowerCamelCase		)

																			A		=  self._prepare_for_class(__lowerCamelCase					,	__lowerCamelCase		)

																			@tf.function
																			def run_in_graph_mode():
																										return model(__lowerCamelCase		)

																			A		=  run_in_graph_mode()
																			self.assertIsNotNone(__lowerCamelCase		)


					def      lowerCamelCase	( self      :Union[str, Any]					,	__UpperCamelCase      :List[str]					,	__UpperCamelCase      :Union[str, Any]		):
												A		=  []
												if model.config.bos_token_id is not None:
																			special_tokens.append(model.config.bos_token_id		)
												if model.config.pad_token_id is not None:
																			special_tokens.append(model.config.pad_token_id		)
												if model.config.eos_token_id is not None:
																			special_tokens.append(model.config.eos_token_id		)

												# create random bad tokens that are not special tokens
												A		=  []
												while len(__lowerCamelCase		) < num_bad_tokens:
																			A		=  tf.squeeze(ids_tensor((1, 1)					,	self.model_tester.vocab_size		)					,	0		).numpy()[0]
																			if token not in special_tokens:
																										bad_tokens.append(__lowerCamelCase		)
												return bad_tokens


					def      lowerCamelCase	( self      :str					,	__UpperCamelCase      :Optional[Any]		):


												for token_id in output_ids[0].numpy().tolist():
																			self.assertGreaterEqual(__lowerCamelCase					,	0		)
																			self.assertLess(__lowerCamelCase					,	self.model_tester.vocab_size		)


					def      lowerCamelCase	( self      :str					,	__UpperCamelCase      :Optional[int]					,	__UpperCamelCase      :Any		):


												for bad_word_ids in bad_words_ids:
																			# for all slices in batch
																			for generated_ids_slice in generated_ids:
																										# for all word idx
																										for i in range(len(__lowerCamelCase		)					,	len(__lowerCamelCase		)		):
																																	# if tokens match
																																	if generated_ids_slice[i - len(__lowerCamelCase		) : i] == bad_word_ids:
																																								return True
												return False









"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


_snake_case					:		Optional[int]							=			logging.get_logger(__name__)

_snake_case					:		List[Any]							=			{
    'ZinengTang/tvlt-base': 'https://huggingface.co/ZinengTang/tvlt-base/blob/main/config.json',
}






class  _UpperCAmelCase       (     lowercase_			):
					UpperCamelCase								=							'''tvlt'''


					def __init__( self      :Dict					,	__UpperCamelCase      :Tuple=2_24					,	__UpperCamelCase      :Dict=20_48					,	__UpperCamelCase      :Optional[Any]=1_28					,	__UpperCamelCase      :Optional[int]=[16, 16]					,	__UpperCamelCase      :Any=[16, 16]					,	__UpperCamelCase      :List[str]=3					,	__UpperCamelCase      :str=1					,	__UpperCamelCase      :List[str]=8					,	__UpperCamelCase      :str=7_68					,	__UpperCamelCase      :List[str]=12					,	__UpperCamelCase      :Tuple=12					,	__UpperCamelCase      :Union[str, Any]=30_72					,	__UpperCamelCase      :List[Any]="gelu"					,	__UpperCamelCase      :List[str]=0.0					,	__UpperCamelCase      :Union[str, Any]=0.0					,	__UpperCamelCase      :List[str]=0.02					,	__UpperCamelCase      :Dict=1e-6					,	__UpperCamelCase      :Any=True					,	__UpperCamelCase      :List[str]=False					,	__UpperCamelCase      :str=16					,	__UpperCamelCase      :List[str]=5_12					,	__UpperCamelCase      :int=8					,	__UpperCamelCase      :int=20_48					,	__UpperCamelCase      :int=0.75					,	__UpperCamelCase      :Tuple=0.15					,	__UpperCamelCase      :Optional[Any]="frame-level"					,	__UpperCamelCase      :int=True					,	__UpperCamelCase      :str=True					,	__UpperCamelCase      :Tuple="classification"					,	**__UpperCamelCase      :Any					,	):
												super().__init__(**__UpperCamelCase		)

												if audio_mask_type not in ("frame-level", "patch_level"):
																			raise ValueError(
																			    "audio_mask_type must be one of two acceptable strategies - {'frame_level', 'patch-level') "
																			    f"got {audio_mask_type}"		)

												A		=  image_size
												A		=  spectrogram_length
												A		=  frequency_length
												A		=  image_patch_size
												A		=  audio_patch_size
												A		=  num_image_channels
												A		=  num_audio_channels
												A		=  num_frames

												A		=  hidden_size
												A		=  num_hidden_layers
												A		=  num_attention_heads
												A		=  intermediate_size
												A		=  hidden_act
												A		=  hidden_dropout_prob
												A		=  attention_probs_dropout_prob
												A		=  initializer_range
												A		=  layer_norm_eps
												A		=  qkv_bias
												A		=  use_mean_pooling

												A		=  decoder_num_attention_heads
												A		=  decoder_hidden_size
												A		=  decoder_num_hidden_layers
												A		=  decoder_intermediate_size
												A		=  pixel_mask_ratio
												A		=  audio_mask_ratio
												A		=  audio_mask_type

												A		=  task_matching
												A		=  task_mae
												A		=  loss_type


