code: 
  
  
  import argparse
  import json
  import re
  from pathlib import Path
  
  import requests
  import torch
  from huggingface_hub import hf_hub_download
  from PIL import Image
  
  from transformers import (
      MobileNetVaConfig,
      MobileNetVaForImageClassification,
      MobileNetVaForSemanticSegmentation,
      MobileNetVaImageProcessor,
      load_tf_weights_in_mobilenet_va,
  )
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  lowerCAmelCase__   	=				logging.get_logger(__name__)
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Union[str, Any]		):
         _A   : Optional[int]       					=				MobileNetVaConfig(layer_norm_eps=0.0_01		)
  
         if "quant" in model_name:
                raise ValueError("Quantized models are not supported."		)
  
         _A   : Any       					=				re.match(r"^.*mobilenet_v2_([^_]*)_([^_]*)$"       ,							_SCREAMING_SNAKE_CASE		)
         if matches:
                _A   : Dict       					=				float(matches[1]		)
                _A   : Union[str, Any]       					=				int(matches[2]		)
  
         if model_name.startswith("deeplabv3_"		):
                _A   : int       					=				8
                _A   : Union[str, Any]       					=				21
                _A   : Dict       					=				'pascal-voc-id2label.json'
         else:
                # The TensorFlow version of MobileNetV2 predicts 1001 classes instead
                # of the usual 1000. The first class (index 0) is "background".
                _A   : Optional[int]       					=				1001
                _A   : Dict       					=				'imagenet-1k-id2label.json'
  
         _A   : List[Any]       					=				'huggingface/label-files'
         _A   : str       					=				json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE       ,							repo_type="dataset"		)       ,							"r"		)		)
  
         if config.num_labels == 1001:
                _A   : List[Any]       					=				{int(_SCREAMING_SNAKE_CASE		) + 1: v for k, v in idalabel.items()}
                _A   : List[Any]       					=				'background'
         else:
                _A   : Tuple       					=				{int(_SCREAMING_SNAKE_CASE		): v for k, v in idalabel.items()}
  
         _A   : str       					=				idalabel
         _A   : Tuple       					=				{v: k for k, v in idalabel.items()}
  
         return config
  def 							_UpperCAmelCase       ():
         _A   : Optional[int]       					=				'http://images.cocodataset.org/val2017/000000039769.jpg'
         _A   : Optional[int]       					=				Image.open(requests.get(_SCREAMING_SNAKE_CASE       ,							stream=_SCREAMING_SNAKE_CASE		).raw		)
         return im
  @torch.no_grad()
  def 							_UpperCAmelCase       (UpperCamelCase__  :						Dict       ,							UpperCamelCase__  :						List[Any]       ,							UpperCamelCase__  :						Union[str, Any]       ,							UpperCamelCase__  :						List[Any]=False		):
         _A   : List[Any]       					=				get_mobilenet_va_config(_SCREAMING_SNAKE_CASE		)
  
         # Load 🤗 model
         if model_name.startswith("deeplabv3_"		):
                _A   : Tuple       					=				MobileNetVaForSemanticSegmentation(_SCREAMING_SNAKE_CASE		).eval()
         else:
                _A   : List[Any]       					=				MobileNetVaForImageClassification(_SCREAMING_SNAKE_CASE		).eval()
  
         # Load weights from TensorFlow checkpoint
         load_tf_weights_in_mobilenet_va(_SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE		)
  
         # Check outputs on an image, prepared by MobileNetV2ImageProcessor
         _A   : Optional[Any]       					=				MobileNetVaImageProcessor(
             crop_size={"width": config.image_size, "height": config.image_size}       ,							size={"shortest_edge": config.image_size + 32}       ,							)
         _A   : int       					=				image_processor(images=prepare_img()       ,							return_tensors="pt"		)
         _A   : Optional[int]       					=				model(**_SCREAMING_SNAKE_CASE		)
         _A   : Optional[Any]       					=				outputs.logits
  
         if model_name.startswith("deeplabv3_"		):
                assert logits.shape == (1, 21, 65, 65)
  
                if model_name == "deeplabv3_mobilenet_v2_1.0_513":
                       _A   : List[Any]       					=				torch.tensor(
                           [
                               [[17.5790, 17.7581, 18.3355], [18.3257, 18.4230, 18.8973], [18.6169, 18.8650, 19.2187]],
                               [[-2.15_95, -2.09_77, -2.37_41], [-2.42_26, -2.30_28, -2.68_35], [-2.78_19, -2.59_91, -2.77_06]],
                               [[4.20_58, 4.83_17, 4.76_38], [4.41_36, 5.03_61, 4.93_83], [4.50_28, 4.96_44, 4.87_34]],
                           ]		)
  
                else:
                       raise ValueError(f"Unknown model name: {model_name}"		)
  
                assert torch.allclose(logits[0, :3, :3, :3]       ,							_SCREAMING_SNAKE_CASE       ,							atol=1E-4		)
         else:
                assert logits.shape == (1, 1001)
  
                if model_name == "mobilenet_v2_1.4_224":
                       _A   : Any       					=				torch.tensor([0.01_81, -1.00_15, 0.46_88]		)
                elif model_name == "mobilenet_v2_1.0_224":
                       _A   : Optional[Any]       					=				torch.tensor([0.24_45, -1.19_93, 0.19_05]		)
                elif model_name == "mobilenet_v2_0.75_160":
                       _A   : Optional[int]       					=				torch.tensor([0.24_82, 0.41_36, 0.66_69]		)
                elif model_name == "mobilenet_v2_0.35_96":
                       _A   : Union[str, Any]       					=				torch.tensor([0.14_51, -0.46_24, 0.71_92]		)
                else:
                       _A   : Union[str, Any]       					=				None
  
                if expected_logits is not None:
                       assert torch.allclose(logits[0, :3]       ,							_SCREAMING_SNAKE_CASE       ,							atol=1E-4		)
  
         Path(_SCREAMING_SNAKE_CASE		).mkdir(exist_ok=_SCREAMING_SNAKE_CASE		)
         print(f"Saving model {model_name} to {pytorch_dump_folder_path}"		)
         model.save_pretrained(_SCREAMING_SNAKE_CASE		)
         print(f"Saving image processor to {pytorch_dump_folder_path}"		)
         image_processor.save_pretrained(_SCREAMING_SNAKE_CASE		)
  
         if push_to_hub:
                print("Pushing to the hub..."		)
                _A   : Tuple       					=				'google/' + model_name
                image_processor.push_to_hub(_SCREAMING_SNAKE_CASE		)
                model.push_to_hub(_SCREAMING_SNAKE_CASE		)
  
  
  if __name__ == "__main__":
     lowerCAmelCase__   	=				argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--model_name',
         default='mobilenet_v2_1.0_224',
         type=str,
         help='Name of the MobileNetV2 model you\'d like to convert. Should in the form \'mobilenet_v2_<depth>_<size>\'.',
     )
     parser.add_argument(
         '--checkpoint_path', required=True, type=str, help='Path to the original TensorFlow checkpoint (.ckpt file).'
     )
     parser.add_argument(
         '--pytorch_dump_folder_path', required=True, type=str, help='Path to the output PyTorch model directory.'
     )
     parser.add_argument(
         '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
     )
  
     lowerCAmelCase__   	=				parser.parse_args()
     convert_movilevit_checkpoint(
         args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
     )
  
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)
  