code: 
  
  
  
  
  """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:
              SCREAMING_SNAKE_CASE       = 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)]
                          )
                          SCREAMING_SNAKE_CASE       = 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_						:
      lowercase__		      =   None
      lowercase__		      =   ()
      lowercase__		      =   ()
      lowercase__		      =   True
      lowercase__		      =   True
      lowercase__		      =   True
      lowercase__		      =   False
  
  
  
  
      def 							__magic_name__							(					self		: Dict			,				snake_case_		: List[str]			,				snake_case_		: Optional[Any]			,				snake_case_		: List[str]=False   )   ->							dict:
  
  
  
  
       '''simple docstring'''
  
       A__ =       copy.deepcopy(snake_case_   )
  
       if model_class in get_values(snake_case_   ):
        A__ =       {
            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__ =       tf.ones(self.model_tester.batch_size			,				dtype=tf.intaa   )
        elif model_class in get_values(snake_case_   ):
         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(snake_case_   ),
            *get_values(snake_case_   ),
        ]:
         A__ =       tf.zeros(self.model_tester.batch_size			,				dtype=tf.intaa   )
        elif model_class in get_values(snake_case_   ):
         A__ =       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__ =       tf.zeros(
             (self.model_tester.batch_size, self.model_tester.seq_length)			,				dtype=tf.intaa   )
       return inputs_dict
  
  
  
  
      @slow
      def 							__magic_name__							(					self		: str   )   ->							int:
  
  
  
  
       '''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(snake_case_			,				snake_case_   )
        A__ =       model_class(snake_case_   )
  
        @tf.function
        def run_in_graph_mode():
         return model(snake_case_   )
  
        A__ =       run_in_graph_mode()
        self.assertIsNotNone(snake_case_   )
  
  
  
  
      @slow
      def 							__magic_name__							(					self		: str   )   ->							Dict:
  
  
  
  
       '''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(snake_case_			,				snake_case_   )
        A__ =       model_class(snake_case_   )
  
        @tf.function(experimental_compile=snake_case_   )
        def run_in_graph_mode():
         return model(snake_case_   )
  
        A__ =       run_in_graph_mode()
        self.assertIsNotNone(snake_case_   )
  
  
  
  
      @slow
      def 							__magic_name__							(					self		: Optional[Any]   )   ->							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(snake_case_   )
        if getattr(snake_case_			,				"hf_compute_loss"			,				snake_case_   ):
         # Test that model correctly compute the loss with kwargs
         A__ =       self._prepare_for_class(inputs_dict.copy()			,				snake_case_			,				return_labels=snake_case_   )
         # 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(snake_case_   )   )
         self.assertGreater(len(snake_case_   )			,				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(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__ =       model.fit(
             snake_case_			,				validation_data=snake_case_			,				steps_per_epoch=1			,				validation_steps=1			,				shuffle=snake_case_			,				verbose=0			,				)
         A__ =       history.history["loss"][0]
         self.assertTrue(not isnan(snake_case_   )   )
         A__ =       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__ =       model_class(snake_case_   )
         model.compile(optimizer=tf.keras.optimizers.SGD(0.0   )			,				jit_compile=snake_case_   )
         A__ =       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__ =       history.history["loss"][0]
         self.assertTrue(not isnan(snake_case_   )   )
         A__ =       history.history["val_loss"][0]
         self.assertTrue(not isnan(snake_case_   )   )
  
  
  
  
      @slow
      def 							__magic_name__							(					self		: Tuple   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       A__,   A__ =       self.model_tester.prepare_config_and_inputs_for_common()
       A__ =       True
       A__ =       True
  
       if hasattr(snake_case_			,				"use_cache"   ):
        A__ =       True
  
       A__ =       getattr(self.model_tester			,				"encoder_seq_length"			,				self.model_tester.seq_length   )
       A__ =       getattr(self.model_tester			,				"key_length"			,				snake_case_   )
  
       for model_class in self.all_model_classes[:2]:
        A__ =       self._prepare_for_class(snake_case_			,				snake_case_   )
        A__ =       model_class(snake_case_   )
        model.build()
        A__ =       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__ =       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__ =       os.path.join(snake_case_			,				"saved_model"			,				"1"   )
         A__ =       tf.keras.models.load_model(snake_case_   )
         A__ =       model(snake_case_   )
  
         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(snake_case_   )			,				snake_case_   )
  
         A__ =       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 							__magic_name__							(					self		: Tuple   )   ->							Tuple:
  
  
  
  
       '''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(snake_case_			,				snake_case_   )
         A__ =       model_class(snake_case_   )
         A__ =       model(snake_case_   )
  
         self.assertIsNotNone(snake_case_   )
       finally:
        tf.keras.mixed_precision.set_global_policy("float32"   )
  
  
  
  
      @slow
      def 							__magic_name__							(					self		: List[Any]   )   ->							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(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__ =       TFSharedEmbeddings(self.model_tester.vocab_size			,				self.model_tester.hidden_size			,				name="shared"   )
         A__ =       False
         A__ =       main_layer_class(snake_case_			,				embed_tokens=snake_case_   )
        else:
         A__ =       main_layer_class(snake_case_   )
  
        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(snake_case_   )[0]
        A__ =       tf.keras.layers.Dense(snake_case_			,				activation="softmax"			,				name="outputs"   )(snake_case_   )
        A__ =       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__ =       os.path.join(snake_case_			,				"keras_model.h5"   )
         model.save(snake_case_   )
         if "T5" in main_layer_class.__name__:
          A__ =       tf.keras.models.load_model(
              snake_case_			,				custom_objects={
                  main_layer_class.__name__: main_layer_class,
                  "TFSharedEmbeddings": TFSharedEmbeddings,
              }			,				)
         else:
          A__ =       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 							__magic_name__							(					self		: Dict   )   ->							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(snake_case_   )
  
        A__ =       copy.deepcopy(snake_case_   )
  
        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"			,				snake_case_   )
         del inputs["input_ids"]
         inputs.pop("decoder_input_ids"			,				snake_case_   )
  
        if not self.is_encoder_decoder:
         A__ =       model.get_input_embeddings()(snake_case_   )
        else:
         A__ =       model.get_input_embeddings()(snake_case_   )
         A__ =       model.get_input_embeddings()(snake_case_   )
  
        A__ =       self._prepare_for_class(snake_case_			,				snake_case_   )
  
        @tf.function
        def run_in_graph_mode():
         return model(snake_case_   )
  
        A__ =       run_in_graph_mode()
        self.assertIsNotNone(snake_case_   )
  
  
  
  
      def 							__magic_name__							(					self		: Tuple			,				snake_case_		: int			,				snake_case_		: List[str]   )   ->							Union[str, Any]:
  
  
  
  
       '''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(snake_case_   ) < 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(snake_case_   )
       return bad_tokens
  
  
  
  
      def 							__magic_name__							(					self		: Optional[Any]			,				snake_case_		: Tuple   )   ->							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 							__magic_name__							(					self		: Union[str, Any]			,				snake_case_		: List[Any]			,				snake_case_		: List[str]   )   ->							Dict:
  
  
  
  
       '''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(snake_case_   )			,				len(snake_case_   )   ):
          # if tokens match
          if generated_ids_slice[i - len(snake_case_   ) : i] == bad_word_ids:
           return True
       return False
  
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import _LazyModule
  
  
  SCREAMING_SNAKE_CASE       = {"tokenization_bert_japanese": ["BertJapaneseTokenizer", "CharacterTokenizer", "MecabTokenizer"]}
  
  
  if TYPE_CHECKING:
        from .tokenization_bert_japanese import BertJapaneseTokenizer, CharacterTokenizer, MecabTokenizer
  
  else:
        import sys
  
        SCREAMING_SNAKE_CASE       = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  
  
  
  
  