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:
                lowerCamelCase_     :     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)]
                              )
                              lowerCamelCase_     :     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       :
  
  
  
  
  
  
   """simple docstring"""
  
  
  
  
   __lowerCAmelCase				      =						None
   __lowerCAmelCase				      =						()
   __lowerCAmelCase				      =						()
   __lowerCAmelCase				      =						True
   __lowerCAmelCase				      =						True
   __lowerCAmelCase				      =						True
   __lowerCAmelCase				      =						False
  
  
   def    SCREAMING_SNAKE_CASE							(	self				,					__A				,					__A				,					__A=False		)      ->  Tuple:
       a					=copy.deepcopy(__A		)
  
       if model_class in get_values(__A		):
           a					={
               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		):
               a					=tf.ones(self.model_tester.batch_size				,					dtype=tf.intaa		)
           elif model_class in get_values(__A		):
               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(__A		),
               *get_values(__A		),
           ]:
               a					=tf.zeros(self.model_tester.batch_size				,					dtype=tf.intaa		)
           elif model_class in get_values(__A		):
               a					=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		),
           ]:
               a					=tf.zeros(
                   (self.model_tester.batch_size, self.model_tester.seq_length)				,					dtype=tf.intaa		)
       return inputs_dict
  
  
   @slow
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  str:
       a					=self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
           a					=self._prepare_for_class(__A				,					__A		)
           a					=model_class(__A		)
  
           @tf.function
           def run_in_graph_mode():
               return model(__A		)
  
           a					=run_in_graph_mode()
           self.assertIsNotNone(__A		)
  
  
   @slow
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  str:
       a					=self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
           a					=self._prepare_for_class(__A				,					__A		)
           a					=model_class(__A		)
  
           @tf.function(experimental_compile=__A		)
           def run_in_graph_mode():
               return model(__A		)
  
           a					=run_in_graph_mode()
           self.assertIsNotNone(__A		)
  
  
   @slow
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Tuple:
       a					=self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
           a					=model_class(__A		)
           if getattr(__A				,					'''hf_compute_loss'''				,					__A		):
               # Test that model correctly compute the loss with kwargs
               a					=self._prepare_for_class(inputs_dict.copy()				,					__A				,					return_labels=__A		)
               # 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(__A		)		)
               self.assertGreater(len(__A		)				,					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(__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
               a					=model.fit(
                   __A				,					validation_data=__A				,					steps_per_epoch=1				,					validation_steps=1				,					shuffle=__A				,					verbose=0				,					)
               a					=history.history["loss"][0]
               self.assertTrue(not isnan(__A		)		)
               a					=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.
               a					=model_class(__A		)
               model.compile(optimizer=tf.keras.optimizers.SGD(0.0		)				,					jit_compile=__A		)
               a					=model.fit(
                   __A				,					__A				,					validation_data=(inputs_minus_labels, labels)				,					steps_per_epoch=1				,					validation_steps=1				,					shuffle=__A				,					verbose=0				,					)
  
               a					=history.history["loss"][0]
               self.assertTrue(not isnan(__A		)		)
               a					=history.history["val_loss"][0]
               self.assertTrue(not isnan(__A		)		)
  
  
   @slow
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Dict:
       a					=self.model_tester.prepare_config_and_inputs_for_common()
       a					=True
       a					=True
  
       if hasattr(__A				,					'''use_cache'''		):
           a					=True
  
       a					=getattr(self.model_tester				,					'''encoder_seq_length'''				,					self.model_tester.seq_length		)
       a					=getattr(self.model_tester				,					'''key_length'''				,					__A		)
  
       for model_class in self.all_model_classes[:2]:
           a					=self._prepare_for_class(__A				,					__A		)
           a					=model_class(__A		)
           model.build()
           a					=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:
                   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(__A				,					saved_model=__A		)
               a					=os.path.join(__A				,					'''saved_model'''				,					'''1'''		)
               a					=tf.keras.models.load_model(__A		)
               a					=model(__A		)
  
               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(__A		)				,					__A		)
  
               a					=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    SCREAMING_SNAKE_CASE							(	self		)      ->  List[str]:
       tf.keras.mixed_precision.set_global_policy('''mixed_float16'''		)
  
       # try/finally block to ensure subsequent tests run in float32
       try:
           a					=self.model_tester.prepare_config_and_inputs_for_common()
           for model_class in self.all_model_classes[:2]:
               a					=self._prepare_for_class(__A				,					__A		)
               a					=model_class(__A		)
               a					=model(__A		)
  
               self.assertIsNotNone(__A		)
       finally:
           tf.keras.mixed_precision.set_global_policy('''float32'''		)
  
  
   @slow
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Union[str, Any]:
       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(__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
               a					=TFSharedEmbeddings(self.model_tester.vocab_size				,					self.model_tester.hidden_size				,					name='''shared'''		)
               a					=False
               a					=main_layer_class(__A				,					embed_tokens=__A		)
           else:
               a					=main_layer_class(__A		)
  
           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(__A		)[0]
           a					=tf.keras.layers.Dense(__A				,					activation='''softmax'''				,					name='''outputs'''		)(__A		)
           a					=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:
               a					=os.path.join(__A				,					'''keras_model.h5'''		)
               model.save(__A		)
               if "T5" in main_layer_class.__name__:
                   a					=tf.keras.models.load_model(
                       __A				,					custom_objects={
                           main_layer_class.__name__: main_layer_class,
                           '''TFSharedEmbeddings''': TFSharedEmbeddings,
                       }				,					)
               else:
                   a					=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    SCREAMING_SNAKE_CASE							(	self		)      ->  Tuple:
       a					=self.model_tester.prepare_config_and_inputs_for_common()
  
       for model_class in self.all_model_classes[:2]:
           a					=model_class(__A		)
  
           a					=copy.deepcopy(__A		)
  
           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'''				,					__A		)
               del inputs["input_ids"]
               inputs.pop('''decoder_input_ids'''				,					__A		)
  
           if not self.is_encoder_decoder:
               a					=model.get_input_embeddings()(__A		)
           else:
               a					=model.get_input_embeddings()(__A		)
               a					=model.get_input_embeddings()(__A		)
  
           a					=self._prepare_for_class(__A				,					__A		)
  
           @tf.function
           def run_in_graph_mode():
               return model(__A		)
  
           a					=run_in_graph_mode()
           self.assertIsNotNone(__A		)
  
  
   def    SCREAMING_SNAKE_CASE							(	self				,					__A				,					__A		)      ->  Dict:
       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(__A		) < 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(__A		)
       return bad_tokens
  
  
   def    SCREAMING_SNAKE_CASE							(	self				,					__A		)      ->  Union[str, Any]:
  
  
  
  
  
  
  
       for token_id in output_ids[0].numpy().tolist():
           self.assertGreaterEqual(__A				,					0		)
           self.assertLess(__A				,					self.model_tester.vocab_size		)
  
  
  
  
  
   def    SCREAMING_SNAKE_CASE							(	self				,					__A				,					__A		)      ->  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(__A		)				,					len(__A		)		):
                   # if tokens match
                   if generated_ids_slice[i - len(__A		) : i] == bad_word_ids:
                       return True
       return False
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  
  import copy
  
  from transformers.configuration_utils import PretrainedConfig
  from transformers.utils import logging
  
  
  lowerCamelCase_     :     int    		=						logging.get_logger(__name__)
  
  
  
  
  
  
  class    __A       ( _SCREAMING_SNAKE_CASE    ):
  
  
  
  
  
  
   """simple docstring"""
  
  
  
  
   __lowerCAmelCase				      =						"hybrid-clip"
   __lowerCAmelCase				      =						True
  
  
   def __init__(	self				,					__A=512				,					**__A		)      ->  Any:
       super().__init__(**__A		)
  
       if "text_config" not in kwargs:
           raise ValueError('''`text_config` can not be `None`.'''		)
  
       if "vision_config" not in kwargs:
           raise ValueError('''`vision_config` can not be `None`.'''		)
  
       a					=kwargs.pop('''text_config'''		)
       a					=kwargs.pop('''vision_config'''		)
  
       a					=text_config.pop('''model_type'''		)
       a					=vision_config.pop('''model_type'''		)
  
       from transformers import AutoConfig
  
       a					=AutoConfig.for_model(__A				,					**__A		)
  
       if vision_model_type == "clip":
           a					=AutoConfig.for_model(__A				,					**__A		).vision_config
       elif vision_model_type == "clip_vision_model":
           from transformers import CLIPVisionConfig
  
           a					=CLIPVisionConfig(**__A		)
       else:
           a					=AutoConfig.for_model(__A				,					**__A		)
  
       a					=projection_dim
       a					=1.0
  
  
   @classmethod
   def    SCREAMING_SNAKE_CASE							(	cls				,					__A				,					__A				,					**__A		)      ->  Tuple:
       return cls(text_config=text_config.to_dict()				,					vision_config=vision_config.to_dict()				,					**__A		)
  
  
  
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Optional[int]:
       a					=copy.deepcopy(self.__dict__		)
       a					=self.text_config.to_dict()
       a					=self.vision_config.to_dict()
       a					=self.__class__.model_type
       return output