


'''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



'''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_					)