



'''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:
												A__						:						List[Any]          =      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)]
																								)
																								A__						:						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        __snake_case		:
							_a       =				None
							_a       =				()
							_a       =				()
							_a       =				True
							_a       =				True
							_a       =				True
							_a       =				False




							def      UpperCAmelCase__    ( self  : Any       ,       A_  : List[str]       ,       A_  : int       ,       A_  : int=False):
									lowerCAmelCase_    :  List[str]             =				copy.deepcopy(A_)

									if model_class in get_values(A_):
											lowerCAmelCase_    :  Union[str, Any]             =				{
											    k: tf.tile(tf.expand_dims(A_       ,       1)       ,       (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1))
											    if isinstance(A_       ,       tf.Tensor) and v.ndim > 0
											    else v
											    for k, v in inputs_dict.items()
											}

									if return_labels:
											if model_class in get_values(A_):
													lowerCAmelCase_    :  str             =				tf.ones(self.model_tester.batch_size       ,       dtype=tf.intaa)
											elif model_class in get_values(A_):
													lowerCAmelCase_    :  str             =				tf.zeros(self.model_tester.batch_size       ,       dtype=tf.intaa)
													lowerCAmelCase_    :  Union[str, Any]             =				tf.zeros(self.model_tester.batch_size       ,       dtype=tf.intaa)
											elif model_class in [
											    *get_values(A_),
											    *get_values(A_),
											]:
													lowerCAmelCase_    :  List[str]             =				tf.zeros(self.model_tester.batch_size       ,       dtype=tf.intaa)
											elif model_class in get_values(A_):
													lowerCAmelCase_    :  List[Any]             =				tf.zeros(self.model_tester.batch_size       ,       dtype=tf.intaa)
											elif model_class in [
											    *get_values(A_),
											    *get_values(A_),
											    *get_values(A_),
											    *get_values(A_),
											    *get_values(A_),
											]:
													lowerCAmelCase_    :  Optional[int]             =				tf.zeros(
													    (self.model_tester.batch_size, self.model_tester.seq_length)       ,       dtype=tf.intaa)
									return inputs_dict




							@slow
							def      UpperCAmelCase__    ( self  : int):
									lowerCAmelCase_    :  Optional[Any]             =				self.model_tester.prepare_config_and_inputs_for_common()
									for model_class in self.all_model_classes[:2]:
											lowerCAmelCase_    :  str             =				self._prepare_for_class(A_       ,       A_)
											lowerCAmelCase_    :  Optional[Any]             =				model_class(A_)

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

											lowerCAmelCase_    :  int             =				run_in_graph_mode()
											self.assertIsNotNone(A_)




							@slow
							def      UpperCAmelCase__    ( self  : List[str]):
									lowerCAmelCase_    :  Dict             =				self.model_tester.prepare_config_and_inputs_for_common()
									for model_class in self.all_model_classes[:2]:
											lowerCAmelCase_    :  List[Any]             =				self._prepare_for_class(A_       ,       A_)
											lowerCAmelCase_    :  int             =				model_class(A_)

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

											lowerCAmelCase_    :  List[Any]             =				run_in_graph_mode()
											self.assertIsNotNone(A_)




							@slow
							def      UpperCAmelCase__    ( self  : Union[str, Any]):
									lowerCAmelCase_    :  Optional[int]             =				self.model_tester.prepare_config_and_inputs_for_common()
									for model_class in self.all_model_classes[:2]:
											lowerCAmelCase_    :  Dict             =				model_class(A_)
											if getattr(A_       ,       '''hf_compute_loss'''       ,       A_):
													# Test that model correctly compute the loss with kwargs
													lowerCAmelCase_    :  Dict             =				self._prepare_for_class(inputs_dict.copy()       ,       A_       ,       return_labels=A_)
													# Is there a better way to remove these decoder inputs?
													lowerCAmelCase_    :  Optional[Any]             =				{
													    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''')
													}

													lowerCAmelCase_    :  int             =				{
													    '''labels''',
													    '''label''',
													    '''label_ids''',
													    '''start_positions''',
													    '''start_position''',
													    '''end_positions''',
													    '''end_position''',
													    '''next_sentence_label''',
													}
													lowerCAmelCase_    :  List[Any]             =				possible_label_cols.intersection(set(A_))
													self.assertGreater(len(A_)       ,       0       ,       msg='''No matching label names found!''')
													lowerCAmelCase_    :  Union[str, Any]             =				{key: val for key, val in prepared_for_class.items() if key in label_names}
													lowerCAmelCase_    :  List[Any]             =				{key: val for key, val in prepared_for_class.items() if key not in label_names}
													self.assertGreater(len(A_)       ,       0)

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

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

													lowerCAmelCase_    :  int             =				history.history['''loss'''][0]
													self.assertTrue(not isnan(A_))
													lowerCAmelCase_    :  Any             =				history.history['''val_loss'''][0]
													self.assertTrue(not isnan(A_))




							@slow
							def      UpperCAmelCase__    ( self  : Tuple):
									lowerCAmelCase_    :  Dict             =				self.model_tester.prepare_config_and_inputs_for_common()
									lowerCAmelCase_    :  Any             =				True
									lowerCAmelCase_    :  Dict             =				True

									if hasattr(A_       ,       '''use_cache'''):
											lowerCAmelCase_    :  Optional[Any]             =				True

									lowerCAmelCase_    :  Union[str, Any]             =				getattr(self.model_tester       ,       '''encoder_seq_length'''       ,       self.model_tester.seq_length)
									lowerCAmelCase_    :  List[Any]             =				getattr(self.model_tester       ,       '''key_length'''       ,       A_)

									for model_class in self.all_model_classes[:2]:
											lowerCAmelCase_    :  Any             =				self._prepare_for_class(A_       ,       A_)
											lowerCAmelCase_    :  Union[str, Any]             =				model_class(A_)
											model.build()
											lowerCAmelCase_    :  Union[str, Any]             =				len(model(A_))

											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:
															lowerCAmelCase_    :  Union[str, Any]             =				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(A_       ,       saved_model=A_)
													lowerCAmelCase_    :  List[str]             =				os.path.join(A_       ,       '''saved_model'''       ,       '''1''')
													lowerCAmelCase_    :  int             =				tf.keras.models.load_model(A_)
													lowerCAmelCase_    :  Optional[Any]             =				model(A_)

													if self.is_encoder_decoder:
															lowerCAmelCase_    :  str             =				outputs['''encoder_hidden_states''']
															lowerCAmelCase_    :  str             =				outputs['''encoder_attentions''']
													else:
															lowerCAmelCase_    :  Optional[int]             =				outputs['''hidden_states''']
															lowerCAmelCase_    :  Tuple             =				outputs['''attentions''']

													self.assertEqual(len(A_)       ,       A_)

													lowerCAmelCase_    :  Dict             =				getattr(
													    self.model_tester       ,       '''expected_num_hidden_layers'''       ,       self.model_tester.num_hidden_layers + 1)

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

													self.assertEqual(len(A_)       ,       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      UpperCAmelCase__    ( self  : Optional[Any]):
									tf.keras.mixed_precision.set_global_policy('''mixed_float16''')

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

													self.assertIsNotNone(A_)
									finally:
											tf.keras.mixed_precision.set_global_policy('''float32''')




							@slow
							def      UpperCAmelCase__    ( self  : Union[str, Any]):
									lowerCAmelCase_    :  Dict             =				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"]
									lowerCAmelCase_    :  str             =				{
									    module_member
									    for model_class in self.all_model_classes
									    for module in (import_module(model_class.__module__),)
									    for module_member_name in dir(A_)
									    if module_member_name.endswith('''MainLayer''')
									    for module_member in (getattr(A_       ,       A_),)
									    if isinstance(A_       ,       A_)
									    and tf.keras.layers.Layer in module_member.__bases__
									    and getattr(A_       ,       '''_keras_serializable'''       ,       A_)
									}

									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
													lowerCAmelCase_    :  Tuple             =				TFSharedEmbeddings(self.model_tester.vocab_size       ,       self.model_tester.hidden_size       ,       name='''shared''')
													lowerCAmelCase_    :  List[Any]             =				False
													lowerCAmelCase_    :  Any             =				main_layer_class(A_       ,       embed_tokens=A_)
											else:
													lowerCAmelCase_    :  Optional[Any]             =				main_layer_class(A_)

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

											if hasattr(self.model_tester       ,       '''num_labels'''):
													lowerCAmelCase_    :  Optional[Any]             =				self.model_tester.num_labels
											else:
													lowerCAmelCase_    :  Tuple             =				2

											lowerCAmelCase_    :  Optional[int]             =				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)

											lowerCAmelCase_    :  Union[str, Any]             =				main_layer(A_)[0]
											lowerCAmelCase_    :  str             =				tf.keras.layers.Dense(A_       ,       activation='''softmax'''       ,       name='''outputs''')(A_)
											lowerCAmelCase_    :  Dict             =				tf.keras.models.Model(inputs=A_       ,       outputs=[outputs])

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

											with tempfile.TemporaryDirectory() as tmpdirname:
													lowerCAmelCase_    :  Optional[int]             =				os.path.join(A_       ,       '''keras_model.h5''')
													model.save(A_)
													if "T5" in main_layer_class.__name__:
															lowerCAmelCase_    :  Optional[Any]             =				tf.keras.models.load_model(
															    A_       ,       custom_objects={
															        main_layer_class.__name__: main_layer_class,
															        '''TFSharedEmbeddings''': TFSharedEmbeddings,
															    }       ,       )
													else:
															lowerCAmelCase_    :  Tuple             =				tf.keras.models.load_model(
															    A_       ,       custom_objects={main_layer_class.__name__: main_layer_class})
													assert isinstance(A_       ,       tf.keras.Model)
													model(A_)




							@slow
							def      UpperCAmelCase__    ( self  : Dict):
									lowerCAmelCase_    :  Optional[Any]             =				self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes[:2]:
											lowerCAmelCase_    :  int             =				model_class(A_)

											lowerCAmelCase_    :  Tuple             =				copy.deepcopy(A_)

											if not self.is_encoder_decoder:
													lowerCAmelCase_    :  List[str]             =				inputs['''input_ids''']
													del inputs["input_ids"]
											else:
													lowerCAmelCase_    :  Union[str, Any]             =				inputs['''input_ids''']
													lowerCAmelCase_    :  List[Any]             =				inputs.get('''decoder_input_ids'''       ,       A_)
													del inputs["input_ids"]
													inputs.pop('''decoder_input_ids'''       ,       A_)

											if not self.is_encoder_decoder:
													lowerCAmelCase_    :  str             =				model.get_input_embeddings()(A_)
											else:
													lowerCAmelCase_    :  Dict             =				model.get_input_embeddings()(A_)
													lowerCAmelCase_    :  str             =				model.get_input_embeddings()(A_)

											lowerCAmelCase_    :  List[str]             =				self._prepare_for_class(A_       ,       A_)

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

											lowerCAmelCase_    :  int             =				run_in_graph_mode()
											self.assertIsNotNone(A_)




							def      UpperCAmelCase__    ( self  : Any       ,       A_  : str       ,       A_  : str):
									lowerCAmelCase_    :  Dict             =				[]
									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
									lowerCAmelCase_    :  Optional[Any]             =				[]
									while len(A_) < num_bad_tokens:
											lowerCAmelCase_    :  Dict             =				tf.squeeze(ids_tensor((1, 1)       ,       self.model_tester.vocab_size)       ,       0).numpy()[0]
											if token not in special_tokens:
													bad_tokens.append(A_)
									return bad_tokens




							def      UpperCAmelCase__    ( self  : str       ,       A_  : Tuple):



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







							def      UpperCAmelCase__    ( self  : Optional[int]       ,       A_  : List[str]       ,       A_  : Optional[int]):



									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(A_)       ,       len(A_)):
															# if tokens match
															if generated_ids_slice[i - len(A_) : i] == bad_word_ids:
																	return True
									return False










from __future__ import annotations

A__						:						Tuple          =      '''Alexander Joslin'''


def     UpperCamelCase(						__UpperCamelCase							:	int				):

		if number <= 0:
				lowerCAmelCase_    :  str             =				f"""n must be greater than 0. Got n = {number}"""
				raise ValueError(__UpperCamelCase				)

		lowerCAmelCase_    :  str             =				[number + 1] * (number + 1)

		# starting position
		lowerCAmelCase_    :  List[Any]             =				0
		for i in range(1  ,__UpperCamelCase				):
				lowerCAmelCase_    :  int             =				min(table[i + 1]  ,table[i] + 1				)
				# check if out of bounds
				if i * 2 <= number:
						lowerCAmelCase_    :  Union[str, Any]             =				min(table[i * 2]  ,table[i] + 1				)
				# check if out of bounds
				if i * 3 <= number:
						lowerCAmelCase_    :  Union[str, Any]             =				min(table[i * 3]  ,table[i] + 1				)
		return table[number]


if __name__ == "__main__":
						import doctest

						doctest.testmod()





