


from __future__ import annotations

import unittest

from transformers import OpenAIGPTConfig, 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.openai.modeling_tf_openai import (
      TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFOpenAIGPTDoubleHeadsModel,
      TFOpenAIGPTForSequenceClassification,
      TFOpenAIGPTLMHeadModel,
      TFOpenAIGPTModel,
  )







class  lowerCamelCase__  :





     def __init__(self						,	UpperCAmelCase						,	)	->  List[str]:
      _lowercase				 =parent
      _lowercase				 =1_3
      _lowercase				 =7
      _lowercase				 =True
      _lowercase				 =True
      _lowercase				 =True
      _lowercase				 =True
      _lowercase				 =True
      _lowercase				 =9_9
      _lowercase				 =3_2
      _lowercase				 =2
      _lowercase				 =4
      _lowercase				 =3_7
      _lowercase				 ='''gelu'''
      _lowercase				 =0.1
      _lowercase				 =0.1
      _lowercase				 =5_1_2
      _lowercase				 =1_6
      _lowercase				 =2
      _lowercase				 =0.02
      _lowercase				 =3
      _lowercase				 =4
      _lowercase				 =None
      _lowercase				 =self.vocab_size - 1





     def 	__A   (self			)	->  int:
      _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
      if self.use_token_type_ids:
       _lowercase				 =ids_tensor([self.batch_size, self.seq_length]						,	self.type_vocab_size			)

      _lowercase				 =None
      if self.use_mc_token_ids:
       _lowercase				 =ids_tensor([self.batch_size, self.num_choices]						,	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				 =OpenAIGPTConfig(
          vocab_size=self.vocab_size						,	n_embd=self.hidden_size						,	n_layer=self.num_hidden_layers						,	n_head=self.num_attention_heads						,	n_positions=self.max_position_embeddings						,	pad_token_id=self.pad_token_id						,	)

      _lowercase				 =ids_tensor([self.num_hidden_layers, self.num_attention_heads]						,	2			)

      return (
          config,
          input_ids,
          input_mask,
          head_mask,
          token_type_ids,
          mc_token_ids,
          sequence_labels,
          token_labels,
          choice_labels,
      )





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	*UpperCAmelCase			)	->  str:
      _lowercase				 =TFOpenAIGPTModel(config=UpperCAmelCase			)
      _lowercase				 ={'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
      _lowercase				 =model(UpperCAmelCase			)

      _lowercase				 =[input_ids, input_mask]
      _lowercase				 =model(UpperCAmelCase			)

      _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			)	->  Optional[int]:
      _lowercase				 =TFOpenAIGPTLMHeadModel(config=UpperCAmelCase			)
      _lowercase				 ={'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
      _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						,	*UpperCAmelCase			)	->  Optional[Any]:
      _lowercase				 =TFOpenAIGPTDoubleHeadsModel(config=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				 =tf.tile(tf.expand_dims(UpperCAmelCase						,	1			)						,	(1, self.num_choices, 1)			)

      _lowercase				 ={
          '''input_ids''': multiple_choice_inputs_ids,
          '''mc_token_ids''': mc_token_ids,
          '''attention_mask''': multiple_choice_input_mask,
          '''token_type_ids''': multiple_choice_token_type_ids,
      }
      _lowercase				 =model(UpperCAmelCase			)
      self.parent.assertEqual(
          result.logits.shape						,	(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)			)
      self.parent.assertEqual(result.mc_logits.shape						,	(self.batch_size, self.num_choices)			)





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	*UpperCAmelCase			)	->  Union[str, Any]:
      _lowercase				 =self.num_labels
      _lowercase				 =ids_tensor([self.batch_size]						,	self.type_sequence_label_size			)
      _lowercase				 ={
          '''input_ids''': input_ids,
          '''attention_mask''': input_mask,
          '''token_type_ids''': token_type_ids,
          '''labels''': sequence_labels,
      }
      _lowercase				 =TFOpenAIGPTForSequenceClassification(UpperCAmelCase			)
      _lowercase				 =model(UpperCAmelCase			)
      self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.num_labels)			)





     def 	__A   (self			)	->  int:
      _lowercase				 =self.prepare_config_and_inputs()

      (
          (
          _lowercase
      ) ,       (
          _lowercase
      ) ,       (
          _lowercase
      ) ,       (
          _lowercase
      ) ,       (
          _lowercase
      ) ,       (
          _lowercase
      ) ,       (
          _lowercase
      ) ,       (
          _lowercase
      ) ,       (
          _lowercase
      ) ,       
      )				 =config_and_inputs

      _lowercase				 ={'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
      return config, inputs_dict







@require_tf
class  lowerCamelCase__  (			lowerCAmelCase  ,				lowerCAmelCase  ,				unittest.TestCase):
     SCREAMING_SNAKE_CASE__      =     (
         (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
         if is_tf_available()
         else ()
     )
     SCREAMING_SNAKE_CASE__      =     (
         (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
     )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
     SCREAMING_SNAKE_CASE__      =     (
         {
             '''feature-extraction''': TFOpenAIGPTModel,
             '''text-classification''': TFOpenAIGPTForSequenceClassification,
             '''text-generation''': TFOpenAIGPTLMHeadModel,
             '''zero-shot''': TFOpenAIGPTForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     SCREAMING_SNAKE_CASE__      =     False
     SCREAMING_SNAKE_CASE__      =     False





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Tuple:
      if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
       # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
       # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
       # tiny config could not be created.
       return True

      return False





     def 	__A   (self			)	->  List[str]:
      _lowercase				 =TFOpenAIGPTModelTester(self			)
      _lowercase				 =ConfigTester(self						,	config_class=UpperCAmelCase						,	n_embd=3_7			)





     def 	__A   (self			)	->  str:
      self.config_tester.run_common_tests()





     def 	__A   (self			)	->  Dict:
      _lowercase				 =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_openai_gpt_model(*UpperCAmelCase			)





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





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





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





     @slow
     def 	__A   (self			)	->  Any:
      for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       _lowercase				 =TFOpenAIGPTModel.from_pretrained(UpperCAmelCase			)
       self.assertIsNotNone(UpperCAmelCase			)







@require_tf
class  lowerCamelCase__  (			unittest.TestCase):





     @slow
     def 	__A   (self			)	->  List[str]:
      _lowercase				 =TFOpenAIGPTLMHeadModel.from_pretrained('''openai-gpt'''			)
      _lowercase				 =tf.convert_to_tensor([[4_8_1, 4_7_3_5, 5_4_4]]						,	dtype=tf.intaa			)  # the president is
      _lowercase				 =[
          4_8_1,
          4_7_3_5,
          5_4_4,
          2_4_6,
          9_6_3,
          8_7_0,
          7_6_2,
          2_3_9,
          2_4_4,
          4_0_4_7_7,
          2_4_4,
          2_4_9,
          7_1_9,
          8_8_1,
          4_8_7,
          5_4_4,
          2_4_0,
          2_4_4,
          6_0_3,
          4_8_1,
      ]  # the president is a very good man. " \n " i\'m sure he is, " said the

      _lowercase				 =model.generate(UpperCAmelCase						,	do_sample=UpperCAmelCase			)
      self.assertListEqual(output_ids[0].numpy().tolist()						,	UpperCAmelCase			)





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			)

