code: 
  
  
  import json
  import os
  import tempfile
  
  import datasets
  from utils import generate_example_dataset, get_duration
  
  
  lowerCAmelCase__   	=				50_00_00
  
  lowerCAmelCase__   	=				os.path.split(__file__)
  lowerCAmelCase__   	=				os.path.join(RESULTS_BASEPATH, 'results', RESULTS_FILENAME.replace('.py', '.json'))
  @get_duration
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Any		):
         _A   : List[Any]       					=				dataset.select(range(0       ,							len(_UpperCAmelCase		)       ,							2		)		)
  @get_duration
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Union[str, Any]		):
         _A   : Tuple       					=				dataset.sort("numbers"		)
  @get_duration
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Union[str, Any]		):
         _A   : List[str]       					=				dataset.shuffle()
  @get_duration
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Dict		):
         _A   : List[Any]       					=				dataset.train_test_split(0.1		)
  @get_duration
  def 							_UpperCAmelCase       (UpperCamelCase__  :						int       ,							UpperCamelCase__  :						Union[str, Any]=10		):
  
  
  
  
  
  
         for shard_id in range(_UpperCAmelCase		):
                _A   : str       					=				dataset.shard(_UpperCAmelCase       ,							_UpperCAmelCase		)
  def 							_UpperCAmelCase       ():
         _A   : Dict       					=				{'num examples': SPEED_TEST_N_EXAMPLES}
         _A   : List[Any]       					=				(select, sort, shuffle, train_test_split, shard)
         with tempfile.TemporaryDirectory() as tmp_dir:
                print("generating dataset"		)
                _A   : Optional[Any]       					=				datasets.Features({"text": datasets.Value("string"		), "numbers": datasets.Value("float32"		)}		)
                _A   : List[str]       					=				generate_example_dataset(
                    os.path.join(_UpperCAmelCase       ,							"dataset.arrow"		)       ,							_UpperCAmelCase       ,							num_examples=_UpperCAmelCase		)
                print("Functions"		)
                for func in functions:
                       print(func.__name__		)
                       _A   : int       					=				func(_UpperCAmelCase		)
  
         with open(_UpperCAmelCase       ,							"wb"		) as f:
                f.write(json.dumps(_UpperCAmelCase		).encode("utf-8"		)		)
  
  
  if __name__ == "__main__":  # useful to run the profiler
     benchmark_indices_mapping()
  
style_context: 
  
  
  import argparse
  import json
  
  import torch
  
  from diffusers import ScoreSdeVePipeline, ScoreSdeVeScheduler, UNetaDModel
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Union[str, Any]       ,							UpperCamelCase__  :						Dict		):
         _A   : Dict       					=				UNetaDModel(**UpperCamelCase__		)
         _A   : Any       					=				checkpoint["all_modules.0.W"].data
         _A   : Any       					=				checkpoint["all_modules.0.W"].data
         _A   : Union[str, Any]       					=				checkpoint["all_modules.1.weight"].data
         _A   : Optional[Any]       					=				checkpoint["all_modules.1.bias"].data
  
         _A   : Dict       					=				checkpoint["all_modules.2.weight"].data
         _A   : List[str]       					=				checkpoint["all_modules.2.bias"].data
  
         _A   : Dict       					=				checkpoint["all_modules.3.weight"].data
         _A   : Union[str, Any]       					=				checkpoint["all_modules.3.bias"].data
  
         _A   : List[str]       					=				checkpoint[list(checkpoint.keys()		)[-4]].data
         _A   : Any       					=				checkpoint[list(checkpoint.keys()		)[-3]].data
         _A   : List[str]       					=				checkpoint[list(checkpoint.keys()		)[-2]].data
         _A   : Optional[int]       					=				checkpoint[list(checkpoint.keys()		)[-1]].data
  
         _A   : str       					=				4
  
         def set_attention_weights(UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Optional[Any]       ,							UpperCamelCase__  :						Tuple		):
                _A   : Any       					=				old_checkpoint[f"all_modules.{index}.NIN_0.W"].data.T
                _A   : int       					=				old_checkpoint[f"all_modules.{index}.NIN_1.W"].data.T
                _A   : int       					=				old_checkpoint[f"all_modules.{index}.NIN_2.W"].data.T
  
                _A   : Any       					=				old_checkpoint[f"all_modules.{index}.NIN_0.b"].data
                _A   : Any       					=				old_checkpoint[f"all_modules.{index}.NIN_1.b"].data
                _A   : List[str]       					=				old_checkpoint[f"all_modules.{index}.NIN_2.b"].data
  
                _A   : Optional[Any]       					=				old_checkpoint[f"all_modules.{index}.NIN_3.W"].data.T
                _A   : Dict       					=				old_checkpoint[f"all_modules.{index}.NIN_3.b"].data
  
                _A   : Union[str, Any]       					=				old_checkpoint[f"all_modules.{index}.GroupNorm_0.weight"].data
                _A   : int       					=				old_checkpoint[f"all_modules.{index}.GroupNorm_0.bias"].data
  
         def set_resnet_weights(UpperCamelCase__  :						str       ,							UpperCamelCase__  :						Any       ,							UpperCamelCase__  :						Dict		):
                _A   : Optional[int]       					=				old_checkpoint[f"all_modules.{index}.Conv_0.weight"].data
                _A   : Optional[int]       					=				old_checkpoint[f"all_modules.{index}.Conv_0.bias"].data
                _A   : Union[str, Any]       					=				old_checkpoint[f"all_modules.{index}.GroupNorm_0.weight"].data
                _A   : int       					=				old_checkpoint[f"all_modules.{index}.GroupNorm_0.bias"].data
  
                _A   : Union[str, Any]       					=				old_checkpoint[f"all_modules.{index}.Conv_1.weight"].data
                _A   : Optional[int]       					=				old_checkpoint[f"all_modules.{index}.Conv_1.bias"].data
                _A   : Tuple       					=				old_checkpoint[f"all_modules.{index}.GroupNorm_1.weight"].data
                _A   : str       					=				old_checkpoint[f"all_modules.{index}.GroupNorm_1.bias"].data
  
                _A   : Tuple       					=				old_checkpoint[f"all_modules.{index}.Dense_0.weight"].data
                _A   : Union[str, Any]       					=				old_checkpoint[f"all_modules.{index}.Dense_0.bias"].data
  
                if new_layer.in_channels != new_layer.out_channels or new_layer.up or new_layer.down:
                       _A   : Tuple       					=				old_checkpoint[f"all_modules.{index}.Conv_2.weight"].data
                       _A   : Optional[Any]       					=				old_checkpoint[f"all_modules.{index}.Conv_2.bias"].data
  
         for i, block in enumerate(new_model_architecture.downsample_blocks		):
                _A   : Any       					=				hasattr(UpperCamelCase__       ,							"attentions"		)
                for j in range(len(block.resnets		)		):
                       set_resnet_weights(block.resnets[j]       ,							UpperCamelCase__       ,							UpperCamelCase__		)
                       module_index += 1
                       if has_attentions:
                              set_attention_weights(block.attentions[j]       ,							UpperCamelCase__       ,							UpperCamelCase__		)
                              module_index += 1
  
                if hasattr(UpperCamelCase__       ,							"downsamplers"		) and block.downsamplers is not None:
                       set_resnet_weights(block.resnet_down       ,							UpperCamelCase__       ,							UpperCamelCase__		)
                       module_index += 1
                       _A   : List[str]       					=				checkpoint[f"all_modules.{module_index}.Conv_0.weight"].data
                       _A   : Optional[int]       					=				checkpoint[f"all_modules.{module_index}.Conv_0.bias"].data
                       module_index += 1
  
         set_resnet_weights(new_model_architecture.mid_block.resnets[0]       ,							UpperCamelCase__       ,							UpperCamelCase__		)
         module_index += 1
         set_attention_weights(new_model_architecture.mid_block.attentions[0]       ,							UpperCamelCase__       ,							UpperCamelCase__		)
         module_index += 1
         set_resnet_weights(new_model_architecture.mid_block.resnets[1]       ,							UpperCamelCase__       ,							UpperCamelCase__		)
         module_index += 1
  
         for i, block in enumerate(new_model_architecture.up_blocks		):
                _A   : Dict       					=				hasattr(UpperCamelCase__       ,							"attentions"		)
                for j in range(len(block.resnets		)		):
                       set_resnet_weights(block.resnets[j]       ,							UpperCamelCase__       ,							UpperCamelCase__		)
                       module_index += 1
                if has_attentions:
                       set_attention_weights(
                           block.attentions[0]       ,							UpperCamelCase__       ,							UpperCamelCase__		)  # why can there only be a single attention layer for up?
                       module_index += 1
  
                if hasattr(UpperCamelCase__       ,							"resnet_up"		) and block.resnet_up is not None:
                       _A   : Dict       					=				checkpoint[f"all_modules.{module_index}.weight"].data
                       _A   : List[Any]       					=				checkpoint[f"all_modules.{module_index}.bias"].data
                       module_index += 1
                       _A   : int       					=				checkpoint[f"all_modules.{module_index}.weight"].data
                       _A   : List[Any]       					=				checkpoint[f"all_modules.{module_index}.bias"].data
                       module_index += 1
                       set_resnet_weights(block.resnet_up       ,							UpperCamelCase__       ,							UpperCamelCase__		)
                       module_index += 1
  
         _A   : str       					=				checkpoint[f"all_modules.{module_index}.weight"].data
         _A   : str       					=				checkpoint[f"all_modules.{module_index}.bias"].data
         module_index += 1
         _A   : Tuple       					=				checkpoint[f"all_modules.{module_index}.weight"].data
         _A   : str       					=				checkpoint[f"all_modules.{module_index}.bias"].data
  
         return new_model_architecture.state_dict()
  
  
  if __name__ == "__main__":
      lowerCAmelCase__   	=				argparse.ArgumentParser()
  
      parser.add_argument(
          '--checkpoint_path',
          default='/Users/arthurzucker/Work/diffusers/ArthurZ/diffusion_pytorch_model.bin',
          type=str,
          required=False,
          help='Path to the checkpoint to convert.',
      )
  
      parser.add_argument(
          '--config_file',
          default='/Users/arthurzucker/Work/diffusers/ArthurZ/config.json',
          type=str,
          required=False,
          help='The config json file corresponding to the architecture.',
      )
  
      parser.add_argument(
          '--dump_path',
          default='/Users/arthurzucker/Work/diffusers/ArthurZ/diffusion_model_new.pt',
          type=str,
          required=False,
          help='Path to the output model.',
      )
  
      lowerCAmelCase__   	=				parser.parse_args()
  
      lowerCAmelCase__   	=				torch.load(args.checkpoint_path, map_location='cpu')
  
      with open(args.config_file) as f:
          lowerCAmelCase__   	=				json.loads(f.read())
  
      lowerCAmelCase__   	=				convert_ncsnpp_checkpoint(
          checkpoint,
          config,
      )
  
      if "sde" in config:
          del config["sde"]
  
      lowerCAmelCase__   	=				UNetaDModel(**config)
      model.load_state_dict(converted_checkpoint)
  
      try:
          lowerCAmelCase__   	=				ScoreSdeVeScheduler.from_config('/'.join(args.checkpoint_path.split('/')[:-1]))
  
          lowerCAmelCase__   	=				ScoreSdeVePipeline(unet=model, scheduler=scheduler)
          pipe.save_pretrained(args.dump_path)
      except:  # noqa: E722
          model.save_pretrained(args.dump_path)
  