



import logging
import os
from dataclasses import dataclass
from typing import List, Optional, Union

import tqdm
from filelock import FileLock

from transformers import (
    BartTokenizer,
    BartTokenizerFast,
    DataProcessor,
    PreTrainedTokenizer,
    RobertaTokenizer,
    RobertaTokenizerFast,
    XLMRobertaTokenizer,
    is_tf_available,
    is_torch_available,
)


lowercase__							:							str									=			logging.getLogger(__name__)






@dataclass(frozen=UpperCAmelCase__    )
class        SCREAMING_SNAKE_CASE__    :

							"""simple docstring"""






							_snake_case     		=  42
							_snake_case     		=  42
							_snake_case     		=  None
							_snake_case     		=  None
							_snake_case     		=  None






@dataclass(frozen=UpperCAmelCase__    )
class        SCREAMING_SNAKE_CASE__    :

							"""simple docstring"""






							_snake_case     		=  42
							_snake_case     		=  None
							_snake_case     		=  None
							_snake_case     		=  None
							_snake_case     		=  None


if is_torch_available():
				import torch
				from torch.utils.data import Dataset






				class        SCREAMING_SNAKE_CASE__    (							UpperCAmelCase__    ):

											"""simple docstring"""






											_snake_case     		=  42



											def __init__(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_ = None     ,	SCREAMING_SNAKE_CASE_=False     ,	SCREAMING_SNAKE_CASE_ = False     ,	)->   Dict:





																	'''simple docstring'''






																	__UpperCamelCase       =			hans_processors[task]()

																	__UpperCamelCase       =			os.path.join(
																	    SCREAMING_SNAKE_CASE_     ,	'''cached_{}_{}_{}_{}'''.format(
																	        '''dev''' if evaluate else '''train'''     ,	tokenizer.__class__.__name__     ,	str(SCREAMING_SNAKE_CASE_			)     ,	SCREAMING_SNAKE_CASE_     ,	)     ,	)
																	__UpperCamelCase       =			processor.get_labels()
																	if tokenizer.__class__ in (
																	    RobertaTokenizer,
																	    RobertaTokenizerFast,
																	    XLMRobertaTokenizer,
																	    BartTokenizer,
																	    BartTokenizerFast,
																	):
																							# HACK(label indices are swapped in RoBERTa pretrained model)
																							__UpperCamelCase       =			label_list[2], label_list[1]
																	__UpperCamelCase       =			label_list

																	# Make sure only the first process in distributed training processes the dataset,
																	# and the others will use the cache.
																	__UpperCamelCase       =			cached_features_file + """.lock"""
																	with FileLock(SCREAMING_SNAKE_CASE_			):
																							if os.path.exists(SCREAMING_SNAKE_CASE_			) and not overwrite_cache:
																													logger.info(F"Loading features from cached file {cached_features_file}"			)
																													__UpperCamelCase       =			torch.load(SCREAMING_SNAKE_CASE_			)
																							else:
																													logger.info(F"Creating features from dataset file at {data_dir}"			)

																													__UpperCamelCase       =			(
																													    processor.get_dev_examples(SCREAMING_SNAKE_CASE_			) if evaluate else processor.get_train_examples(SCREAMING_SNAKE_CASE_			)
																													)

																													logger.info('''Training examples: %s'''     ,	len(SCREAMING_SNAKE_CASE_			)			)
																													__UpperCamelCase       =			hans_convert_examples_to_features(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			)
																													logger.info('''Saving features into cached file %s'''     ,	SCREAMING_SNAKE_CASE_			)
																													torch.save(self.features     ,	SCREAMING_SNAKE_CASE_			)



											def __len__(  self			)->   str:





																	'''simple docstring'''






																	return len(self.features			)



											def __getitem__(  self     ,	SCREAMING_SNAKE_CASE_			)->   InputFeatures:





																	'''simple docstring'''






																	return self.features[i]



											def     A__		(  self			)->   str:





																	'''simple docstring'''






																	return self.label_list


if is_tf_available():
				import tensorflow as tf






				class        SCREAMING_SNAKE_CASE__    :

											"""simple docstring"""






											_snake_case     		=  42



											def __init__(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_ = 128     ,	SCREAMING_SNAKE_CASE_=False     ,	SCREAMING_SNAKE_CASE_ = False     ,	)->   Any:





																	'''simple docstring'''






																	__UpperCamelCase       =			hans_processors[task]()
																	__UpperCamelCase       =			processor.get_labels()
																	if tokenizer.__class__ in (
																	    RobertaTokenizer,
																	    RobertaTokenizerFast,
																	    XLMRobertaTokenizer,
																	    BartTokenizer,
																	    BartTokenizerFast,
																	):
																							# HACK(label indices are swapped in RoBERTa pretrained model)
																							__UpperCamelCase       =			label_list[2], label_list[1]
																	__UpperCamelCase       =			label_list

																	__UpperCamelCase       =			processor.get_dev_examples(SCREAMING_SNAKE_CASE_			) if evaluate else processor.get_train_examples(SCREAMING_SNAKE_CASE_			)
																	__UpperCamelCase       =			hans_convert_examples_to_features(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			)

																	def gen():
																							for ex_index, ex in tqdm.tqdm(enumerate(self.features			)     ,	desc='''convert examples to features'''			):
																													if ex_index % 10000 == 0:
																																			logger.info('''Writing example %d of %d''' % (ex_index, len(SCREAMING_SNAKE_CASE_			))			)

																													yield (
																													    {
																													        "example_id": 0,
																													        "input_ids": ex.input_ids,
																													        "attention_mask": ex.attention_mask,
																													        "token_type_ids": ex.token_type_ids,
																													    },
																													    ex.label,
																													)

																	__UpperCamelCase       =			tf.data.Dataset.from_generator(
																	    SCREAMING_SNAKE_CASE_     ,	(
																	        {
																	            '''example_id''': tf.intaa,
																	            '''input_ids''': tf.intaa,
																	            '''attention_mask''': tf.intaa,
																	            '''token_type_ids''': tf.intaa,
																	        },
																	        tf.intaa,
																	    )     ,	(
																	        {
																	            '''example_id''': tf.TensorShape([]			),
																	            '''input_ids''': tf.TensorShape([None, None]			),
																	            '''attention_mask''': tf.TensorShape([None, None]			),
																	            '''token_type_ids''': tf.TensorShape([None, None]			),
																	        },
																	        tf.TensorShape([]			),
																	    )     ,	)



											def     A__		(  self			)->   Dict:





																	'''simple docstring'''






																	return self.dataset



											def __len__(  self			)->   Dict:





																	'''simple docstring'''






																	return len(self.features			)



											def __getitem__(  self     ,	SCREAMING_SNAKE_CASE_			)->   InputFeatures:





																	'''simple docstring'''






																	return self.features[i]



											def     A__		(  self			)->   Optional[Any]:





																	'''simple docstring'''






																	return self.label_list






class        SCREAMING_SNAKE_CASE__    (							UpperCAmelCase__    ):

							"""simple docstring"""






							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_			)->   int:





													'''simple docstring'''






													return self._create_examples(self._read_tsv(os.path.join(SCREAMING_SNAKE_CASE_     ,	'''heuristics_train_set.txt'''			)			)     ,	'''train'''			)



							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_			)->   Optional[Any]:





													'''simple docstring'''






													return self._create_examples(self._read_tsv(os.path.join(SCREAMING_SNAKE_CASE_     ,	'''heuristics_evaluation_set.txt'''			)			)     ,	'''dev'''			)



							def     A__		(  self			)->   Dict:





													'''simple docstring'''






													return ["contradiction", "entailment", "neutral"]



							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			)->   Tuple:





													'''simple docstring'''






													__UpperCamelCase       =			[]
													for i, line in enumerate(SCREAMING_SNAKE_CASE_			):
																			if i == 0:
																									continue
																			__UpperCamelCase       =			"""%s-%s""" % (set_type, line[0])
																			__UpperCamelCase       =			line[5]
																			__UpperCamelCase       =			line[6]
																			__UpperCamelCase       =			line[7][2:] if line[7].startswith('''ex'''			) else line[7]
																			__UpperCamelCase       =			line[0]
																			examples.append(InputExample(guid=SCREAMING_SNAKE_CASE_     ,	text_a=SCREAMING_SNAKE_CASE_     ,	text_b=SCREAMING_SNAKE_CASE_     ,	label=SCREAMING_SNAKE_CASE_     ,	pairID=SCREAMING_SNAKE_CASE_			)			)
													return examples





def 	A_ (							snake_case							:   List[str] ,      snake_case							:   List[str] ,      snake_case							:   Optional[Any] ,      snake_case							:   Dict ,      )      ->    int:



						'''simple docstring'''

						__UpperCamelCase       =			{label: i for i, label in enumerate(snake_case )}

						__UpperCamelCase       =			[]
						for ex_index, example in tqdm.tqdm(enumerate(snake_case ) ,      desc='''convert examples to features''' ):
												if ex_index % 10000 == 0:
																		logger.info('''Writing example %d''' % (ex_index) )

												__UpperCamelCase       =			tokenizer(
												    example.text_a ,      example.text_b ,      add_special_tokens=snake_case ,      max_length=snake_case ,      padding='''max_length''' ,      truncation=snake_case ,      return_overflowing_tokens=snake_case ,      )

												__UpperCamelCase       =			label_map[example.label] if example.label in label_map else 0

												__UpperCamelCase       =			int(example.pairID )

												features.append(InputFeatures(**snake_case ,      label=snake_case ,      pairID=snake_case ) )

						for i, example in enumerate(examples[:5] ):
												logger.info('''*** Example ***''' )
												logger.info(f"guid: {example}" )
												logger.info(f"features: {features[i]}" )

						return features


lowercase__							:							Any									=			{
    "hans": 3,
}



lowercase__							:							Dict									=			{
    "hans": HansProcessor,
}






import argparse
import collections
import json
from pathlib import Path

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

from transformers import (
    MobileViTImageProcessor,
    MobileViTVaConfig,
    MobileViTVaForImageClassification,
    MobileViTVaForSemanticSegmentation,
)
from transformers.utils import logging


logging.set_verbosity_info()
lowercase__							:							Union[str, Any]									=			logging.get_logger(__name__)




def 	A_ (							snake_case							:   List[str] )      ->    List[str]:



						'''simple docstring'''

						print('''Loading config file...''' )

						def flatten_yaml_as_dict(snake_case							:   Optional[int] ,      snake_case							:   List[Any]="" ,      snake_case							:   str="." ):
												__UpperCamelCase       =			[]
												for k, v in d.items():
																		__UpperCamelCase       =			parent_key + sep + k if parent_key else k
																		if isinstance(snake_case ,      collections.abc.MutableMapping ):
																								items.extend(flatten_yaml_as_dict(snake_case ,      snake_case ,      sep=snake_case ).items() )
																		else:
																								items.append((new_key, v) )
												return dict(snake_case )

						__UpperCamelCase       =			argparse.Namespace()
						with open(snake_case ,      '''r''' ) as yaml_file:
												try:
																		__UpperCamelCase       =			yaml.load(snake_case ,      Loader=yaml.FullLoader )

																		__UpperCamelCase       =			flatten_yaml_as_dict(snake_case )
																		for k, v in flat_cfg.items():
																								setattr(snake_case ,      snake_case ,      snake_case )
												except yaml.YAMLError as exc:
																		logger.error('''Error while loading config file: {}. Error message: {}'''.format(snake_case ,      str(snake_case ) ) )
						return config




def 	A_ (							snake_case							:   List[Any] ,      snake_case							:   Optional[Any] )      ->    Union[str, Any]:



						'''simple docstring'''

						__UpperCamelCase       =			MobileViTVaConfig()

						__UpperCamelCase       =			False

						# dataset
						if task_name.startswith('''imagenet1k_''' ):
												__UpperCamelCase       =			1000
												if int(task_name.strip().split('''_''' )[-1] ) == 384:
																		__UpperCamelCase       =			384
												else:
																		__UpperCamelCase       =			256
												__UpperCamelCase       =			'''imagenet-1k-id2label.json'''
						elif task_name.startswith('''imagenet21k_to_1k_''' ):
												__UpperCamelCase       =			21000
												if int(task_name.strip().split('''_''' )[-1] ) == 384:
																		__UpperCamelCase       =			384
												else:
																		__UpperCamelCase       =			256
												__UpperCamelCase       =			'''imagenet-22k-id2label.json'''
						elif task_name.startswith('''ade20k_''' ):
												__UpperCamelCase       =			151
												__UpperCamelCase       =			512
												__UpperCamelCase       =			'''ade20k-id2label.json'''
												__UpperCamelCase       =			True
						elif task_name.startswith('''voc_''' ):
												__UpperCamelCase       =			21
												__UpperCamelCase       =			512
												__UpperCamelCase       =			'''pascal-voc-id2label.json'''
												__UpperCamelCase       =			True

						# orig_config
						__UpperCamelCase       =			load_orig_config_file(snake_case )
						assert getattr(snake_case ,      '''model.classification.name''' ,      -1 ) == "mobilevit_v2", "Invalid model"
						__UpperCamelCase       =			getattr(snake_case ,      '''model.classification.mitv2.width_multiplier''' ,      1.0 )
						assert (
						    getattr(snake_case ,      '''model.classification.mitv2.attn_norm_layer''' ,      -1 ) == "layer_norm_2d"
						), "Norm layers other than layer_norm_2d is not supported"
						__UpperCamelCase       =			getattr(snake_case ,      '''model.classification.activation.name''' ,      '''swish''' )
						# config.image_size == getattr(orig_config,  'sampler.bs.crop_size_width', 256)

						if is_segmentation_model:
												__UpperCamelCase       =			getattr(snake_case ,      '''model.segmentation.output_stride''' ,      16 )
												if "_deeplabv3" in task_name:
																		__UpperCamelCase       =			getattr(snake_case ,      '''model.segmentation.deeplabv3.aspp_rates''' ,      [12, 24, 36] )
																		__UpperCamelCase       =			getattr(snake_case ,      '''model.segmentation.deeplabv3.aspp_out_channels''' ,      512 )
																		__UpperCamelCase       =			getattr(snake_case ,      '''model.segmentation.deeplabv3.aspp_dropout''' ,      0.1 )

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

						return config




def 	A_ (							snake_case							:   List[Any] ,      snake_case							:   int ,      snake_case							:   Any )      ->    str:



						'''simple docstring'''

						__UpperCamelCase       =			dct.pop(snake_case )
						__UpperCamelCase       =			val




def 	A_ (							snake_case							:   int ,      snake_case							:   List[Any]=False )      ->    Optional[Any]:



						'''simple docstring'''

						if base_model:
												__UpperCamelCase       =			''''''
						else:
												__UpperCamelCase       =			'''mobilevitv2.'''

						__UpperCamelCase       =			[]
						for k in state_dict.keys():
												if k[:8] == "encoder.":
																		__UpperCamelCase       =			k[8:]
												else:
																		__UpperCamelCase       =			k

												if ".block." in k:
																		__UpperCamelCase       =			k_new.replace('''.block.''' ,      '''.''' )
												if ".conv." in k:
																		__UpperCamelCase       =			k_new.replace('''.conv.''' ,      '''.convolution.''' )
												if ".norm." in k:
																		__UpperCamelCase       =			k_new.replace('''.norm.''' ,      '''.normalization.''' )

												if "conv_1." in k:
																		__UpperCamelCase       =			k_new.replace('''conv_1.''' ,      f"{model_prefix}conv_stem." )
												for i in [1, 2]:
																		if f"layer_{i}." in k:
																								__UpperCamelCase       =			k_new.replace(f"layer_{i}." ,      f"{model_prefix}encoder.layer.{i-1}.layer." )
												if ".exp_1x1." in k:
																		__UpperCamelCase       =			k_new.replace('''.exp_1x1.''' ,      '''.expand_1x1.''' )
												if ".red_1x1." in k:
																		__UpperCamelCase       =			k_new.replace('''.red_1x1.''' ,      '''.reduce_1x1.''' )

												for i in [3, 4, 5]:
																		if f"layer_{i}.0." in k:
																								__UpperCamelCase       =			k_new.replace(f"layer_{i}.0." ,      f"{model_prefix}encoder.layer.{i-1}.downsampling_layer." )
																		if f"layer_{i}.1.local_rep.0." in k:
																								__UpperCamelCase       =			k_new.replace(f"layer_{i}.1.local_rep.0." ,      f"{model_prefix}encoder.layer.{i-1}.conv_kxk." )
																		if f"layer_{i}.1.local_rep.1." in k:
																								__UpperCamelCase       =			k_new.replace(f"layer_{i}.1.local_rep.1." ,      f"{model_prefix}encoder.layer.{i-1}.conv_1x1." )

												for i in [3, 4, 5]:
																		if i == 3:
																								__UpperCamelCase       =			[0, 1]
																		elif i == 4:
																								__UpperCamelCase       =			[0, 1, 2, 3]
																		elif i == 5:
																								__UpperCamelCase       =			[0, 1, 2]

																		for j in j_in:
																								if f"layer_{i}.1.global_rep.{j}." in k:
																														__UpperCamelCase       =			k_new.replace(
																														    f"layer_{i}.1.global_rep.{j}." ,      f"{model_prefix}encoder.layer.{i-1}.transformer.layer.{j}." )
																		if f"layer_{i}.1.global_rep.{j+1}." in k:
																								__UpperCamelCase       =			k_new.replace(
																								    f"layer_{i}.1.global_rep.{j+1}." ,      f"{model_prefix}encoder.layer.{i-1}.layernorm." )

																		if f"layer_{i}.1.conv_proj." in k:
																								__UpperCamelCase       =			k_new.replace(f"layer_{i}.1.conv_proj." ,      f"{model_prefix}encoder.layer.{i-1}.conv_projection." )

												if "pre_norm_attn.0." in k:
																		__UpperCamelCase       =			k_new.replace('''pre_norm_attn.0.''' ,      '''layernorm_before.''' )
												if "pre_norm_attn.1." in k:
																		__UpperCamelCase       =			k_new.replace('''pre_norm_attn.1.''' ,      '''attention.''' )
												if "pre_norm_ffn.0." in k:
																		__UpperCamelCase       =			k_new.replace('''pre_norm_ffn.0.''' ,      '''layernorm_after.''' )
												if "pre_norm_ffn.1." in k:
																		__UpperCamelCase       =			k_new.replace('''pre_norm_ffn.1.''' ,      '''ffn.conv1.''' )
												if "pre_norm_ffn.3." in k:
																		__UpperCamelCase       =			k_new.replace('''pre_norm_ffn.3.''' ,      '''ffn.conv2.''' )

												if "classifier.1." in k:
																		__UpperCamelCase       =			k_new.replace('''classifier.1.''' ,      '''classifier.''' )

												if "seg_head." in k:
																		__UpperCamelCase       =			k_new.replace('''seg_head.''' ,      '''segmentation_head.''' )
												if ".aspp_layer." in k:
																		__UpperCamelCase       =			k_new.replace('''.aspp_layer.''' ,      '''.''' )
												if ".aspp_pool." in k:
																		__UpperCamelCase       =			k_new.replace('''.aspp_pool.''' ,      '''.''' )

												rename_keys.append((k, k_new) )
						return rename_keys




def 	A_ (							snake_case							:   List[str] )      ->    str:



						'''simple docstring'''

						__UpperCamelCase       =			[]
						for k in state_dict.keys():
												if k.startswith('''seg_head.aux_head.''' ):
																		keys_to_ignore.append(snake_case )
						for k in keys_to_ignore:
												state_dict.pop(snake_case ,      snake_case )




def 	A_ (							)      ->    str:



						'''simple docstring'''

						__UpperCamelCase       =			'''http://images.cocodataset.org/val2017/000000039769.jpg'''
						# url = "https://cdn.britannica.com/86/141086-050-9D7C75EE/Gulfstream-G450-business-jet-passengers.jpg"
						__UpperCamelCase       =			Image.open(requests.get(snake_case ,      stream=snake_case ).raw )
						return im




@torch.no_grad()
def 	A_ (							snake_case							:   Dict ,      snake_case							:   List[str] ,      snake_case							:   Optional[Any] ,      snake_case							:   Optional[int] )      ->    int:



						'''simple docstring'''

						__UpperCamelCase       =			get_mobilevitva_config(snake_case ,      snake_case )

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

						# load huggingface model
						if task_name.startswith('''ade20k_''' ) or task_name.startswith('''voc_''' ):
												__UpperCamelCase       =			MobileViTVaForSemanticSegmentation(snake_case ).eval()
												__UpperCamelCase       =			False
						else:
												__UpperCamelCase       =			MobileViTVaForImageClassification(snake_case ).eval()
												__UpperCamelCase       =			False

						# remove and rename some keys of load the original model
						__UpperCamelCase       =			checkpoint
						remove_unused_keys(snake_case )
						__UpperCamelCase       =			create_rename_keys(snake_case ,      base_model=snake_case )
						for rename_key_src, rename_key_dest in rename_keys:
												rename_key(snake_case ,      snake_case ,      snake_case )

						# load modified state_dict
						model.load_state_dict(snake_case )

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

						# verify classification model
						if task_name.startswith('''imagenet''' ):
												__UpperCamelCase       =			outputs.logits
												__UpperCamelCase       =			logits.argmax(-1 ).item()
												print('''Predicted class:''' ,      model.config.idalabel[predicted_class_idx] )
												if task_name.startswith('''imagenet1k_256''' ) and config.width_multiplier == 1.0:
																		# expected_logits for base variant
																		__UpperCamelCase       =			torch.tensor([-1.63_36e00, -7.32_04e-02, -5.18_83e-01] )
																		assert torch.allclose(logits[0, :3] ,      snake_case ,      atol=1e-4 )

						Path(snake_case ).mkdir(exist_ok=snake_case )
						print(f"Saving model {task_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 __name__ == "__main__":
				lowercase__							:							Any									=			argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    "--task",
				    default="imagenet1k_256",
				    type=str,
				    help=(
				        "Name of the task for which the MobileViTV2 model you'd like to convert is trained on . "
				        "\n                Classification (ImageNet-1k)\n                    - MobileViTV2 (256x256) : imagenet1k_256\n                    - MobileViTV2 (Trained on 256x256 and Finetuned on 384x384) : imagenet1k_384\n                    - MobileViTV2 (Trained on ImageNet-21k and Finetuned on ImageNet-1k 256x256) :\n                      imagenet21k_to_1k_256\n                    - MobileViTV2 (Trained on ImageNet-21k, Finetuned on ImageNet-1k 256x256, and Finetuned on\n                      ImageNet-1k 384x384) : imagenet21k_to_1k_384\n                Segmentation\n                    - ADE20K Dataset : ade20k_deeplabv3\n                    - Pascal VOC 2012 Dataset: voc_deeplabv3\n            "
				    ),
				    choices=[
				        "imagenet1k_256",
				        "imagenet1k_384",
				        "imagenet21k_to_1k_256",
				        "imagenet21k_to_1k_384",
				        "ade20k_deeplabv3",
				        "voc_deeplabv3",
				    ],
				)

				parser.add_argument(
				    "--orig_checkpoint_path", required=True, type=str, help="Path to the original state dict (.pt file)."
				)
				parser.add_argument("--orig_config_path", required=True, type=str, help="Path to the original config file.")
				parser.add_argument(
				    "--pytorch_dump_folder_path", required=True, type=str, help="Path to the output PyTorch model directory."
				)

				lowercase__							:							Tuple									=			parser.parse_args()
				convert_mobilevitva_checkpoint(
				    args.task, args.orig_checkpoint_path, args.orig_config_path, args.pytorch_dump_folder_path
				)




