


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:
    UpperCAmelCase__        =				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)]
        )
        UpperCAmelCase__        =				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__  :
     SCREAMING_SNAKE_CASE__      =     None
     SCREAMING_SNAKE_CASE__      =     ()
     SCREAMING_SNAKE_CASE__      =     ()
     SCREAMING_SNAKE_CASE__      =     True
     SCREAMING_SNAKE_CASE__      =     True
     SCREAMING_SNAKE_CASE__      =     True
     SCREAMING_SNAKE_CASE__      =     False





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase=False			)	->  dict:
      _lowercase				 =copy.deepcopy(UpperCAmelCase			)

      if model_class in get_values(UpperCAmelCase			):
       _lowercase				 ={
           k: tf.tile(tf.expand_dims(UpperCAmelCase						,	1			)						,	(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)			)
           if isinstance(UpperCAmelCase						,	tf.Tensor			) and v.ndim > 0
           else v
           for k, v in inputs_dict.items()
       }

      if return_labels:
       if model_class in get_values(UpperCAmelCase			):
        _lowercase				 =tf.ones(self.model_tester.batch_size						,	dtype=tf.intaa			)
       elif model_class in get_values(UpperCAmelCase			):
        _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(UpperCAmelCase			),
           *get_values(UpperCAmelCase			),
       ]:
        _lowercase				 =tf.zeros(self.model_tester.batch_size						,	dtype=tf.intaa			)
       elif model_class in get_values(UpperCAmelCase			):
        _lowercase				 =tf.zeros(self.model_tester.batch_size						,	dtype=tf.intaa			)
       elif model_class in [
           *get_values(UpperCAmelCase			),
           *get_values(UpperCAmelCase			),
           *get_values(UpperCAmelCase			),
           *get_values(UpperCAmelCase			),
           *get_values(UpperCAmelCase			),
       ]:
        _lowercase				 =tf.zeros(
            (self.model_tester.batch_size, self.model_tester.seq_length)						,	dtype=tf.intaa			)
      return inputs_dict





     @slow
     def 	__A   (self			)	->  Any:
      _lowercase ,       _lowercase				 =self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes[:2]:
       _lowercase				 =self._prepare_for_class(UpperCAmelCase						,	UpperCAmelCase			)
       _lowercase				 =model_class(UpperCAmelCase			)

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

       _lowercase				 =run_in_graph_mode()
       self.assertIsNotNone(UpperCAmelCase			)





     @slow
     def 	__A   (self			)	->  Optional[Any]:
      _lowercase ,       _lowercase				 =self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes[:2]:
       _lowercase				 =self._prepare_for_class(UpperCAmelCase						,	UpperCAmelCase			)
       _lowercase				 =model_class(UpperCAmelCase			)

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

       _lowercase				 =run_in_graph_mode()
       self.assertIsNotNone(UpperCAmelCase			)





     @slow
     def 	__A   (self			)	->  Optional[int]:
      # This is a copy of the test_keras_fit method, but we use XLA compilation instead of eager
      _lowercase ,       _lowercase				 =self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes[:2]:
       _lowercase				 =model_class(UpperCAmelCase			)
       if getattr(UpperCAmelCase						,	'''hf_compute_loss'''						,	UpperCAmelCase			):
        # Test that model correctly compute the loss with kwargs
        _lowercase				 =self._prepare_for_class(inputs_dict.copy()						,	UpperCAmelCase						,	return_labels=UpperCAmelCase			)
        # 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(UpperCAmelCase			)			)
        self.assertGreater(len(UpperCAmelCase			)						,	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(UpperCAmelCase			)						,	0			)

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

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

        _lowercase				 =history.history['''loss'''][0]
        self.assertTrue(not isnan(UpperCAmelCase			)			)
        _lowercase				 =history.history['''val_loss'''][0]
        self.assertTrue(not isnan(UpperCAmelCase			)			)





     @slow
     def 	__A   (self			)	->  Union[str, Any]:
      _lowercase ,       _lowercase				 =self.model_tester.prepare_config_and_inputs_for_common()
      _lowercase				 =True
      _lowercase				 =True

      if hasattr(UpperCAmelCase						,	'''use_cache'''			):
       _lowercase				 =True

      _lowercase				 =getattr(self.model_tester						,	'''encoder_seq_length'''						,	self.model_tester.seq_length			)
      _lowercase				 =getattr(self.model_tester						,	'''key_length'''						,	UpperCAmelCase			)

      for model_class in self.all_model_classes[:2]:
       _lowercase				 =self._prepare_for_class(UpperCAmelCase						,	UpperCAmelCase			)
       _lowercase				 =model_class(UpperCAmelCase			)
       model.build()
       _lowercase				 =len(model(UpperCAmelCase			)			)

       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(UpperCAmelCase						,	saved_model=UpperCAmelCase			)
        _lowercase				 =os.path.join(UpperCAmelCase						,	'''saved_model'''						,	'''1'''			)
        _lowercase				 =tf.keras.models.load_model(UpperCAmelCase			)
        _lowercase				 =model(UpperCAmelCase			)

        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(UpperCAmelCase			)						,	UpperCAmelCase			)

        _lowercase				 =getattr(
            self.model_tester						,	'''expected_num_hidden_layers'''						,	self.model_tester.num_hidden_layers + 1			)

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

        self.assertEqual(len(UpperCAmelCase			)						,	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 	__A   (self			)	->  str:
      tf.keras.mixed_precision.set_global_policy('''mixed_float16'''			)

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

        self.assertIsNotNone(UpperCAmelCase			)
      finally:
       tf.keras.mixed_precision.set_global_policy('''float32'''			)





     @slow
     def 	__A   (self			)	->  List[Any]:
      _lowercase ,       _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(UpperCAmelCase			)
          if module_member_name.endswith('''MainLayer'''			)
          for module_member in (getattr(UpperCAmelCase						,	UpperCAmelCase			),)
          if isinstance(UpperCAmelCase						,	UpperCAmelCase			)
          and tf.keras.layers.Layer in module_member.__bases__
          and getattr(UpperCAmelCase						,	'''_keras_serializable'''						,	UpperCAmelCase			)
      }

      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(UpperCAmelCase						,	embed_tokens=UpperCAmelCase			)
       else:
        _lowercase				 =main_layer_class(UpperCAmelCase			)

       _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(UpperCAmelCase			)[0]
       _lowercase				 =tf.keras.layers.Dense(UpperCAmelCase						,	activation='''softmax'''						,	name='''outputs'''			)(UpperCAmelCase			)
       _lowercase				 =tf.keras.models.Model(inputs=UpperCAmelCase						,	outputs=[outputs]			)

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

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





     @slow
     def 	__A   (self			)	->  Optional[Any]:
      _lowercase ,       _lowercase				 =self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes[:2]:
       _lowercase				 =model_class(UpperCAmelCase			)

       _lowercase				 =copy.deepcopy(UpperCAmelCase			)

       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'''						,	UpperCAmelCase			)
        del inputs["input_ids"]
        inputs.pop('''decoder_input_ids'''						,	UpperCAmelCase			)

       if not self.is_encoder_decoder:
        _lowercase				 =model.get_input_embeddings()(UpperCAmelCase			)
       else:
        _lowercase				 =model.get_input_embeddings()(UpperCAmelCase			)
        _lowercase				 =model.get_input_embeddings()(UpperCAmelCase			)

       _lowercase				 =self._prepare_for_class(UpperCAmelCase						,	UpperCAmelCase			)

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

       _lowercase				 =run_in_graph_mode()
       self.assertIsNotNone(UpperCAmelCase			)





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase			)	->  int:
      # special tokens cannot be bad tokens
      _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(UpperCAmelCase			) < 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(UpperCAmelCase			)
      return bad_tokens





     def 	__A   (self						,	UpperCAmelCase			)	->  Optional[Any]:
      for token_id in output_ids[0].numpy().tolist():
       self.assertGreaterEqual(UpperCAmelCase						,	0			)
       self.assertLess(UpperCAmelCase						,	self.model_tester.vocab_size			)





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Optional[int]:
      # for all bad word tokens
      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(UpperCAmelCase			)						,	len(UpperCAmelCase			)			):
         # if tokens match
         if generated_ids_slice[i - len(UpperCAmelCase			) : i] == bad_word_ids:
          return True
      return False





from __future__ import annotations

import unittest

from transformers import MPNetConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers.models.mpnet.modeling_tf_mpnet import (
      TFMPNetForMaskedLM,
      TFMPNetForMultipleChoice,
      TFMPNetForQuestionAnswering,
      TFMPNetForSequenceClassification,
      TFMPNetForTokenClassification,
      TFMPNetModel,
  )







class  lowerCamelCase__  :





     def __init__(self						,	UpperCAmelCase						,	UpperCAmelCase=1_3						,	UpperCAmelCase=7						,	UpperCAmelCase=True						,	UpperCAmelCase=True						,	UpperCAmelCase=False						,	UpperCAmelCase=True						,	UpperCAmelCase=9_9						,	UpperCAmelCase=6_4						,	UpperCAmelCase=2						,	UpperCAmelCase=4						,	UpperCAmelCase=6_4						,	UpperCAmelCase="gelu"						,	UpperCAmelCase=0.1						,	UpperCAmelCase=0.1						,	UpperCAmelCase=5_1_2						,	UpperCAmelCase=1_6						,	UpperCAmelCase=2						,	UpperCAmelCase=0.02						,	UpperCAmelCase=3						,	UpperCAmelCase=4						,	UpperCAmelCase=None						,	)	->  Optional[Any]:
      _lowercase				 =parent
      _lowercase				 =batch_size
      _lowercase				 =seq_length
      _lowercase				 =is_training
      _lowercase				 =use_input_mask
      _lowercase				 =use_token_type_ids
      _lowercase				 =use_labels
      _lowercase				 =vocab_size
      _lowercase				 =hidden_size
      _lowercase				 =num_hidden_layers
      _lowercase				 =num_attention_heads
      _lowercase				 =intermediate_size
      _lowercase				 =hidden_act
      _lowercase				 =hidden_dropout_prob
      _lowercase				 =attention_probs_dropout_prob
      _lowercase				 =max_position_embeddings
      _lowercase				 =type_vocab_size
      _lowercase				 =type_sequence_label_size
      _lowercase				 =initializer_range
      _lowercase				 =num_labels
      _lowercase				 =num_choices
      _lowercase				 =scope





     def 	__A   (self			)	->  Union[str, Any]:
      _lowercase				 =ids_tensor([self.batch_size, self.seq_length]						,	self.vocab_size			)

      _lowercase				 =None
      if self.use_input_mask:
       _lowercase				 =random_attention_mask([self.batch_size, self.seq_length]			)

      _lowercase				 =None
      _lowercase				 =None
      _lowercase				 =None
      if self.use_labels:
       _lowercase				 =ids_tensor([self.batch_size]						,	self.type_sequence_label_size			)
       _lowercase				 =ids_tensor([self.batch_size, self.seq_length]						,	self.num_labels			)
       _lowercase				 =ids_tensor([self.batch_size]						,	self.num_choices			)

      _lowercase				 =MPNetConfig(
          vocab_size=self.vocab_size						,	hidden_size=self.hidden_size						,	num_hidden_layers=self.num_hidden_layers						,	num_attention_heads=self.num_attention_heads						,	intermediate_size=self.intermediate_size						,	hidden_act=self.hidden_act						,	hidden_dropout_prob=self.hidden_dropout_prob						,	attention_probs_dropout_prob=self.attention_probs_dropout_prob						,	max_position_embeddings=self.max_position_embeddings						,	initializer_range=self.initializer_range						,	)
      return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Tuple:
      _lowercase				 =TFMPNetModel(config=UpperCAmelCase			)
      _lowercase				 ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
      _lowercase				 =model(UpperCAmelCase			)
      _lowercase				 =[input_ids, input_mask]
      _lowercase				 =model(UpperCAmelCase			)
      self.parent.assertEqual(result.last_hidden_state.shape						,	(self.batch_size, self.seq_length, self.hidden_size)			)





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  int:
      _lowercase				 =TFMPNetForMaskedLM(config=UpperCAmelCase			)
      _lowercase				 ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
      _lowercase				 =model(UpperCAmelCase			)
      self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.seq_length, self.vocab_size)			)





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Union[str, Any]:
      _lowercase				 =TFMPNetForQuestionAnswering(config=UpperCAmelCase			)
      _lowercase				 ={
          '''input_ids''': input_ids,
          '''attention_mask''': input_mask,
      }
      _lowercase				 =model(UpperCAmelCase			)
      self.parent.assertEqual(result.start_logits.shape						,	(self.batch_size, self.seq_length)			)
      self.parent.assertEqual(result.end_logits.shape						,	(self.batch_size, self.seq_length)			)





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Dict:
      _lowercase				 =self.num_labels
      _lowercase				 =TFMPNetForSequenceClassification(UpperCAmelCase			)
      _lowercase				 ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
      _lowercase				 =model(UpperCAmelCase			)
      self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.num_labels)			)





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  List[Any]:
      _lowercase				 =self.num_choices
      _lowercase				 =TFMPNetForMultipleChoice(UpperCAmelCase			)
      _lowercase				 =tf.tile(tf.expand_dims(UpperCAmelCase						,	1			)						,	(1, self.num_choices, 1)			)
      _lowercase				 =tf.tile(tf.expand_dims(UpperCAmelCase						,	1			)						,	(1, self.num_choices, 1)			)
      _lowercase				 ={
          '''input_ids''': multiple_choice_inputs_ids,
          '''attention_mask''': multiple_choice_input_mask,
      }
      _lowercase				 =model(UpperCAmelCase			)
      self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.num_choices)			)





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Dict:
      _lowercase				 =self.num_labels
      _lowercase				 =TFMPNetForTokenClassification(UpperCAmelCase			)
      _lowercase				 ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
      _lowercase				 =model(UpperCAmelCase			)
      self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.seq_length, self.num_labels)			)





     def 	__A   (self			)	->  List[Any]:
      _lowercase				 =self.prepare_config_and_inputs()
      ((_lowercase) ,       (_lowercase) ,       (_lowercase) ,       (_lowercase) ,       (_lowercase) ,       (_lowercase))				 =config_and_inputs
      _lowercase				 ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
      return config, inputs_dict







@require_tf
class  lowerCamelCase__  (			lowerCAmelCase  ,				lowerCAmelCase  ,				unittest.TestCase):
     SCREAMING_SNAKE_CASE__      =     (
         (
             TFMPNetForMaskedLM,
             TFMPNetForMultipleChoice,
             TFMPNetForQuestionAnswering,
             TFMPNetForSequenceClassification,
             TFMPNetForTokenClassification,
             TFMPNetModel,
         )
         if is_tf_available()
         else ()
     )
     SCREAMING_SNAKE_CASE__      =     (
         {
             '''feature-extraction''': TFMPNetModel,
             '''fill-mask''': TFMPNetForMaskedLM,
             '''question-answering''': TFMPNetForQuestionAnswering,
             '''text-classification''': TFMPNetForSequenceClassification,
             '''token-classification''': TFMPNetForTokenClassification,
             '''zero-shot''': TFMPNetForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     SCREAMING_SNAKE_CASE__      =     False
     SCREAMING_SNAKE_CASE__      =     False





     def 	__A   (self			)	->  Union[str, Any]:
      _lowercase				 =TFMPNetModelTester(self			)
      _lowercase				 =ConfigTester(self						,	config_class=UpperCAmelCase						,	hidden_size=3_7			)





     def 	__A   (self			)	->  Optional[Any]:
      self.config_tester.run_common_tests()





     def 	__A   (self			)	->  Tuple:
      _lowercase				 =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mpnet_model(*UpperCAmelCase			)





     def 	__A   (self			)	->  Tuple:
      _lowercase				 =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mpnet_for_masked_lm(*UpperCAmelCase			)





     def 	__A   (self			)	->  str:
      _lowercase				 =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mpnet_for_question_answering(*UpperCAmelCase			)





     def 	__A   (self			)	->  List[str]:
      _lowercase				 =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mpnet_for_sequence_classification(*UpperCAmelCase			)





     def 	__A   (self			)	->  Any:
      _lowercase				 =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mpnet_for_multiple_choice(*UpperCAmelCase			)





     def 	__A   (self			)	->  List[str]:
      _lowercase				 =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_mpnet_for_token_classification(*UpperCAmelCase			)





     @slow
     def 	__A   (self			)	->  Tuple:
      for model_name in ["microsoft/mpnet-base"]:
       _lowercase				 =TFMPNetModel.from_pretrained(UpperCAmelCase			)
       self.assertIsNotNone(UpperCAmelCase			)







@require_tf
class  lowerCamelCase__  (			unittest.TestCase):





     @slow
     def 	__A   (self			)	->  Dict:
      _lowercase				 =TFMPNetModel.from_pretrained('''microsoft/mpnet-base'''			)
      _lowercase				 =tf.constant([[0, 1, 2, 3, 4, 5]]			)
      _lowercase				 =model(UpperCAmelCase			)[0]

      _lowercase				 =[1, 6, 7_6_8]
      self.assertEqual(output.shape						,	UpperCAmelCase			)

      _lowercase				 =tf.constant(
          [
              [
                  [-0.106_7172, 0.0821_6473, 0.002_4543],
                  [-0.0346_5879, 0.835_4118, -0.0325_2288],
                  [-0.0656_9476, -0.1242_4111, -0.049_4436],
              ]
          ]			)
      tf.debugging.assert_near(output[:, :3, :3]						,	UpperCAmelCase						,	atol=1e-4			)

