

import argparse
import json

import torch

from diffusers import AutoencoderKL, DDPMPipeline, DDPMScheduler, UNetaDModel, VQModel




def     UpperCAmelCase__				(    _A   :				Optional[Any]			,   _A   :				Optional[int]=1							):





  '''simple docstring'''







  if n_shave_prefix_segments >= 0:
    return ".".join(path.split('''.'''							)[n_shave_prefix_segments:]							)
  else:
    return ".".join(path.split('''.'''							)[:n_shave_prefix_segments]							)




def     UpperCAmelCase__				(    _A   :				Optional[int]			,   _A   :				Optional[Any]=0							):





  '''simple docstring'''







  a__						=[]
  for old_item in old_list:
    a__						=old_item
    a__						=new_item.replace('''block.'''			,   '''resnets.'''							)
    a__						=new_item.replace('''conv_shorcut'''			,   '''conv1'''							)
    a__						=new_item.replace('''in_shortcut'''			,   '''conv_shortcut'''							)
    a__						=new_item.replace('''temb_proj'''			,   '''time_emb_proj'''							)

    a__						=shave_segments(lowercase__			,   n_shave_prefix_segments=lowercase__							)

    mapping.append({'''old''': old_item, '''new''': new_item}							)

  return mapping




def     UpperCAmelCase__				(    _A   :				List[str]			,   _A   :				Optional[Any]=0			,   _A   :				Dict=False							):





  '''simple docstring'''







  a__						=[]
  for old_item in old_list:
    a__						=old_item

    # In `model.mid`, the layer is called `attn`.
    if not in_mid:
      a__						=new_item.replace('''attn'''			,   '''attentions'''							)
    a__						=new_item.replace('''.k.'''			,   '''.key.'''							)
    a__						=new_item.replace('''.v.'''			,   '''.value.'''							)
    a__						=new_item.replace('''.q.'''			,   '''.query.'''							)

    a__						=new_item.replace('''proj_out'''			,   '''proj_attn'''							)
    a__						=new_item.replace('''norm'''			,   '''group_norm'''							)

    a__						=shave_segments(lowercase__			,   n_shave_prefix_segments=lowercase__							)
    mapping.append({'''old''': old_item, '''new''': new_item}							)

  return mapping




def     UpperCAmelCase__				(    _A   :				str			,   _A   :				Optional[Any]			,   _A   :				int			,   _A   :				Dict=None			,   _A   :				Union[str, Any]=None			,   _A   :				Optional[Any]=None							):





  '''simple docstring'''







  assert isinstance(lowercase__			,   lowercase__							), "Paths should be a list of dicts containing 'old' and 'new' keys."

  if attention_paths_to_split is not None:
    if config is None:
      raise ValueError('''Please specify the config if setting \'attention_paths_to_split\' to \'True\'.'''							)

    for path, path_map in attention_paths_to_split.items():
      a__						=old_checkpoint[path]
      a__						=old_tensor.shape[0] // 3

      a__						=(-1, channels) if len(old_tensor.shape							) == 3 else (-1)

      a__						=old_tensor.shape[0] // config.get('''num_head_channels'''			,   1							) // 3

      a__						=old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]							)
      a__,   a__,   a__						=old_tensor.split(channels // num_heads			,   dim=1							)

      a__						=query.reshape(lowercase__							).squeeze()
      a__						=key.reshape(lowercase__							).squeeze()
      a__						=value.reshape(lowercase__							).squeeze()

  for path in paths:
    a__						=path['''new''']

    if attention_paths_to_split is not None and new_path in attention_paths_to_split:
      continue

    a__						=new_path.replace('''down.'''			,   '''down_blocks.'''							)
    a__						=new_path.replace('''up.'''			,   '''up_blocks.'''							)

    if additional_replacements is not None:
      for replacement in additional_replacements:
        a__						=new_path.replace(replacement['''old''']			,   replacement['''new''']							)

    if "attentions" in new_path:
      a__						=old_checkpoint[path['''old''']].squeeze()
    else:
      a__						=old_checkpoint[path['''old''']]




def     UpperCAmelCase__				(    _A   :				Union[str, Any]			,   _A   :				Tuple							):





  '''simple docstring'''







  a__						={}

  a__						=checkpoint['''temb.dense.0.weight''']
  a__						=checkpoint['''temb.dense.0.bias''']
  a__						=checkpoint['''temb.dense.1.weight''']
  a__						=checkpoint['''temb.dense.1.bias''']

  a__						=checkpoint['''norm_out.weight''']
  a__						=checkpoint['''norm_out.bias''']

  a__						=checkpoint['''conv_in.weight''']
  a__						=checkpoint['''conv_in.bias''']
  a__						=checkpoint['''conv_out.weight''']
  a__						=checkpoint['''conv_out.bias''']

  a__						=len({'''.'''.join(layer.split('''.'''							)[:2]							) for layer in checkpoint if '''down''' in layer}							)
  a__						={
      layer_id: [key for key in checkpoint if F"""down.{layer_id}""" in key] for layer_id in range(lowercase__							)
  }

  a__						=len({'''.'''.join(layer.split('''.'''							)[:2]							) for layer in checkpoint if '''up''' in layer}							)
  a__						={layer_id: [key for key in checkpoint if F"""up.{layer_id}""" in key] for layer_id in range(lowercase__							)}

  for i in range(lowercase__							):
    a__						=(i - 1) // (config['''layers_per_block'''] + 1)

    if any('''downsample''' in layer for layer in down_blocks[i]							):
      a__						=checkpoint[
          F"""down.{i}.downsample.op.weight"""
      ]
      a__						=checkpoint[F"""down.{i}.downsample.op.bias"""]
    #            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.weight'] = checkpoint[f'down.{i}.downsample.conv.weight']
    #            new_checkpoint[f'down_blocks.{i}.downsamplers.0.op.bias'] = checkpoint[f'down.{i}.downsample.conv.bias']

    if any('''block''' in layer for layer in down_blocks[i]							):
      a__						=len(
          {'''.'''.join(shave_segments(lowercase__			,   2							).split('''.'''							)[:2]							) for layer in down_blocks[i] if '''block''' in layer}							)
      a__						={
          layer_id: [key for key in down_blocks[i] if F"""block.{layer_id}""" in key]
          for layer_id in range(lowercase__							)
      }

      if num_blocks > 0:
        for j in range(config['''layers_per_block''']							):
          a__						=renew_resnet_paths(blocks[j]							)
          assign_to_checkpoint(lowercase__			,   lowercase__			,   lowercase__							)

    if any('''attn''' in layer for layer in down_blocks[i]							):
      a__						=len(
          {'''.'''.join(shave_segments(lowercase__			,   2							).split('''.'''							)[:2]							) for layer in down_blocks[i] if '''attn''' in layer}							)
      a__						={
          layer_id: [key for key in down_blocks[i] if F"""attn.{layer_id}""" in key]
          for layer_id in range(lowercase__							)
      }

      if num_attn > 0:
        for j in range(config['''layers_per_block''']							):
          a__						=renew_attention_paths(attns[j]							)
          assign_to_checkpoint(lowercase__			,   lowercase__			,   lowercase__			,   config=lowercase__							)

  a__						=[key for key in checkpoint if '''mid.block_1''' in key]
  a__						=[key for key in checkpoint if '''mid.block_2''' in key]
  a__						=[key for key in checkpoint if '''mid.attn_1''' in key]

  # Mid new 2
  a__						=renew_resnet_paths(lowercase__							)
  assign_to_checkpoint(
      lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_1''', '''new''': '''resnets.0'''}]			,   )

  a__						=renew_resnet_paths(lowercase__							)
  assign_to_checkpoint(
      lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_2''', '''new''': '''resnets.1'''}]			,   )

  a__						=renew_attention_paths(lowercase__			,   in_mid=lowercase__							)
  assign_to_checkpoint(
      lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''attn_1''', '''new''': '''attentions.0'''}]			,   )

  for i in range(lowercase__							):
    a__						=num_up_blocks - 1 - i

    if any('''upsample''' in layer for layer in up_blocks[i]							):
      a__						=checkpoint[
          F"""up.{i}.upsample.conv.weight"""
      ]
      a__						=checkpoint[F"""up.{i}.upsample.conv.bias"""]

    if any('''block''' in layer for layer in up_blocks[i]							):
      a__						=len(
          {'''.'''.join(shave_segments(lowercase__			,   2							).split('''.'''							)[:2]							) for layer in up_blocks[i] if '''block''' in layer}							)
      a__						={
          layer_id: [key for key in up_blocks[i] if F"""block.{layer_id}""" in key] for layer_id in range(lowercase__							)
      }

      if num_blocks > 0:
        for j in range(config['''layers_per_block'''] + 1							):
          a__						={'''old''': F"""up_blocks.{i}""", '''new''': F"""up_blocks.{block_id}"""}
          a__						=renew_resnet_paths(blocks[j]							)
          assign_to_checkpoint(lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[replace_indices]							)

    if any('''attn''' in layer for layer in up_blocks[i]							):
      a__						=len(
          {'''.'''.join(shave_segments(lowercase__			,   2							).split('''.'''							)[:2]							) for layer in up_blocks[i] if '''attn''' in layer}							)
      a__						={
          layer_id: [key for key in up_blocks[i] if F"""attn.{layer_id}""" in key] for layer_id in range(lowercase__							)
      }

      if num_attn > 0:
        for j in range(config['''layers_per_block'''] + 1							):
          a__						={'''old''': F"""up_blocks.{i}""", '''new''': F"""up_blocks.{block_id}"""}
          a__						=renew_attention_paths(attns[j]							)
          assign_to_checkpoint(lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[replace_indices]							)

  a__						={k.replace('''mid_new_2'''			,   '''mid_block'''							): v for k, v in new_checkpoint.items()}
  return new_checkpoint




def     UpperCAmelCase__				(    _A   :				List[Any]			,   _A   :				Optional[int]							):





  '''simple docstring'''







  a__						={}

  a__						=checkpoint['''encoder.norm_out.weight''']
  a__						=checkpoint['''encoder.norm_out.bias''']

  a__						=checkpoint['''encoder.conv_in.weight''']
  a__						=checkpoint['''encoder.conv_in.bias''']
  a__						=checkpoint['''encoder.conv_out.weight''']
  a__						=checkpoint['''encoder.conv_out.bias''']

  a__						=checkpoint['''decoder.norm_out.weight''']
  a__						=checkpoint['''decoder.norm_out.bias''']

  a__						=checkpoint['''decoder.conv_in.weight''']
  a__						=checkpoint['''decoder.conv_in.bias''']
  a__						=checkpoint['''decoder.conv_out.weight''']
  a__						=checkpoint['''decoder.conv_out.bias''']

  a__						=len({'''.'''.join(layer.split('''.'''							)[:3]							) for layer in checkpoint if '''down''' in layer}							)
  a__						={
      layer_id: [key for key in checkpoint if F"""down.{layer_id}""" in key] for layer_id in range(lowercase__							)
  }

  a__						=len({'''.'''.join(layer.split('''.'''							)[:3]							) for layer in checkpoint if '''up''' in layer}							)
  a__						={layer_id: [key for key in checkpoint if F"""up.{layer_id}""" in key] for layer_id in range(lowercase__							)}

  for i in range(lowercase__							):
    a__						=(i - 1) // (config['''layers_per_block'''] + 1)

    if any('''downsample''' in layer for layer in down_blocks[i]							):
      a__						=checkpoint[
          F"""encoder.down.{i}.downsample.conv.weight"""
      ]
      a__						=checkpoint[
          F"""encoder.down.{i}.downsample.conv.bias"""
      ]

    if any('''block''' in layer for layer in down_blocks[i]							):
      a__						=len(
          {'''.'''.join(shave_segments(lowercase__			,   3							).split('''.'''							)[:3]							) for layer in down_blocks[i] if '''block''' in layer}							)
      a__						={
          layer_id: [key for key in down_blocks[i] if F"""block.{layer_id}""" in key]
          for layer_id in range(lowercase__							)
      }

      if num_blocks > 0:
        for j in range(config['''layers_per_block''']							):
          a__						=renew_resnet_paths(blocks[j]							)
          assign_to_checkpoint(lowercase__			,   lowercase__			,   lowercase__							)

    if any('''attn''' in layer for layer in down_blocks[i]							):
      a__						=len(
          {'''.'''.join(shave_segments(lowercase__			,   3							).split('''.'''							)[:3]							) for layer in down_blocks[i] if '''attn''' in layer}							)
      a__						={
          layer_id: [key for key in down_blocks[i] if F"""attn.{layer_id}""" in key]
          for layer_id in range(lowercase__							)
      }

      if num_attn > 0:
        for j in range(config['''layers_per_block''']							):
          a__						=renew_attention_paths(attns[j]							)
          assign_to_checkpoint(lowercase__			,   lowercase__			,   lowercase__			,   config=lowercase__							)

  a__						=[key for key in checkpoint if '''mid.block_1''' in key]
  a__						=[key for key in checkpoint if '''mid.block_2''' in key]
  a__						=[key for key in checkpoint if '''mid.attn_1''' in key]

  # Mid new 2
  a__						=renew_resnet_paths(lowercase__							)
  assign_to_checkpoint(
      lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_1''', '''new''': '''resnets.0'''}]			,   )

  a__						=renew_resnet_paths(lowercase__							)
  assign_to_checkpoint(
      lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_2''', '''new''': '''resnets.1'''}]			,   )

  a__						=renew_attention_paths(lowercase__			,   in_mid=lowercase__							)
  assign_to_checkpoint(
      lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''attn_1''', '''new''': '''attentions.0'''}]			,   )

  for i in range(lowercase__							):
    a__						=num_up_blocks - 1 - i

    if any('''upsample''' in layer for layer in up_blocks[i]							):
      a__						=checkpoint[
          F"""decoder.up.{i}.upsample.conv.weight"""
      ]
      a__						=checkpoint[
          F"""decoder.up.{i}.upsample.conv.bias"""
      ]

    if any('''block''' in layer for layer in up_blocks[i]							):
      a__						=len(
          {'''.'''.join(shave_segments(lowercase__			,   3							).split('''.'''							)[:3]							) for layer in up_blocks[i] if '''block''' in layer}							)
      a__						={
          layer_id: [key for key in up_blocks[i] if F"""block.{layer_id}""" in key] for layer_id in range(lowercase__							)
      }

      if num_blocks > 0:
        for j in range(config['''layers_per_block'''] + 1							):
          a__						={'''old''': F"""up_blocks.{i}""", '''new''': F"""up_blocks.{block_id}"""}
          a__						=renew_resnet_paths(blocks[j]							)
          assign_to_checkpoint(lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[replace_indices]							)

    if any('''attn''' in layer for layer in up_blocks[i]							):
      a__						=len(
          {'''.'''.join(shave_segments(lowercase__			,   3							).split('''.'''							)[:3]							) for layer in up_blocks[i] if '''attn''' in layer}							)
      a__						={
          layer_id: [key for key in up_blocks[i] if F"""attn.{layer_id}""" in key] for layer_id in range(lowercase__							)
      }

      if num_attn > 0:
        for j in range(config['''layers_per_block'''] + 1							):
          a__						={'''old''': F"""up_blocks.{i}""", '''new''': F"""up_blocks.{block_id}"""}
          a__						=renew_attention_paths(attns[j]							)
          assign_to_checkpoint(lowercase__			,   lowercase__			,   lowercase__			,   additional_replacements=[replace_indices]							)

  a__						={k.replace('''mid_new_2'''			,   '''mid_block'''							): v for k, v in new_checkpoint.items()}
  a__						=checkpoint['''quant_conv.weight''']
  a__						=checkpoint['''quant_conv.bias''']
  if "quantize.embedding.weight" in checkpoint:
    a__						=checkpoint['''quantize.embedding.weight''']
  a__						=checkpoint['''post_quant_conv.weight''']
  a__						=checkpoint['''post_quant_conv.bias''']

  return new_checkpoint


if __name__ == "__main__":
       lowerCamelCase     =      argparse.ArgumentParser()

       parser.add_argument(
           '''--checkpoint_path''', default=None, type=str, required=True, help='''Path to the checkpoint to convert.'''
       )

       parser.add_argument(
           '''--config_file''',
           default=None,
           type=str,
           required=True,
           help='''The config json file corresponding to the architecture.''',
       )

       parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')

       lowerCamelCase     =      parser.parse_args()
       lowerCamelCase     =      torch.load(args.checkpoint_path)

       with open(args.config_file) as f:
              lowerCamelCase     =      json.loads(f.read())

       # unet case
       lowerCamelCase     =      {key.split('''.''')[0] for key in checkpoint.keys()}
       if "encoder" in key_prefix_set and "decoder" in key_prefix_set:
              lowerCamelCase     =      convert_vq_autoenc_checkpoint(checkpoint, config)
       else:
              lowerCamelCase     =      convert_ddpm_checkpoint(checkpoint, config)

       if "ddpm" in config:
              del config["ddpm"]

       if config["_class_name"] == "VQModel":
              lowerCamelCase     =      VQModel(**config)
              model.load_state_dict(converted_checkpoint)
              model.save_pretrained(args.dump_path)
       elif config["_class_name"] == "AutoencoderKL":
              lowerCamelCase     =      AutoencoderKL(**config)
              model.load_state_dict(converted_checkpoint)
              model.save_pretrained(args.dump_path)
       else:
              lowerCamelCase     =      UNetaDModel(**config)
              model.load_state_dict(converted_checkpoint)

              lowerCamelCase     =      DDPMScheduler.from_config('''/'''.join(args.checkpoint_path.split('''/''')[:-1]))

              lowerCamelCase     =      DDPMPipeline(unet=model, scheduler=scheduler)
              pipe.save_pretrained(args.dump_path)



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 ) )
