





'''simple docstring'''
def 				lowercase__   (   __lowercase						:  int				,  __lowercase						:  int     ) ->      int:



       """simple docstring"""






       while a != 0:
              __UpperCamelCase       ,						__UpperCamelCase       =  b % a, a
       return b


def 				lowercase__   (   __lowercase						:  int				,  __lowercase						:  int     ) ->      int:



       """simple docstring"""






       if gcd(__lowercase				,  __lowercase     ) != 1:
              __UpperCamelCase       =  F'''mod inverse of {a!r} and {m!r} does not exist'''
              raise ValueError(__lowercase     )
       __UpperCamelCase       ,						__UpperCamelCase       ,						__UpperCamelCase       =  1, 0, a
       __UpperCamelCase       ,						__UpperCamelCase       ,						__UpperCamelCase       =  0, 1, m
       while va != 0:
              __UpperCamelCase       =  ua // va
              __UpperCamelCase       ,						__UpperCamelCase       ,						__UpperCamelCase       ,						__UpperCamelCase       ,						__UpperCamelCase       ,						__UpperCamelCase       =  (ua - q * va), (ua - q * va), (ua - q * va), va, va, va
       return ua % m

'''simple docstring'''




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()
__SCREAMING_SNAKE_CASE       :     Union[str, Any]     =  logging.get_logger(__name__)

def 	UpperCamelCase_							(					_UpperCAmelCase  :      str    )    ->    Optional[Any]:


       """simple docstring"""







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

       _UpperCAmelCase     :  Tuple							      =    "huggingface/label-files"
       if "ade20k-full" in model_name:
              # this should be ok
              _UpperCAmelCase     :  Dict							      =    847
              _UpperCAmelCase     :  Any							      =    "maskformer-ade20k-full-id2label.json"
       elif "ade" in model_name:
              # this should be ok
              _UpperCAmelCase     :  Any							      =    150
              _UpperCAmelCase     :  Any							      =    "ade20k-id2label.json"
       elif "coco-stuff" in model_name:
              # this should be ok
              _UpperCAmelCase     :  Tuple							      =    171
              _UpperCAmelCase     :  Union[str, Any]							      =    "maskformer-coco-stuff-id2label.json"
       elif "coco" in model_name:
              # TODO
              _UpperCAmelCase     :  Any							      =    133
              _UpperCAmelCase     :  int							      =    "coco-panoptic-id2label.json"
       elif "cityscapes" in model_name:
              # this should be ok
              _UpperCAmelCase     :  Optional[int]							      =    19
              _UpperCAmelCase     :  str							      =    "cityscapes-id2label.json"
       elif "vistas" in model_name:
              # this should be ok
              _UpperCAmelCase     :  Optional[int]							      =    65
              _UpperCAmelCase     :  Tuple							      =    "mapillary-vistas-id2label.json"

       _UpperCAmelCase     :  List[Any]							      =    json.load(open(hf_hub_download(_UpperCAmelCase			,	_UpperCAmelCase			,	repo_type="dataset"    )			,	"r"    )    )
       _UpperCAmelCase     :  Tuple							      =    {int(_UpperCAmelCase    ): v for k, v in idalabel.items()}

       return config

def 	UpperCamelCase_							(					_UpperCAmelCase  :      Optional[int]    )    ->    List[Any]:


       """simple docstring"""







       _UpperCAmelCase     :  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 	UpperCamelCase_							(					_UpperCAmelCase  :      int			,	_UpperCAmelCase  :      Tuple			,	_UpperCAmelCase  :      List[Any]    )    ->    List[str]:


       """simple docstring"""







       _UpperCAmelCase     :  Optional[int]							      =    dct.pop(_UpperCAmelCase    )
       _UpperCAmelCase     :  List[str]							      =    val

def 	UpperCamelCase_							(					_UpperCAmelCase  :      List[Any]			,	_UpperCAmelCase  :      Tuple    )    ->    Optional[int]:


       """simple docstring"""







       _UpperCAmelCase     :  List[str]							      =    [int(backbone_config.embed_dim * 2**i    ) for i in range(len(backbone_config.depths    )    )]
       for i in range(len(backbone_config.depths    )    ):
              _UpperCAmelCase     :  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)
                     _UpperCAmelCase     :  Any							      =    state_dict.pop(F"""backbone.layers.{i}.blocks.{j}.attn.qkv.weight"""    )
                     _UpperCAmelCase     :  Optional[int]							      =    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
                     _UpperCAmelCase     :  List[str]							      =    in_proj_weight[:dim, :]
                     _UpperCAmelCase     :  Tuple							      =    in_proj_bias[: dim]
                     _UpperCAmelCase     :  List[Any]							      =    in_proj_weight[
                         dim : dim * 2, :
                     ]
                     _UpperCAmelCase     :  List[str]							      =    in_proj_bias[
                         dim : dim * 2
                     ]
                     _UpperCAmelCase     :  Optional[Any]							      =    in_proj_weight[
                         -dim :, :
                     ]
                     _UpperCAmelCase     :  Dict							      =    in_proj_bias[-dim :]
                     # fmt: on

def 	UpperCamelCase_							(					_UpperCAmelCase  :      Dict			,	_UpperCAmelCase  :      str    )    ->    Dict:


       """simple docstring"""







       _UpperCAmelCase     :  Union[str, Any]							      =    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)
              _UpperCAmelCase     :  Dict							      =    state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight"""    )
              _UpperCAmelCase     :  Dict							      =    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
              _UpperCAmelCase     :  int							      =    in_proj_weight[: hidden_size, :]
              _UpperCAmelCase     :  Union[str, Any]							      =    in_proj_bias[:config.hidden_size]
              _UpperCAmelCase     :  List[str]							      =    in_proj_weight[hidden_size : hidden_size * 2, :]
              _UpperCAmelCase     :  List[str]							      =    in_proj_bias[hidden_size : hidden_size * 2]
              _UpperCAmelCase     :  int							      =    in_proj_weight[-hidden_size :, :]
              _UpperCAmelCase     :  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)
              _UpperCAmelCase     :  Optional[Any]							      =    state_dict.pop(F"""sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight"""    )
              _UpperCAmelCase     :  Tuple							      =    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
              _UpperCAmelCase     :  Any							      =    in_proj_weight[: hidden_size, :]
              _UpperCAmelCase     :  Tuple							      =    in_proj_bias[:config.hidden_size]
              _UpperCAmelCase     :  Dict							      =    in_proj_weight[hidden_size : hidden_size * 2, :]
              _UpperCAmelCase     :  Dict							      =    in_proj_bias[hidden_size : hidden_size * 2]
              _UpperCAmelCase     :  Optional[int]							      =    in_proj_weight[-hidden_size :, :]
              _UpperCAmelCase     :  Union[str, Any]							      =    in_proj_bias[-hidden_size :]
       # fmt: on

def 	UpperCamelCase_							(					)    ->    torch.Tensor:


       """simple docstring"""







       _UpperCAmelCase     :  int							      =    "http://images.cocodataset.org/val2017/000000039769.jpg"
       _UpperCAmelCase     :  Any							      =    Image.open(requests.get(_UpperCAmelCase			,	stream=_UpperCAmelCase    ).raw    )
       return im

@torch.no_grad()
def 	UpperCamelCase_							(					_UpperCAmelCase  :      str			,	_UpperCAmelCase  :      str			,	_UpperCAmelCase  :      str			,	_UpperCAmelCase  :      bool = False    )    ->    List[str]:


       """simple docstring"""







       _UpperCAmelCase     :  Optional[int]							      =    get_maskformer_config(_UpperCAmelCase    )

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

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

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

       # update to torch tensors
       for key, value in state_dict.items():
              _UpperCAmelCase     :  Tuple							      =    torch.from_numpy(_UpperCAmelCase    )

       # load 🤗 model
       _UpperCAmelCase     :  Union[str, Any]							      =    MaskFormerForInstanceSegmentation(_UpperCAmelCase    )
       model.eval()

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

       _UpperCAmelCase      ,  _UpperCAmelCase     :  Any							      =    model.load_state_dict(_UpperCAmelCase			,	strict=_UpperCAmelCase    )
       assert missing_keys == [
           "model.pixel_level_module.encoder.model.layernorm.weight",
           "model.pixel_level_module.encoder.model.layernorm.bias",
       ]
       assert len(_UpperCAmelCase    ) == 0, F"""Unexpected keys: {unexpected_keys}"""

       # verify results
       _UpperCAmelCase     :  Optional[int]							      =    prepare_img()
       if "vistas" in model_name:
              _UpperCAmelCase     :  int							      =    65
       elif "cityscapes" in model_name:
              _UpperCAmelCase     :  Tuple							      =    65_535
       else:
              _UpperCAmelCase     :  Any							      =    255
       _UpperCAmelCase     :  Optional[Any]							      =    True if "ade" in model_name else False
       _UpperCAmelCase     :  Optional[int]							      =    MaskFormerImageProcessor(ignore_index=_UpperCAmelCase			,	reduce_labels=_UpperCAmelCase    )

       _UpperCAmelCase     :  Optional[int]							      =    image_processor(_UpperCAmelCase			,	return_tensors="pt"    )

       _UpperCAmelCase     :  List[Any]							      =    model(**_UpperCAmelCase    )

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

       if model_name == "maskformer-swin-tiny-ade":
              _UpperCAmelCase     :  Tuple							      =    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]			,	_UpperCAmelCase			,	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(_UpperCAmelCase    ).mkdir(exist_ok=_UpperCAmelCase    )
              model.save_pretrained(_UpperCAmelCase    )
              image_processor.save_pretrained(_UpperCAmelCase    )

       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__":
  __SCREAMING_SNAKE_CASE       :     Optional[Any]     =  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."""
  )

  __SCREAMING_SNAKE_CASE       :     int     =  parser.parse_args()
  convert_maskformer_checkpoint(
      args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
  )

