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        lowerCAmelCase_	:
         def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_=13,    SCREAMING_SNAKE_CASE_=7,    SCREAMING_SNAKE_CASE_=True,    SCREAMING_SNAKE_CASE_=True,    SCREAMING_SNAKE_CASE_=True,    SCREAMING_SNAKE_CASE_=99,    SCREAMING_SNAKE_CASE_=32,    SCREAMING_SNAKE_CASE_=5,    SCREAMING_SNAKE_CASE_=4,    SCREAMING_SNAKE_CASE_=37,    SCREAMING_SNAKE_CASE_="gelu",    SCREAMING_SNAKE_CASE_=0.1,    SCREAMING_SNAKE_CASE_=0.1,    SCREAMING_SNAKE_CASE_=512,    SCREAMING_SNAKE_CASE_=16,    SCREAMING_SNAKE_CASE_=2,    SCREAMING_SNAKE_CASE_=0.02,    SCREAMING_SNAKE_CASE_=3,    SCREAMING_SNAKE_CASE_=4,    SCREAMING_SNAKE_CASE_=None,    )  ->	List[str]:
            UpperCamelCase					:						Optional[int]					=			parent
            UpperCamelCase					:						Dict					=			batch_size
            UpperCamelCase					:						Optional[int]					=			seq_length
            UpperCamelCase					:						Optional[Any]					=			is_training
            UpperCamelCase					:						Dict					=			use_input_mask
            UpperCamelCase					:						str					=			use_labels
            UpperCamelCase					:						Optional[Any]					=			vocab_size
            UpperCamelCase					:						Any					=			hidden_size
            UpperCamelCase					:						Optional[Any]					=			num_hidden_layers
            UpperCamelCase					:						Tuple					=			num_attention_heads
            UpperCamelCase					:						str					=			intermediate_size
            UpperCamelCase					:						Union[str, Any]					=			hidden_act
            UpperCamelCase					:						Any					=			hidden_dropout_prob
            UpperCamelCase					:						Optional[Any]					=			attention_probs_dropout_prob
            UpperCamelCase					:						Union[str, Any]					=			max_position_embeddings
            UpperCamelCase					:						Optional[int]					=			type_vocab_size
            UpperCamelCase					:						Optional[int]					=			type_sequence_label_size
            UpperCamelCase					:						int					=			initializer_range
            UpperCamelCase					:						str					=			num_labels
            UpperCamelCase					:						Union[str, Any]					=			num_choices
            UpperCamelCase					:						Any					=			scope
         def       snake_case_ (    self )  ->	int:
            UpperCamelCase					:						List[Any]					=			ids_tensor([self.batch_size, self.seq_length],    self.vocab_size )
  
            UpperCamelCase					:						Optional[Any]					=			None
            if self.use_input_mask:
               UpperCamelCase					:						Dict					=			random_attention_mask([self.batch_size, self.seq_length] )
  
            UpperCamelCase					:						str					=			None
            UpperCamelCase					:						Optional[Any]					=			None
            UpperCamelCase					:						str					=			None
            if self.use_labels:
               UpperCamelCase					:						int					=			ids_tensor([self.batch_size],    self.type_sequence_label_size )
               UpperCamelCase					:						Optional[Any]					=			ids_tensor([self.batch_size, self.seq_length],    self.num_labels )
               UpperCamelCase					:						List[str]					=			ids_tensor([self.batch_size],    self.num_choices )
  
            UpperCamelCase					:						Union[str, Any]					=			self.get_config()
  
            return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
         def       snake_case_ (    self )  ->	Union[str, Any]:
            UpperCamelCase					:						Tuple					=			ids_tensor([self.batch_size, self.seq_length],    self.vocab_size )
  
            UpperCamelCase					:						Any					=			None
            if self.use_input_mask:
               UpperCamelCase					:						List[str]					=			random_attention_mask([self.batch_size, self.seq_length] )
            UpperCamelCase					:						Union[str, Any]					=			self.get_config()
  
            return config, input_ids, input_mask
         def       snake_case_ (    self )  ->	List[Any]:
            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       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Optional[int]:
            UpperCamelCase					:						List[str]					=			ErnieMModel(config=SCREAMING_SNAKE_CASE_ )
            model.to(SCREAMING_SNAKE_CASE_ )
            model.eval()
            UpperCamelCase					:						Union[str, Any]					=			model(SCREAMING_SNAKE_CASE_,    return_dict=SCREAMING_SNAKE_CASE_ )
            self.parent.assertEqual(result.last_hidden_state.shape,    (self.batch_size, self.seq_length, self.hidden_size) )
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Tuple:
            UpperCamelCase					:						Union[str, Any]					=			ErnieMForQuestionAnswering(config=SCREAMING_SNAKE_CASE_ )
            model.to(SCREAMING_SNAKE_CASE_ )
            model.eval()
            UpperCamelCase					:						Optional[int]					=			model(
                SCREAMING_SNAKE_CASE_,    attention_mask=SCREAMING_SNAKE_CASE_,    start_positions=SCREAMING_SNAKE_CASE_,    end_positions=SCREAMING_SNAKE_CASE_,    )
            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       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	str:
            UpperCamelCase					:						Any					=			ErnieMForInformationExtraction(config=SCREAMING_SNAKE_CASE_ )
            model.to(SCREAMING_SNAKE_CASE_ )
            model.eval()
            UpperCamelCase					:						str					=			torch.ones_like(SCREAMING_SNAKE_CASE_,    dtype=torch.floataa )
            UpperCamelCase					:						Optional[int]					=			model(
                SCREAMING_SNAKE_CASE_,    attention_mask=SCREAMING_SNAKE_CASE_,    start_positions=SCREAMING_SNAKE_CASE_,    end_positions=SCREAMING_SNAKE_CASE_,    )
            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       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Dict:
            UpperCamelCase					:						Optional[int]					=			self.num_labels
            UpperCamelCase					:						Optional[int]					=			ErnieMForSequenceClassification(SCREAMING_SNAKE_CASE_ )
            model.to(SCREAMING_SNAKE_CASE_ )
            model.eval()
            UpperCamelCase					:						List[Any]					=			model(SCREAMING_SNAKE_CASE_,    attention_mask=SCREAMING_SNAKE_CASE_,    labels=SCREAMING_SNAKE_CASE_ )
            self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_labels) )
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Dict:
            UpperCamelCase					:						int					=			self.num_labels
            UpperCamelCase					:						Union[str, Any]					=			ErnieMForTokenClassification(config=SCREAMING_SNAKE_CASE_ )
            model.to(SCREAMING_SNAKE_CASE_ )
            model.eval()
            input_ids.to(SCREAMING_SNAKE_CASE_ )
            input_mask.to(SCREAMING_SNAKE_CASE_ )
            token_labels.to(SCREAMING_SNAKE_CASE_ )
  
            UpperCamelCase					:						List[str]					=			model(SCREAMING_SNAKE_CASE_,    attention_mask=SCREAMING_SNAKE_CASE_,    labels=SCREAMING_SNAKE_CASE_ )
  
            self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.num_labels) )
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	str:
            UpperCamelCase					:						int					=			self.num_choices
            UpperCamelCase					:						Any					=			ErnieMForMultipleChoice(config=SCREAMING_SNAKE_CASE_ )
            model.to(SCREAMING_SNAKE_CASE_ )
            model.eval()
            UpperCamelCase					:						List[Any]					=			input_ids.unsqueeze(1 ).expand(-1,    self.num_choices,    -1 ).contiguous()
            UpperCamelCase					:						Any					=			input_mask.unsqueeze(1 ).expand(-1,    self.num_choices,    -1 ).contiguous()
            UpperCamelCase					:						str					=			model(
                SCREAMING_SNAKE_CASE_,    attention_mask=SCREAMING_SNAKE_CASE_,    labels=SCREAMING_SNAKE_CASE_,    )
            self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_choices) )
  
  
  
  
  
  
         def       snake_case_ (    self )  ->	int:
            UpperCamelCase					:						Optional[int]					=			self.prepare_config_and_inputs()
            (
                (
                UpperCamelCase
            )			,  (
                UpperCamelCase
            )			,  (
                UpperCamelCase
            )			,  (
                UpperCamelCase
            )			,  (
                UpperCamelCase
            )			,  (
                UpperCamelCase
            )			,  
            )					:						Union[str, Any]					=			config_and_inputs
            UpperCamelCase					:						Tuple					=			{'input_ids': input_ids, 'attention_mask': input_mask}
            return config, inputs_dict
  
  
  
  
  
  
  @require_torch
  class        lowerCAmelCase_	(						a__ ,					a__ ,					unittest.TestCase							):
         UpperCAmelCase__       :      Tuple       =						(
             (
                 ErnieMModel,
                 ErnieMForMultipleChoice,
                 ErnieMForQuestionAnswering,
                 ErnieMForSequenceClassification,
                 ErnieMForTokenClassification,
             )
             if is_torch_available()
             else ()
         )
         UpperCAmelCase__       :      List[str]       =						()
         UpperCAmelCase__       :      int       =						(
             {
                 "feature-extraction": ErnieMModel,
                 "question-answering": ErnieMForQuestionAnswering,
                 "text-classification": ErnieMForSequenceClassification,
                 "token-classification": ErnieMForTokenClassification,
                 "zero-shot": ErnieMForSequenceClassification,
             }
             if is_torch_available()
             else {}
         )
         UpperCAmelCase__       :      Tuple       =						False
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Optional[int]:
            if pipeline_test_casse_name == "QAPipelineTests":
               return True
  
            return False
         def       snake_case_ (    self )  ->	List[str]:
            UpperCamelCase					:						List[str]					=			ErnieMModelTester(self )
            UpperCamelCase					:						int					=			ConfigTester(self,    config_class=SCREAMING_SNAKE_CASE_,    hidden_size=37 )
         def       snake_case_ (    self )  ->	int:
            self.config_tester.run_common_tests()
         def       snake_case_ (    self )  ->	Optional[int]:
            UpperCamelCase					:						List[Any]					=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_ )
         def       snake_case_ (    self )  ->	Any:
            UpperCamelCase					:						Optional[Any]					=			self.model_tester.prepare_config_and_inputs()
            for type in ["absolute", "relative_key", "relative_key_query"]:
               UpperCamelCase					:						int					=			type
               self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_ )
         def       snake_case_ (    self )  ->	Any:
            UpperCamelCase					:						Tuple					=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE_ )
         def       snake_case_ (    self )  ->	Any:
            UpperCamelCase					:						Dict					=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE_ )
         def       snake_case_ (    self )  ->	List[str]:
            UpperCamelCase					:						Dict					=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE_ )
         def       snake_case_ (    self )  ->	Optional[Any]:
            UpperCamelCase					:						Optional[Any]					=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_information_extraction(*SCREAMING_SNAKE_CASE_ )
         def       snake_case_ (    self )  ->	Any:
            UpperCamelCase					:						List[Any]					=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE_ )
  
  
  
  
  
  
         @slow
         def       snake_case_ (    self )  ->	List[str]:
            for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               UpperCamelCase					:						List[Any]					=			ErnieMModel.from_pretrained(SCREAMING_SNAKE_CASE_ )
               self.assertIsNotNone(SCREAMING_SNAKE_CASE_ )
  
  
  
  
  
  
  @require_torch
  class        lowerCAmelCase_	(						unittest.TestCase							):
         @slow
         def       snake_case_ (    self )  ->	Union[str, Any]:
            UpperCamelCase					:						Optional[Any]					=			ErnieMModel.from_pretrained('susnato/ernie-m-base_pytorch' )
            model.eval()
            UpperCamelCase					:						Optional[Any]					=			torch.tensor([[0, 1, 2, 3, 4, 5]] )
            UpperCamelCase					:						Optional[Any]					=			model(SCREAMING_SNAKE_CASE_ )[0]
  
            # TODO Replace vocab size
            UpperCamelCase					:						Dict					=			768
  
            UpperCamelCase					:						int					=			torch.Size((1, 6, hidden_size) )
            self.assertEqual(output.shape,    SCREAMING_SNAKE_CASE_ )
  
            UpperCamelCase					:						Optional[Any]					=			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],    SCREAMING_SNAKE_CASE_,    atol=1e-3 ) )
  
  
  
  
style_context: 
  
  
  
  import json
  import logging
  import os
  import subprocess
  from argparse import ArgumentParser
  
  
  __UpperCAmelCase      = logging.getLogger(__name__)
  def 	UpperCamelCase			(     )			->  List[str]:
     UpperCamelCase					:						Union[str, Any]					=			ArgumentParser()
     UpperCamelCase			,  UpperCamelCase					:						Optional[int]					=			parser.parse_known_args()
     for arg in unknown:
        if arg.startswith(('-', '--')			):
           parser.add_argument(arg.split('='			)[0]			)
  
     return parser.parse_args()
  def 	UpperCamelCase			(     )			->  Optional[Any]:
     UpperCamelCase					:						int					=			parse_args()
     UpperCamelCase					:						Dict					=			8888
     UpperCamelCase					:						Union[str, Any]					=			int(os.environ['SM_NUM_GPUS']			)
     UpperCamelCase					:						Optional[Any]					=			json.loads(os.environ['SM_HOSTS']			)
     UpperCamelCase					:						Dict					=			len(snake_case__			)
     UpperCamelCase					:						int					=			os.environ['SM_CURRENT_HOST']
     UpperCamelCase					:						List[str]					=			hosts.index(snake_case__			)
     UpperCamelCase					:						Optional[Any]					=			'INFO'
  
     if num_nodes > 1:
        UpperCamelCase					:						List[Any]					=			F"""python -m torch.distributed.launch \
                  --nnodes={num_nodes}  \
                  --node_rank={rank}  \
                  --nproc_per_node={num_gpus}  \
                  --master_addr={hosts[0]}  \
                  --master_port={port} \
                  ./run_glue.py \
                  {"".join(["nested fstring" for parameter,value in args.__dict__.items()]			)}"""
     else:
        UpperCamelCase					:						Any					=			F"""python -m torch.distributed.launch \
              --nproc_per_node={num_gpus}  \
              ./run_glue.py \
              {"".join(["nested fstring" for parameter,value in args.__dict__.items()]			)}"""
     try:
        subprocess.run(snake_case__ ,  shell=snake_case__			)
     except Exception as e:
        logger.info(snake_case__			)
  
  
  if __name__ == "__main__":
      main()
  
  
  
  