


from typing import TYPE_CHECKING

from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available


__lowerCAmelCase									=				{
    '''configuration_utils''': ['''GenerationConfig'''],
    '''streamers''': ['''TextIteratorStreamer''', '''TextStreamer'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowerCAmelCase									=				[
     '''Constraint''',
     '''ConstraintListState''',
     '''DisjunctiveConstraint''',
     '''PhrasalConstraint''',
 ]
 __lowerCAmelCase									=				[
     '''BeamHypotheses''',
     '''BeamScorer''',
     '''BeamSearchScorer''',
     '''ConstrainedBeamSearchScorer''',
 ]
 __lowerCAmelCase									=				[
     '''EpsilonLogitsWarper''',
     '''EtaLogitsWarper''',
     '''ForcedBOSTokenLogitsProcessor''',
     '''ForcedEOSTokenLogitsProcessor''',
     '''HammingDiversityLogitsProcessor''',
     '''InfNanRemoveLogitsProcessor''',
     '''LogitsProcessor''',
     '''LogitsProcessorList''',
     '''LogitsWarper''',
     '''MinLengthLogitsProcessor''',
     '''MinNewTokensLengthLogitsProcessor''',
     '''NoBadWordsLogitsProcessor''',
     '''NoRepeatNGramLogitsProcessor''',
     '''PrefixConstrainedLogitsProcessor''',
     '''RepetitionPenaltyLogitsProcessor''',
     '''SequenceBiasLogitsProcessor''',
     '''EncoderRepetitionPenaltyLogitsProcessor''',
     '''TemperatureLogitsWarper''',
     '''TopKLogitsWarper''',
     '''TopPLogitsWarper''',
     '''TypicalLogitsWarper''',
     '''EncoderNoRepeatNGramLogitsProcessor''',
     '''ExponentialDecayLengthPenalty''',
     '''LogitNormalization''',
 ]
 __lowerCAmelCase									=				[
     '''MaxNewTokensCriteria''',
     '''MaxLengthCriteria''',
     '''MaxTimeCriteria''',
     '''StoppingCriteria''',
     '''StoppingCriteriaList''',
     '''validate_stopping_criteria''',
 ]
 __lowerCAmelCase									=				[
     '''GenerationMixin''',
     '''top_k_top_p_filtering''',
     '''GreedySearchEncoderDecoderOutput''',
     '''GreedySearchDecoderOnlyOutput''',
     '''SampleEncoderDecoderOutput''',
     '''SampleDecoderOnlyOutput''',
     '''BeamSearchEncoderDecoderOutput''',
     '''BeamSearchDecoderOnlyOutput''',
     '''BeamSampleEncoderDecoderOutput''',
     '''BeamSampleDecoderOnlyOutput''',
     '''ContrastiveSearchEncoderDecoderOutput''',
     '''ContrastiveSearchDecoderOnlyOutput''',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowerCAmelCase									=				[
     '''TFForcedBOSTokenLogitsProcessor''',
     '''TFForcedEOSTokenLogitsProcessor''',
     '''TFLogitsProcessor''',
     '''TFLogitsProcessorList''',
     '''TFLogitsWarper''',
     '''TFMinLengthLogitsProcessor''',
     '''TFNoBadWordsLogitsProcessor''',
     '''TFNoRepeatNGramLogitsProcessor''',
     '''TFRepetitionPenaltyLogitsProcessor''',
     '''TFTemperatureLogitsWarper''',
     '''TFTopKLogitsWarper''',
     '''TFTopPLogitsWarper''',
     '''TFForceTokensLogitsProcessor''',
     '''TFSuppressTokensAtBeginLogitsProcessor''',
     '''TFSuppressTokensLogitsProcessor''',
 ]
 __lowerCAmelCase									=				[
     '''TFGenerationMixin''',
     '''tf_top_k_top_p_filtering''',
     '''TFGreedySearchDecoderOnlyOutput''',
     '''TFGreedySearchEncoderDecoderOutput''',
     '''TFSampleEncoderDecoderOutput''',
     '''TFSampleDecoderOnlyOutput''',
     '''TFBeamSearchEncoderDecoderOutput''',
     '''TFBeamSearchDecoderOnlyOutput''',
     '''TFBeamSampleEncoderDecoderOutput''',
     '''TFBeamSampleDecoderOnlyOutput''',
     '''TFContrastiveSearchEncoderDecoderOutput''',
     '''TFContrastiveSearchDecoderOnlyOutput''',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowerCAmelCase									=				[
     '''FlaxForcedBOSTokenLogitsProcessor''',
     '''FlaxForcedEOSTokenLogitsProcessor''',
     '''FlaxLogitsProcessor''',
     '''FlaxLogitsProcessorList''',
     '''FlaxLogitsWarper''',
     '''FlaxMinLengthLogitsProcessor''',
     '''FlaxTemperatureLogitsWarper''',
     '''FlaxTopKLogitsWarper''',
     '''FlaxTopPLogitsWarper''',
 ]
 __lowerCAmelCase									=				[
     '''FlaxGenerationMixin''',
     '''FlaxGreedySearchOutput''',
     '''FlaxSampleOutput''',
     '''FlaxBeamSearchOutput''',
 ]

if TYPE_CHECKING:
 from .configuration_utils import GenerationConfig
 from .streamers import TextIteratorStreamer, TextStreamer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
  from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
  from .logits_process import (
      EncoderNoRepeatNGramLogitsProcessor,
      EncoderRepetitionPenaltyLogitsProcessor,
      EpsilonLogitsWarper,
      EtaLogitsWarper,
      ExponentialDecayLengthPenalty,
      ForcedBOSTokenLogitsProcessor,
      ForcedEOSTokenLogitsProcessor,
      HammingDiversityLogitsProcessor,
      InfNanRemoveLogitsProcessor,
      LogitNormalization,
      LogitsProcessor,
      LogitsProcessorList,
      LogitsWarper,
      MinLengthLogitsProcessor,
      MinNewTokensLengthLogitsProcessor,
      NoBadWordsLogitsProcessor,
      NoRepeatNGramLogitsProcessor,
      PrefixConstrainedLogitsProcessor,
      RepetitionPenaltyLogitsProcessor,
      SequenceBiasLogitsProcessor,
      TemperatureLogitsWarper,
      TopKLogitsWarper,
      TopPLogitsWarper,
      TypicalLogitsWarper,
  )
  from .stopping_criteria import (
      MaxLengthCriteria,
      MaxNewTokensCriteria,
      MaxTimeCriteria,
      StoppingCriteria,
      StoppingCriteriaList,
      validate_stopping_criteria,
  )
  from .utils import (
      BeamSampleDecoderOnlyOutput,
      BeamSampleEncoderDecoderOutput,
      BeamSearchDecoderOnlyOutput,
      BeamSearchEncoderDecoderOutput,
      ContrastiveSearchDecoderOnlyOutput,
      ContrastiveSearchEncoderDecoderOutput,
      GenerationMixin,
      GreedySearchDecoderOnlyOutput,
      GreedySearchEncoderDecoderOutput,
      SampleDecoderOnlyOutput,
      SampleEncoderDecoderOutput,
      top_k_top_p_filtering,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tf_logits_process import (
      TFForcedBOSTokenLogitsProcessor,
      TFForcedEOSTokenLogitsProcessor,
      TFForceTokensLogitsProcessor,
      TFLogitsProcessor,
      TFLogitsProcessorList,
      TFLogitsWarper,
      TFMinLengthLogitsProcessor,
      TFNoBadWordsLogitsProcessor,
      TFNoRepeatNGramLogitsProcessor,
      TFRepetitionPenaltyLogitsProcessor,
      TFSuppressTokensAtBeginLogitsProcessor,
      TFSuppressTokensLogitsProcessor,
      TFTemperatureLogitsWarper,
      TFTopKLogitsWarper,
      TFTopPLogitsWarper,
  )
  from .tf_utils import (
      TFBeamSampleDecoderOnlyOutput,
      TFBeamSampleEncoderDecoderOutput,
      TFBeamSearchDecoderOnlyOutput,
      TFBeamSearchEncoderDecoderOutput,
      TFContrastiveSearchDecoderOnlyOutput,
      TFContrastiveSearchEncoderDecoderOutput,
      TFGenerationMixin,
      TFGreedySearchDecoderOnlyOutput,
      TFGreedySearchEncoderDecoderOutput,
      TFSampleDecoderOnlyOutput,
      TFSampleEncoderDecoderOutput,
      tf_top_k_top_p_filtering,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .flax_logits_process import (
      FlaxForcedBOSTokenLogitsProcessor,
      FlaxForcedEOSTokenLogitsProcessor,
      FlaxLogitsProcessor,
      FlaxLogitsProcessorList,
      FlaxLogitsWarper,
      FlaxMinLengthLogitsProcessor,
      FlaxTemperatureLogitsWarper,
      FlaxTopKLogitsWarper,
      FlaxTopPLogitsWarper,
  )
  from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
 import sys

 __lowerCAmelCase									=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






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     __a     :
 def __init__(  self							,					lowerCAmelCase__							,					lowerCAmelCase__=13							,					lowerCAmelCase__=7							,					lowerCAmelCase__=True							,					lowerCAmelCase__=True							,					lowerCAmelCase__=True							,					lowerCAmelCase__=99							,					lowerCAmelCase__=32							,					lowerCAmelCase__=5							,					lowerCAmelCase__=4							,					lowerCAmelCase__=37							,					lowerCAmelCase__="gelu"							,					lowerCAmelCase__=0.1							,					lowerCAmelCase__=0.1							,					lowerCAmelCase__=512							,					lowerCAmelCase__=16							,					lowerCAmelCase__=2							,					lowerCAmelCase__=0.0_2							,					lowerCAmelCase__=3							,					lowerCAmelCase__=4							,					lowerCAmelCase__=None							,					)   ->							List[Any]:




        '''simple docstring'''
        lowercase__:  Tuple         =  parent
        lowercase__:  Optional[int]         =  batch_size
        lowercase__:  Optional[Any]         =  seq_length
        lowercase__:  Dict         =  is_training
        lowercase__:  List[str]         =  use_input_mask
        lowercase__:  Tuple         =  use_labels
        lowercase__:  List[str]         =  vocab_size
        lowercase__:  Any         =  hidden_size
        lowercase__:  Optional[int]         =  num_hidden_layers
        lowercase__:  str         =  num_attention_heads
        lowercase__:  Any         =  intermediate_size
        lowercase__:  List[str]         =  hidden_act
        lowercase__:  str         =  hidden_dropout_prob
        lowercase__:  Optional[Any]         =  attention_probs_dropout_prob
        lowercase__:  Optional[Any]         =  max_position_embeddings
        lowercase__:  List[str]         =  type_vocab_size
        lowercase__:  List[Any]         =  type_sequence_label_size
        lowercase__:  Any         =  initializer_range
        lowercase__:  str         =  num_labels
        lowercase__:  Tuple         =  num_choices
        lowercase__:  str         =  scope
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							str:




        '''simple docstring'''
        lowercase__:  int         =  ids_tensor([self.batch_size, self.seq_length]							,					self.vocab_size					)

        lowercase__:  str         =  None
        if self.use_input_mask:
               lowercase__:  Dict         =  random_attention_mask([self.batch_size, self.seq_length]					)

        lowercase__:  Optional[Any]         =  None
        lowercase__:  Tuple         =  None
        lowercase__:  Any         =  None
        if self.use_labels:
               lowercase__:  List[Any]         =  ids_tensor([self.batch_size]							,					self.type_sequence_label_size					)
               lowercase__:  List[str]         =  ids_tensor([self.batch_size, self.seq_length]							,					self.num_labels					)
               lowercase__:  Dict         =  ids_tensor([self.batch_size]							,					self.num_choices					)

        lowercase__:  int         =  self.get_config()

        return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Dict:




        '''simple docstring'''
        lowercase__:  Tuple         =  ids_tensor([self.batch_size, self.seq_length]							,					self.vocab_size					)

        lowercase__:  List[str]         =  None
        if self.use_input_mask:
               lowercase__:  Union[str, Any]         =  random_attention_mask([self.batch_size, self.seq_length]					)
        lowercase__:  Any         =  self.get_config()

        return config, input_ids, input_mask
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Tuple:




        '''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 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							str:




        '''simple docstring'''
        lowercase__:  str         =  ErnieMModel(config=lowerCAmelCase__					)
        model.to(lowerCAmelCase__					)
        model.eval()
        lowercase__:  List[Any]         =  model(lowerCAmelCase__							,					return_dict=lowerCAmelCase__					)
        self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, self.seq_length, self.hidden_size)					)
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							Optional[Any]:




        '''simple docstring'''
        lowercase__:  Optional[Any]         =  ErnieMForQuestionAnswering(config=lowerCAmelCase__					)
        model.to(lowerCAmelCase__					)
        model.eval()
        lowercase__:  List[str]         =  model(
            lowerCAmelCase__							,					attention_mask=lowerCAmelCase__							,					start_positions=lowerCAmelCase__							,					end_positions=lowerCAmelCase__							,					)
        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 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							List[Any]:




        '''simple docstring'''
        lowercase__:  Dict         =  ErnieMForInformationExtraction(config=lowerCAmelCase__					)
        model.to(lowerCAmelCase__					)
        model.eval()
        lowercase__:  Any         =  torch.ones_like(lowerCAmelCase__							,					dtype=torch.floataa					)
        lowercase__:  Tuple         =  model(
            lowerCAmelCase__							,					attention_mask=lowerCAmelCase__							,					start_positions=lowerCAmelCase__							,					end_positions=lowerCAmelCase__							,					)
        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 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							Tuple:




        '''simple docstring'''
        lowercase__:  Tuple         =  self.num_labels
        lowercase__:  str         =  ErnieMForSequenceClassification(lowerCAmelCase__					)
        model.to(lowerCAmelCase__					)
        model.eval()
        lowercase__:  Optional[int]         =  model(lowerCAmelCase__							,					attention_mask=lowerCAmelCase__							,					labels=lowerCAmelCase__					)
        self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_labels)					)
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							List[Any]:




        '''simple docstring'''
        lowercase__:  Union[str, Any]         =  self.num_labels
        lowercase__:  Dict         =  ErnieMForTokenClassification(config=lowerCAmelCase__					)
        model.to(lowerCAmelCase__					)
        model.eval()
        input_ids.to(lowerCAmelCase__					)
        input_mask.to(lowerCAmelCase__					)
        token_labels.to(lowerCAmelCase__					)

        lowercase__:  Optional[Any]         =  model(lowerCAmelCase__							,					attention_mask=lowerCAmelCase__							,					labels=lowerCAmelCase__					)

        self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.seq_length, self.num_labels)					)
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							Optional[int]:




        '''simple docstring'''
        lowercase__:  Dict         =  self.num_choices
        lowercase__:  Any         =  ErnieMForMultipleChoice(config=lowerCAmelCase__					)
        model.to(lowerCAmelCase__					)
        model.eval()
        lowercase__:  Optional[int]         =  input_ids.unsqueeze(1					).expand(-1							,					self.num_choices							,					-1					).contiguous()
        lowercase__:  Any         =  input_mask.unsqueeze(1					).expand(-1							,					self.num_choices							,					-1					).contiguous()
        lowercase__:  Union[str, Any]         =  model(
            lowerCAmelCase__							,					attention_mask=lowerCAmelCase__							,					labels=lowerCAmelCase__							,					)
        self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_choices)					)
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Optional[int]:




        '''simple docstring'''
        lowercase__:  int         =  self.prepare_config_and_inputs()
        (
            (
            lowercase__
        )     ,		(
            lowercase__
        )     ,		(
            lowercase__
        )     ,		(
            lowercase__
        )     ,		(
            lowercase__
        )     ,		(
            lowercase__
        )     ,		
        ):  Optional[Any]         =  config_and_inputs
        lowercase__:  int         =  {'input_ids': input_ids, 'attention_mask': input_mask}
        return config, inputs_dict





@require_torch
class     __a     (       __UpperCamelCase			,			__UpperCamelCase			,			unittest.TestCase ):
 __lowercase					:				List[str]  	=					(
     (
         ErnieMModel,
         ErnieMForMultipleChoice,
         ErnieMForQuestionAnswering,
         ErnieMForSequenceClassification,
         ErnieMForTokenClassification,
     )
     if is_torch_available()
     else ()
 )
 __lowercase					:				List[str]  	=					()
 __lowercase					:				Optional[int]  	=					(
     {
         'feature-extraction': ErnieMModel,
         'question-answering': ErnieMForQuestionAnswering,
         'text-classification': ErnieMForSequenceClassification,
         'token-classification': ErnieMForTokenClassification,
         'zero-shot': ErnieMForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 __lowercase					:				Optional[Any]  	=					False
 def 						SCREAMING_SNAKE_CASE__  (  self							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__							,					lowerCAmelCase__					)   ->							int:




        '''simple docstring'''
        if pipeline_test_casse_name == "QAPipelineTests":
               return True

        return False
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							List[Any]:




        '''simple docstring'''
        lowercase__:  Any         =  ErnieMModelTester(self					)
        lowercase__:  List[str]         =  ConfigTester(self							,					config_class=lowerCAmelCase__							,					hidden_size=37					)
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Tuple:




        '''simple docstring'''
        self.config_tester.run_common_tests()
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							str:




        '''simple docstring'''
        lowercase__:  Union[str, Any]         =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCAmelCase__					)
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Tuple:




        '''simple docstring'''
        lowercase__:  int         =  self.model_tester.prepare_config_and_inputs()
        for type in ["absolute", "relative_key", "relative_key_query"]:
               lowercase__:  str         =  type
               self.model_tester.create_and_check_model(*lowerCAmelCase__					)
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Tuple:




        '''simple docstring'''
        lowercase__:  Optional[Any]         =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase__					)
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Dict:




        '''simple docstring'''
        lowercase__:  Tuple         =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase__					)
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Optional[Any]:




        '''simple docstring'''
        lowercase__:  Any         =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase__					)
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							List[str]:




        '''simple docstring'''
        lowercase__:  Optional[int]         =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_information_extraction(*lowerCAmelCase__					)
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Optional[Any]:




        '''simple docstring'''
        lowercase__:  Optional[int]         =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase__					)
 @slow
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							Any:




        '''simple docstring'''
        for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowercase__:  Tuple         =  ErnieMModel.from_pretrained(lowerCAmelCase__					)
               self.assertIsNotNone(lowerCAmelCase__					)





@require_torch
class     __a     (       unittest.TestCase ):
 @slow
 def 						SCREAMING_SNAKE_CASE__  (  self					)   ->							List[Any]:




        '''simple docstring'''
        lowercase__:  Optional[Any]         =  ErnieMModel.from_pretrained('susnato/ernie-m-base_pytorch'					)
        model.eval()
        lowercase__:  Union[str, Any]         =  torch.tensor([[0, 1, 2, 3, 4, 5]]					)
        lowercase__:  str         =  model(lowerCAmelCase__					)[0]

        # TODO Replace vocab size
        lowercase__:  Union[str, Any]         =  768

        lowercase__:  Any         =  torch.Size((1, 6, hidden_size)					)
        self.assertEqual(output.shape							,					lowerCAmelCase__					)

        lowercase__:  str         =  torch.tensor(
            [[[-0.0_0_1_2, 0.1_2_4_5, -0.0_2_1_4], [-0.0_7_4_2, 0.0_2_4_4, -0.0_7_7_1], [-0.0_3_3_3, 0.1_1_6_4, -0.1_5_5_4]]]					)

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


