




'''simple docstring'''



import argparse
import os
import re

import tensorflow as tf
import torch

from transformers import BertConfig, BertModel
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase_			=						logging.get_logger(__name__)
def 			SCREAMING_SNAKE_CASE_			(							__A    :			Union[str, Any]	,					__A    :			str	,					__A    :			Optional[Any]  )			->			Union[str, Any]:
   _SCREAMING_SNAKE_CASE	=				os.path.abspath(__A  )
   logger.info(f"""Converting TensorFlow checkpoint from {tf_path}"""  )
   # Load weights from TF model
   _SCREAMING_SNAKE_CASE	=				tf.train.list_variables(__A  )
   _SCREAMING_SNAKE_CASE	=				[]
   _SCREAMING_SNAKE_CASE	=				[]
   _SCREAMING_SNAKE_CASE	=				[]
   for full_name, shape in init_vars:
      # logger.info(f"Loading TF weight {name} with shape {shape}")
      _SCREAMING_SNAKE_CASE	=				full_name.split("/"  )
      if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
         logger.info(f"""Skipping non-model layer {full_name}"""  )
         continue
      if "optimizer" in full_name:
         logger.info(f"""Skipping optimization layer {full_name}"""  )
         continue
      if name[0] == "model":
         # ignore initial 'model'
         _SCREAMING_SNAKE_CASE	=				name[1:]
      # figure out how many levels deep the name is
      _SCREAMING_SNAKE_CASE	=				0
      for _name in name:
         if _name.startswith("layer_with_weights"  ):
            depth += 1
         else:
            break
      layer_depth.append(__A  )
      # read data
      _SCREAMING_SNAKE_CASE	=				tf.train.load_variable(__A	,					__A  )
      names.append("/".join(__A  )  )
      arrays.append(__A  )
   logger.info(f"""Read a total of {len(__A  ):,} layers"""  )

   # Sanity check
   if len(set(__A  )  ) != 1:
      raise ValueError(f"""Found layer names with different depths (layer depth {list(set(__A  )  )})"""  )
   _SCREAMING_SNAKE_CASE	=				list(set(__A  )  )[0]
   if layer_depth != 1:
      raise ValueError(
          "The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP"
          " heads."  )

   # convert layers
   logger.info("Converting weights..."  )
   for full_name, array in zip(__A	,					__A  ):
      _SCREAMING_SNAKE_CASE	=				full_name.split("/"  )
      _SCREAMING_SNAKE_CASE	=				model
      _SCREAMING_SNAKE_CASE	=				[]
      for i, m_name in enumerate(__A  ):
         if m_name == ".ATTRIBUTES":
            # variable names end with .ATTRIBUTES/VARIABLE_VALUE
            break
         if m_name.startswith("layer_with_weights"  ):
            _SCREAMING_SNAKE_CASE	=				int(m_name.split("-"  )[-1]  )
            if layer_num <= 2:
               # embedding layers
               # layer_num 0: word_embeddings
               # layer_num 1: position_embeddings
               # layer_num 2: token_type_embeddings
               continue
            elif layer_num == 3:
               # embedding LayerNorm
               trace.extend(["embeddings", "LayerNorm"]  )
               _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"embeddings"  )
               _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"LayerNorm"  )
            elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
               # encoder layers
               trace.extend(["encoder", "layer", str(layer_num - 4  )]  )
               _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"encoder"  )
               _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"layer"  )
               _SCREAMING_SNAKE_CASE	=				pointer[layer_num - 4]
            elif layer_num == config.num_hidden_layers + 4:
               # pooler layer
               trace.extend(["pooler", "dense"]  )
               _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"pooler"  )
               _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"dense"  )
         elif m_name == "embeddings":
            trace.append("embeddings"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"embeddings"  )
            if layer_num == 0:
               trace.append("word_embeddings"  )
               _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"word_embeddings"  )
            elif layer_num == 1:
               trace.append("position_embeddings"  )
               _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"position_embeddings"  )
            elif layer_num == 2:
               trace.append("token_type_embeddings"  )
               _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"token_type_embeddings"  )
            else:
               raise ValueError(f"""Unknown embedding layer with name {full_name}"""  )
            trace.append("weight"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"weight"  )
         elif m_name == "_attention_layer":
            # self-attention layer
            trace.extend(["attention", "self"]  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"attention"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"self"  )
         elif m_name == "_attention_layer_norm":
            # output attention norm
            trace.extend(["attention", "output", "LayerNorm"]  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"attention"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"output"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"LayerNorm"  )
         elif m_name == "_attention_output_dense":
            # output attention dense
            trace.extend(["attention", "output", "dense"]  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"attention"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"output"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"dense"  )
         elif m_name == "_output_dense":
            # output dense
            trace.extend(["output", "dense"]  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"output"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"dense"  )
         elif m_name == "_output_layer_norm":
            # output dense
            trace.extend(["output", "LayerNorm"]  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"output"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"LayerNorm"  )
         elif m_name == "_key_dense":
            # attention key
            trace.append("key"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"key"  )
         elif m_name == "_query_dense":
            # attention query
            trace.append("query"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"query"  )
         elif m_name == "_value_dense":
            # attention value
            trace.append("value"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"value"  )
         elif m_name == "_intermediate_dense":
            # attention intermediate dense
            trace.extend(["intermediate", "dense"]  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"intermediate"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"dense"  )
         elif m_name == "_output_layer_norm":
            # output layer norm
            trace.append("output"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"output"  )
         # weights & biases
         elif m_name in ["bias", "beta"]:
            trace.append("bias"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"bias"  )
         elif m_name in ["kernel", "gamma"]:
            trace.append("weight"  )
            _SCREAMING_SNAKE_CASE	=				getattr(__A	,					"weight"  )
         else:
            logger.warning(f"""Ignored {m_name}"""  )
        # for certain layers reshape is necessary
      _SCREAMING_SNAKE_CASE	=				".".join(__A  )
      if re.match(R"(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)"	,					__A  ) or re.match(
          R"(\S+)\.attention\.output\.dense\.weight"	,					__A  ):
         _SCREAMING_SNAKE_CASE	=				array.reshape(pointer.data.shape  )
      if "kernel" in full_name:
         _SCREAMING_SNAKE_CASE	=				array.transpose()
      if pointer.shape == array.shape:
         _SCREAMING_SNAKE_CASE	=				torch.from_numpy(__A  )
      else:
         raise ValueError(
             f"""Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:"""
             f""" {array.shape}"""  )
      logger.info(f"""Successfully set variable {full_name} to PyTorch layer {trace}"""  )
   return model
def 			SCREAMING_SNAKE_CASE_			(							__A    :			List[Any]	,					__A    :			int	,					__A    :			Dict  )			->			int:
   # Instantiate model
   logger.info(f"""Loading model based on config from {config_path}..."""  )
   _SCREAMING_SNAKE_CASE	=				BertConfig.from_json_file(__A  )
   _SCREAMING_SNAKE_CASE	=				BertModel(__A  )

   # Load weights from checkpoint
   logger.info(f"""Loading weights from checkpoint {tf_checkpoint_path}..."""  )
   load_tfa_weights_in_bert(__A	,					__A	,					__A  )

   # Save pytorch-model
   logger.info(f"""Saving PyTorch model to {pytorch_dump_path}..."""  )
   torch.save(model.state_dict()	,					__A  )


if __name__ == "__main__":
 lowerCamelCase_			=						argparse.ArgumentParser()
 parser.add_argument(
     '--tf_checkpoint_path', type=str, required=True, help='Path to the TensorFlow 2.x checkpoint path.'
 )
 parser.add_argument(
     '--bert_config_file',
     type=str,
     required=True,
     help='The config json file corresponding to the BERT model. This specifies the model architecture.',
 )
 parser.add_argument(
     '--pytorch_dump_path',
     type=str,
     required=True,
     help='Path to the output PyTorch model (must include filename).',
 )
 lowerCamelCase_			=						parser.parse_args()
 convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)







'''simple docstring'''



import argparse
import math
import os
from copy import deepcopy

import torch
from audio_diffusion.models import DiffusionAttnUnetaD
from diffusion import sampling
from torch import nn

from diffusers import DanceDiffusionPipeline, IPNDMScheduler, UNetaDModel


lowerCamelCase_			=						{
    'gwf-440k': {
        'url': 'https://model-server.zqevans2.workers.dev/gwf-440k.ckpt',
        'sample_rate': 4_80_00,
        'sample_size': 6_55_36,
    },
    'jmann-small-190k': {
        'url': 'https://model-server.zqevans2.workers.dev/jmann-small-190k.ckpt',
        'sample_rate': 4_80_00,
        'sample_size': 6_55_36,
    },
    'jmann-large-580k': {
        'url': 'https://model-server.zqevans2.workers.dev/jmann-large-580k.ckpt',
        'sample_rate': 4_80_00,
        'sample_size': 13_10_72,
    },
    'maestro-uncond-150k': {
        'url': 'https://model-server.zqevans2.workers.dev/maestro-uncond-150k.ckpt',
        'sample_rate': 1_60_00,
        'sample_size': 6_55_36,
    },
    'unlocked-uncond-250k': {
        'url': 'https://model-server.zqevans2.workers.dev/unlocked-uncond-250k.ckpt',
        'sample_rate': 1_60_00,
        'sample_size': 6_55_36,
    },
    'honk-140k': {
        'url': 'https://model-server.zqevans2.workers.dev/honk-140k.ckpt',
        'sample_rate': 1_60_00,
        'sample_size': 6_55_36,
    },
}
def 			SCREAMING_SNAKE_CASE_			(							__A    :			List[Any]	,					__A    :			List[Any]  )			->			Tuple:
   return torch.atana(__A	,					__A  ) / math.pi * 2
def 			SCREAMING_SNAKE_CASE_			(							__A    :			str  )			->			Tuple:
   _SCREAMING_SNAKE_CASE	=				torch.sin(t * math.pi / 2  ) ** 2
   _SCREAMING_SNAKE_CASE	=				(1 - sigma**2) ** 0.5
   return alpha_sigma_to_t(__A	,					__A  )







class 		lowercase_   (			A       ):


   """simple docstring"""

   pass







class 		lowercase_   (			nn.Module       ):


   """simple docstring"""

   def __init__(   self :     int  ,				__lowerCamelCase :     Dict   ):

      """simple docstring"""
      super().__init__()

      _SCREAMING_SNAKE_CASE	=				DiffusionAttnUnetaD(__lowerCamelCase  ,				n_attn_layers=4   )
      _SCREAMING_SNAKE_CASE	=				deepcopy(self.diffusion   )
      _SCREAMING_SNAKE_CASE	=				torch.quasirandom.SobolEngine(1  ,				scramble=__lowerCamelCase   )


def 			SCREAMING_SNAKE_CASE_			(							__A    :			Any  )			->			Union[str, Any]:
   _SCREAMING_SNAKE_CASE	=				MODELS_MAP[model_name]["url"]
   os.system(f"""wget {url} ./"""  )

   return f"""./{model_name}.ckpt"""


lowerCamelCase_			=						{
    '1': 'resnets.0',
    '2': 'attentions.0',
    '3': 'resnets.1',
    '4': 'attentions.1',
    '5': 'resnets.2',
    '6': 'attentions.2',
}
lowerCamelCase_			=						{
    '8': 'resnets.0',
    '9': 'attentions.0',
    '10': 'resnets.1',
    '11': 'attentions.1',
    '12': 'resnets.2',
    '13': 'attentions.2',
}
lowerCamelCase_			=						{
    '1': 'resnets.0',
    '2': 'attentions.0',
    '3': 'resnets.1',
    '4': 'attentions.1',
    '5': 'resnets.2',
    '6': 'attentions.2',
    '8': 'resnets.3',
    '9': 'attentions.3',
    '10': 'resnets.4',
    '11': 'attentions.4',
    '12': 'resnets.5',
    '13': 'attentions.5',
}
lowerCamelCase_			=						{
    '0': 'resnets.0',
    '1': 'resnets.1',
    '2': 'resnets.2',
    '4': 'resnets.0',
    '5': 'resnets.1',
    '6': 'resnets.2',
}

lowerCamelCase_			=						{
    'skip': 'conv_skip',
    'main.0': 'conv_1',
    'main.1': 'group_norm_1',
    'main.3': 'conv_2',
    'main.4': 'group_norm_2',
}

lowerCamelCase_			=						{
    'norm': 'group_norm',
    'qkv_proj': ['query', 'key', 'value'],
    'out_proj': ['proj_attn'],
}
def 			SCREAMING_SNAKE_CASE_			(							__A    :			Optional[int]  )			->			Dict:
   if name.startswith("skip"  ):
      return name.replace("skip"	,					RES_CONV_MAP["skip"]  )

   # name has to be of format main.{digit}
   if not name.startswith("main."  ):
      raise ValueError(f"""ResConvBlock error with {name}"""  )

   return name.replace(name[:6]	,					RES_CONV_MAP[name[:6]]  )
def 			SCREAMING_SNAKE_CASE_			(							__A    :			Union[str, Any]  )			->			Union[str, Any]:
   for key, value in ATTN_MAP.items():
      if name.startswith(__A  ) and not isinstance(__A	,					__A  ):
         return name.replace(__A	,					__A  )
      elif name.startswith(__A  ):
         return [name.replace(__A	,					__A  ) for v in value]
   raise ValueError(f"""Attn error with {name}"""  )
def 			SCREAMING_SNAKE_CASE_			(							__A    :			Dict	,					__A    :			List[Any]=13  )			->			List[Any]:
   _SCREAMING_SNAKE_CASE	=				input_string

   if string.split("."  )[0] == "timestep_embed":
      return string.replace("timestep_embed"	,					"time_proj"  )

   _SCREAMING_SNAKE_CASE	=				0
   if string.startswith("net.3."  ):
      depth += 1
      _SCREAMING_SNAKE_CASE	=				string[6:]
   elif string.startswith("net."  ):
      _SCREAMING_SNAKE_CASE	=				string[4:]

   while string.startswith("main.7."  ):
      depth += 1
      _SCREAMING_SNAKE_CASE	=				string[7:]

   if string.startswith("main."  ):
      _SCREAMING_SNAKE_CASE	=				string[5:]

   # mid block
   if string[:2].isdigit():
      _SCREAMING_SNAKE_CASE	=				string[:2]
      _SCREAMING_SNAKE_CASE	=				string[2:]
   else:
      _SCREAMING_SNAKE_CASE	=				string[0]
      _SCREAMING_SNAKE_CASE	=				string[1:]

   if depth == max_depth:
      _SCREAMING_SNAKE_CASE	=				MID_NUM_TO_LAYER[layer_num]
      _SCREAMING_SNAKE_CASE	=				"mid_block"
   elif depth > 0 and int(__A  ) < 7:
      _SCREAMING_SNAKE_CASE	=				DOWN_NUM_TO_LAYER[layer_num]
      _SCREAMING_SNAKE_CASE	=				f"""down_blocks.{depth}"""
   elif depth > 0 and int(__A  ) > 7:
      _SCREAMING_SNAKE_CASE	=				UP_NUM_TO_LAYER[layer_num]
      _SCREAMING_SNAKE_CASE	=				f"""up_blocks.{max_depth - depth - 1}"""
   elif depth == 0:
      _SCREAMING_SNAKE_CASE	=				DEPTH_0_TO_LAYER[layer_num]
      _SCREAMING_SNAKE_CASE	=				f"""up_blocks.{max_depth - 1}""" if int(__A  ) > 3 else "down_blocks.0"

   if not string_left.startswith("."  ):
      raise ValueError(f"""Naming error with {input_string} and string_left: {string_left}."""  )

   _SCREAMING_SNAKE_CASE	=				string_left[1:]

   if "resnets" in new_layer:
      _SCREAMING_SNAKE_CASE	=				convert_resconv_naming(__A  )
   elif "attentions" in new_layer:
      _SCREAMING_SNAKE_CASE	=				convert_attn_naming(__A  )
      _SCREAMING_SNAKE_CASE	=				new_string_left

   if not isinstance(__A	,					__A  ):
      _SCREAMING_SNAKE_CASE	=				prefix + "." + new_layer + "." + string_left
   else:
      _SCREAMING_SNAKE_CASE	=				[prefix + "." + new_layer + "." + s for s in string_left]
   return new_string
def 			SCREAMING_SNAKE_CASE_			(							__A    :			List[Any]  )			->			int:
   _SCREAMING_SNAKE_CASE	=				{}
   for k, v in state_dict.items():
      if k.endswith("kernel"  ):
         # up- and downsample layers, don't have trainable weights
         continue

      _SCREAMING_SNAKE_CASE	=				rename(__A  )

      # check if we need to transform from Conv => Linear for attention
      if isinstance(__A	,					__A  ):
         _SCREAMING_SNAKE_CASE	=				transform_conv_attns(__A	,					__A	,					__A  )
      else:
         _SCREAMING_SNAKE_CASE	=				v

   return new_state_dict
def 			SCREAMING_SNAKE_CASE_			(							__A    :			Tuple	,					__A    :			Dict	,					__A    :			Tuple  )			->			Optional[int]:
   if len(__A  ) == 1:
      if len(v.shape  ) == 3:
         # weight
         _SCREAMING_SNAKE_CASE	=				v[:, :, 0]
      else:
         # bias
         _SCREAMING_SNAKE_CASE	=				v
   else:
      # qkv matrices
      _SCREAMING_SNAKE_CASE	=				v.shape[0]
      _SCREAMING_SNAKE_CASE	=				trippled_shape // 3
      for i in range(3  ):
         if len(v.shape  ) == 3:
            _SCREAMING_SNAKE_CASE	=				v[i * single_shape : (i + 1) * single_shape, :, 0]
         else:
            _SCREAMING_SNAKE_CASE	=				v[i * single_shape : (i + 1) * single_shape]
   return new_state_dict
def 			SCREAMING_SNAKE_CASE_			(							__A    :			str  )			->			Optional[int]:
   _SCREAMING_SNAKE_CASE	=				torch.device("cuda" if torch.cuda.is_available() else "cpu"  )

   _SCREAMING_SNAKE_CASE	=				args.model_path.split("/"  )[-1].split("."  )[0]
   if not os.path.isfile(args.model_path  ):
      assert (
          model_name == args.model_path
      ), f"""Make sure to provide one of the official model names {MODELS_MAP.keys()}"""
      _SCREAMING_SNAKE_CASE	=				download(__A  )

   _SCREAMING_SNAKE_CASE	=				MODELS_MAP[model_name]["sample_rate"]
   _SCREAMING_SNAKE_CASE	=				MODELS_MAP[model_name]["sample_size"]

   _SCREAMING_SNAKE_CASE	=				Object()
   _SCREAMING_SNAKE_CASE	=				sample_size
   _SCREAMING_SNAKE_CASE	=				sample_rate
   _SCREAMING_SNAKE_CASE	=				0

   _SCREAMING_SNAKE_CASE	=				UNetaDModel(sample_size=__A	,					sample_rate=__A  )
   _SCREAMING_SNAKE_CASE	=				diffusers_model.state_dict()

   _SCREAMING_SNAKE_CASE	=				DiffusionUncond(__A  )
   orig_model.load_state_dict(torch.load(args.model_path	,					map_location=__A  )["state_dict"]  )
   _SCREAMING_SNAKE_CASE	=				orig_model.diffusion_ema.eval()
   _SCREAMING_SNAKE_CASE	=				orig_model.state_dict()
   _SCREAMING_SNAKE_CASE	=				rename_orig_weights(__A  )

   _SCREAMING_SNAKE_CASE	=				set(renamed_state_dict.keys()  ) - set(diffusers_state_dict.keys()  )
   _SCREAMING_SNAKE_CASE	=				set(diffusers_state_dict.keys()  ) - set(renamed_state_dict.keys()  )

   assert len(__A  ) == 0, f"""Problem with {renamed_minus_diffusers}"""
   assert all(k.endswith("kernel"  ) for k in list(__A  )  ), f"""Problem with {diffusers_minus_renamed}"""

   for key, value in renamed_state_dict.items():
      assert (
          diffusers_state_dict[key].squeeze().shape == value.squeeze().shape
      ), f"""Shape for {key} doesn't match. Diffusers: {diffusers_state_dict[key].shape} vs. {value.shape}"""
      if key == "time_proj.weight":
         _SCREAMING_SNAKE_CASE	=				value.squeeze()

      _SCREAMING_SNAKE_CASE	=				value

   diffusers_model.load_state_dict(__A  )

   _SCREAMING_SNAKE_CASE	=				1_00
   _SCREAMING_SNAKE_CASE	=				33

   _SCREAMING_SNAKE_CASE	=				IPNDMScheduler(num_train_timesteps=__A  )

   _SCREAMING_SNAKE_CASE	=				torch.manual_seed(__A  )
   _SCREAMING_SNAKE_CASE	=				torch.randn([1, 2, config.sample_size]	,					generator=__A  ).to(__A  )

   _SCREAMING_SNAKE_CASE	=				torch.linspace(1	,					0	,					steps + 1	,					device=__A  )[:-1]
   _SCREAMING_SNAKE_CASE	=				get_crash_schedule(__A  )

   _SCREAMING_SNAKE_CASE	=				DanceDiffusionPipeline(unet=__A	,					scheduler=__A  )

   _SCREAMING_SNAKE_CASE	=				torch.manual_seed(33  )
   _SCREAMING_SNAKE_CASE	=				pipe(num_inference_steps=__A	,					generator=__A  ).audios

   _SCREAMING_SNAKE_CASE	=				sampling.iplms_sample(__A	,					__A	,					__A	,					{}  )
   _SCREAMING_SNAKE_CASE	=				generated.clamp(-1	,					1  )

   _SCREAMING_SNAKE_CASE	=				(generated - audio).abs().sum()
   _SCREAMING_SNAKE_CASE	=				(generated - audio).abs().max()

   if args.save:
      pipe.save_pretrained(args.checkpoint_path  )

   print("Diff sum"	,					__A  )
   print("Diff max"	,					__A  )

   assert diff_max < 1e-3, f"""Diff max: {diff_max} is too much :-/"""

   print(f"""Conversion for {model_name} successful!"""  )


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

 parser.add_argument('--model_path', default=None, type=str, required=True, help='Path to the model to convert.')
 parser.add_argument(
     '--save', default=True, type=bool, required=False, help='Whether to save the converted model or not.'
 )
 parser.add_argument('--checkpoint_path', default=None, type=str, required=True, help='Path to the output model.')
 lowerCamelCase_			=						parser.parse_args()

 main(args)

