# DISCLAIMER: This file is strongly influenced by https://github.com/ermongroup/ddim

from dataclasses import dataclass
from typing import Optional, Tuple, Union

import flax
import jax
import jax.numpy as jnp

from ..configuration_utils import ConfigMixin, register_to_config
from .scheduling_utils_flax import (
    CommonSchedulerState,
    FlaxKarrasDiffusionSchedulers,
    FlaxSchedulerMixin,
    FlaxSchedulerOutput,
    add_noise_common,
    get_velocity_common,
)



@flax.struct.dataclass
class        lowerCamelCase__				:
			UpperCamelCase__    							=42

			# setable values
			UpperCamelCase__    							=42
			UpperCamelCase__    							=42
			UpperCamelCase__    							=None





			@classmethod
			def   SCREAMING_SNAKE_CASE__     (       cls	:	str  ,  lowercase__	:	CommonSchedulerState  ,  lowercase__	:	jnp.ndarray  ,  lowercase__	:	jnp.ndarray						):
										return cls(common=lowercase__  ,  init_noise_sigma=lowercase__  ,  timesteps=lowercase__						)







@dataclass
class        lowerCamelCase__				(   UpperCAmelCase				):
			UpperCamelCase__    							=42







class        lowerCamelCase__				(   UpperCAmelCase       ,UpperCAmelCase				):
			UpperCamelCase__    							=[e.name for e in FlaxKarrasDiffusionSchedulers]

			UpperCamelCase__    							=42





			@property
			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										return True





			@register_to_config
			def __init__(       self	:	Optional[Any]  ,  lowercase__	:	int = 10_00  ,  lowercase__	:	float = 0.0_0_0_1  ,  lowercase__	:	float = 0.0_2  ,  lowercase__	:	str = "linear"  ,  lowercase__	:	Optional[jnp.ndarray] = None  ,  lowercase__	:	str = "fixed_small"  ,  lowercase__	:	bool = True  ,  lowercase__	:	str = "epsilon"  ,  lowercase__	:	jnp.dtype = jnp.floataa  ,  ):
										_lowerCAmelCase							=							dtype





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	Optional[CommonSchedulerState] = None						):
										if common is None:
																	_lowerCAmelCase							=							CommonSchedulerState.create(self						)

										# standard deviation of the initial noise distribution
										_lowerCAmelCase							=							jnp.array(1.0  ,  dtype=self.dtype						)

										_lowerCAmelCase							=							jnp.arange(0  ,  self.config.num_train_timesteps						).round()[::-1]

										return DDPMSchedulerState.create(
										    common=lowercase__  ,  init_noise_sigma=lowercase__  ,  timesteps=lowercase__  ,  )





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]  ,  lowercase__	:	DDPMSchedulerState  ,  lowercase__	:	jnp.ndarray  ,  lowercase__	:	Optional[int] = None						):
										return sample





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple  ,  lowercase__	:	DDPMSchedulerState  ,  lowercase__	:	int  ,  lowercase__	:	Tuple = ()						):
										_lowerCAmelCase							=							self.config.num_train_timesteps // num_inference_steps
										# creates integer timesteps by multiplying by ratio
										# rounding to avoid issues when num_inference_step is power of 3
										_lowerCAmelCase							=							(jnp.arange(0  ,  lowercase__						) * step_ratio).round()[::-1]

										return state.replace(
										    num_inference_steps=lowercase__  ,  timesteps=lowercase__  ,  )





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[Any]  ,  lowercase__	:	DDPMSchedulerState  ,  lowercase__	:	Tuple  ,  lowercase__	:	int=None  ,  lowercase__	:	int=None						):
										_lowerCAmelCase							=							state.common.alphas_cumprod[t]
										_lowerCAmelCase							=							jnp.where(t > 0  ,  state.common.alphas_cumprod[t - 1]  ,  jnp.array(1.0  ,  dtype=self.dtype						)						)

										# For t > 0, compute predicted variance βt (see formula (6) and (7) from https://arxiv.org/pdf/2006.11239.pdf)
										# and sample from it to get previous sample
										# x_{t-1} ~ N(pred_prev_sample, variance) == add variance to pred_sample
										_lowerCAmelCase							=							(1 - alpha_prod_t_prev) / (1 - alpha_prod_t) * state.common.betas[t]

										if variance_type is None:
																	_lowerCAmelCase							=							self.config.variance_type

										# hacks - were probably added for training stability
										if variance_type == "fixed_small":
																	_lowerCAmelCase							=							jnp.clip(lowercase__  ,  a_min=1e-20						)
										# for rl-diffuser https://arxiv.org/abs/2205.09991
										elif variance_type == "fixed_small_log":
																	_lowerCAmelCase							=							jnp.log(jnp.clip(lowercase__  ,  a_min=1e-20						)						)
										elif variance_type == "fixed_large":
																	_lowerCAmelCase							=							state.common.betas[t]
										elif variance_type == "fixed_large_log":
																	# Glide max_log
																	_lowerCAmelCase							=							jnp.log(state.common.betas[t]						)
										elif variance_type == "learned":
																	return predicted_variance
										elif variance_type == "learned_range":
																	_lowerCAmelCase							=							variance
																	_lowerCAmelCase							=							state.common.betas[t]
																	_lowerCAmelCase							=							(predicted_variance + 1) / 2
																	_lowerCAmelCase							=							frac * max_log + (1 - frac) * min_log

										return variance





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	DDPMSchedulerState  ,  lowercase__	:	jnp.ndarray  ,  lowercase__	:	int  ,  lowercase__	:	jnp.ndarray  ,  lowercase__	:	Optional[jax.random.KeyArray] = None  ,  lowercase__	:	bool = True  ,  ):
										_lowerCAmelCase							=							timestep

										if key is None:
																	_lowerCAmelCase							=							jax.random.PRNGKey(0						)

										if model_output.shape[1] == sample.shape[1] * 2 and self.config.variance_type in ["learned", "learned_range"]:
																	_lowerCAmelCase			,		_lowerCAmelCase							=							jnp.split(lowercase__  ,  sample.shape[1]  ,  axis=1						)
										else:
																	_lowerCAmelCase							=							None

										# 1. compute alphas, betas
										_lowerCAmelCase							=							state.common.alphas_cumprod[t]
										_lowerCAmelCase							=							jnp.where(t > 0  ,  state.common.alphas_cumprod[t - 1]  ,  jnp.array(1.0  ,  dtype=self.dtype						)						)
										_lowerCAmelCase							=							1 - alpha_prod_t
										_lowerCAmelCase							=							1 - alpha_prod_t_prev

										# 2. compute predicted original sample from predicted noise also called
										# "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf
										if self.config.prediction_type == "epsilon":
																	_lowerCAmelCase							=							(sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5
										elif self.config.prediction_type == "sample":
																	_lowerCAmelCase							=							model_output
										elif self.config.prediction_type == "v_prediction":
																	_lowerCAmelCase							=							(alpha_prod_t**0.5) * sample - (beta_prod_t**0.5) * model_output
										else:
																	raise ValueError(
																	    f'prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample` '
																	    ' for the FlaxDDPMScheduler.'						)

										# 3. Clip "predicted x_0"
										if self.config.clip_sample:
																	_lowerCAmelCase							=							jnp.clip(lowercase__  ,  -1  ,  1						)

										# 4. Compute coefficients for pred_original_sample x_0 and current sample x_t
										# See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
										_lowerCAmelCase							=							(alpha_prod_t_prev ** 0.5 * state.common.betas[t]) / beta_prod_t
										_lowerCAmelCase							=							state.common.alphas[t] ** 0.5 * beta_prod_t_prev / beta_prod_t

										# 5. Compute predicted previous sample µ_t
										# See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
										_lowerCAmelCase							=							pred_original_sample_coeff * pred_original_sample + current_sample_coeff * sample

										# 6. Add noise
										def random_variance():
																	_lowerCAmelCase							=							jax.random.split(lowercase__  ,  num=1						)
																	_lowerCAmelCase							=							jax.random.normal(lowercase__  ,  shape=model_output.shape  ,  dtype=self.dtype						)
																	return (self._get_variance(lowercase__  ,  lowercase__  ,  predicted_variance=lowercase__						) ** 0.5) * noise

										_lowerCAmelCase							=							jnp.where(t > 0  ,  random_variance()  ,  jnp.zeros(model_output.shape  ,  dtype=self.dtype						)						)

										_lowerCAmelCase							=							pred_prev_sample + variance

										if not return_dict:
																	return (pred_prev_sample, state)

										return FlaxDDPMSchedulerOutput(prev_sample=lowercase__  ,  state=lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[Any]  ,  lowercase__	:	DDPMSchedulerState  ,  lowercase__	:	jnp.ndarray  ,  lowercase__	:	jnp.ndarray  ,  lowercase__	:	jnp.ndarray  ,  ):
										return add_noise_common(state.common  ,  lowercase__  ,  lowercase__  ,  lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Any  ,  lowercase__	:	DDPMSchedulerState  ,  lowercase__	:	jnp.ndarray  ,  lowercase__	:	jnp.ndarray  ,  lowercase__	:	jnp.ndarray  ,  ):
										return get_velocity_common(state.common  ,  lowercase__  ,  lowercase__  ,  lowercase__						)





			def __len__(       self	:	List[str]						):
										return self.config.num_train_timesteps







import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    MobileViTConfig,
    MobileViTForImageClassification,
    MobileViTForSemanticSegmentation,
    MobileViTImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_lowercase:	Dict       			=		logging.get_logger(__name__)






def _lowerCamelCase  (		snake_case  ):
							_lowerCAmelCase							=							MobileViTConfig()

							# size of the architecture
							if "mobilevit_s" in mobilevit_name:
														_lowerCAmelCase							=							[144, 192, 240]
														_lowerCAmelCase							=							[16, 32, 64, 96, 128, 160, 640]
							elif "mobilevit_xs" in mobilevit_name:
														_lowerCAmelCase							=							[96, 120, 144]
														_lowerCAmelCase							=							[16, 32, 48, 64, 80, 96, 384]
							elif "mobilevit_xxs" in mobilevit_name:
														_lowerCAmelCase							=							[64, 80, 96]
														_lowerCAmelCase							=							[16, 16, 24, 48, 64, 80, 320]
														_lowerCAmelCase							=							0.05
														_lowerCAmelCase							=							2.0

							if mobilevit_name.startswith('deeplabv3_'  ):
														_lowerCAmelCase							=							512
														_lowerCAmelCase							=							16
														_lowerCAmelCase							=							21
														_lowerCAmelCase							=							'pascal-voc-id2label.json'
							else:
														_lowerCAmelCase							=							1_000
														_lowerCAmelCase							=							'imagenet-1k-id2label.json'

							_lowerCAmelCase							=							'huggingface/label-files'
							_lowerCAmelCase							=							json.load(open(hf_hub_download(snake_case     , snake_case     , repo_type='dataset'  )     , 'r'  )  )
							_lowerCAmelCase							=							{int(snake_case  ): v for k, v in idalabel.items()}
							_lowerCAmelCase							=							idalabel
							_lowerCAmelCase							=							{v: k for k, v in idalabel.items()}

							return config






def _lowerCamelCase  (		snake_case     , snake_case=False  ):
							for i in range(1     , 6  ):
														if F'layer_{i}.' in name:
																					_lowerCAmelCase							=							name.replace(F'layer_{i}.'     , F'encoder.layer.{i - 1}.'  )

							if "conv_1." in name:
														_lowerCAmelCase							=							name.replace('conv_1.'     , 'conv_stem.'  )
							if ".block." in name:
														_lowerCAmelCase							=							name.replace('.block.'     , '.'  )

							if "exp_1x1" in name:
														_lowerCAmelCase							=							name.replace('exp_1x1'     , 'expand_1x1'  )
							if "red_1x1" in name:
														_lowerCAmelCase							=							name.replace('red_1x1'     , 'reduce_1x1'  )
							if ".local_rep.conv_3x3." in name:
														_lowerCAmelCase							=							name.replace('.local_rep.conv_3x3.'     , '.conv_kxk.'  )
							if ".local_rep.conv_1x1." in name:
														_lowerCAmelCase							=							name.replace('.local_rep.conv_1x1.'     , '.conv_1x1.'  )
							if ".norm." in name:
														_lowerCAmelCase							=							name.replace('.norm.'     , '.normalization.'  )
							if ".conv." in name:
														_lowerCAmelCase							=							name.replace('.conv.'     , '.convolution.'  )
							if ".conv_proj." in name:
														_lowerCAmelCase							=							name.replace('.conv_proj.'     , '.conv_projection.'  )

							for i in range(0     , 2  ):
														for j in range(0     , 4  ):
																					if F'.{i}.{j}.' in name:
																												_lowerCAmelCase							=							name.replace(F'.{i}.{j}.'     , F'.{i}.layer.{j}.'  )

							for i in range(2     , 6  ):
														for j in range(0     , 4  ):
																					if F'.{i}.{j}.' in name:
																												_lowerCAmelCase							=							name.replace(F'.{i}.{j}.'     , F'.{i}.'  )
																												if "expand_1x1" in name:
																																			_lowerCAmelCase							=							name.replace('expand_1x1'     , 'downsampling_layer.expand_1x1'  )
																												if "conv_3x3" in name:
																																			_lowerCAmelCase							=							name.replace('conv_3x3'     , 'downsampling_layer.conv_3x3'  )
																												if "reduce_1x1" in name:
																																			_lowerCAmelCase							=							name.replace('reduce_1x1'     , 'downsampling_layer.reduce_1x1'  )

							for i in range(2     , 5  ):
														if F'.global_rep.{i}.weight' in name:
																					_lowerCAmelCase							=							name.replace(F'.global_rep.{i}.weight'     , '.layernorm.weight'  )
														if F'.global_rep.{i}.bias' in name:
																					_lowerCAmelCase							=							name.replace(F'.global_rep.{i}.bias'     , '.layernorm.bias'  )

							if ".global_rep." in name:
														_lowerCAmelCase							=							name.replace('.global_rep.'     , '.transformer.'  )
							if ".pre_norm_mha.0." in name:
														_lowerCAmelCase							=							name.replace('.pre_norm_mha.0.'     , '.layernorm_before.'  )
							if ".pre_norm_mha.1.out_proj." in name:
														_lowerCAmelCase							=							name.replace('.pre_norm_mha.1.out_proj.'     , '.attention.output.dense.'  )
							if ".pre_norm_ffn.0." in name:
														_lowerCAmelCase							=							name.replace('.pre_norm_ffn.0.'     , '.layernorm_after.'  )
							if ".pre_norm_ffn.1." in name:
														_lowerCAmelCase							=							name.replace('.pre_norm_ffn.1.'     , '.intermediate.dense.'  )
							if ".pre_norm_ffn.4." in name:
														_lowerCAmelCase							=							name.replace('.pre_norm_ffn.4.'     , '.output.dense.'  )
							if ".transformer." in name:
														_lowerCAmelCase							=							name.replace('.transformer.'     , '.transformer.layer.'  )

							if ".aspp_layer." in name:
														_lowerCAmelCase							=							name.replace('.aspp_layer.'     , '.'  )
							if ".aspp_pool." in name:
														_lowerCAmelCase							=							name.replace('.aspp_pool.'     , '.'  )
							if "seg_head." in name:
														_lowerCAmelCase							=							name.replace('seg_head.'     , 'segmentation_head.'  )
							if "segmentation_head.classifier.classifier." in name:
														_lowerCAmelCase							=							name.replace('segmentation_head.classifier.classifier.'     , 'segmentation_head.classifier.'  )

							if "classifier.fc." in name:
														_lowerCAmelCase							=							name.replace('classifier.fc.'     , 'classifier.'  )
							elif (not base_model) and ("segmentation_head." not in name):
														_lowerCAmelCase							=							'mobilevit.' + name

							return name






def _lowerCamelCase  (		snake_case     , snake_case     , snake_case=False  ):
							if base_model:
														_lowerCAmelCase							=							''
							else:
														_lowerCAmelCase							=							'mobilevit.'

							for key in orig_state_dict.copy().keys():
														_lowerCAmelCase							=							orig_state_dict.pop(snake_case  )

														if key[:8] == "encoder.":
																					_lowerCAmelCase							=							key[8:]

														if "qkv" in key:
																					_lowerCAmelCase							=							key.split('.'  )
																					_lowerCAmelCase							=							int(key_split[0][6:]  ) - 1
																					_lowerCAmelCase							=							int(key_split[3]  )
																					_lowerCAmelCase							=							model.get_submodule(F'{model_prefix}encoder.layer.{layer_num}'  )
																					_lowerCAmelCase							=							layer.transformer.layer[transformer_num].attention.attention.all_head_size
																					_lowerCAmelCase							=							(
																					    F'{model_prefix}encoder.layer.{layer_num}.transformer.layer.{transformer_num}.attention.attention.'
																					)
																					if "weight" in key:
																												_lowerCAmelCase							=							val[:dim, :]
																												_lowerCAmelCase							=							val[dim : dim * 2, :]
																												_lowerCAmelCase							=							val[-dim:, :]
																					else:
																												_lowerCAmelCase							=							val[:dim]
																												_lowerCAmelCase							=							val[dim : dim * 2]
																												_lowerCAmelCase							=							val[-dim:]
														else:
																					_lowerCAmelCase							=							val

							return orig_state_dict






def _lowerCamelCase  (		):
							_lowerCAmelCase							=							'http://images.cocodataset.org/val2017/000000039769.jpg'
							_lowerCAmelCase							=							Image.open(requests.get(snake_case     , stream=snake_case  ).raw  )
							return im






@torch.no_grad()
def _lowerCamelCase  (		snake_case     , snake_case     , snake_case     , snake_case=False  ):
							_lowerCAmelCase							=							get_mobilevit_config(snake_case  )

							# load original state_dict
							_lowerCAmelCase							=							torch.load(snake_case     , map_location='cpu'  )

							# load 🤗 model
							if mobilevit_name.startswith('deeplabv3_'  ):
														_lowerCAmelCase							=							MobileViTForSemanticSegmentation(snake_case  ).eval()
							else:
														_lowerCAmelCase							=							MobileViTForImageClassification(snake_case  ).eval()

							_lowerCAmelCase							=							convert_state_dict(snake_case     , snake_case  )
							model.load_state_dict(snake_case  )

							# Check outputs on an image, prepared by MobileViTImageProcessor
							_lowerCAmelCase							=							MobileViTImageProcessor(crop_size=config.image_size     , size=config.image_size + 32  )
							_lowerCAmelCase							=							image_processor(images=prepare_img()     , return_tensors='pt'  )
							_lowerCAmelCase							=							model(**snake_case  )
							_lowerCAmelCase							=							outputs.logits

							if mobilevit_name.startswith('deeplabv3_'  ):
														assert logits.shape == (1, 21, 32, 32)

														if mobilevit_name == "deeplabv3_mobilevit_s":
																					_lowerCAmelCase							=							torch.tensor(
																					    [
																					        [[6.20_65, 6.12_92, 6.20_70], [6.10_79, 6.12_54, 6.17_47], [6.00_42, 6.10_71, 6.10_34]],
																					        [[-6.92_53, -6.86_53, -7.03_98], [-7.32_18, -7.39_83, -7.36_70], [-7.19_61, -7.24_82, -7.15_69]],
																					        [[-4.47_23, -4.43_48, -4.37_69], [-5.36_29, -5.46_32, -5.45_98], [-5.15_87, -5.34_02, -5.50_59]],
																					    ]  )
														elif mobilevit_name == "deeplabv3_mobilevit_xs":
																					_lowerCAmelCase							=							torch.tensor(
																					    [
																					        [[5.44_49, 5.57_33, 5.63_14], [5.18_15, 5.39_30, 5.59_63], [5.16_56, 5.43_33, 5.48_53]],
																					        [[-9.44_23, -9.77_66, -9.67_14], [-9.15_81, -9.57_20, -9.55_19], [-9.10_06, -9.64_58, -9.57_03]],
																					        [[-7.77_21, -7.37_16, -7.15_83], [-8.45_99, -8.06_24, -7.79_44], [-8.41_72, -7.83_66, -7.50_25]],
																					    ]  )
														elif mobilevit_name == "deeplabv3_mobilevit_xxs":
																					_lowerCAmelCase							=							torch.tensor(
																					    [
																					        [[6.98_11, 6.97_43, 7.31_23], [7.17_77, 7.19_31, 7.39_38], [7.56_33, 7.80_50, 7.89_01]],
																					        [[-10.55_36, -10.23_32, -10.29_24], [-10.23_36, -9.86_24, -9.59_64], [-10.88_40, -10.81_58, -10.66_59]],
																					        [[-3.49_38, -3.06_31, -2.86_20], [-3.42_05, -2.81_35, -2.68_75], [-3.41_79, -2.79_45, -2.87_50]],
																					    ]  )
														else:
																					raise ValueError(F'Unknown mobilevit_name: {mobilevit_name}'  )

														assert torch.allclose(logits[0, :3, :3, :3]     , snake_case     , atol=1E-4  )
							else:
														assert logits.shape == (1, 1_000)

														if mobilevit_name == "mobilevit_s":
																					_lowerCAmelCase							=							torch.tensor([-0.98_66, 0.23_92, -1.12_41]  )
														elif mobilevit_name == "mobilevit_xs":
																					_lowerCAmelCase							=							torch.tensor([-2.47_61, -0.93_99, -1.95_87]  )
														elif mobilevit_name == "mobilevit_xxs":
																					_lowerCAmelCase							=							torch.tensor([-1.93_64, -1.23_27, -0.46_53]  )
														else:
																					raise ValueError(F'Unknown mobilevit_name: {mobilevit_name}'  )

														assert torch.allclose(logits[0, :3]     , snake_case     , atol=1E-4  )

							Path(snake_case  ).mkdir(exist_ok=snake_case  )
							print(F'Saving model {mobilevit_name} to {pytorch_dump_folder_path}'  )
							model.save_pretrained(snake_case  )
							print(F'Saving image processor to {pytorch_dump_folder_path}'  )
							image_processor.save_pretrained(snake_case  )

							if push_to_hub:
														_lowerCAmelCase							=							{
														    'mobilevit_s': 'mobilevit-small',
														    'mobilevit_xs': 'mobilevit-x-small',
														    'mobilevit_xxs': 'mobilevit-xx-small',
														    'deeplabv3_mobilevit_s': 'deeplabv3-mobilevit-small',
														    'deeplabv3_mobilevit_xs': 'deeplabv3-mobilevit-x-small',
														    'deeplabv3_mobilevit_xxs': 'deeplabv3-mobilevit-xx-small',
														}

														print('Pushing to the hub...'  )
														_lowerCAmelCase							=							model_mapping[mobilevit_name]
														image_processor.push_to_hub(snake_case     , organization='apple'  )
														model.push_to_hub(snake_case     , organization='apple'  )


if __name__ == "__main__":
				_lowercase:	Union[str, Any]       			=		argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '''--mobilevit_name''',
				    default='''mobilevit_s''',
				    type=str,
				    help=(
				        '''Name of the MobileViT model you\'d like to convert. Should be one of \'mobilevit_s\', \'mobilevit_xs\','''
				        ''' \'mobilevit_xxs\', \'deeplabv3_mobilevit_s\', \'deeplabv3_mobilevit_xs\', \'deeplabv3_mobilevit_xxs\'.'''
				    ),
				)
				parser.add_argument(
				    '''--checkpoint_path''', required=True, type=str, help='''Path to the original state dict (.pt 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.'''
				)

				_lowercase:	List[str]       			=		parser.parse_args()
				convert_movilevit_checkpoint(
				    args.mobilevit_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
				)






