

def    UpperCamelCase(					lowercase_			,					lowercase_							)	->				float:





  '''simple docstring'''





  snake_case_       						=      float()
  try:
    snake_case_       						=      mass * acceleration
  except Exception:
    return -0.0
  return force


if __name__ == "__main__":
    import doctest

    # run doctest
    doctest.testmod()

    # demo
    lowerCamelCase_    =					12.5
    lowerCamelCase_    =					10
    lowerCamelCase_    =					newtons_second_law_of_motion(mass, acceleration)
    print('''The force is ''', force, '''N''')


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							,  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.02							,  lowerCamelCase=3							,  lowerCamelCase=4							,  lowerCamelCase=None							,  )						->       Optional[int]:
        snake_case_       						=      parent
        snake_case_       						=      batch_size
        snake_case_       						=      seq_length
        snake_case_       						=      is_training
        snake_case_       						=      use_input_mask
        snake_case_       						=      use_labels
        snake_case_       						=      vocab_size
        snake_case_       						=      hidden_size
        snake_case_       						=      num_hidden_layers
        snake_case_       						=      num_attention_heads
        snake_case_       						=      intermediate_size
        snake_case_       						=      hidden_act
        snake_case_       						=      hidden_dropout_prob
        snake_case_       						=      attention_probs_dropout_prob
        snake_case_       						=      max_position_embeddings
        snake_case_       						=      type_vocab_size
        snake_case_       						=      type_sequence_label_size
        snake_case_       						=      initializer_range
        snake_case_       						=      num_labels
        snake_case_       						=      num_choices
        snake_case_       						=      scope







      def 	lowerCAmelCase_    (     self   )						->       Optional[Any]:
        snake_case_       						=      ids_tensor([self.batch_size, self.seq_length]							,  self.vocab_size   )

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

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

        snake_case_       						=      self.get_config()

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







      def 	lowerCAmelCase_    (     self   )						->       Optional[Any]:
        snake_case_       						=      ids_tensor([self.batch_size, self.seq_length]							,  self.vocab_size   )

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

        return config, input_ids, input_mask







      def 	lowerCAmelCase_    (     self   )						->       Optional[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 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Union[str, Any]:
        snake_case_       						=      ErnieMModel(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      model(lowerCamelCase							,  return_dict=lowerCamelCase   )
        self.parent.assertEqual(result.last_hidden_state.shape							,  (self.batch_size, self.seq_length, self.hidden_size)   )







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Tuple:
        snake_case_       						=      ErnieMForQuestionAnswering(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      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 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Tuple:
        snake_case_       						=      ErnieMForInformationExtraction(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      torch.ones_like(lowerCamelCase							,  dtype=torch.floataa   )
        snake_case_       						=      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 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Optional[Any]:
        snake_case_       						=      self.num_labels
        snake_case_       						=      ErnieMForSequenceClassification(lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      model(lowerCamelCase							,  attention_mask=lowerCamelCase							,  labels=lowerCamelCase   )
        self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.num_labels)   )







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Union[str, Any]:
        snake_case_       						=      self.num_labels
        snake_case_       						=      ErnieMForTokenClassification(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        input_ids.to(lowerCamelCase   )
        input_mask.to(lowerCamelCase   )
        token_labels.to(lowerCamelCase   )

        snake_case_       						=      model(lowerCamelCase							,  attention_mask=lowerCamelCase							,  labels=lowerCamelCase   )

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







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Any:
        snake_case_       						=      self.num_choices
        snake_case_       						=      ErnieMForMultipleChoice(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      input_ids.unsqueeze(1   ).expand(-1							,  self.num_choices							,  -1   ).contiguous()
        snake_case_       						=      input_mask.unsqueeze(1   ).expand(-1							,  self.num_choices							,  -1   ).contiguous()
        snake_case_       						=      model(
            lowerCamelCase							,  attention_mask=lowerCamelCase							,  labels=lowerCamelCase							,  )
        self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.num_choices)   )







      def 	lowerCAmelCase_    (     self   )						->       str:
        snake_case_       						=      self.prepare_config_and_inputs()
        (
            (
            snake_case_
        )						,				(
            snake_case_
        )						,				(
            snake_case_
        )						,				(
            snake_case_
        )						,				(
            snake_case_
        )						,				(
            snake_case_
        )						,				
        )       						=      config_and_inputs
        snake_case_       						=      {"""input_ids""": input_ids, """attention_mask""": input_mask}
        return config, inputs_dict







@require_torch
class  __lowerCamelCase				(	__snake_case  ,							__snake_case  ,							unittest.TestCase	):
      lowerCamelCase_	:      Optional[int]          =					(
          (
              ErnieMModel,
              ErnieMForMultipleChoice,
              ErnieMForQuestionAnswering,
              ErnieMForSequenceClassification,
              ErnieMForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      lowerCamelCase_	:      List[str]          =					()
      lowerCamelCase_	:      Optional[int]          =					(
          {
              'feature-extraction': ErnieMModel,
              'question-answering': ErnieMForQuestionAnswering,
              'text-classification': ErnieMForSequenceClassification,
              'token-classification': ErnieMForTokenClassification,
              'zero-shot': ErnieMForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      lowerCamelCase_	:      List[Any]          =					False







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Tuple:
        if pipeline_test_casse_name == "QAPipelineTests":
          return True

        return False







      def 	lowerCAmelCase_    (     self   )						->       Tuple:
        snake_case_       						=      ErnieMModelTester(self   )
        snake_case_       						=      ConfigTester(self							,  config_class=lowerCamelCase							,  hidden_size=37   )







      def 	lowerCAmelCase_    (     self   )						->       Any:
        self.config_tester.run_common_tests()







      def 	lowerCAmelCase_    (     self   )						->       Dict:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       int:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        for type in ["absolute", "relative_key", "relative_key_query"]:
          snake_case_       						=      type
          self.model_tester.create_and_check_model(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       Dict:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       Optional[Any]:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       List[Any]:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       List[Any]:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_information_extraction(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       Union[str, Any]:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*lowerCamelCase   )







      @slow
      def 	lowerCAmelCase_    (     self   )						->       int:
        for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          snake_case_       						=      ErnieMModel.from_pretrained(lowerCamelCase   )
          self.assertIsNotNone(lowerCamelCase   )







@require_torch
class  __lowerCamelCase				(	unittest.TestCase	):







      @slow
      def 	lowerCAmelCase_    (     self   )						->       List[Any]:
        snake_case_       						=      ErnieMModel.from_pretrained("""susnato/ernie-m-base_pytorch"""   )
        model.eval()
        snake_case_       						=      torch.tensor([[0, 1, 2, 3, 4, 5]]   )
        snake_case_       						=      model(lowerCamelCase   )[0]

        # TODO Replace vocab size
        snake_case_       						=      768

        snake_case_       						=      torch.Size((1, 6, hidden_size)   )
        self.assertEqual(output.shape							,  lowerCamelCase   )

        snake_case_       						=      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]							,  lowerCamelCase							,  atol=1e-3   )   )