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:
                __lowercase:		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)]
                              )
                              __lowercase:		Optional[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  UpperCAmelCase :
   _lowerCamelCase :					Any    					=					None
   _lowerCamelCase :					str    					=					()
   _lowerCamelCase :					List[Any]    					=					()
   _lowerCamelCase :					List[Any]    					=					True
   _lowerCamelCase :					Optional[int]    					=					True
   _lowerCamelCase :					Any    					=					True
   _lowerCamelCase :					List[str]    					=					False
  
   def 		lowercase_						( self :	Optional[Any],					a_ :	Union[str, Any],					a_ :	Union[str, Any],					a_ :	Dict=False					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						copy.deepcopy(a_					)
  
      if model_class in get_values(a_					):
         UpperCamelCase__ 						=						{
             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_					):
            UpperCamelCase__ 						=						tf.ones(self.model_tester.batch_size,					dtype=tf.intaa					)
         elif model_class in get_values(a_					):
            UpperCamelCase__ 						=						tf.zeros(self.model_tester.batch_size,					dtype=tf.intaa					)
            UpperCamelCase__ 						=						tf.zeros(self.model_tester.batch_size,					dtype=tf.intaa					)
         elif model_class in [
             *get_values(a_					),
             *get_values(a_					),
         ]:
            UpperCamelCase__ 						=						tf.zeros(self.model_tester.batch_size,					dtype=tf.intaa					)
         elif model_class in get_values(a_					):
            UpperCamelCase__ 						=						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_					),
         ]:
            UpperCamelCase__ 						=						tf.zeros(
                (self.model_tester.batch_size, self.model_tester.seq_length),					dtype=tf.intaa					)
      return inputs_dict
  
   @slow
   def 		lowercase_						( self :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes[:2]:
         UpperCamelCase__ 						=						self._prepare_for_class(a_,					a_					)
         UpperCamelCase__ 						=						model_class(a_					)
  
         @tf.function
         def run_in_graph_mode():
            return model(a_					)
  
         UpperCamelCase__ 						=						run_in_graph_mode()
         self.assertIsNotNone(a_					)
  
   @slow
   def 		lowercase_						( self :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes[:2]:
         UpperCamelCase__ 						=						self._prepare_for_class(a_,					a_					)
         UpperCamelCase__ 						=						model_class(a_					)
  
         @tf.function(experimental_compile=a_					)
         def run_in_graph_mode():
            return model(a_					)
  
         UpperCamelCase__ 						=						run_in_graph_mode()
         self.assertIsNotNone(a_					)
  
   @slow
   def 		lowercase_						( self :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes[:2]:
         UpperCamelCase__ 						=						model_class(a_					)
         if getattr(a_,					"hf_compute_loss",					a_					):
            # Test that model correctly compute the loss with kwargs
            UpperCamelCase__ 						=						self._prepare_for_class(inputs_dict.copy(),					a_,					return_labels=a_					)
            # Is there a better way to remove these decoder inputs?
            UpperCamelCase__ 						=						{
                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")
            }
  
            UpperCamelCase__ 						=						{
                "labels",
                "label",
                "label_ids",
                "start_positions",
                "start_position",
                "end_positions",
                "end_position",
                "next_sentence_label",
            }
            UpperCamelCase__ 						=						possible_label_cols.intersection(set(a_					)					)
            self.assertGreater(len(a_					),					0,					msg="No matching label names found!"					)
            UpperCamelCase__ 						=						{key: val for key, val in prepared_for_class.items() if key in label_names}
            UpperCamelCase__ 						=						{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
            UpperCamelCase__ 						=						model.fit(
                a_,					validation_data=a_,					steps_per_epoch=1,					validation_steps=1,					shuffle=a_,					verbose=0,					)
            UpperCamelCase__ 						=						history.history["loss"][0]
            self.assertTrue(not isnan(a_					)					)
            UpperCamelCase__ 						=						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.
            UpperCamelCase__ 						=						model_class(a_					)
            model.compile(optimizer=tf.keras.optimizers.SGD(0.0					),					jit_compile=a_					)
            UpperCamelCase__ 						=						model.fit(
                a_,					a_,					validation_data=(inputs_minus_labels, labels),					steps_per_epoch=1,					validation_steps=1,					shuffle=a_,					verbose=0,					)
  
            UpperCamelCase__ 						=						history.history["loss"][0]
            self.assertTrue(not isnan(a_					)					)
            UpperCamelCase__ 						=						history.history["val_loss"][0]
            self.assertTrue(not isnan(a_					)					)
  
   @slow
   def 		lowercase_						( self :	Tuple					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						self.model_tester.prepare_config_and_inputs_for_common()
      UpperCamelCase__ 						=						True
      UpperCamelCase__ 						=						True
  
      if hasattr(a_,					"use_cache"					):
         UpperCamelCase__ 						=						True
  
      UpperCamelCase__ 						=						getattr(self.model_tester,					"encoder_seq_length",					self.model_tester.seq_length					)
      UpperCamelCase__ 						=						getattr(self.model_tester,					"key_length",					a_					)
  
      for model_class in self.all_model_classes[:2]:
         UpperCamelCase__ 						=						self._prepare_for_class(a_,					a_					)
         UpperCamelCase__ 						=						model_class(a_					)
         model.build()
         UpperCamelCase__ 						=						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:
               UpperCamelCase__ 						=						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_					)
            UpperCamelCase__ 						=						os.path.join(a_,					"saved_model",					"1"					)
            UpperCamelCase__ 						=						tf.keras.models.load_model(a_					)
            UpperCamelCase__ 						=						model(a_					)
  
            if self.is_encoder_decoder:
               UpperCamelCase__ 						=						outputs["encoder_hidden_states"]
               UpperCamelCase__ 						=						outputs["encoder_attentions"]
            else:
               UpperCamelCase__ 						=						outputs["hidden_states"]
               UpperCamelCase__ 						=						outputs["attentions"]
  
            self.assertEqual(len(a_					),					a_					)
  
            UpperCamelCase__ 						=						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 		lowercase_						( self :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      tf.keras.mixed_precision.set_global_policy("mixed_float16"					)
  
      # try/finally block to ensure subsequent tests run in float32
      try:
         UpperCamelCase__						,		UpperCamelCase__ 						=						self.model_tester.prepare_config_and_inputs_for_common()
         for model_class in self.all_model_classes[:2]:
            UpperCamelCase__ 						=						self._prepare_for_class(a_,					a_					)
            UpperCamelCase__ 						=						model_class(a_					)
            UpperCamelCase__ 						=						model(a_					)
  
            self.assertIsNotNone(a_					)
      finally:
         tf.keras.mixed_precision.set_global_policy("float32"					)
  
   @slow
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						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"]
      UpperCamelCase__ 						=						{
          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
            UpperCamelCase__ 						=						TFSharedEmbeddings(self.model_tester.vocab_size,					self.model_tester.hidden_size,					name="shared"					)
            UpperCamelCase__ 						=						False
            UpperCamelCase__ 						=						main_layer_class(a_,					embed_tokens=a_					)
         else:
            UpperCamelCase__ 						=						main_layer_class(a_					)
  
         UpperCamelCase__ 						=						{
             name: tf.keras.Input(tensor.shape[1:],					dtype=tensor.dtype					) for name, tensor in inputs_dict.items()
         }
  
         if hasattr(self.model_tester,					"num_labels"					):
            UpperCamelCase__ 						=						self.model_tester.num_labels
         else:
            UpperCamelCase__ 						=						2
  
         UpperCamelCase__ 						=						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					)
  
         UpperCamelCase__ 						=						main_layer(a_					)[0]
         UpperCamelCase__ 						=						tf.keras.layers.Dense(a_,					activation="softmax",					name="outputs"					)(a_					)
         UpperCamelCase__ 						=						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:
            UpperCamelCase__ 						=						os.path.join(a_,					"keras_model.h5"					)
            model.save(a_					)
            if "T5" in main_layer_class.__name__:
               UpperCamelCase__ 						=						tf.keras.models.load_model(
                   a_,					custom_objects={
                       main_layer_class.__name__: main_layer_class,
                       "TFSharedEmbeddings": TFSharedEmbeddings,
                   },					)
            else:
               UpperCamelCase__ 						=						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 		lowercase_						( self :	Optional[int]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						self.model_tester.prepare_config_and_inputs_for_common()
  
      for model_class in self.all_model_classes[:2]:
         UpperCamelCase__ 						=						model_class(a_					)
  
         UpperCamelCase__ 						=						copy.deepcopy(a_					)
  
         if not self.is_encoder_decoder:
            UpperCamelCase__ 						=						inputs["input_ids"]
            del inputs["input_ids"]
         else:
            UpperCamelCase__ 						=						inputs["input_ids"]
            UpperCamelCase__ 						=						inputs.get("decoder_input_ids",					a_					)
            del inputs["input_ids"]
            inputs.pop("decoder_input_ids",					a_					)
  
         if not self.is_encoder_decoder:
            UpperCamelCase__ 						=						model.get_input_embeddings()(a_					)
         else:
            UpperCamelCase__ 						=						model.get_input_embeddings()(a_					)
            UpperCamelCase__ 						=						model.get_input_embeddings()(a_					)
  
         UpperCamelCase__ 						=						self._prepare_for_class(a_,					a_					)
  
         @tf.function
         def run_in_graph_mode():
            return model(a_					)
  
         UpperCamelCase__ 						=						run_in_graph_mode()
         self.assertIsNotNone(a_					)
  
   def 		lowercase_						( self :	Optional[Any],					a_ :	str,					a_ :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						[]
      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
      UpperCamelCase__ 						=						[]
      while len(a_					) < num_bad_tokens:
         UpperCamelCase__ 						=						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 		lowercase_						( self :	List[Any],					a_ :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      for token_id in output_ids[0].numpy().tolist():
         self.assertGreaterEqual(a_,					0					)
         self.assertLess(a_,					self.model_tester.vocab_size					)
  
   def 		lowercase_						( self :	Optional[Any],					a_ :	List[Any],					a_ :	int					):
  
  
  
  
  
      """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(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'''
  
  from typing import List
  
  from ...processing_utils import ProcessorMixin
  from ...utils import is_torch_available
  
  
  if is_torch_available():
         import torch
  
  
  
  
  
  
  
  class  UpperCAmelCase (       SCREAMING_SNAKE_CASE__):
   _lowerCamelCase :					Tuple    					=					['image_processor', 'tokenizer']
   _lowerCamelCase :					Tuple    					=					'OneFormerImageProcessor'
   _lowerCamelCase :					List[Any]    					=					('CLIPTokenizer', 'CLIPTokenizerFast')
  
   def __init__( self :	Any,					a_ :	Dict=None,					a_ :	int=None,					a_ :	int = 77,					a_ :	int = 77,					**a_ :	int					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      if image_processor is None:
         raise ValueError("You need to specify an `image_processor`."					)
      if tokenizer is None:
         raise ValueError("You need to specify a `tokenizer`."					)
  
      UpperCamelCase__ 						=						max_seq_length
      UpperCamelCase__ 						=						task_seq_length
  
      super().__init__(a_,					a_					)
  
   def 		lowercase_						( self :	Any,					a_ :	Optional[Any]=None,					a_ :	Optional[int]=77					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      if text_list is None:
         raise ValueError("tokens cannot be None."					)
  
      UpperCamelCase__ 						=						self.tokenizer(a_,					padding="max_length",					max_length=a_,					truncation=a_					)
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						tokens["attention_mask"], tokens["input_ids"]
  
      UpperCamelCase__ 						=						[]
      for attn_mask, input_id in zip(a_,					a_					):
         UpperCamelCase__ 						=						torch.tensor(a_					) * torch.tensor(a_					)
         token_inputs.append(token.unsqueeze(0					)					)
  
      UpperCamelCase__ 						=						torch.cat(a_,					dim=0					)
      return token_inputs
  
   def __call__( self :	str,					a_ :	Dict=None,					a_ :	str=None,					a_ :	Tuple=None,					**a_ :	Any					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      if task_inputs is None:
         raise ValueError("You have to specify the task_input. Found None."					)
      elif images is None:
         raise ValueError("You have to specify the image. Found None."					)
  
      if not all(task in ["semantic", "instance", "panoptic"] for task in task_inputs					):
         raise ValueError("task_inputs must be semantic, instance, or panoptic."					)
  
      UpperCamelCase__ 						=						self.image_processor(a_,					a_,					a_,					**a_					)
  
      if isinstance(a_,					a_					):
         UpperCamelCase__ 						=						[task_inputs]
  
      if isinstance(a_,					a_					) and all(isinstance(a_,					a_					) for task_input in task_inputs					):
         UpperCamelCase__ 						=						[]
         for task in task_inputs:
            UpperCamelCase__ 						=						f'the task is {task}'
            task_token_inputs.append(a_					)
         UpperCamelCase__ 						=						self._preprocess_text(a_,					max_length=self.task_seq_length					)
      else:
         raise TypeError("Task Inputs should be a string or a list of strings."					)
  
      if hasattr(a_,					"text_inputs"					):
         UpperCamelCase__ 						=						encoded_inputs.text_inputs
  
         UpperCamelCase__ 						=						[]
         for texts in texts_list:
            UpperCamelCase__ 						=						self._preprocess_text(a_,					max_length=self.max_seq_length					)
            text_inputs.append(text_input_list.unsqueeze(0					)					)
  
         UpperCamelCase__ 						=						torch.cat(a_,					dim=0					)
  
      return encoded_inputs
  
   def 		lowercase_						( self :	Union[str, Any],					a_ :	Tuple=None,					a_ :	List[str]=None,					a_ :	Optional[Any]=None,					**a_ :	Tuple					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      if task_inputs is None:
         raise ValueError("You have to specify the task_input. Found None."					)
      elif images is None:
         raise ValueError("You have to specify the image. Found None."					)
  
      if not all(task in ["semantic", "instance", "panoptic"] for task in task_inputs					):
         raise ValueError("task_inputs must be semantic, instance, or panoptic."					)
  
      UpperCamelCase__ 						=						self.image_processor.encode_inputs(a_,					a_,					a_,					**a_					)
  
      if isinstance(a_,					a_					):
         UpperCamelCase__ 						=						[task_inputs]
  
      if isinstance(a_,					a_					) and all(isinstance(a_,					a_					) for task_input in task_inputs					):
         UpperCamelCase__ 						=						[]
         for task in task_inputs:
            UpperCamelCase__ 						=						f'the task is {task}'
            task_token_inputs.append(a_					)
         UpperCamelCase__ 						=						self._preprocess_text(a_,					max_length=self.task_seq_length					)
      else:
         raise TypeError("Task Inputs should be a string or a list of strings."					)
  
      if hasattr(a_,					"text_inputs"					):
         UpperCamelCase__ 						=						encoded_inputs.text_inputs
  
         UpperCamelCase__ 						=						[]
         for texts in texts_list:
            UpperCamelCase__ 						=						self._preprocess_text(a_,					max_length=self.max_seq_length					)
            text_inputs.append(text_input_list.unsqueeze(0					)					)
  
         UpperCamelCase__ 						=						torch.cat(a_,					dim=0					)
  
      return encoded_inputs
  
   def 		lowercase_						( self :	Any,					*a_ :	int,					**a_ :	Optional[int]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return self.image_processor.post_process_semantic_segmentation(*a_,					**a_					)
  
   def 		lowercase_						( self :	str,					*a_ :	Tuple,					**a_ :	Optional[int]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return self.image_processor.post_process_instance_segmentation(*a_,					**a_					)
  
   def 		lowercase_						( self :	Dict,					*a_ :	str,					**a_ :	int					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return self.image_processor.post_process_panoptic_segmentation(*a_,					**a_					)