code: 
  
  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 		__magic_name__    :
  
     '''simple docstring'''
  
  
  
  
     def __init__(       self,					lowercase_,					lowercase_=13,					lowercase_=7,					lowercase_=True,					lowercase_=True,					lowercase_=True,					lowercase_=99,					lowercase_=32,					lowercase_=5,					lowercase_=4,					lowercase_=37,					lowercase_="gelu",					lowercase_=0.1,					lowercase_=0.1,					lowercase_=512,					lowercase_=16,					lowercase_=2,					lowercase_=0.02,					lowercase_=3,					lowercase_=4,					lowercase_=None,					)							->					List[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=parent
       a__						=batch_size
       a__						=seq_length
       a__						=is_training
       a__						=use_input_mask
       a__						=use_labels
       a__						=vocab_size
       a__						=hidden_size
       a__						=num_hidden_layers
       a__						=num_attention_heads
       a__						=intermediate_size
       a__						=hidden_act
       a__						=hidden_dropout_prob
       a__						=attention_probs_dropout_prob
       a__						=max_position_embeddings
       a__						=type_vocab_size
       a__						=type_sequence_label_size
       a__						=initializer_range
       a__						=num_labels
       a__						=num_choices
       a__						=scope
  
  
  
     def 				_UpperCAmelCase				(       self )							->					List[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=ids_tensor([self.batch_size, self.seq_length],					self.vocab_size )
  
       a__						=None
       if self.use_input_mask:
         a__						=random_attention_mask([self.batch_size, self.seq_length] )
  
       a__						=None
       a__						=None
       a__						=None
       if self.use_labels:
         a__						=ids_tensor([self.batch_size],					self.type_sequence_label_size )
         a__						=ids_tensor([self.batch_size, self.seq_length],					self.num_labels )
         a__						=ids_tensor([self.batch_size],					self.num_choices )
  
       a__						=self.get_config()
  
       return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=ids_tensor([self.batch_size, self.seq_length],					self.vocab_size )
  
       a__						=None
       if self.use_input_mask:
         a__						=random_attention_mask([self.batch_size, self.seq_length] )
       a__						=self.get_config()
  
       return config, input_ids, input_mask
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """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 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_ )							->					Union[str, Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=ErnieMModel(config=lowercase_ )
       model.to(lowercase_ )
       model.eval()
       a__						=model(lowercase_,					return_dict=lowercase_ )
       self.parent.assertEqual(result.last_hidden_state.shape,					(self.batch_size, self.seq_length, self.hidden_size) )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_ )							->					List[str]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=ErnieMForQuestionAnswering(config=lowercase_ )
       model.to(lowercase_ )
       model.eval()
       a__						=model(
           lowercase_,					attention_mask=lowercase_,					start_positions=lowercase_,					end_positions=lowercase_,					)
       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 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_ )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=ErnieMForInformationExtraction(config=lowercase_ )
       model.to(lowercase_ )
       model.eval()
       a__						=torch.ones_like(lowercase_,					dtype=torch.floataa )
       a__						=model(
           lowercase_,					attention_mask=lowercase_,					start_positions=lowercase_,					end_positions=lowercase_,					)
       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 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_ )							->					Union[str, Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.num_labels
       a__						=ErnieMForSequenceClassification(lowercase_ )
       model.to(lowercase_ )
       model.eval()
       a__						=model(lowercase_,					attention_mask=lowercase_,					labels=lowercase_ )
       self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.num_labels) )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_ )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.num_labels
       a__						=ErnieMForTokenClassification(config=lowercase_ )
       model.to(lowercase_ )
       model.eval()
       input_ids.to(lowercase_ )
       input_mask.to(lowercase_ )
       token_labels.to(lowercase_ )
  
       a__						=model(lowercase_,					attention_mask=lowercase_,					labels=lowercase_ )
  
       self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.seq_length, self.num_labels) )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_ )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.num_choices
       a__						=ErnieMForMultipleChoice(config=lowercase_ )
       model.to(lowercase_ )
       model.eval()
       a__						=input_ids.unsqueeze(1 ).expand(-1,					self.num_choices,					-1 ).contiguous()
       a__						=input_mask.unsqueeze(1 ).expand(-1,					self.num_choices,					-1 ).contiguous()
       a__						=model(
           lowercase_,					attention_mask=lowercase_,					labels=lowercase_,					)
       self.parent.assertEqual(result.logits.shape,					(self.batch_size, self.num_choices) )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.prepare_config_and_inputs()
       (
           (
           a__   
       ),   (
           a__   
       ),   (
           a__   
       ),   (
           a__   
       ),   (
           a__   
       ),   (
           a__   
       ),      
       )						=config_and_inputs
       a__						={'''input_ids''': input_ids, '''attention_mask''': input_mask}
       return config, inputs_dict
  
  
  
  
  
  
  
  @require_torch
  class 		__magic_name__    (							lowerCamelCase__	, lowerCamelCase__	, unittest.TestCase							):
  
     '''simple docstring'''
  
  
  
  
     lowerCamelCase__				:			List[Any]												=     (
         (
             ErnieMModel,
             ErnieMForMultipleChoice,
             ErnieMForQuestionAnswering,
             ErnieMForSequenceClassification,
             ErnieMForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     lowerCamelCase__				:			Union[str, Any]												=     ()
     lowerCamelCase__				:			Union[str, Any]												=     (
         {
             'feature-extraction': ErnieMModel,
             'question-answering': ErnieMForQuestionAnswering,
             'text-classification': ErnieMForSequenceClassification,
             'token-classification': ErnieMForTokenClassification,
             'zero-shot': ErnieMForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     lowerCamelCase__				:			Any												=     False
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_,					lowercase_ )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       if pipeline_test_casse_name == "QAPipelineTests":
         return True
  
       return False
  
  
  
     def 				_UpperCAmelCase				(       self )							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=ErnieMModelTester(self )
       a__						=ConfigTester(self,					config_class=lowercase_,					hidden_size=37 )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       self.config_tester.run_common_tests()
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Union[str, Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
         a__						=type
         self.model_tester.create_and_check_model(*lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Tuple:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					str:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_information_extraction(*lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*lowercase_ )
  
  
  
     @slow
     def 				_UpperCAmelCase				(       self )							->					str:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         a__						=ErnieMModel.from_pretrained(lowercase_ )
         self.assertIsNotNone(lowercase_ )
  
  
  
  
  
  
  
  @require_torch
  class 		__magic_name__    (							unittest.TestCase							):
  
     '''simple docstring'''
  
  
  
  
     @slow
     def 				_UpperCAmelCase				(       self )							->					str:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=ErnieMModel.from_pretrained('''susnato/ernie-m-base_pytorch''' )
       model.eval()
       a__						=torch.tensor([[0, 1, 2, 3, 4, 5]] )
       a__						=model(lowercase_ )[0]
  
       # TODO Replace vocab size
       a__						=768
  
       a__						=torch.Size((1, 6, hidden_size) )
       self.assertEqual(output.shape,					lowercase_ )
  
       a__						=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],					lowercase_,					atol=1E-3 ) )
  
style_context: 
  
  import os
  from shutil import copyfile
  from typing import List, Optional, Tuple
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import is_sentencepiece_available, logging
  
  
  if is_sentencepiece_available():
         from .tokenization_xglm import XGLMTokenizer
  else:
         lowerCamelCase     =      None
  
  
  lowerCamelCase     =      logging.get_logger(__name__)
  
  lowerCamelCase     =      {'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''}
  
  lowerCamelCase     =      {
      '''vocab_file''': {
          '''facebook/xglm-564M''': '''https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model''',
      },
      '''tokenizer_file''': {
          '''facebook/xglm-564M''': '''https://huggingface.co/facebook/xglm-564M/resolve/main/tokenizer.json''',
      },
  }
  
  lowerCamelCase     =      {
      '''facebook/xglm-564M''': 2048,
  }
  
  
  
  
  
  
  
  class 		__magic_name__    (							lowerCamelCase__							):
  
     '''simple docstring'''
  
  
  
  
     lowerCamelCase__				:			int												=     VOCAB_FILES_NAMES
     lowerCamelCase__				:			List[str]												=     PRETRAINED_VOCAB_FILES_MAP
     lowerCamelCase__				:			Dict												=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     lowerCamelCase__				:			Any												=     ['input_ids', 'attention_mask']
     lowerCamelCase__				:			Any												=     XGLMTokenizer
  
  
  
     def __init__(       self,					lowercase_=None,					lowercase_=None,					lowercase_="<s>",					lowercase_="</s>",					lowercase_="</s>",					lowercase_="<s>",					lowercase_="<unk>",					lowercase_="<pad>",					**lowercase_,					)							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=7
       a__						=[F"""<madeupword{i}>""" for i in range(self.num_madeup_words )]
  
       a__						=kwargs.get('''additional_special_tokens''',					[] )
       kwargs["additional_special_tokens"] += [
           word for word in madeup_words if word not in kwargs["additional_special_tokens"]
       ]
  
       super().__init__(
           lowercase_,					tokenizer_file=lowercase_,					bos_token=lowercase_,					eos_token=lowercase_,					sep_token=lowercase_,					cls_token=lowercase_,					unk_token=lowercase_,					pad_token=lowercase_,					**lowercase_,					)
  
       a__						=vocab_file
       a__						=False if not self.vocab_file else True
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = None )							->					List[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       if token_ids_a is None:
         return [self.sep_token_id] + token_ids_a
       a__						=[self.sep_token_id]
       return sep + token_ids_a + sep + sep + token_ids_a
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = None )							->					List[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=[self.sep_token_id]
  
       if token_ids_a is None:
         return len(sep + token_ids_a ) * [0]
       return len(sep + token_ids_a + sep + sep + token_ids_a ) * [0]
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = None )							->					Tuple[str]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       if not self.can_save_slow_tokenizer:
         raise ValueError(
             '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
             '''tokenizer.''' )
  
       if not os.path.isdir(lowercase_ ):
         logger.error(F"""Vocabulary path ({save_directory}) should be a directory.""" )
         return
       a__						=os.path.join(
           lowercase_,					(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] )
  
       if os.path.abspath(self.vocab_file ) != os.path.abspath(lowercase_ ):
         copyfile(self.vocab_file,					lowercase_ )
  
       return (out_vocab_file,)
  