code: 
  
  import argparse
  import json
  
  import torch
  
  from diffusers import AutoencoderKL, DDPMPipeline, DDPMScheduler, UNetaDModel, VQModel
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				Any			,   _A   :				Tuple=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   :				Dict			,   _A   :				Optional[int]=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(_A			,   n_shave_prefix_segments=_A							)
  
      mapping.append({'''old''': old_item, '''new''': new_item}							)
  
    return mapping
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				Union[str, Any]			,   _A   :				Tuple=0			,   _A   :				Any=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(_A			,   n_shave_prefix_segments=_A							)
      mapping.append({'''old''': old_item, '''new''': new_item}							)
  
    return mapping
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				List[str]			,   _A   :				Any			,   _A   :				Tuple			,   _A   :				Optional[Any]=None			,   _A   :				Tuple=None			,   _A   :				List[str]=None							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    assert isinstance(_A			,   _A							), "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(_A							).squeeze()
        a__						=key.reshape(_A							).squeeze()
        a__						=value.reshape(_A							).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   :				Optional[int]			,   _A   :				Optional[int]							):
  
  
  
  
  
    '''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(_A							)
    }
  
    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(_A							)}
  
    for i in range(_A							):
      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(_A			,   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(_A							)
        }
  
        if num_blocks > 0:
          for j in range(config['''layers_per_block''']							):
            a__						=renew_resnet_paths(blocks[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A							)
  
      if any('''attn''' in layer for layer in down_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   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(_A							)
        }
  
        if num_attn > 0:
          for j in range(config['''layers_per_block''']							):
            a__						=renew_attention_paths(attns[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A			,   config=_A							)
  
    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(_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_1''', '''new''': '''resnets.0'''}]			,   )
  
    a__						=renew_resnet_paths(_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_2''', '''new''': '''resnets.1'''}]			,   )
  
    a__						=renew_attention_paths(_A			,   in_mid=_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''attn_1''', '''new''': '''attentions.0'''}]			,   )
  
    for i in range(_A							):
      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(_A			,   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(_A							)
        }
  
        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(_A			,   _A			,   _A			,   additional_replacements=[replace_indices]							)
  
      if any('''attn''' in layer for layer in up_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   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(_A							)
        }
  
        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(_A			,   _A			,   _A			,   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   :				Union[str, Any]			,   _A   :				List[Any]							):
  
  
  
  
  
    '''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(_A							)
    }
  
    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(_A							)}
  
    for i in range(_A							):
      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(_A			,   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(_A							)
        }
  
        if num_blocks > 0:
          for j in range(config['''layers_per_block''']							):
            a__						=renew_resnet_paths(blocks[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A							)
  
      if any('''attn''' in layer for layer in down_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   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(_A							)
        }
  
        if num_attn > 0:
          for j in range(config['''layers_per_block''']							):
            a__						=renew_attention_paths(attns[j]							)
            assign_to_checkpoint(_A			,   _A			,   _A			,   config=_A							)
  
    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(_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_1''', '''new''': '''resnets.0'''}]			,   )
  
    a__						=renew_resnet_paths(_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''block_2''', '''new''': '''resnets.1'''}]			,   )
  
    a__						=renew_attention_paths(_A			,   in_mid=_A							)
    assign_to_checkpoint(
        _A			,   _A			,   _A			,   additional_replacements=[{'''old''': '''mid.''', '''new''': '''mid_new_2.'''}, {'''old''': '''attn_1''', '''new''': '''attentions.0'''}]			,   )
  
    for i in range(_A							):
      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(_A			,   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(_A							)
        }
  
        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(_A			,   _A			,   _A			,   additional_replacements=[replace_indices]							)
  
      if any('''attn''' in layer for layer in up_blocks[i]							):
        a__						=len(
            {'''.'''.join(shave_segments(_A			,   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(_A							)
        }
  
        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(_A			,   _A			,   _A			,   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)
  
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 		__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 ) )
  