


'''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__:   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)]
            )
            A__:   int    =	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 A__	:
      __UpperCamelCase	:  List[str]     	=							None
      __UpperCamelCase	:  Dict     	=							()
      __UpperCamelCase	:  Union[str, Any]     	=							()
      __UpperCamelCase	:  Optional[int]     	=							True
      __UpperCamelCase	:  Optional[int]     	=							True
      __UpperCamelCase	:  Optional[int]     	=							True
      __UpperCamelCase	:  List[Any]     	=							False






      def __UpperCAmelCase	(			self      :Union[str, Any]					,						SCREAMING_SNAKE_CASE      :Optional[int]					,						SCREAMING_SNAKE_CASE      :Dict					,						SCREAMING_SNAKE_CASE      :int=False     )	-> dict:




             '''simple docstring'''
             _a   :			str					 =copy.deepcopy(snake_case_     )

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

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






      @slow
      def __UpperCAmelCase	(			self      :List[Any]     )	-> List[Any]:




             '''simple docstring'''
             _a ,   _a   :			Any					 =self.model_tester.prepare_config_and_inputs_for_common()
             for model_class in self.all_model_classes[:2]:
                    _a   :			Optional[int]					 =self._prepare_for_class(snake_case_					,						snake_case_     )
                    _a   :			Optional[int]					 =model_class(snake_case_     )

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

                    _a   :			Optional[Any]					 =run_in_graph_mode()
                    self.assertIsNotNone(snake_case_     )






      @slow
      def __UpperCAmelCase	(			self      :Optional[int]     )	-> int:




             '''simple docstring'''
             _a ,   _a   :			Dict					 =self.model_tester.prepare_config_and_inputs_for_common()
             for model_class in self.all_model_classes[:2]:
                    _a   :			List[str]					 =self._prepare_for_class(snake_case_					,						snake_case_     )
                    _a   :			str					 =model_class(snake_case_     )

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

                    _a   :			Dict					 =run_in_graph_mode()
                    self.assertIsNotNone(snake_case_     )






      @slow
      def __UpperCAmelCase	(			self      :str     )	-> List[Any]:




             '''simple docstring'''
             # This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
             _a ,   _a   :			Tuple					 =self.model_tester.prepare_config_and_inputs_for_common()
             for model_class in self.all_model_classes[:2]:
                    _a   :			Union[str, Any]					 =model_class(snake_case_     )
                    if getattr(snake_case_					,						"""hf_compute_loss"""					,						snake_case_     ):
                           # Test that model correctly compute the loss with kwargs
                           _a   :			List[Any]					 =self._prepare_for_class(inputs_dict.copy()					,						snake_case_					,						return_labels=snake_case_     )
                           # Is there a better way to remove these decoder inputs?
                           _a   :			int					 ={
                               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   :			Any					 ={
                               """labels""",
                               """label""",
                               """label_ids""",
                               """start_positions""",
                               """start_position""",
                               """end_positions""",
                               """end_position""",
                               """next_sentence_label""",
                           }
                           _a   :			List[str]					 =possible_label_cols.intersection(set(snake_case_     )     )
                           self.assertGreater(len(snake_case_     )					,						0					,						msg="""No matching label names found!"""     )
                           _a   :			Optional[int]					 ={key: val for key, val in prepared_for_class.items() if key in label_names}
                           _a   :			Dict					 ={key: val for key, val in prepared_for_class.items() if key not in label_names}
                           self.assertGreater(len(snake_case_     )					,						0     )

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

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

                           _a   :			Any					 =history.history["""loss"""][0]
                           self.assertTrue(not isnan(snake_case_     )     )
                           _a   :			Optional[int]					 =history.history["""val_loss"""][0]
                           self.assertTrue(not isnan(snake_case_     )     )






      @slow
      def __UpperCAmelCase	(			self      :Optional[int]     )	-> int:




             '''simple docstring'''
             _a ,   _a   :			int					 =self.model_tester.prepare_config_and_inputs_for_common()
             _a   :			Any					 =True
             _a   :			Tuple					 =True

             if hasattr(snake_case_					,						"""use_cache"""     ):
                    _a   :			Dict					 =True

             _a   :			Optional[Any]					 =getattr(self.model_tester					,						"""encoder_seq_length"""					,						self.model_tester.seq_length     )
             _a   :			str					 =getattr(self.model_tester					,						"""key_length"""					,						snake_case_     )

             for model_class in self.all_model_classes[:2]:
                    _a   :			Optional[int]					 =self._prepare_for_class(snake_case_					,						snake_case_     )
                    _a   :			Dict					 =model_class(snake_case_     )
                    model.build()
                    _a   :			List[str]					 =len(model(snake_case_     )     )

                    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   :			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(snake_case_					,						saved_model=snake_case_     )
                           _a   :			List[Any]					 =os.path.join(snake_case_					,						"""saved_model"""					,						"""1"""     )
                           _a   :			Tuple					 =tf.keras.models.load_model(snake_case_     )
                           _a   :			Union[str, Any]					 =model(snake_case_     )

                           if self.is_encoder_decoder:
                                  _a   :			List[Any]					 =outputs["""encoder_hidden_states"""]
                                  _a   :			Union[str, Any]					 =outputs["""encoder_attentions"""]
                           else:
                                  _a   :			Dict					 =outputs["""hidden_states"""]
                                  _a   :			int					 =outputs["""attentions"""]

                           self.assertEqual(len(snake_case_     )					,						snake_case_     )

                           _a   :			Any					 =getattr(
                               self.model_tester					,						"""expected_num_hidden_layers"""					,						self.model_tester.num_hidden_layers + 1     )

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

                           self.assertEqual(len(snake_case_     )					,						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      :List[str]     )	-> str:




             '''simple docstring'''
             tf.keras.mixed_precision.set_global_policy("""mixed_float16"""     )

             # try/finally block to ensure subsequent tests run in float32
             try:
                    _a ,   _a   :			Union[str, Any]					 =self.model_tester.prepare_config_and_inputs_for_common()
                    for model_class in self.all_model_classes[:2]:
                           _a   :			Union[str, Any]					 =self._prepare_for_class(snake_case_					,						snake_case_     )
                           _a   :			Optional[Any]					 =model_class(snake_case_     )
                           _a   :			Optional[int]					 =model(snake_case_     )

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






      @slow
      def __UpperCAmelCase	(			self      :Union[str, Any]     )	-> Optional[int]:




             '''simple docstring'''
             _a ,   _a   :			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"]
             _a   :			Any					 ={
                 module_member
                 for model_class in self.all_model_classes
                 for module in (import_module(model_class.__module__     ),)
                 for module_member_name in dir(snake_case_     )
                 if module_member_name.endswith("""MainLayer"""     )
                 for module_member in (getattr(snake_case_					,						snake_case_     ),)
                 if isinstance(snake_case_					,						snake_case_     )
                 and tf.keras.layers.Layer in module_member.__bases__
                 and getattr(snake_case_					,						"""_keras_serializable"""					,						snake_case_     )
             }

             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   :			Optional[Any]					 =TFSharedEmbeddings(self.model_tester.vocab_size					,						self.model_tester.hidden_size					,						name="""shared"""     )
                           _a   :			Tuple					 =False
                           _a   :			Optional[int]					 =main_layer_class(snake_case_					,						embed_tokens=snake_case_     )
                    else:
                           _a   :			Dict					 =main_layer_class(snake_case_     )

                    _a   :			Dict					 ={
                        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   :			Optional[Any]					 =self.model_tester.num_labels
                    else:
                           _a   :			str					 =2

                    _a   :			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     )

                    _a   :			Optional[int]					 =main_layer(snake_case_     )[0]
                    _a   :			str					 =tf.keras.layers.Dense(snake_case_					,						activation="""softmax"""					,						name="""outputs"""     )(snake_case_     )
                    _a   :			List[str]					 =tf.keras.models.Model(inputs=snake_case_					,						outputs=[outputs]     )

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

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






      @slow
      def __UpperCAmelCase	(			self      :Tuple     )	-> str:




             '''simple docstring'''
             _a ,   _a   :			Tuple					 =self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes[:2]:
                    _a   :			List[str]					 =model_class(snake_case_     )

                    _a   :			Optional[int]					 =copy.deepcopy(snake_case_     )

                    if not self.is_encoder_decoder:
                           _a   :			List[str]					 =inputs["""input_ids"""]
                           del inputs["input_ids"]
                    else:
                           _a   :			int					 =inputs["""input_ids"""]
                           _a   :			int					 =inputs.get("""decoder_input_ids"""					,						snake_case_     )
                           del inputs["input_ids"]
                           inputs.pop("""decoder_input_ids"""					,						snake_case_     )

                    if not self.is_encoder_decoder:
                           _a   :			Any					 =model.get_input_embeddings()(snake_case_     )
                    else:
                           _a   :			Any					 =model.get_input_embeddings()(snake_case_     )
                           _a   :			Optional[int]					 =model.get_input_embeddings()(snake_case_     )

                    _a   :			Optional[Any]					 =self._prepare_for_class(snake_case_					,						snake_case_     )

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

                    _a   :			str					 =run_in_graph_mode()
                    self.assertIsNotNone(snake_case_     )






      def __UpperCAmelCase	(			self      :Optional[int]					,						SCREAMING_SNAKE_CASE      :Dict					,						SCREAMING_SNAKE_CASE      :Optional[Any]     )	-> Union[str, Any]:




             '''simple docstring'''
             # special tokens cannot be bad tokens
             _a   :			Union[str, Any]					 =[]
             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   :			Tuple					 =[]
             while len(snake_case_     ) < num_bad_tokens:
                    _a   :			List[str]					 =tf.squeeze(ids_tensor((1, 1)					,						self.model_tester.vocab_size     )					,						0     ).numpy()[0]
                    if token not in special_tokens:
                           bad_tokens.append(snake_case_     )
             return bad_tokens






      def __UpperCAmelCase	(			self      :int					,						SCREAMING_SNAKE_CASE      :List[Any]     )	-> Optional[Any]:




             '''simple docstring'''
             for token_id in output_ids[0].numpy().tolist():
                    self.assertGreaterEqual(snake_case_					,						0     )
                    self.assertLess(snake_case_					,						self.model_tester.vocab_size     )






      def __UpperCAmelCase	(			self      :Optional[int]					,						SCREAMING_SNAKE_CASE      :Union[str, Any]					,						SCREAMING_SNAKE_CASE      :List[Any]     )	-> Any:




             '''simple docstring'''
             # for all bad word tokens
             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(snake_case_     )					,						len(snake_case_     )     ):
                                  # if tokens match
                                  if generated_ids_slice[i - len(snake_case_     ) : i] == bad_word_ids:
                                         return True
             return False






'''simple docstring'''







import math


def      SCREAMING_SNAKE_CASE_ (  _UpperCAmelCase     :     int  )  ->      int:
       return sum(int(_UpperCAmelCase  ) for digit in str(_UpperCAmelCase  )  )


def      SCREAMING_SNAKE_CASE_ (  _UpperCAmelCase     :     int = 30  )  ->      int:
       _a   :			List[Any]					 =[]
       for digit in range(2   ,100  ):
              for power in range(2   ,100  ):
                     _a   :			Optional[Any]					 =int(math.pow(_UpperCAmelCase   ,_UpperCAmelCase  )  )
                     if digit == digit_sum(_UpperCAmelCase  ):
                            digit_to_powers.append(_UpperCAmelCase  )

       digit_to_powers.sort()
       return digit_to_powers[n - 1]


if __name__ == "__main__":
   print(solution())


