





import unittest

from transformers import ErnieMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        ErnieMForInformationExtraction,
        ErnieMForMultipleChoice,
        ErnieMForQuestionAnswering,
        ErnieMForSequenceClassification,
        ErnieMForTokenClassification,
        ErnieMModel,
    )
    from transformers.models.ernie_m.modeling_ernie_m import ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST



class  SCREAMING_SNAKE_CASE_  :


  """simple docstring"""





  def __init__(  self	,  A	,  A=13	,  A=7	,  A=True	,  A=True	,  A=True	,  A=99	,  A=32	,  A=5	,  A=4	,  A=37	,  A="gelu"	,  A=0.1	,  A=0.1	,  A=5_12	,  A=16	,  A=2	,  A=0.02	,  A=3	,  A=4	,  A=None	,  )		->   Optional[int]:





       '''simple docstring'''







       __magic_name__				=       parent
       __magic_name__				=       batch_size
       __magic_name__				=       seq_length
       __magic_name__				=       is_training
       __magic_name__				=       use_input_mask
       __magic_name__				=       use_labels
       __magic_name__				=       vocab_size
       __magic_name__				=       hidden_size
       __magic_name__				=       num_hidden_layers
       __magic_name__				=       num_attention_heads
       __magic_name__				=       intermediate_size
       __magic_name__				=       hidden_act
       __magic_name__				=       hidden_dropout_prob
       __magic_name__				=       attention_probs_dropout_prob
       __magic_name__				=       max_position_embeddings
       __magic_name__				=       type_vocab_size
       __magic_name__				=       type_sequence_label_size
       __magic_name__				=       initializer_range
       __magic_name__				=       num_labels
       __magic_name__				=       num_choices
       __magic_name__				=       scope





  def 			__A      (  self						)		->   Dict:





       '''simple docstring'''







       __magic_name__				=       ids_tensor([self.batch_size, self.seq_length]	,  self.vocab_size						)

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

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

       __magic_name__				=       self.get_config()

       return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels





  def 			__A      (  self						)		->   int:





       '''simple docstring'''







       __magic_name__				=       ids_tensor([self.batch_size, self.seq_length]	,  self.vocab_size						)

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

       return config, input_ids, input_mask





  def 			__A      (  self						)		->   Union[str, Any]:





       '''simple docstring'''







       return ErnieMConfig(
           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	,  type_vocab_size=self.type_vocab_size	,  initializer_range=self.initializer_range	,  )





  def 			__A      (  self	,  A	,  A	,  A	,  A	,  A	,  A						)		->   Union[str, Any]:





       '''simple docstring'''







       __magic_name__				=       ErnieMModel(config=A						)
       model.to(A						)
       model.eval()
       __magic_name__				=       model(A	,  return_dict=A						)
       self.parent.assertEqual(result.last_hidden_state.shape	,  (self.batch_size, self.seq_length, self.hidden_size)						)





  def 			__A      (  self	,  A	,  A	,  A	,  A	,  A	,  A						)		->   List[str]:





       '''simple docstring'''







       __magic_name__				=       ErnieMForQuestionAnswering(config=A						)
       model.to(A						)
       model.eval()
       __magic_name__				=       model(
           A	,  attention_mask=A	,  start_positions=A	,  end_positions=A	,  )
       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	,  A	,  A	,  A	,  A	,  A	,  A						)		->   Optional[Any]:





       '''simple docstring'''







       __magic_name__				=       ErnieMForInformationExtraction(config=A						)
       model.to(A						)
       model.eval()
       __magic_name__				=       torch.ones_like(A	,  dtype=torch.floataa						)
       __magic_name__				=       model(
           A	,  attention_mask=A	,  start_positions=A	,  end_positions=A	,  )
       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	,  A	,  A	,  A	,  A	,  A	,  A						)		->   Optional[Any]:





       '''simple docstring'''







       __magic_name__				=       self.num_labels
       __magic_name__				=       ErnieMForSequenceClassification(A						)
       model.to(A						)
       model.eval()
       __magic_name__				=       model(A	,  attention_mask=A	,  labels=A						)
       self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.num_labels)						)





  def 			__A      (  self	,  A	,  A	,  A	,  A	,  A	,  A						)		->   List[Any]:





       '''simple docstring'''







       __magic_name__				=       self.num_labels
       __magic_name__				=       ErnieMForTokenClassification(config=A						)
       model.to(A						)
       model.eval()
       input_ids.to(A						)
       input_mask.to(A						)
       token_labels.to(A						)

       __magic_name__				=       model(A	,  attention_mask=A	,  labels=A						)

       self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.seq_length, self.num_labels)						)





  def 			__A      (  self	,  A	,  A	,  A	,  A	,  A	,  A						)		->   Optional[int]:





       '''simple docstring'''







       __magic_name__				=       self.num_choices
       __magic_name__				=       ErnieMForMultipleChoice(config=A						)
       model.to(A						)
       model.eval()
       __magic_name__				=       input_ids.unsqueeze(1						).expand(-1	,  self.num_choices	,  -1						).contiguous()
       __magic_name__				=       input_mask.unsqueeze(1						).expand(-1	,  self.num_choices	,  -1						).contiguous()
       __magic_name__				=       model(
           A	,  attention_mask=A	,  labels=A	,  )
       self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.num_choices)						)







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





       '''simple docstring'''







       __magic_name__				=       self.prepare_config_and_inputs()
       (
           (
           __magic_name__
       )		,  (
           __magic_name__
       )		,  (
           __magic_name__
       )		,  (
           __magic_name__
       )		,  (
           __magic_name__
       )		,  (
           __magic_name__
       )		,  
       )				=       config_and_inputs
       __magic_name__				=       {'''input_ids''': input_ids, '''attention_mask''': input_mask}
       return config, inputs_dict



@require_torch
class  SCREAMING_SNAKE_CASE_  ( SCREAMING_SNAKE_CASE__   ,							SCREAMING_SNAKE_CASE__   ,							unittest.TestCase			):


  """simple docstring"""





  _a								=							(
      (
          ErnieMModel,
          ErnieMForMultipleChoice,
          ErnieMForQuestionAnswering,
          ErnieMForSequenceClassification,
          ErnieMForTokenClassification,
      )
      if is_torch_available()
      else ()
  )
  _a								=							()
  _a								=							(
      {
          """feature-extraction""": ErnieMModel,
          """question-answering""": ErnieMForQuestionAnswering,
          """text-classification""": ErnieMForSequenceClassification,
          """token-classification""": ErnieMForTokenClassification,
          """zero-shot""": ErnieMForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  _a								=							False





  def 			__A      (  self	,  A	,  A	,  A	,  A	,  A						)		->   Union[str, Any]:





       '''simple docstring'''







       if pipeline_test_casse_name == "QAPipelineTests":
            return True

       return False





  def 			__A      (  self						)		->   int:





       '''simple docstring'''







       __magic_name__				=       ErnieMModelTester(self						)
       __magic_name__				=       ConfigTester(self	,  config_class=A	,  hidden_size=37						)





  def 			__A      (  self						)		->   Optional[int]:





       '''simple docstring'''







       self.config_tester.run_common_tests()





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





       '''simple docstring'''







       __magic_name__				=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*A						)





  def 			__A      (  self						)		->   List[Any]:





       '''simple docstring'''







       __magic_name__				=       self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
            __magic_name__				=       type
            self.model_tester.create_and_check_model(*A						)





  def 			__A      (  self						)		->   List[Any]:





       '''simple docstring'''







       __magic_name__				=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*A						)





  def 			__A      (  self						)		->   Optional[int]:





       '''simple docstring'''







       __magic_name__				=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*A						)





  def 			__A      (  self						)		->   Union[str, Any]:





       '''simple docstring'''







       __magic_name__				=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*A						)





  def 			__A      (  self						)		->   Dict:





       '''simple docstring'''







       __magic_name__				=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_information_extraction(*A						)





  def 			__A      (  self						)		->   List[str]:





       '''simple docstring'''







       __magic_name__				=       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*A						)







  @slow
  def 			__A      (  self						)		->   List[str]:





       '''simple docstring'''







       for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __magic_name__				=       ErnieMModel.from_pretrained(A						)
            self.assertIsNotNone(A						)



@require_torch
class  SCREAMING_SNAKE_CASE_  ( unittest.TestCase			):


  """simple docstring"""





  @slow
  def 			__A      (  self						)		->   str:





       '''simple docstring'''







       __magic_name__				=       ErnieMModel.from_pretrained('''susnato/ernie-m-base_pytorch'''						)
       model.eval()
       __magic_name__				=       torch.tensor([[0, 1, 2, 3, 4, 5]]						)
       __magic_name__				=       model(A						)[0]

       # TODO Replace vocab size
       __magic_name__				=       7_68

       __magic_name__				=       torch.Size((1, 6, hidden_size)						)
       self.assertEqual(output.shape	,  A						)

       __magic_name__				=       torch.tensor(
           [[[-0.00_12, 0.12_45, -0.02_14], [-0.07_42, 0.02_44, -0.07_71], [-0.03_33, 0.11_64, -0.15_54]]]						)

       self.assertTrue(torch.allclose(output[:, :3, :3]	,  A	,  atol=1E-3						)						)






from math import pi




def   _SCREAMING_SNAKE_CASE      (	snake_case_		:						float						):
     return degree / (180 / pi)


if __name__ == "__main__":
    from doctest import testmod

    testmod()