


from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)





import argparse
import json
import pickle
from pathlib import Path

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

from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig
from transformers.utils import logging


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







def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Dict										=       SwinConfig.from_pretrained(
							    "microsoft/swin-tiny-patch4-window7-224"							,     out_features=["stage1", "stage2", "stage3", "stage4"]     )
							__snake_case		:      List[Any]										=       MaskFormerConfig(backbone_config=__lowerCamelCase     )

							__snake_case		:      List[Any]										=       "huggingface/label-files"
							if "ade20k-full" in model_name:
														# this should be ok
														__snake_case		:      Any										=       8_4_7
														__snake_case		:      List[Any]										=       "maskformer-ade20k-full-id2label.json"
							elif "ade" in model_name:
														# this should be ok
														__snake_case		:      Optional[int]										=       1_5_0
														__snake_case		:      int										=       "ade20k-id2label.json"
							elif "coco-stuff" in model_name:
														# this should be ok
														__snake_case		:      Optional[Any]										=       1_7_1
														__snake_case		:      List[str]										=       "maskformer-coco-stuff-id2label.json"
							elif "coco" in model_name:
														# TODO
														__snake_case		:      Optional[int]										=       1_3_3
														__snake_case		:      int										=       "coco-panoptic-id2label.json"
							elif "cityscapes" in model_name:
														# this should be ok
														__snake_case		:      Union[str, Any]										=       1_9
														__snake_case		:      Dict										=       "cityscapes-id2label.json"
							elif "vistas" in model_name:
														# this should be ok
														__snake_case		:      Any										=       6_5
														__snake_case		:      Any										=       "mapillary-vistas-id2label.json"

							__snake_case		:      str										=       json.load(open(hf_hub_download(__lowerCamelCase							,     __lowerCamelCase							,     repo_type="dataset"     )							,     "r"     )     )
							__snake_case		:      Tuple										=       {int(__lowerCamelCase     ): v for k, v in idalabel.items()}

							return config







def     lowerCAmelCase_					( __lowerCamelCase     ):
							__snake_case		:      Dict										=       []
							# stem
							# fmt: off
							rename_keys.append(("backbone.patch_embed.proj.weight", "model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight")     )
							rename_keys.append(("backbone.patch_embed.proj.bias", "model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias")     )
							rename_keys.append(("backbone.patch_embed.norm.weight", "model.pixel_level_module.encoder.model.embeddings.norm.weight")     )
							rename_keys.append(("backbone.patch_embed.norm.bias", "model.pixel_level_module.encoder.model.embeddings.norm.bias")     )
							# stages
							for i in range(len(config.backbone_config.depths     )     ):
														for j in range(config.backbone_config.depths[i]     ):
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.norm1.weight', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.norm1.bias', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.attn.relative_position_index', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.attn.proj.weight', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.attn.proj.bias', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.norm2.weight', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.norm2.bias', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.mlp.fc1.weight', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.mlp.fc1.bias', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.mlp.fc2.weight', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight')     )
																					rename_keys.append((F'backbone.layers.{i}.blocks.{j}.mlp.fc2.bias', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias')     )

														if i < 3:
																					rename_keys.append((F'backbone.layers.{i}.downsample.reduction.weight', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight')     )
																					rename_keys.append((F'backbone.layers.{i}.downsample.norm.weight', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight')     )
																					rename_keys.append((F'backbone.layers.{i}.downsample.norm.bias', F'model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias')     )
														rename_keys.append((F'backbone.norm{i}.weight', F'model.pixel_level_module.encoder.hidden_states_norms.{i}.weight')     )
														rename_keys.append((F'backbone.norm{i}.bias', F'model.pixel_level_module.encoder.hidden_states_norms.{i}.bias')     )

							# FPN
							rename_keys.append(("sem_seg_head.layer_4.weight", "model.pixel_level_module.decoder.fpn.stem.0.weight")     )
							rename_keys.append(("sem_seg_head.layer_4.norm.weight", "model.pixel_level_module.decoder.fpn.stem.1.weight")     )
							rename_keys.append(("sem_seg_head.layer_4.norm.bias", "model.pixel_level_module.decoder.fpn.stem.1.bias")     )
							for source_index, target_index in zip(range(3							,     0							,     -1     )							,     range(0							,     3     )     ):
														rename_keys.append((F'sem_seg_head.adapter_{source_index}.weight', F'model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight')     )
														rename_keys.append((F'sem_seg_head.adapter_{source_index}.norm.weight', F'model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight')     )
														rename_keys.append((F'sem_seg_head.adapter_{source_index}.norm.bias', F'model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias')     )
														rename_keys.append((F'sem_seg_head.layer_{source_index}.weight', F'model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight')     )
														rename_keys.append((F'sem_seg_head.layer_{source_index}.norm.weight', F'model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight')     )
														rename_keys.append((F'sem_seg_head.layer_{source_index}.norm.bias', F'model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias')     )
							rename_keys.append(("sem_seg_head.mask_features.weight", "model.pixel_level_module.decoder.mask_projection.weight")     )
							rename_keys.append(("sem_seg_head.mask_features.bias", "model.pixel_level_module.decoder.mask_projection.bias")     )

							# Transformer decoder
							for idx in range(config.decoder_config.decoder_layers     ):
														# self-attention out projection
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight', F'model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight')     )
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias', F'model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias')     )
														# cross-attention out projection
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight', F'model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight')     )
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias', F'model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias')     )
														# MLP 1
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight', F'model.transformer_module.decoder.layers.{idx}.fc1.weight')     )
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias', F'model.transformer_module.decoder.layers.{idx}.fc1.bias')     )
														# MLP 2
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight', F'model.transformer_module.decoder.layers.{idx}.fc2.weight')     )
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias', F'model.transformer_module.decoder.layers.{idx}.fc2.bias')     )
														# layernorm 1 (self-attention layernorm)
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight', F'model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight')     )
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias', F'model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias')     )
														# layernorm 2 (cross-attention layernorm)
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight', F'model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight')     )
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias', F'model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias')     )
														# layernorm 3 (final layernorm)
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight', F'model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight')     )
														rename_keys.append((F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias', F'model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias')     )

							rename_keys.append(("sem_seg_head.predictor.transformer.decoder.norm.weight", "model.transformer_module.decoder.layernorm.weight")     )
							rename_keys.append(("sem_seg_head.predictor.transformer.decoder.norm.bias", "model.transformer_module.decoder.layernorm.bias")     )

							# heads on top
							rename_keys.append(("sem_seg_head.predictor.query_embed.weight", "model.transformer_module.queries_embedder.weight")     )

							rename_keys.append(("sem_seg_head.predictor.input_proj.weight", "model.transformer_module.input_projection.weight")     )
							rename_keys.append(("sem_seg_head.predictor.input_proj.bias", "model.transformer_module.input_projection.bias")     )

							rename_keys.append(("sem_seg_head.predictor.class_embed.weight", "class_predictor.weight")     )
							rename_keys.append(("sem_seg_head.predictor.class_embed.bias", "class_predictor.bias")     )

							for i in range(3     ):
														rename_keys.append((F'sem_seg_head.predictor.mask_embed.layers.{i}.weight', F'mask_embedder.{i}.0.weight')     )
														rename_keys.append((F'sem_seg_head.predictor.mask_embed.layers.{i}.bias', F'mask_embedder.{i}.0.bias')     )
							# fmt: on

							return rename_keys







def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      Dict										=       dct.pop(__lowerCamelCase     )
							__snake_case		:      Any										=       val







def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							__snake_case		:      List[Any]										=       [int(backbone_config.embed_dim * 2**i     ) for i in range(len(backbone_config.depths     )     )]
							for i in range(len(backbone_config.depths     )     ):
														__snake_case		:      Optional[int]										=       num_features[i]
														for j in range(backbone_config.depths[i]     ):
																					# fmt: off
																					# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
																					__snake_case		:      Tuple										=       state_dict.pop(F'backbone.layers.{i}.blocks.{j}.attn.qkv.weight'     )
																					__snake_case		:      Tuple										=       state_dict.pop(F'backbone.layers.{i}.blocks.{j}.attn.qkv.bias'     )
																					# next, add query, keys and values (in that order) to the state dict
																					__snake_case		:      Tuple										=       in_proj_weight[:dim, :]
																					__snake_case		:      Tuple										=       in_proj_bias[: dim]
																					__snake_case		:      Union[str, Any]										=       in_proj_weight[
																					    dim : dim * 2, :
																					]
																					__snake_case		:      Tuple										=       in_proj_bias[
																					    dim : dim * 2
																					]
																					__snake_case		:      str										=       in_proj_weight[
																					    -dim :, :
																					]
																					__snake_case		:      Any										=       in_proj_bias[-dim :]
																					# fmt: on







def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							# fmt: off
							__snake_case		:      Optional[int]										=       config.decoder_config.hidden_size
							for idx in range(config.decoder_config.decoder_layers     ):
														# read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias)
														__snake_case		:      List[str]										=       state_dict.pop(F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight'     )
														__snake_case		:      Union[str, Any]										=       state_dict.pop(F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias'     )
														# next, add query, keys and values (in that order) to the state dict
														__snake_case		:      Any										=       in_proj_weight[: hidden_size, :]
														__snake_case		:      Optional[int]										=       in_proj_bias[:config.hidden_size]
														__snake_case		:      Any										=       in_proj_weight[hidden_size : hidden_size * 2, :]
														__snake_case		:      Any										=       in_proj_bias[hidden_size : hidden_size * 2]
														__snake_case		:      Tuple										=       in_proj_weight[-hidden_size :, :]
														__snake_case		:      Optional[Any]										=       in_proj_bias[-hidden_size :]
														# read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias)
														__snake_case		:      Optional[Any]										=       state_dict.pop(F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight'     )
														__snake_case		:      Union[str, Any]										=       state_dict.pop(F'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias'     )
														# next, add query, keys and values (in that order) to the state dict
														__snake_case		:      int										=       in_proj_weight[: hidden_size, :]
														__snake_case		:      Tuple										=       in_proj_bias[:config.hidden_size]
														__snake_case		:      str										=       in_proj_weight[hidden_size : hidden_size * 2, :]
														__snake_case		:      Optional[Any]										=       in_proj_bias[hidden_size : hidden_size * 2]
														__snake_case		:      Optional[Any]										=       in_proj_weight[-hidden_size :, :]
														__snake_case		:      Tuple										=       in_proj_bias[-hidden_size :]
							# fmt: on







def     lowerCAmelCase_					( ):
							__snake_case		:      List[str]										=       "http://images.cocodataset.org/val2017/000000039769.jpg"
							__snake_case		:      List[str]										=       Image.open(requests.get(__lowerCamelCase							,     stream=__lowerCamelCase     ).raw     )
							return im







@torch.no_grad()
def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase = False     ):
							__snake_case		:      Optional[int]										=       get_maskformer_config(__lowerCamelCase     )

							# load original state_dict
							with open(__lowerCamelCase							,     "rb"     ) as f:
														__snake_case		:      int										=       pickle.load(__lowerCamelCase     )
							__snake_case		:      Optional[int]										=       data["model"]

							# for name, param in state_dict.items():
							#     print(name, param.shape)

							# rename keys
							__snake_case		:      Tuple										=       create_rename_keys(__lowerCamelCase     )
							for src, dest in rename_keys:
														rename_key(__lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase     )
							read_in_swin_q_k_v(__lowerCamelCase							,     config.backbone_config     )
							read_in_decoder_q_k_v(__lowerCamelCase							,     __lowerCamelCase     )

							# update to torch tensors
							for key, value in state_dict.items():
														__snake_case		:      int										=       torch.from_numpy(__lowerCamelCase     )

							# load 🤗 model
							__snake_case		:      List[str]										=       MaskFormerForInstanceSegmentation(__lowerCamelCase     )
							model.eval()

							for name, param in model.named_parameters():
														print(__lowerCamelCase							,     param.shape     )

							__snake_case			,      __snake_case		:      List[str]										=       model.load_state_dict(__lowerCamelCase							,     strict=__lowerCamelCase     )
							assert missing_keys == [
							    "model.pixel_level_module.encoder.model.layernorm.weight",
							    "model.pixel_level_module.encoder.model.layernorm.bias",
							]
							assert len(__lowerCamelCase     ) == 0, F'Unexpected keys: {unexpected_keys}'

							# verify results
							__snake_case		:      Union[str, Any]										=       prepare_img()
							if "vistas" in model_name:
														__snake_case		:      Optional[int]										=       6_5
							elif "cityscapes" in model_name:
														__snake_case		:      Optional[int]										=       6_5_5_3_5
							else:
														__snake_case		:      Union[str, Any]										=       2_5_5
							__snake_case		:      Union[str, Any]										=       True if "ade" in model_name else False
							__snake_case		:      str										=       MaskFormerImageProcessor(ignore_index=__lowerCamelCase							,     reduce_labels=__lowerCamelCase     )

							__snake_case		:      List[str]										=       image_processor(__lowerCamelCase							,     return_tensors="pt"     )

							__snake_case		:      Tuple										=       model(**__lowerCamelCase     )

							print("Logits:"							,     outputs.class_queries_logits[0, :3, :3]     )

							if model_name == "maskformer-swin-tiny-ade":
														__snake_case		:      Optional[Any]										=       torch.tensor(
														    [[3.6_3_5_3, -4.4_7_7_0, -2.6_0_6_5], [0.5_0_8_1, -4.2_3_9_4, -3.5_3_4_3], [2.1_9_0_9, -5.0_3_5_3, -1.9_3_2_3]]     )
							assert torch.allclose(outputs.class_queries_logits[0, :3, :3]							,     __lowerCamelCase							,     atol=1e-4     )
							print("Looks ok!"     )

							if pytorch_dump_folder_path is not None:
														print(F'Saving model and image processor to {pytorch_dump_folder_path}'     )
														Path(__lowerCamelCase     ).mkdir(exist_ok=__lowerCamelCase     )
														model.save_pretrained(__lowerCamelCase     )
														image_processor.save_pretrained(__lowerCamelCase     )

							if push_to_hub:
														print("Pushing model and image processor to the hub..."     )
														model.push_to_hub(F'nielsr/{model_name}'     )
														image_processor.push_to_hub(F'nielsr/{model_name}'     )


if __name__ == "__main__":
			_snake_case					:		List[str]      =    argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    "--model_name",
			    default="maskformer-swin-tiny-ade",
			    type=str,
			    help=("Name of the MaskFormer model you'd like to convert",),
			)
			parser.add_argument(
			    "--checkpoint_path",
			    default="/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl",
			    type=str,
			    help="Path to the original state dict (.pth file).",
			)
			parser.add_argument(
			    "--pytorch_dump_folder_path", default=None, 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."
			)

			_snake_case					:		List[str]      =    parser.parse_args()
			convert_maskformer_checkpoint(
			    args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
			)

