code: 
  
  
  
  
  
  
  import argparse
  import json
  from pathlib import Path
  
  import requests
  import torch
  from huggingface_hub import hf_hub_download
  from PIL import Image
  
  from transformers import ConvNextConfig, ConvNextForImageClassification, ConvNextImageProcessor
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  __A  							=  logging.get_logger(__name__)
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Tuple		)  ->							int:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase    							=ConvNextConfig()
  
         if "tiny" in checkpoint_url:
                __UpperCAmelCase    							=[3, 3, 9, 3]
                __UpperCAmelCase    							=[96, 192, 384, 768]
         if "small" in checkpoint_url:
                __UpperCAmelCase    							=[3, 3, 27, 3]
                __UpperCAmelCase    							=[96, 192, 384, 768]
         if "base" in checkpoint_url:
                __UpperCAmelCase    							=[3, 3, 27, 3]
                __UpperCAmelCase    							=[128, 256, 512, 1024]
         if "large" in checkpoint_url:
                __UpperCAmelCase    							=[3, 3, 27, 3]
                __UpperCAmelCase    							=[192, 384, 768, 1536]
         if "xlarge" in checkpoint_url:
                __UpperCAmelCase    							=[3, 3, 27, 3]
                __UpperCAmelCase    							=[256, 512, 1024, 2048]
  
         if "1k" in checkpoint_url:
                __UpperCAmelCase    							=1000
                __UpperCAmelCase    							="""imagenet-1k-id2label.json"""
                __UpperCAmelCase    							=(1, 1000)
         else:
                __UpperCAmelCase    							=21841
                __UpperCAmelCase    							="""imagenet-22k-id2label.json"""
                __UpperCAmelCase    							=(1, 21841)
  
         __UpperCAmelCase    							="""huggingface/label-files"""
         __UpperCAmelCase    							=num_labels
         __UpperCAmelCase    							=json.load(open(hf_hub_download(A_     ,			A_     ,			repo_type="""dataset"""		)     ,			"""r"""		)		)
         __UpperCAmelCase    							={int(A_		): v for k, v in idalabel.items()}
         if "1k" not in checkpoint_url:
                # this dataset contains 21843 labels but the model only has 21841
                # we delete the classes as mentioned in https://github.com/google-research/big_transfer/issues/18
                del idalabel[9205]
                del idalabel[15027]
         __UpperCAmelCase    							=idalabel
         __UpperCAmelCase    							={v: k for k, v in idalabel.items()}
         __UpperCAmelCase    							=hidden_sizes
         __UpperCAmelCase    							=depths
  
         return config, expected_shape
  
  
  
  
  
  
  
  def 			lowercase__  (				A_:	Optional[Any]		)  ->							List[Any]:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         if "downsample_layers.0.0" in name:
                __UpperCAmelCase    							=name.replace("""downsample_layers.0.0"""     ,			"""embeddings.patch_embeddings"""		)
         if "downsample_layers.0.1" in name:
                __UpperCAmelCase    							=name.replace("""downsample_layers.0.1"""     ,			"""embeddings.norm"""		)  # we rename to layernorm later on
         if "downsample_layers.1.0" in name:
                __UpperCAmelCase    							=name.replace("""downsample_layers.1.0"""     ,			"""stages.1.downsampling_layer.0"""		)
         if "downsample_layers.1.1" in name:
                __UpperCAmelCase    							=name.replace("""downsample_layers.1.1"""     ,			"""stages.1.downsampling_layer.1"""		)
         if "downsample_layers.2.0" in name:
                __UpperCAmelCase    							=name.replace("""downsample_layers.2.0"""     ,			"""stages.2.downsampling_layer.0"""		)
         if "downsample_layers.2.1" in name:
                __UpperCAmelCase    							=name.replace("""downsample_layers.2.1"""     ,			"""stages.2.downsampling_layer.1"""		)
         if "downsample_layers.3.0" in name:
                __UpperCAmelCase    							=name.replace("""downsample_layers.3.0"""     ,			"""stages.3.downsampling_layer.0"""		)
         if "downsample_layers.3.1" in name:
                __UpperCAmelCase    							=name.replace("""downsample_layers.3.1"""     ,			"""stages.3.downsampling_layer.1"""		)
         if "stages" in name and "downsampling_layer" not in name:
                # stages.0.0. for instance should be renamed to stages.0.layers.0.
                __UpperCAmelCase    							=name[: len("""stages.0"""		)] + """.layers""" + name[len("""stages.0"""		) :]
         if "stages" in name:
                __UpperCAmelCase    							=name.replace("""stages"""     ,			"""encoder.stages"""		)
         if "norm" in name:
                __UpperCAmelCase    							=name.replace("""norm"""     ,			"""layernorm"""		)
         if "gamma" in name:
                __UpperCAmelCase    							=name.replace("""gamma"""     ,			"""layer_scale_parameter"""		)
         if "head" in name:
                __UpperCAmelCase    							=name.replace("""head"""     ,			"""classifier"""		)
  
         return name
  
  
  
  
  
  
  
  def 			lowercase__  (				)  ->							Any:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase    							="""http://images.cocodataset.org/val2017/000000039769.jpg"""
         __UpperCAmelCase    							=Image.open(requests.get(A_     ,			stream=A_		).raw		)
         return im
  
  
  
  
  
  
  
  @torch.no_grad()
  def 			lowercase__  (				A_:	Tuple     ,			A_:	Tuple		)  ->							List[Any]:
  
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
         __UpperCAmelCase							,   __UpperCAmelCase    							=get_convnext_config(A_		)
         # load original state_dict from URL
         __UpperCAmelCase    							=torch.hub.load_state_dict_from_url(A_		)["""model"""]
         # rename keys
         for key in state_dict.copy().keys():
                __UpperCAmelCase    							=state_dict.pop(A_		)
                __UpperCAmelCase    							=val
         # add prefix to all keys expect classifier head
         for key in state_dict.copy().keys():
                __UpperCAmelCase    							=state_dict.pop(A_		)
                if not key.startswith("""classifier"""		):
                       __UpperCAmelCase    							="""convnext.""" + key
                __UpperCAmelCase    							=val
  
         # load HuggingFace model
         __UpperCAmelCase    							=ConvNextForImageClassification(A_		)
         model.load_state_dict(A_		)
         model.eval()
  
         # Check outputs on an image, prepared by ConvNextImageProcessor
         __UpperCAmelCase    							=224 if """224""" in checkpoint_url else 384
         __UpperCAmelCase    							=ConvNextImageProcessor(size=A_		)
         __UpperCAmelCase    							=image_processor(images=prepare_img()     ,			return_tensors="""pt"""		).pixel_values
  
         __UpperCAmelCase    							=model(A_		).logits
  
         # note: the logits below were obtained without center cropping
         if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth":
                __UpperCAmelCase    							=torch.tensor([-0.1_2_1_0, -0.6_6_0_5, 0.1_9_1_8]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_small_1k_224_ema.pth":
                __UpperCAmelCase    							=torch.tensor([-0.4_4_7_3, -0.1_8_4_7, -0.6_3_6_5]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_224_ema.pth":
                __UpperCAmelCase    							=torch.tensor([0.4_5_2_5, 0.7_5_3_9, 0.0_3_0_8]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_384.pth":
                __UpperCAmelCase    							=torch.tensor([0.3_5_6_1, 0.6_3_5_0, -0.0_3_8_4]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_224_ema.pth":
                __UpperCAmelCase    							=torch.tensor([0.4_1_7_4, -0.0_9_8_9, 0.1_4_8_9]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_384.pth":
                __UpperCAmelCase    							=torch.tensor([0.2_5_1_3, -0.1_3_4_9, -0.1_6_1_3]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_224.pth":
                __UpperCAmelCase    							=torch.tensor([1.2_9_8_0, 0.3_6_3_1, -0.1_1_9_8]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_224.pth":
                __UpperCAmelCase    							=torch.tensor([1.2_9_6_3, 0.1_2_2_7, 0.1_7_2_3]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_224.pth":
                __UpperCAmelCase    							=torch.tensor([1.7_9_5_6, 0.8_3_9_0, 0.2_8_2_0]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_224.pth":
                __UpperCAmelCase    							=torch.tensor([-0.2_8_2_2, -0.0_5_0_2, -0.0_8_7_8]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_384.pth":
                __UpperCAmelCase    							=torch.tensor([-0.5_6_7_2, -0.0_7_3_0, -0.4_3_4_8]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_224.pth":
                __UpperCAmelCase    							=torch.tensor([0.2_6_8_1, 0.2_3_6_5, 0.6_2_4_6]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_384.pth":
                __UpperCAmelCase    							=torch.tensor([-0.2_6_4_2, 0.3_9_3_1, 0.5_1_1_6]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_224_ema.pth":
                __UpperCAmelCase    							=torch.tensor([-0.6_6_7_7, -0.1_8_7_3, -0.8_3_7_9]		)
         elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_384_ema.pth":
                __UpperCAmelCase    							=torch.tensor([-0.7_7_4_9, -0.2_9_6_7, -0.6_4_4_4]		)
         else:
                raise ValueError(F'''Unknown URL: {checkpoint_url}'''		)
  
         assert torch.allclose(logits[0, :3]     ,			A_     ,			atol=1e-3		)
         assert logits.shape == expected_shape
  
         Path(A_		).mkdir(exist_ok=A_		)
         print(F'''Saving model to {pytorch_dump_folder_path}'''		)
         model.save_pretrained(A_		)
         print(F'''Saving image processor to {pytorch_dump_folder_path}'''		)
         image_processor.save_pretrained(A_		)
  
         print("""Pushing model to the hub..."""		)
         __UpperCAmelCase    							="""convnext"""
         if "tiny" in checkpoint_url:
                model_name += "-tiny"
         elif "small" in checkpoint_url:
                model_name += "-small"
         elif "base" in checkpoint_url:
                model_name += "-base"
         elif "xlarge" in checkpoint_url:
                model_name += "-xlarge"
         elif "large" in checkpoint_url:
                model_name += "-large"
         if "224" in checkpoint_url:
                model_name += "-224"
         elif "384" in checkpoint_url:
                model_name += "-384"
         if "22k" in checkpoint_url and "1k" not in checkpoint_url:
                model_name += "-22k"
         if "22k" in checkpoint_url and "1k" in checkpoint_url:
                model_name += "-22k-1k"
  
         model.push_to_hub(
             repo_path_or_name=Path(A_     ,			A_		)     ,			organization="""nielsr"""     ,			commit_message="""Add model"""     ,			)
  
  
  if __name__ == "__main__":
     __A  							=  argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         "--checkpoint_url",
         default="https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth",
         type=str,
         help="URL of the original ConvNeXT checkpoint you'd like to convert.",
     )
     parser.add_argument(
         "--pytorch_dump_folder_path",
         default=None,
         type=str,
         required=True,
         help="Path to the output PyTorch model directory.",
     )
  
     __A  							=  parser.parse_args()
     convert_convnext_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  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 :
      """simple docstring"""
  
      def __init__(							self			:    Any   ,    __SCREAMING_SNAKE_CASE			:    str   ,    __SCREAMING_SNAKE_CASE			:    List[str]=13   ,    __SCREAMING_SNAKE_CASE			:    Union[str, Any]=7   ,    __SCREAMING_SNAKE_CASE			:    List[Any]=True   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]=True   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]=True   ,    __SCREAMING_SNAKE_CASE			:    str=99   ,    __SCREAMING_SNAKE_CASE			:    int=32   ,    __SCREAMING_SNAKE_CASE			:    str=5   ,    __SCREAMING_SNAKE_CASE			:    int=4   ,    __SCREAMING_SNAKE_CASE			:    List[str]=37   ,    __SCREAMING_SNAKE_CASE			:    int="gelu"   ,    __SCREAMING_SNAKE_CASE			:    Tuple=0.1   ,    __SCREAMING_SNAKE_CASE			:    List[str]=0.1   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]=512   ,    __SCREAMING_SNAKE_CASE			:    int=16   ,    __SCREAMING_SNAKE_CASE			:    int=2   ,    __SCREAMING_SNAKE_CASE			:    Any=0.02   ,    __SCREAMING_SNAKE_CASE			:    Dict=3   ,    __SCREAMING_SNAKE_CASE			:    Dict=4   ,    __SCREAMING_SNAKE_CASE			:    str=None   ,    )			->       Optional[Any]:
             __UpperCAmelCase    							=parent
             __UpperCAmelCase    							=batch_size
             __UpperCAmelCase    							=seq_length
             __UpperCAmelCase    							=is_training
             __UpperCAmelCase    							=use_input_mask
             __UpperCAmelCase    							=use_labels
             __UpperCAmelCase    							=vocab_size
             __UpperCAmelCase    							=hidden_size
             __UpperCAmelCase    							=num_hidden_layers
             __UpperCAmelCase    							=num_attention_heads
             __UpperCAmelCase    							=intermediate_size
             __UpperCAmelCase    							=hidden_act
             __UpperCAmelCase    							=hidden_dropout_prob
             __UpperCAmelCase    							=attention_probs_dropout_prob
             __UpperCAmelCase    							=max_position_embeddings
             __UpperCAmelCase    							=type_vocab_size
             __UpperCAmelCase    							=type_sequence_label_size
             __UpperCAmelCase    							=initializer_range
             __UpperCAmelCase    							=num_labels
             __UpperCAmelCase    							=num_choices
             __UpperCAmelCase    							=scope
  
  
  
      def _a       (							self			:    str			)			->       Optional[Any]:
             __UpperCAmelCase    							=ids_tensor([self.batch_size, self.seq_length]   ,    self.vocab_size			)
  
             __UpperCAmelCase    							=None
             if self.use_input_mask:
                    __UpperCAmelCase    							=random_attention_mask([self.batch_size, self.seq_length]			)
  
             __UpperCAmelCase    							=None
             __UpperCAmelCase    							=None
             __UpperCAmelCase    							=None
             if self.use_labels:
                    __UpperCAmelCase    							=ids_tensor([self.batch_size]   ,    self.type_sequence_label_size			)
                    __UpperCAmelCase    							=ids_tensor([self.batch_size, self.seq_length]   ,    self.num_labels			)
                    __UpperCAmelCase    							=ids_tensor([self.batch_size]   ,    self.num_choices			)
  
             __UpperCAmelCase    							=self.get_config()
  
             return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
  
  
  
      def _a       (							self			:    Optional[Any]			)			->       Any:
             __UpperCAmelCase    							=ids_tensor([self.batch_size, self.seq_length]   ,    self.vocab_size			)
  
             __UpperCAmelCase    							=None
             if self.use_input_mask:
                    __UpperCAmelCase    							=random_attention_mask([self.batch_size, self.seq_length]			)
             __UpperCAmelCase    							=self.get_config()
  
             return config, input_ids, input_mask
  
  
  
      def _a       (							self			:    List[str]			)			->       List[str]:
             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 _a       (							self			:    str   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]   ,    __SCREAMING_SNAKE_CASE			:    List[str]   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]   ,    __SCREAMING_SNAKE_CASE			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    str   ,    __SCREAMING_SNAKE_CASE			:    Dict			)			->       Optional[int]:
             __UpperCAmelCase    							=ErnieMModel(config=__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=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 _a       (							self			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    List[str]   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]   ,    __SCREAMING_SNAKE_CASE			:    List[Any]   ,    __SCREAMING_SNAKE_CASE			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    Any   ,    __SCREAMING_SNAKE_CASE			:    Dict			)			->       int:
             __UpperCAmelCase    							=ErnieMForQuestionAnswering(config=__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=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 _a       (							self			:    Optional[Any]   ,    __SCREAMING_SNAKE_CASE			:    List[str]   ,    __SCREAMING_SNAKE_CASE			:    List[Any]   ,    __SCREAMING_SNAKE_CASE			:    List[str]   ,    __SCREAMING_SNAKE_CASE			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]			)			->       Any:
             __UpperCAmelCase    							=ErnieMForInformationExtraction(config=__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=torch.ones_like(__SCREAMING_SNAKE_CASE   ,    dtype=torch.floataa			)
             __UpperCAmelCase    							=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 _a       (							self			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]   ,    __SCREAMING_SNAKE_CASE			:    Any   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]   ,    __SCREAMING_SNAKE_CASE			:    List[Any]   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]			)			->       str:
             __UpperCAmelCase    							=self.num_labels
             __UpperCAmelCase    							=ErnieMForSequenceClassification(__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=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 _a       (							self			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]   ,    __SCREAMING_SNAKE_CASE			:    List[Any]   ,    __SCREAMING_SNAKE_CASE			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]   ,    __SCREAMING_SNAKE_CASE			:    Dict			)			->       Dict:
             __UpperCAmelCase    							=self.num_labels
             __UpperCAmelCase    							=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    							=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 _a       (							self			:    Optional[Any]   ,    __SCREAMING_SNAKE_CASE			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    Optional[int]   ,    __SCREAMING_SNAKE_CASE			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    int   ,    __SCREAMING_SNAKE_CASE			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    Optional[Any]			)			->       List[Any]:
             __UpperCAmelCase    							=self.num_choices
             __UpperCAmelCase    							=ErnieMForMultipleChoice(config=__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
             __UpperCAmelCase    							=input_ids.unsqueeze(1			).expand(-1   ,    self.num_choices   ,    -1			).contiguous()
             __UpperCAmelCase    							=input_mask.unsqueeze(1			).expand(-1   ,    self.num_choices   ,    -1			).contiguous()
             __UpperCAmelCase    							=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 _a       (							self			:    Any			)			->       List[str]:
             __UpperCAmelCase    							=self.prepare_config_and_inputs()
             (
                 (
                 __UpperCAmelCase
             )							,   (
                 __UpperCAmelCase
             )							,   (
                 __UpperCAmelCase
             )							,   (
                 __UpperCAmelCase
             )							,   (
                 __UpperCAmelCase
             )							,   (
                 __UpperCAmelCase
             )							,   
             )    							=config_and_inputs
             __UpperCAmelCase    							={"""input_ids""": input_ids, """attention_mask""": input_mask}
             return config, inputs_dict
  
  
  
  
  @require_torch
  class 							_A (    UpperCamelCase				,				UpperCamelCase				,				unittest.TestCase							):
      """simple docstring"""
  
      lowerCamelCase  :       Union[str, Any]   =   (
          (
              ErnieMModel,
              ErnieMForMultipleChoice,
              ErnieMForQuestionAnswering,
              ErnieMForSequenceClassification,
              ErnieMForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      lowerCamelCase  :       Optional[Any]   =   ()
      lowerCamelCase  :       str   =   (
          {
              'feature-extraction': ErnieMModel,
              'question-answering': ErnieMForQuestionAnswering,
              'text-classification': ErnieMForSequenceClassification,
              'token-classification': ErnieMForTokenClassification,
              'zero-shot': ErnieMForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      lowerCamelCase  :       Optional[int]   =   False
  
  
  
      def _a       (							self			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    Dict   ,    __SCREAMING_SNAKE_CASE			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    List[Any]   ,    __SCREAMING_SNAKE_CASE			:    int   ,    __SCREAMING_SNAKE_CASE			:    int			)			->       Optional[int]:
             if pipeline_test_casse_name == "QAPipelineTests":
                    return True
  
             return False
  
  
  
      def _a       (							self			:    Optional[int]			)			->       List[Any]:
             __UpperCAmelCase    							=ErnieMModelTester(self			)
             __UpperCAmelCase    							=ConfigTester(self   ,    config_class=__SCREAMING_SNAKE_CASE   ,    hidden_size=37			)
  
  
  
      def _a       (							self			:    int			)			->       List[str]:
             self.config_tester.run_common_tests()
  
  
  
      def _a       (							self			:    str			)			->       str:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Optional[int]			)			->       List[str]:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                    __UpperCAmelCase    							=type
                    self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Optional[int]			)			->       str:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    List[str]			)			->       Union[str, Any]:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Any			)			->       str:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    str			)			->       List[Any]:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_information_extraction(*__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    List[Any]			)			->       List[str]:
             __UpperCAmelCase    							=self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE			)
  
  
  
      @slow
      def _a       (							self			:    List[str]			)			->       Optional[Any]:
             for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    __UpperCAmelCase    							=ErnieMModel.from_pretrained(__SCREAMING_SNAKE_CASE			)
                    self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
  
  
  
  
  @require_torch
  class 							_A (    unittest.TestCase							):
      """simple docstring"""
  
      @slow
      def _a       (							self			:    Tuple			)			->       Optional[Any]:
             __UpperCAmelCase    							=ErnieMModel.from_pretrained("""susnato/ernie-m-base_pytorch"""			)
             model.eval()
             __UpperCAmelCase    							=torch.tensor([[0, 1, 2, 3, 4, 5]]			)
             __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE			)[0]
  
             # TODO Replace vocab size
             __UpperCAmelCase    							=768
  
             __UpperCAmelCase    							=torch.Size((1, 6, hidden_size)			)
             self.assertEqual(output.shape   ,    __SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=torch.tensor(
                 [[[-0.0_012, 0.1_245, -0.0_214], [-0.0_742, 0.0_244, -0.0_771], [-0.0_333, 0.1_164, -0.1_554]]]			)
  
             self.assertTrue(torch.allclose(output[:, :3, :3]   ,    __SCREAMING_SNAKE_CASE   ,    atol=1e-3			)			)
  
  
  
  
  