


import copy
from typing import Dict, Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


__UpperCAmelCase      			=  logging.get_logger(__name__)

__UpperCAmelCase      			=  {
    """shi-labs/oneformer_ade20k_swin_tiny""": (
        """https://huggingface.co/shi-labs/oneformer_ade20k_swin_tiny/blob/main/config.json"""
    ),
    # See all OneFormer models at https://huggingface.co/models?filter=oneformer
}



class 							lowercase__(						snake_case__			):






      '''simple docstring'''







      snake_case__       =					'''oneformer'''
      snake_case__       =					{'''hidden_size''': '''hidden_dim'''}




      def __init__(		self   ,			__SCREAMING_SNAKE_CASE = None   ,			__SCREAMING_SNAKE_CASE = 2_55   ,			__SCREAMING_SNAKE_CASE = 1_50   ,			__SCREAMING_SNAKE_CASE = 0.1   ,			__SCREAMING_SNAKE_CASE = 2.0   ,			__SCREAMING_SNAKE_CASE = 5.0   ,			__SCREAMING_SNAKE_CASE = 5.0   ,			__SCREAMING_SNAKE_CASE = 0.5   ,			__SCREAMING_SNAKE_CASE = 0.07   ,			__SCREAMING_SNAKE_CASE = 1_25_44   ,			__SCREAMING_SNAKE_CASE = 3.0   ,			__SCREAMING_SNAKE_CASE = 0.75   ,			__SCREAMING_SNAKE_CASE = 0.02   ,			__SCREAMING_SNAKE_CASE = 1.0   ,			__SCREAMING_SNAKE_CASE = 1E-05   ,			__SCREAMING_SNAKE_CASE = False   ,			__SCREAMING_SNAKE_CASE = True   ,			__SCREAMING_SNAKE_CASE = True   ,			__SCREAMING_SNAKE_CASE = [4, 8, 16, 32]   ,			__SCREAMING_SNAKE_CASE = 77   ,			__SCREAMING_SNAKE_CASE = 2_56   ,			__SCREAMING_SNAKE_CASE = 77   ,			__SCREAMING_SNAKE_CASE = 6   ,			__SCREAMING_SNAKE_CASE = 4_94_08   ,			__SCREAMING_SNAKE_CASE = 2   ,			__SCREAMING_SNAKE_CASE = 16   ,			__SCREAMING_SNAKE_CASE = 2_56   ,			__SCREAMING_SNAKE_CASE = 2_56   ,			__SCREAMING_SNAKE_CASE = 2_56   ,			__SCREAMING_SNAKE_CASE = 10_24   ,			__SCREAMING_SNAKE_CASE = "GN"   ,			__SCREAMING_SNAKE_CASE = 6   ,			__SCREAMING_SNAKE_CASE = 10   ,			__SCREAMING_SNAKE_CASE = True   ,			__SCREAMING_SNAKE_CASE = 8   ,			__SCREAMING_SNAKE_CASE = 0.1   ,			__SCREAMING_SNAKE_CASE = 20_48   ,			__SCREAMING_SNAKE_CASE = False   ,			__SCREAMING_SNAKE_CASE = False   ,			__SCREAMING_SNAKE_CASE = 2   ,			__SCREAMING_SNAKE_CASE = 4   ,			**__SCREAMING_SNAKE_CASE   ,			)					->						Dict:







         """simple docstring"""







         if backbone_config is None:
            logger.info("`backbone_config` is unset. Initializing the config with the default `Swin` backbone.")
            UpperCamelCase__ :			Union[str, Any] 						=CONFIG_MAPPING["swin"](
                image_size=2_24   ,			in_channels=3   ,			patch_size=4   ,			embed_dim=96   ,			depths=[2, 2, 6, 2]   ,			num_heads=[3, 6, 12, 24]   ,			window_size=7   ,			drop_path_rate=0.3   ,			use_absolute_embeddings=__SCREAMING_SNAKE_CASE   ,			out_features=["stage1", "stage2", "stage3", "stage4"]   ,			)
         elif isinstance(__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE):
            UpperCamelCase__ :			List[str] 						=backbone_config.get("model_type")
            UpperCamelCase__ :			Tuple 						=CONFIG_MAPPING[backbone_model_type]
            UpperCamelCase__ :			List[str] 						=config_class.from_dict(__SCREAMING_SNAKE_CASE)

         UpperCamelCase__ :			List[Any] 						=backbone_config

         UpperCamelCase__ :			Dict 						=ignore_value
         UpperCamelCase__ :			Tuple 						=num_queries
         UpperCamelCase__ :			Dict 						=no_object_weight
         UpperCamelCase__ :			Optional[Any] 						=class_weight
         UpperCamelCase__ :			Tuple 						=mask_weight
         UpperCamelCase__ :			Any 						=dice_weight
         UpperCamelCase__ :			Union[str, Any] 						=contrastive_weight
         UpperCamelCase__ :			Any 						=contrastive_temperature
         UpperCamelCase__ :			Dict 						=train_num_points
         UpperCamelCase__ :			Optional[Any] 						=oversample_ratio
         UpperCamelCase__ :			Dict 						=importance_sample_ratio
         UpperCamelCase__ :			List[str] 						=init_std
         UpperCamelCase__ :			int 						=init_xavier_std
         UpperCamelCase__ :			Optional[Any] 						=layer_norm_eps
         UpperCamelCase__ :			Dict 						=is_training
         UpperCamelCase__ :			Tuple 						=use_auxiliary_loss
         UpperCamelCase__ :			Dict 						=output_auxiliary_logits
         UpperCamelCase__ :			Union[str, Any] 						=strides
         UpperCamelCase__ :			List[Any] 						=task_seq_len
         UpperCamelCase__ :			Dict 						=text_encoder_width
         UpperCamelCase__ :			Tuple 						=text_encoder_context_length
         UpperCamelCase__ :			List[Any] 						=text_encoder_num_layers
         UpperCamelCase__ :			Union[str, Any] 						=text_encoder_vocab_size
         UpperCamelCase__ :			Optional[Any] 						=text_encoder_proj_layers
         UpperCamelCase__ :			Dict 						=text_encoder_n_ctx
         UpperCamelCase__ :			Dict 						=conv_dim
         UpperCamelCase__ :			List[Any] 						=mask_dim
         UpperCamelCase__ :			int 						=hidden_dim
         UpperCamelCase__ :			List[str] 						=encoder_feedforward_dim
         UpperCamelCase__ :			Any 						=norm
         UpperCamelCase__ :			Any 						=encoder_layers
         UpperCamelCase__ :			Union[str, Any] 						=decoder_layers
         UpperCamelCase__ :			List[str] 						=use_task_norm
         UpperCamelCase__ :			str 						=num_attention_heads
         UpperCamelCase__ :			Optional[Any] 						=dropout
         UpperCamelCase__ :			Dict 						=dim_feedforward
         UpperCamelCase__ :			int 						=pre_norm
         UpperCamelCase__ :			str 						=enforce_input_proj
         UpperCamelCase__ :			Union[str, Any] 						=query_dec_layers
         UpperCamelCase__ :			str 						=common_stride
         UpperCamelCase__ :			Any 						=decoder_layers

         super().__init__(**__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						Dict[str, any]:







         """simple docstring"""







         UpperCamelCase__ :			Union[str, Any] 						=copy.deepcopy(self.__dict__)
         UpperCamelCase__ :			Dict 						=self.backbone_config.to_dict()
         UpperCamelCase__ :			Optional[Any] 						=self.__class__.model_type
         return output





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






      '''simple docstring'''







      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=5_12   ,			__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   ,			)					->						Any:







         """simple docstring"""







         UpperCamelCase__ :			Optional[Any] 						=parent
         UpperCamelCase__ :			Tuple 						=batch_size
         UpperCamelCase__ :			Union[str, Any] 						=seq_length
         UpperCamelCase__ :			Union[str, Any] 						=is_training
         UpperCamelCase__ :			Tuple 						=use_input_mask
         UpperCamelCase__ :			Union[str, Any] 						=use_labels
         UpperCamelCase__ :			Union[str, Any] 						=vocab_size
         UpperCamelCase__ :			List[Any] 						=hidden_size
         UpperCamelCase__ :			Dict 						=num_hidden_layers
         UpperCamelCase__ :			Any 						=num_attention_heads
         UpperCamelCase__ :			List[str] 						=intermediate_size
         UpperCamelCase__ :			List[Any] 						=hidden_act
         UpperCamelCase__ :			Tuple 						=hidden_dropout_prob
         UpperCamelCase__ :			Any 						=attention_probs_dropout_prob
         UpperCamelCase__ :			Tuple 						=max_position_embeddings
         UpperCamelCase__ :			Dict 						=type_vocab_size
         UpperCamelCase__ :			Tuple 						=type_sequence_label_size
         UpperCamelCase__ :			Tuple 						=initializer_range
         UpperCamelCase__ :			List[str] 						=num_labels
         UpperCamelCase__ :			Any 						=num_choices
         UpperCamelCase__ :			Tuple 						=scope




      def    UpperCAmelCase							(		self)					->						int:







         """simple docstring"""







         UpperCamelCase__ :			List[str] 						=ids_tensor([self.batch_size, self.seq_length]   ,			self.vocab_size)

         UpperCamelCase__ :			Any 						=None
         if self.use_input_mask:
            UpperCamelCase__ :			int 						=random_attention_mask([self.batch_size, self.seq_length])

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

         UpperCamelCase__ :			Tuple 						=self.get_config()

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




      def    UpperCAmelCase							(		self)					->						str:







         """simple docstring"""







         UpperCamelCase__ :			Tuple 						=ids_tensor([self.batch_size, self.seq_length]   ,			self.vocab_size)

         UpperCamelCase__ :			List[str] 						=None
         if self.use_input_mask:
            UpperCamelCase__ :			Union[str, Any] 						=random_attention_mask([self.batch_size, self.seq_length])
         UpperCamelCase__ :			Union[str, Any] 						=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   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						str:







         """simple docstring"""







         UpperCamelCase__ :			Tuple 						=ErnieMModel(config=__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()
         UpperCamelCase__ :			int 						=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    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						List[Any]:







         """simple docstring"""







         UpperCamelCase__ :			str 						=ErnieMForQuestionAnswering(config=__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()
         UpperCamelCase__ :			Dict 						=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    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						Dict:







         """simple docstring"""







         UpperCamelCase__ :			Any 						=ErnieMForInformationExtraction(config=__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()
         UpperCamelCase__ :			int 						=torch.ones_like(__SCREAMING_SNAKE_CASE   ,			dtype=torch.floataa)
         UpperCamelCase__ :			Union[str, Any] 						=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    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						List[str]:







         """simple docstring"""







         UpperCamelCase__ :			List[Any] 						=self.num_labels
         UpperCamelCase__ :			List[Any] 						=ErnieMForSequenceClassification(__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()
         UpperCamelCase__ :			Union[str, 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    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						Tuple:







         """simple docstring"""







         UpperCamelCase__ :			List[str] 						=self.num_labels
         UpperCamelCase__ :			int 						=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__ :			Tuple 						=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    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						Optional[Any]:







         """simple docstring"""







         UpperCamelCase__ :			List[Any] 						=self.num_choices
         UpperCamelCase__ :			List[str] 						=ErnieMForMultipleChoice(config=__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()
         UpperCamelCase__ :			Optional[Any] 						=input_ids.unsqueeze(1).expand(-1   ,			self.num_choices   ,			-1).contiguous()
         UpperCamelCase__ :			int 						=input_mask.unsqueeze(1).expand(-1   ,			self.num_choices   ,			-1).contiguous()
         UpperCamelCase__ :			Optional[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_choices))




      def    UpperCAmelCase							(		self)					->						Union[str, Any]:







         """simple docstring"""







         UpperCamelCase__ :			Tuple 						=self.prepare_config_and_inputs()
         (
             (
             UpperCamelCase__
         )						,	(
             UpperCamelCase__
         )						,	(
             UpperCamelCase__
         )						,	(
             UpperCamelCase__
         )						,	(
             UpperCamelCase__
         )						,	(
             UpperCamelCase__
         )						,	
         ) :			int 						=config_and_inputs
         UpperCamelCase__ :			Tuple 						={"input_ids": input_ids, "attention_mask": input_mask}
         return config, inputs_dict




@require_torch
class 							lowercase__(						snake_case__			,							snake_case__			,							unittest.TestCase			):






      '''simple docstring'''







      snake_case__       =					(
          (
              ErnieMModel,
              ErnieMForMultipleChoice,
              ErnieMForQuestionAnswering,
              ErnieMForSequenceClassification,
              ErnieMForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      snake_case__       =					()
      snake_case__       =					(
          {
              '''feature-extraction''': ErnieMModel,
              '''question-answering''': ErnieMForQuestionAnswering,
              '''text-classification''': ErnieMForSequenceClassification,
              '''token-classification''': ErnieMForTokenClassification,
              '''zero-shot''': ErnieMForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      snake_case__       =					False




      def    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						Optional[Any]:







         """simple docstring"""







         if pipeline_test_casse_name == "QAPipelineTests":
            return True

         return False




      def    UpperCAmelCase							(		self)					->						Optional[int]:







         """simple docstring"""







         UpperCamelCase__ :			Dict 						=ErnieMModelTester(self)
         UpperCamelCase__ :			int 						=ConfigTester(self   ,			config_class=__SCREAMING_SNAKE_CASE   ,			hidden_size=37)




      def    UpperCAmelCase							(		self)					->						List[Any]:







         """simple docstring"""







         self.config_tester.run_common_tests()




      def    UpperCAmelCase							(		self)					->						List[str]:







         """simple docstring"""







         UpperCamelCase__ :			Any 						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						Union[str, Any]:







         """simple docstring"""







         UpperCamelCase__ :			int 						=self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
            UpperCamelCase__ :			List[str] 						=type
            self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						List[str]:







         """simple docstring"""







         UpperCamelCase__ :			Optional[Any] 						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						Tuple:







         """simple docstring"""







         UpperCamelCase__ :			Optional[Any] 						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						Any:







         """simple docstring"""







         UpperCamelCase__ :			Optional[int] 						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						List[str]:







         """simple docstring"""







         UpperCamelCase__ :			Union[str, Any] 						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_information_extraction(*__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						Union[str, Any]:







         """simple docstring"""







         UpperCamelCase__ :			Optional[Any] 						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE)




      @slow
      def    UpperCAmelCase							(		self)					->						Tuple:







         """simple docstring"""







         for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCamelCase__ :			Optional[Any] 						=ErnieMModel.from_pretrained(__SCREAMING_SNAKE_CASE)
            self.assertIsNotNone(__SCREAMING_SNAKE_CASE)




@require_torch
class 							lowercase__(						unittest.TestCase			):






      '''simple docstring'''







      @slow
      def    UpperCAmelCase							(		self)					->						Any:







         """simple docstring"""







         UpperCamelCase__ :			Optional[int] 						=ErnieMModel.from_pretrained("susnato/ernie-m-base_pytorch")
         model.eval()
         UpperCamelCase__ :			int 						=torch.tensor([[0, 1, 2, 3, 4, 5]])
         UpperCamelCase__ :			List[Any] 						=model(__SCREAMING_SNAKE_CASE)[0]

         # TODO Replace vocab size
         UpperCamelCase__ :			List[Any] 						=7_68

         UpperCamelCase__ :			Dict 						=torch.Size((1, 6, hidden_size))
         self.assertEqual(output.shape   ,			__SCREAMING_SNAKE_CASE)

         UpperCamelCase__ :			Union[str, 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))

