


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  lowerCamelCase__  :





     def __init__(self						,	UpperCAmelCase						,	UpperCAmelCase=1_3						,	UpperCAmelCase=7						,	UpperCAmelCase=True						,	UpperCAmelCase=True						,	UpperCAmelCase=True						,	UpperCAmelCase=9_9						,	UpperCAmelCase=3_2						,	UpperCAmelCase=5						,	UpperCAmelCase=4						,	UpperCAmelCase=3_7						,	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						,	)	->  List[Any]:
      _lowercase				 =parent
      _lowercase				 =batch_size
      _lowercase				 =seq_length
      _lowercase				 =is_training
      _lowercase				 =use_input_mask
      _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			)	->  List[str]:
      _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				 =self.get_config()

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





     def 	__A   (self			)	->  List[str]:
      _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				 =self.get_config()

      return config, input_ids, input_mask





     def 	__A   (self			)	->  int:
      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						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Dict:
      _lowercase				 =ErnieMModel(config=UpperCAmelCase			)
      model.to(UpperCAmelCase			)
      model.eval()
      _lowercase				 =model(UpperCAmelCase						,	return_dict=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			)	->  Tuple:
      _lowercase				 =ErnieMForQuestionAnswering(config=UpperCAmelCase			)
      model.to(UpperCAmelCase			)
      model.eval()
      _lowercase				 =model(
          UpperCAmelCase						,	attention_mask=UpperCAmelCase						,	start_positions=UpperCAmelCase						,	end_positions=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			)	->  str:
      _lowercase				 =ErnieMForInformationExtraction(config=UpperCAmelCase			)
      model.to(UpperCAmelCase			)
      model.eval()
      _lowercase				 =torch.ones_like(UpperCAmelCase						,	dtype=torch.floataa			)
      _lowercase				 =model(
          UpperCAmelCase						,	attention_mask=UpperCAmelCase						,	start_positions=UpperCAmelCase						,	end_positions=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			)	->  Union[str, Any]:
      _lowercase				 =self.num_labels
      _lowercase				 =ErnieMForSequenceClassification(UpperCAmelCase			)
      model.to(UpperCAmelCase			)
      model.eval()
      _lowercase				 =model(UpperCAmelCase						,	attention_mask=UpperCAmelCase						,	labels=UpperCAmelCase			)
      self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.num_labels)			)





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Optional[Any]:
      _lowercase				 =self.num_labels
      _lowercase				 =ErnieMForTokenClassification(config=UpperCAmelCase			)
      model.to(UpperCAmelCase			)
      model.eval()
      input_ids.to(UpperCAmelCase			)
      input_mask.to(UpperCAmelCase			)
      token_labels.to(UpperCAmelCase			)

      _lowercase				 =model(UpperCAmelCase						,	attention_mask=UpperCAmelCase						,	labels=UpperCAmelCase			)

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





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Optional[int]:
      _lowercase				 =self.num_choices
      _lowercase				 =ErnieMForMultipleChoice(config=UpperCAmelCase			)
      model.to(UpperCAmelCase			)
      model.eval()
      _lowercase				 =input_ids.unsqueeze(1			).expand(-1						,	self.num_choices						,	-1			).contiguous()
      _lowercase				 =input_mask.unsqueeze(1			).expand(-1						,	self.num_choices						,	-1			).contiguous()
      _lowercase				 =model(
          UpperCAmelCase						,	attention_mask=UpperCAmelCase						,	labels=UpperCAmelCase						,	)
      self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.num_choices)			)





     def 	__A   (self			)	->  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_torch
class  lowerCamelCase__  (			lowerCAmelCase  ,				lowerCAmelCase  ,				unittest.TestCase):
     SCREAMING_SNAKE_CASE__      =     (
         (
             ErnieMModel,
             ErnieMForMultipleChoice,
             ErnieMForQuestionAnswering,
             ErnieMForSequenceClassification,
             ErnieMForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     SCREAMING_SNAKE_CASE__      =     ()
     SCREAMING_SNAKE_CASE__      =     (
         {
             '''feature-extraction''': ErnieMModel,
             '''question-answering''': ErnieMForQuestionAnswering,
             '''text-classification''': ErnieMForSequenceClassification,
             '''token-classification''': ErnieMForTokenClassification,
             '''zero-shot''': ErnieMForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     SCREAMING_SNAKE_CASE__      =     False





     def 	__A   (self						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase						,	UpperCAmelCase			)	->  Union[str, Any]:
      if pipeline_test_casse_name == "QAPipelineTests":
       return True

      return False





     def 	__A   (self			)	->  str:
      _lowercase				 =ErnieMModelTester(self			)
      _lowercase				 =ConfigTester(self						,	config_class=UpperCAmelCase						,	hidden_size=3_7			)





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





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





     def 	__A   (self			)	->  Union[str, Any]:
      _lowercase				 =self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
       _lowercase				 =type
       self.model_tester.create_and_check_model(*UpperCAmelCase			)





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





     def 	__A   (self			)	->  Union[str, Any]:
      _lowercase				 =self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase			)





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





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





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





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







@require_torch
class  lowerCamelCase__  (			unittest.TestCase):





     @slow
     def 	__A   (self			)	->  Union[str, Any]:
      _lowercase				 =ErnieMModel.from_pretrained('''susnato/ernie-m-base_pytorch'''			)
      model.eval()
      _lowercase				 =torch.tensor([[0, 1, 2, 3, 4, 5]]			)
      _lowercase				 =model(UpperCAmelCase			)[0]

      # TODO Replace vocab size
      _lowercase				 =7_6_8

      _lowercase				 =torch.Size((1, 6, hidden_size)			)
      self.assertEqual(output.shape						,	UpperCAmelCase			)

      _lowercase				 =torch.tensor(
          [[[-0.0012, 0.1245, -0.0214], [-0.0742, 0.0244, -0.0771], [-0.0333, 0.1164, -0.1554]]]			)

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





from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCAmelCase__        =				logging.get_logger(__name__)

UpperCAmelCase__        =				{
    '''google/rembert''': '''https://huggingface.co/google/rembert/resolve/main/config.json''',
    # See all RemBERT models at https://huggingface.co/models?filter=rembert
}







class  lowerCamelCase__  (			lowerCAmelCase):
     SCREAMING_SNAKE_CASE__      =     '''rembert'''





     def __init__(self						,	UpperCAmelCase=2_5_0_3_0_0						,	UpperCAmelCase=1_1_5_2						,	UpperCAmelCase=3_2						,	UpperCAmelCase=1_8						,	UpperCAmelCase=2_5_6						,	UpperCAmelCase=1_6_6_4						,	UpperCAmelCase=4_6_0_8						,	UpperCAmelCase="gelu"						,	UpperCAmelCase=0.0						,	UpperCAmelCase=0.0						,	UpperCAmelCase=0.1						,	UpperCAmelCase=5_1_2						,	UpperCAmelCase=2						,	UpperCAmelCase=0.02						,	UpperCAmelCase=1e-12						,	UpperCAmelCase=True						,	UpperCAmelCase=0						,	UpperCAmelCase=3_1_2						,	UpperCAmelCase=3_1_3						,	**UpperCAmelCase						,	)	->  Tuple:
      super().__init__(pad_token_id=UpperCAmelCase						,	bos_token_id=UpperCAmelCase						,	eos_token_id=UpperCAmelCase						,	**UpperCAmelCase			)

      _lowercase				 =vocab_size
      _lowercase				 =input_embedding_size
      _lowercase				 =output_embedding_size
      _lowercase				 =max_position_embeddings
      _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				 =classifier_dropout_prob
      _lowercase				 =initializer_range
      _lowercase				 =type_vocab_size
      _lowercase				 =layer_norm_eps
      _lowercase				 =use_cache
      _lowercase				 =False







class  lowerCamelCase__  (			lowerCAmelCase):





     @property
     def 	__A   (self			)	->  Mapping[str, Mapping[int, str]]:
      if self.task == "multiple-choice":
       _lowercase				 ={0: '''batch''', 1: '''choice''', 2: '''sequence'''}
      else:
       _lowercase				 ={0: '''batch''', 1: '''sequence'''}
      return OrderedDict(
          [
              ('''input_ids''', dynamic_axis),
              ('''attention_mask''', dynamic_axis),
              ('''token_type_ids''', dynamic_axis),
          ]			)





     @property
     def 	__A   (self			)	->  float:
      return 1e-4

