






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 :    List[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  __lowercase :







     '''simple docstring'''
     SCREAMING_SNAKE_CASE				  =			None
     SCREAMING_SNAKE_CASE				  =			()
     SCREAMING_SNAKE_CASE				  =			()
     SCREAMING_SNAKE_CASE				  =			True
     SCREAMING_SNAKE_CASE				  =			True
     SCREAMING_SNAKE_CASE				  =			True
     SCREAMING_SNAKE_CASE				  =			False




     def 						lowerCAmelCase_       (			self    :     int	,		UpperCamelCase_    :     str	,		UpperCamelCase_    :     Union[str, Any]	,		UpperCamelCase_    :     Optional[Any]=False			):


         """simple docstring"""



         __A             =		copy.deepcopy(UpperCamelCase_			)

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

         if return_labels:
             if model_class in get_values(UpperCamelCase_			):
                 __A             =		tf.ones(self.model_tester.batch_size	,		dtype=tf.intaa			)
             elif model_class in get_values(UpperCamelCase_			):
                 __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(UpperCamelCase_			),
                 *get_values(UpperCamelCase_			),
             ]:
                 __A             =		tf.zeros(self.model_tester.batch_size	,		dtype=tf.intaa			)
             elif model_class in get_values(UpperCamelCase_			):
                 __A             =		tf.zeros(self.model_tester.batch_size	,		dtype=tf.intaa			)
             elif model_class in [
                 *get_values(UpperCamelCase_			),
                 *get_values(UpperCamelCase_			),
                 *get_values(UpperCamelCase_			),
                 *get_values(UpperCamelCase_			),
                 *get_values(UpperCamelCase_			),
             ]:
                 __A             =		tf.zeros(
                     (self.model_tester.batch_size, self.model_tester.seq_length)	,		dtype=tf.intaa			)
         return inputs_dict




     @slow
     def 						lowerCAmelCase_       (			self    :     Optional[Any]			):


         """simple docstring"""



         __A      ,		__A             =		self.model_tester.prepare_config_and_inputs_for_common()
         for model_class in self.all_model_classes[:2]:
             __A             =		self._prepare_for_class(UpperCamelCase_	,		UpperCamelCase_			)
             __A             =		model_class(UpperCamelCase_			)

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

             __A             =		run_in_graph_mode()
             self.assertIsNotNone(UpperCamelCase_			)




     @slow
     def 						lowerCAmelCase_       (			self    :     List[Any]			):


         """simple docstring"""



         __A      ,		__A             =		self.model_tester.prepare_config_and_inputs_for_common()
         for model_class in self.all_model_classes[:2]:
             __A             =		self._prepare_for_class(UpperCamelCase_	,		UpperCamelCase_			)
             __A             =		model_class(UpperCamelCase_			)

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

             __A             =		run_in_graph_mode()
             self.assertIsNotNone(UpperCamelCase_			)




     @slow
     def 						lowerCAmelCase_       (			self    :     Tuple			):


         """simple docstring"""



         __A      ,		__A             =		self.model_tester.prepare_config_and_inputs_for_common()
         for model_class in self.all_model_classes[:2]:
             __A             =		model_class(UpperCamelCase_			)
             if getattr(UpperCamelCase_	,		"""hf_compute_loss"""	,		UpperCamelCase_			):
                 # Test that model correctly compute the loss with kwargs
                 __A             =		self._prepare_for_class(inputs_dict.copy()	,		UpperCamelCase_	,		return_labels=UpperCamelCase_			)
                 # 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(UpperCamelCase_			)			)
                 self.assertGreater(len(UpperCamelCase_			)	,		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(UpperCamelCase_			)	,		0			)

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

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

                 __A             =		history.history["""loss"""][0]
                 self.assertTrue(not isnan(UpperCamelCase_			)			)
                 __A             =		history.history["""val_loss"""][0]
                 self.assertTrue(not isnan(UpperCamelCase_			)			)




     @slow
     def 						lowerCAmelCase_       (			self    :     Optional[Any]			):


         """simple docstring"""



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

         if hasattr(UpperCamelCase_	,		"""use_cache"""			):
             __A             =		True

         __A             =		getattr(self.model_tester	,		"""encoder_seq_length"""	,		self.model_tester.seq_length			)
         __A             =		getattr(self.model_tester	,		"""key_length"""	,		UpperCamelCase_			)

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

             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(UpperCamelCase_	,		saved_model=UpperCamelCase_			)
                 __A             =		os.path.join(UpperCamelCase_	,		"""saved_model"""	,		"""1"""			)
                 __A             =		tf.keras.models.load_model(UpperCamelCase_			)
                 __A             =		model(UpperCamelCase_			)

                 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(UpperCamelCase_			)	,		UpperCamelCase_			)

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

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

                 self.assertEqual(len(UpperCamelCase_			)	,		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    :     Any			):


         """simple docstring"""



         tf.keras.mixed_precision.set_global_policy("""mixed_float16"""			)

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

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




     @slow
     def 						lowerCAmelCase_       (			self    :     Any			):


         """simple docstring"""



         __A      ,		__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(UpperCamelCase_			)
             if module_member_name.endswith("""MainLayer"""			)
             for module_member in (getattr(UpperCamelCase_	,		UpperCamelCase_			),)
             if isinstance(UpperCamelCase_	,		UpperCamelCase_			)
             and tf.keras.layers.Layer in module_member.__bases__
             and getattr(UpperCamelCase_	,		"""_keras_serializable"""	,		UpperCamelCase_			)
         }

         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(UpperCamelCase_	,		embed_tokens=UpperCamelCase_			)
             else:
                 __A             =		main_layer_class(UpperCamelCase_			)

             __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(UpperCamelCase_			)[0]
             __A             =		tf.keras.layers.Dense(UpperCamelCase_	,		activation="""softmax"""	,		name="""outputs"""			)(UpperCamelCase_			)
             __A             =		tf.keras.models.Model(inputs=UpperCamelCase_	,		outputs=[outputs]			)

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

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




     @slow
     def 						lowerCAmelCase_       (			self    :     str			):


         """simple docstring"""



         __A      ,		__A             =		self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes[:2]:
             __A             =		model_class(UpperCamelCase_			)

             __A             =		copy.deepcopy(UpperCamelCase_			)

             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"""	,		UpperCamelCase_			)
                 del inputs["input_ids"]
                 inputs.pop("""decoder_input_ids"""	,		UpperCamelCase_			)

             if not self.is_encoder_decoder:
                 __A             =		model.get_input_embeddings()(UpperCamelCase_			)
             else:
                 __A             =		model.get_input_embeddings()(UpperCamelCase_			)
                 __A             =		model.get_input_embeddings()(UpperCamelCase_			)

             __A             =		self._prepare_for_class(UpperCamelCase_	,		UpperCamelCase_			)

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

             __A             =		run_in_graph_mode()
             self.assertIsNotNone(UpperCamelCase_			)




     def 						lowerCAmelCase_       (			self    :     Tuple	,		UpperCamelCase_    :     Dict	,		UpperCamelCase_    :     str			):


         """simple docstring"""



         __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(UpperCamelCase_			) < 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(UpperCamelCase_			)
         return bad_tokens




     def 						lowerCAmelCase_       (			self    :     Dict	,		UpperCamelCase_    :     int			):


         """simple docstring"""



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





     def 						lowerCAmelCase_       (			self    :     List[Any]	,		UpperCamelCase_    :     Optional[int]	,		UpperCamelCase_    :     Union[str, Any]			):


         """simple docstring"""



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












def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int     ,			__lowercase				:     int      )  -> int:





    """simple docstring"""

    __A             =		1.0
    for i in range(1     ,			r + 1      ):
        ret *= (n + 1 - i) / i
    return round(__lowercase      )



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int      )  -> int:





    """simple docstring"""

    return choose(8 + n     ,			__lowercase      ) + choose(9 + n     ,			__lowercase      ) - 1_0



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int      )  -> int:





    """simple docstring"""

    return sum(non_bouncy_exact(__lowercase      ) for i in range(1     ,			n + 1      )      )



def      _SCREAMING_SNAKE_CASE  (	__lowercase				:     int = 1_0_0      )  -> int:





    """simple docstring"""

    return non_bouncy_upto(__lowercase      )


if __name__ == "__main__":
  print(f"""{solution() = }""")




