

"""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					 =				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					 =				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    _lowerCAmelCase    :







 """simple docstring"""







 __UpperCAmelCase      :   Any  						=      None
 __UpperCAmelCase      :   Tuple  						=      ()
 __UpperCAmelCase      :   Union[str, Any]  						=      ()
 __UpperCAmelCase      :   Tuple  						=      True
 __UpperCAmelCase      :   List[Any]  						=      True
 __UpperCAmelCase      :   int  						=      True
 __UpperCAmelCase      :   Optional[Any]  						=      False


 def    _lowercase					(     self				:     int,   UpperCAmelCase__				:     Dict,   UpperCAmelCase__				:     Tuple,   UpperCAmelCase__				:     List[str]=False      ):
    __lowercase								=		copy.deepcopy(__SCREAMING_SNAKE_CASE      )

    if model_class in get_values(__SCREAMING_SNAKE_CASE      ):
       __lowercase								=		{
           k: tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE,   1      ),   (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)      )
           if isinstance(__SCREAMING_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(__SCREAMING_SNAKE_CASE      ):
          __lowercase								=		tf.ones(self.model_tester.batch_size,   dtype=tf.intaa      )
       elif model_class in get_values(__SCREAMING_SNAKE_CASE      ):
          __lowercase								=		tf.zeros(self.model_tester.batch_size,   dtype=tf.intaa      )
          __lowercase								=		tf.zeros(self.model_tester.batch_size,   dtype=tf.intaa      )
       elif model_class in [
           *get_values(__SCREAMING_SNAKE_CASE      ),
           *get_values(__SCREAMING_SNAKE_CASE      ),
       ]:
          __lowercase								=		tf.zeros(self.model_tester.batch_size,   dtype=tf.intaa      )
       elif model_class in get_values(__SCREAMING_SNAKE_CASE      ):
          __lowercase								=		tf.zeros(self.model_tester.batch_size,   dtype=tf.intaa      )
       elif model_class in [
           *get_values(__SCREAMING_SNAKE_CASE      ),
           *get_values(__SCREAMING_SNAKE_CASE      ),
           *get_values(__SCREAMING_SNAKE_CASE      ),
           *get_values(__SCREAMING_SNAKE_CASE      ),
           *get_values(__SCREAMING_SNAKE_CASE      ),
       ]:
          __lowercase								=		tf.zeros(
              (self.model_tester.batch_size, self.model_tester.seq_length),   dtype=tf.intaa      )
    return inputs_dict


 @slow
 def    _lowercase					(     self				:     Optional[int]      ):
    __lowercase								=		self.model_tester.prepare_config_and_inputs_for_common()
    for model_class in self.all_model_classes[:2]:
       __lowercase								=		self._prepare_for_class(__SCREAMING_SNAKE_CASE,   __SCREAMING_SNAKE_CASE      )
       __lowercase								=		model_class(__SCREAMING_SNAKE_CASE      )

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

       __lowercase								=		run_in_graph_mode()
       self.assertIsNotNone(__SCREAMING_SNAKE_CASE      )


 @slow
 def    _lowercase					(     self				:     Tuple      ):
    __lowercase								=		self.model_tester.prepare_config_and_inputs_for_common()
    for model_class in self.all_model_classes[:2]:
       __lowercase								=		self._prepare_for_class(__SCREAMING_SNAKE_CASE,   __SCREAMING_SNAKE_CASE      )
       __lowercase								=		model_class(__SCREAMING_SNAKE_CASE      )

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

       __lowercase								=		run_in_graph_mode()
       self.assertIsNotNone(__SCREAMING_SNAKE_CASE      )


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

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

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

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

          __lowercase								=		history.history['''loss'''][0]
          self.assertTrue(not isnan(__SCREAMING_SNAKE_CASE      )      )
          __lowercase								=		history.history['''val_loss'''][0]
          self.assertTrue(not isnan(__SCREAMING_SNAKE_CASE      )      )


 @slow
 def    _lowercase					(     self				:     List[str]      ):
    __lowercase								=		self.model_tester.prepare_config_and_inputs_for_common()
    __lowercase								=		True
    __lowercase								=		True

    if hasattr(__SCREAMING_SNAKE_CASE,   "use_cache"      ):
       __lowercase								=		True

    __lowercase								=		getattr(self.model_tester,   "encoder_seq_length",   self.model_tester.seq_length      )
    __lowercase								=		getattr(self.model_tester,   "key_length",   __SCREAMING_SNAKE_CASE      )

    for model_class in self.all_model_classes[:2]:
       __lowercase								=		self._prepare_for_class(__SCREAMING_SNAKE_CASE,   __SCREAMING_SNAKE_CASE      )
       __lowercase								=		model_class(__SCREAMING_SNAKE_CASE      )
       model.build()
       __lowercase								=		len(model(__SCREAMING_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:
             __lowercase								=		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(__SCREAMING_SNAKE_CASE,   saved_model=__SCREAMING_SNAKE_CASE      )
          __lowercase								=		os.path.join(__SCREAMING_SNAKE_CASE,   "saved_model",   "1"      )
          __lowercase								=		tf.keras.models.load_model(__SCREAMING_SNAKE_CASE      )
          __lowercase								=		model(__SCREAMING_SNAKE_CASE      )

          if self.is_encoder_decoder:
             __lowercase								=		outputs['''encoder_hidden_states''']
             __lowercase								=		outputs['''encoder_attentions''']
          else:
             __lowercase								=		outputs['''hidden_states''']
             __lowercase								=		outputs['''attentions''']

          self.assertEqual(len(__SCREAMING_SNAKE_CASE      ),   __SCREAMING_SNAKE_CASE      )

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

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

          self.assertEqual(len(__SCREAMING_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    _lowercase					(     self				:     Optional[int]      ):
    tf.keras.mixed_precision.set_global_policy("mixed_float16"      )

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

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


 @slow
 def    _lowercase					(     self				:     List[Any]      ):
    __lowercase								=		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"]
    __lowercase								=		{
        module_member
        for model_class in self.all_model_classes
        for module in (import_module(model_class.__module__      ),)
        for module_member_name in dir(__SCREAMING_SNAKE_CASE      )
        if module_member_name.endswith("MainLayer"      )
        for module_member in (getattr(__SCREAMING_SNAKE_CASE,   __SCREAMING_SNAKE_CASE      ),)
        if isinstance(__SCREAMING_SNAKE_CASE,   __SCREAMING_SNAKE_CASE      )
        and tf.keras.layers.Layer in module_member.__bases__
        and getattr(__SCREAMING_SNAKE_CASE,   "_keras_serializable",   __SCREAMING_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
          __lowercase								=		TFSharedEmbeddings(self.model_tester.vocab_size,   self.model_tester.hidden_size,   name="shared"      )
          __lowercase								=		False
          __lowercase								=		main_layer_class(__SCREAMING_SNAKE_CASE,   embed_tokens=__SCREAMING_SNAKE_CASE      )
       else:
          __lowercase								=		main_layer_class(__SCREAMING_SNAKE_CASE      )

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

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

       __lowercase								=		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      )

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

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

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


 @slow
 def    _lowercase					(     self				:     Any      ):
    __lowercase								=		self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes[:2]:
       __lowercase								=		model_class(__SCREAMING_SNAKE_CASE      )

       __lowercase								=		copy.deepcopy(__SCREAMING_SNAKE_CASE      )

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

       if not self.is_encoder_decoder:
          __lowercase								=		model.get_input_embeddings()(__SCREAMING_SNAKE_CASE      )
       else:
          __lowercase								=		model.get_input_embeddings()(__SCREAMING_SNAKE_CASE      )
          __lowercase								=		model.get_input_embeddings()(__SCREAMING_SNAKE_CASE      )

       __lowercase								=		self._prepare_for_class(__SCREAMING_SNAKE_CASE,   __SCREAMING_SNAKE_CASE      )

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

       __lowercase								=		run_in_graph_mode()
       self.assertIsNotNone(__SCREAMING_SNAKE_CASE      )


 def    _lowercase					(     self				:     Tuple,   UpperCAmelCase__				:     List[str],   UpperCAmelCase__				:     List[str]      ):
    __lowercase								=		[]
    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
    __lowercase								=		[]
    while len(__SCREAMING_SNAKE_CASE      ) < num_bad_tokens:
       __lowercase								=		tf.squeeze(ids_tensor((1, 1),   self.model_tester.vocab_size      ),   0      ).numpy()[0]
       if token not in special_tokens:
          bad_tokens.append(__SCREAMING_SNAKE_CASE      )
    return bad_tokens


 def    _lowercase					(     self				:     Any,   UpperCAmelCase__				:     Tuple      ):




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



 def    _lowercase					(     self				:     Tuple,   UpperCAmelCase__				:     int,   UpperCAmelCase__				:     Union[str, 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(__SCREAMING_SNAKE_CASE      ),   len(__SCREAMING_SNAKE_CASE      )      ):
             # if tokens match
             if generated_ids_slice[i - len(__SCREAMING_SNAKE_CASE      ) : i] == bad_word_ids:
                return True
    return False








def   a						(				SCREAMING_SNAKE_CASE_   :		int							):






       """simple docstring"""





       UpperCamelCase     :						Tuple 						=		[True for i in range(n + 1							)]
       UpperCamelCase     :						Tuple 						=		[i - 1 for i in range(n + 1							)]
       UpperCamelCase     :						Optional[Any] 						=		[]
       for i in range(2				,      n + 1							):
              if is_prime[i]:
                     primes.append(SCREAMING_SNAKE_CASE_							)
              for j in range(0				,      len(SCREAMING_SNAKE_CASE_							)							):
                     if i * primes[j] >= n:
                            break
                     UpperCamelCase     :						Any 						=		False

                     if i % primes[j] == 0:
                            UpperCamelCase     :						int 						=		totients[i] * primes[j]
                            break

                     UpperCamelCase     :						Dict 						=		totients[i] * (primes[j] - 1)

       return totients


if __name__ == "__main__":
  import doctest

  doctest.testmod()

