



"""simple docstring"""
import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import BeitImageProcessor



class       SCREAMING_SNAKE_CASE__  (					unittest.TestCase ):

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=7      ,     _SCREAMING_SNAKE_CASE=3      ,     _SCREAMING_SNAKE_CASE=18      ,     _SCREAMING_SNAKE_CASE=30      ,     _SCREAMING_SNAKE_CASE=400      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=None      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=None      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=[0.5, 0.5, 0.5]      ,     _SCREAMING_SNAKE_CASE=[0.5, 0.5, 0.5]      ,     _SCREAMING_SNAKE_CASE=False      ,     )  ->      List[str]:





    '''simple docstring'''




    UpperCAmelCase	:					Dict	=	size if size is not None else {"""height""": 20, """width""": 20}
    UpperCAmelCase	:					Optional[int]	=	crop_size if crop_size is not None else {"""height""": 18, """width""": 18}
    UpperCAmelCase	:					Optional[int]	=	parent
    UpperCAmelCase	:					Any	=	batch_size
    UpperCAmelCase	:					Dict	=	num_channels
    UpperCAmelCase	:					Union[str, Any]	=	image_size
    UpperCAmelCase	:					int	=	min_resolution
    UpperCAmelCase	:					Any	=	max_resolution
    UpperCAmelCase	:					int	=	do_resize
    UpperCAmelCase	:					Optional[int]	=	size
    UpperCAmelCase	:					Tuple	=	do_center_crop
    UpperCAmelCase	:					List[str]	=	crop_size
    UpperCAmelCase	:					Dict	=	do_normalize
    UpperCAmelCase	:					List[str]	=	image_mean
    UpperCAmelCase	:					Any	=	image_std
    UpperCAmelCase	:					List[Any]	=	do_reduce_labels




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    return {
        "do_resize": self.do_resize,
        "size": self.size,
        "do_center_crop": self.do_center_crop,
        "crop_size": self.crop_size,
        "do_normalize": self.do_normalize,
        "image_mean": self.image_mean,
        "image_std": self.image_std,
        "do_reduce_labels": self.do_reduce_labels,
    }

def       _snake_case						(						):
 UpperCAmelCase	:					Tuple	=	load_dataset("""hf-internal-testing/fixtures_ade20k"""			,		split="""test"""						)

 UpperCAmelCase	:					Any	=	Image.open(dataset[0]["""file"""]						)
 UpperCAmelCase	:					Optional[int]	=	Image.open(dataset[1]["""file"""]						)

 return image, map

def       _snake_case						(						):
 UpperCAmelCase	:					Optional[int]	=	load_dataset("""hf-internal-testing/fixtures_ade20k"""			,		split="""test"""						)

 UpperCAmelCase	:					int	=	Image.open(ds[0]["""file"""]						)
 UpperCAmelCase	:					Optional[int]	=	Image.open(ds[1]["""file"""]						)
 UpperCAmelCase	:					Dict	=	Image.open(ds[2]["""file"""]						)
 UpperCAmelCase	:					List[Any]	=	Image.open(ds[3]["""file"""]						)

 return [imagea, imagea], [mapa, mapa]



@require_torch
@require_vision
class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   int						=						BeitImageProcessor if is_vision_available() else None

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      str:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	BeitImageProcessingTester(self						)

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[str]:





    '''simple docstring'''




    return self.image_processor_tester.prepare_image_processor_dict()

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    UpperCAmelCase	:					Union[str, Any]	=	self.image_processing_class(**self.image_processor_dict						)
    self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,     """do_resize"""						)						)
    self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,     """size"""						)						)
    self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,     """do_center_crop"""						)						)
    self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,     """center_crop"""						)						)
    self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,     """do_normalize"""						)						)
    self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,     """image_mean"""						)						)
    self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,     """image_std"""						)						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	self.image_processing_class.from_dict(self.image_processor_dict						)
    self.assertEqual(image_processor.size      ,     {"""height""": 20, """width""": 20}						)
    self.assertEqual(image_processor.crop_size      ,     {"""height""": 18, """width""": 18}						)
    self.assertEqual(image_processor.do_reduce_labels      ,     _SCREAMING_SNAKE_CASE						)

    UpperCAmelCase	:					str	=	self.image_processing_class.from_dict(
        self.image_processor_dict      ,     size=42      ,     crop_size=84      ,     reduce_labels=_SCREAMING_SNAKE_CASE						)
    self.assertEqual(image_processor.size      ,     {"""height""": 42, """width""": 42}						)
    self.assertEqual(image_processor.crop_size      ,     {"""height""": 84, """width""": 84}						)
    self.assertEqual(image_processor.do_reduce_labels      ,     _SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    pass

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[str]:





    '''simple docstring'''




    UpperCAmelCase	:					List[Any]	=	self.image_processing_class(**self.image_processor_dict						)
    # create random PIL images
    UpperCAmelCase	:					List[Any]	=	prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=_SCREAMING_SNAKE_CASE						)
    for image in image_inputs:
     self.assertIsInstance(_SCREAMING_SNAKE_CASE      ,     Image.Image						)

    # Test not batched input
    UpperCAmelCase	:					List[Any]	=	image_processing(image_inputs[0]      ,     return_tensors="""pt"""						).pixel_values
    self.assertEqual(
        encoded_images.shape      ,     (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )

    # Test batched
    UpperCAmelCase	:					Any	=	image_processing(_SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						).pixel_values
    self.assertEqual(
        encoded_images.shape      ,     (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.image_processing_class(**self.image_processor_dict						)
    # create random numpy tensors
    UpperCAmelCase	:					List[Any]	=	prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=_SCREAMING_SNAKE_CASE      ,     numpify=_SCREAMING_SNAKE_CASE						)
    for image in image_inputs:
     self.assertIsInstance(_SCREAMING_SNAKE_CASE      ,     np.ndarray						)

    # Test not batched input
    UpperCAmelCase	:					Any	=	image_processing(image_inputs[0]      ,     return_tensors="""pt"""						).pixel_values
    self.assertEqual(
        encoded_images.shape      ,     (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )

    # Test batched
    UpperCAmelCase	:					str	=	image_processing(_SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						).pixel_values
    self.assertEqual(
        encoded_images.shape      ,     (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )

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





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	self.image_processing_class(**self.image_processor_dict						)
    # create random PyTorch tensors
    UpperCAmelCase	:					Optional[Any]	=	prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=_SCREAMING_SNAKE_CASE      ,     torchify=_SCREAMING_SNAKE_CASE						)
    for image in image_inputs:
     self.assertIsInstance(_SCREAMING_SNAKE_CASE      ,     torch.Tensor						)

    # Test not batched input
    UpperCAmelCase	:					int	=	image_processing(image_inputs[0]      ,     return_tensors="""pt"""						).pixel_values
    self.assertEqual(
        encoded_images.shape      ,     (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )

    # Test batched
    UpperCAmelCase	:					Optional[Any]	=	image_processing(_SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						).pixel_values
    self.assertEqual(
        encoded_images.shape      ,     (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	self.image_processing_class(**self.image_processor_dict						)
    # create random PyTorch tensors
    UpperCAmelCase	:					Any	=	prepare_image_inputs(self.image_processor_tester      ,     equal_resolution=_SCREAMING_SNAKE_CASE      ,     torchify=_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Tuple	=	[]
    for image in image_inputs:
     self.assertIsInstance(_SCREAMING_SNAKE_CASE      ,     torch.Tensor						)
     maps.append(torch.zeros(image.shape[-2:]						).long()						)

    # Test not batched input
    UpperCAmelCase	:					Optional[int]	=	image_processing(image_inputs[0]      ,     maps[0]      ,     return_tensors="""pt"""						)
    self.assertEqual(
        encoding["""pixel_values"""].shape      ,     (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )
    self.assertEqual(
        encoding["""labels"""].shape      ,     (
            1,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )
    self.assertEqual(encoding["""labels"""].dtype      ,     torch.long						)
    self.assertTrue(encoding["""labels"""].min().item() >= 0						)
    self.assertTrue(encoding["""labels"""].max().item() <= 255						)

    # Test batched
    UpperCAmelCase	:					Tuple	=	image_processing(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						)
    self.assertEqual(
        encoding["""pixel_values"""].shape      ,     (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )
    self.assertEqual(
        encoding["""labels"""].shape      ,     (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )
    self.assertEqual(encoding["""labels"""].dtype      ,     torch.long						)
    self.assertTrue(encoding["""labels"""].min().item() >= 0						)
    self.assertTrue(encoding["""labels"""].max().item() <= 255						)

    # Test not batched input (PIL images)
    UpperCAmelCase	,		UpperCAmelCase	:					Any	=	prepare_semantic_single_inputs()

    UpperCAmelCase	:					int	=	image_processing(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						)
    self.assertEqual(
        encoding["""pixel_values"""].shape      ,     (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )
    self.assertEqual(
        encoding["""labels"""].shape      ,     (
            1,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )
    self.assertEqual(encoding["""labels"""].dtype      ,     torch.long						)
    self.assertTrue(encoding["""labels"""].min().item() >= 0						)
    self.assertTrue(encoding["""labels"""].max().item() <= 255						)

    # Test batched input (PIL images)
    UpperCAmelCase	,		UpperCAmelCase	:					List[str]	=	prepare_semantic_batch_inputs()

    UpperCAmelCase	:					Union[str, Any]	=	image_processing(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						)
    self.assertEqual(
        encoding["""pixel_values"""].shape      ,     (
            2,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )
    self.assertEqual(
        encoding["""labels"""].shape      ,     (
            2,
            self.image_processor_tester.crop_size["""height"""],
            self.image_processor_tester.crop_size["""width"""],
        )      ,     )
    self.assertEqual(encoding["""labels"""].dtype      ,     torch.long						)
    self.assertTrue(encoding["""labels"""].min().item() >= 0						)
    self.assertTrue(encoding["""labels"""].max().item() <= 255						)




   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	self.image_processing_class(**self.image_processor_dict						)

    # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
    UpperCAmelCase	,		UpperCAmelCase	:					Dict	=	prepare_semantic_single_inputs()
    UpperCAmelCase	:					Union[str, Any]	=	image_processing(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						)
    self.assertTrue(encoding["""labels"""].min().item() >= 0						)
    self.assertTrue(encoding["""labels"""].max().item() <= 150						)

    UpperCAmelCase	:					List[Any]	=	True
    UpperCAmelCase	:					Union[str, Any]	=	image_processing(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     return_tensors="""pt"""						)
    self.assertTrue(encoding["""labels"""].min().item() >= 0						)
    self.assertTrue(encoding["""labels"""].max().item() <= 255						)





"""simple docstring"""
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 (
    SwiftFormerConfig,
    SwiftFormerForImageClassification,
    ViTImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
A:   Optional[int]								=		logging.get_logger(__name__)

A:   Optional[int]								=		torch.device("cpu")

def       _snake_case						(						):
 UpperCAmelCase	:					List[Any]	=	"""http://images.cocodataset.org/val2017/000000039769.jpg"""
 UpperCAmelCase	:					Tuple	=	Image.open(requests.get(UpperCamelCase			,		stream=UpperCamelCase						).raw						)
 return im

def       _snake_case						(						UpperCamelCase						:		int						):
 if swiftformer_name == "swiftformer_xs":
  return torch.tensor([-2.1_7_0_3e0_0, 2.1_1_0_7e0_0, -2.0_8_1_1e0_0, 8.8_6_8_5e-0_1, 2.4_3_6_0e-0_1]						)

 elif swiftformer_name == "swiftformer_s":
  return torch.tensor([3.9_6_3_6e-0_1, 2.3_4_7_8e-0_1, -1.6_9_6_3e0_0, -1.7_3_8_1e0_0, -8.6_3_3_7e-0_1]						)

 elif swiftformer_name == "swiftformer_l1":
  return torch.tensor([-4.2_7_6_8e-0_1, -4.7_4_2_9e-0_1, -1.0_8_9_7e0_0, -1.0_2_4_8e0_0, 3.5_5_2_3e-0_2]						)

 elif swiftformer_name == "swiftformer_l3":
  return torch.tensor([-2.5_3_3_0e-0_1, 2.4_2_1_1e-0_1, -6.0_1_8_5e-0_1, -8.2_7_8_9e-0_1, -6.0_4_4_6e-0_2]						)

def       _snake_case						(						UpperCamelCase						:		Optional[Any]			,		UpperCamelCase						:		List[str]			,		UpperCamelCase						:		str						):
 UpperCAmelCase	:					int	=	dct.pop(UpperCamelCase						)
 UpperCAmelCase	:					Any	=	val

def       _snake_case						(						UpperCamelCase						:		Union[str, Any]						):
 UpperCAmelCase	:					Optional[int]	=	[]
 for k in state_dict.keys():
  UpperCAmelCase	:					Optional[Any]	=	k
  if ".pwconv" in k:
   UpperCAmelCase	:					int	=	k_new.replace(""".pwconv"""			,		""".point_wise_conv"""						)
  if ".dwconv" in k:
   UpperCAmelCase	:					Tuple	=	k_new.replace(""".dwconv"""			,		""".depth_wise_conv"""						)
  if ".Proj." in k:
   UpperCAmelCase	:					List[Any]	=	k_new.replace(""".Proj."""			,		""".proj."""						)
  if "patch_embed" in k_new:
   UpperCAmelCase	:					Any	=	k_new.replace("""patch_embed"""			,		"""swiftformer.patch_embed.patch_embedding"""						)
  if "network" in k_new:
   UpperCAmelCase	:					int	=	k_new.split("""."""						)
   if ls[2].isdigit():
    UpperCAmelCase	:					List[Any]	=	"""swiftformer.encoder.network.""" + ls[1] + """.blocks.""" + ls[2] + """.""" + """.""".join(ls[3:]						)
   else:
    UpperCAmelCase	:					Any	=	k_new.replace("""network"""			,		"""swiftformer.encoder.network"""						)
  rename_keys.append((k, k_new)						)
 return rename_keys

@torch.no_grad()
def       _snake_case						(						UpperCamelCase						:		int			,		UpperCamelCase						:		int			,		UpperCamelCase						:		Optional[int]						):
 UpperCAmelCase	:					List[Any]	=	SwiftFormerConfig()

 # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
 UpperCAmelCase	:					Optional[Any]	=	1000
 UpperCAmelCase	:					Tuple	=	"""huggingface/label-files"""
 UpperCAmelCase	:					List[str]	=	"""imagenet-1k-id2label.json"""
 UpperCAmelCase	:					Dict	=	json.load(open(hf_hub_download(UpperCamelCase			,		UpperCamelCase			,		repo_type="""dataset"""						)			,		"""r"""						)						)
 UpperCAmelCase	:					Dict	=	{int(UpperCamelCase						): v for k, v in idalabel.items()}
 UpperCAmelCase	:					str	=	idalabel
 UpperCAmelCase	:					Dict	=	{v: k for k, v in idalabel.items()}

 # size of the architecture
 if swiftformer_name == "swiftformer_xs":
  UpperCAmelCase	:					Any	=	[3, 3, 6, 4]
  UpperCAmelCase	:					List[str]	=	[48, 56, 112, 220]

 elif swiftformer_name == "swiftformer_s":
  UpperCAmelCase	:					Dict	=	[3, 3, 9, 6]
  UpperCAmelCase	:					Union[str, Any]	=	[48, 64, 168, 224]

 elif swiftformer_name == "swiftformer_l1":
  UpperCAmelCase	:					int	=	[4, 3, 10, 5]
  UpperCAmelCase	:					Optional[int]	=	[48, 96, 192, 384]

 elif swiftformer_name == "swiftformer_l3":
  UpperCAmelCase	:					Union[str, Any]	=	[4, 4, 12, 6]
  UpperCAmelCase	:					List[Any]	=	[64, 128, 320, 512]

 # load state_dict of original model, remove and rename some keys
 if original_ckpt:
  if original_ckpt.startswith("""https"""						):
   UpperCAmelCase	:					List[str]	=	torch.hub.load_state_dict_from_url(UpperCamelCase			,		map_location="""cpu"""			,		check_hash=UpperCamelCase						)
  else:
   UpperCAmelCase	:					Any	=	torch.load(UpperCamelCase			,		map_location="""cpu"""						)
 UpperCAmelCase	:					Optional[Any]	=	checkpoint

 UpperCAmelCase	:					Dict	=	create_rename_keys(UpperCamelCase						)
 for rename_key_src, rename_key_dest in rename_keys:
  rename_key(UpperCamelCase			,		UpperCamelCase			,		UpperCamelCase						)

 # load HuggingFace model
 UpperCAmelCase	:					List[Any]	=	SwiftFormerForImageClassification(UpperCamelCase						).eval()
 hf_model.load_state_dict(UpperCamelCase						)

 # prepare test inputs
 UpperCAmelCase	:					Dict	=	prepare_img()
 UpperCAmelCase	:					Tuple	=	ViTImageProcessor.from_pretrained("""preprocessor_config"""						)
 UpperCAmelCase	:					Optional[int]	=	processor(images=UpperCamelCase			,		return_tensors="""pt"""						)

 # compare outputs from both models
 UpperCAmelCase	:					Optional[int]	=	get_expected_output(UpperCamelCase						)
 UpperCAmelCase	:					List[str]	=	hf_model(inputs["""pixel_values"""]						).logits

 assert hf_logits.shape == torch.Size([1, 1000]						)
 assert torch.allclose(hf_logits[0, 0:5]			,		UpperCamelCase			,		atol=1e-3						)

 Path(UpperCamelCase						).mkdir(exist_ok=UpperCamelCase						)
 print(F"Saving model {swiftformer_name} to {pytorch_dump_folder_path}"						)
 hf_model.save_pretrained(UpperCamelCase						)


if __name__ == "__main__":
      A:   List[str]								=		argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          "--swiftformer_name",
          default="swiftformer_xs",
          choices=["swiftformer_xs", "swiftformer_s", "swiftformer_l1", "swiftformer_l3"],
          type=str,
          help="Name of the SwiftFormer model you'd like to convert.",
      )
      parser.add_argument(
          "--pytorch_dump_folder_path",
          default="./converted_outputs/",
          type=str,
          help="Path to the output PyTorch model directory.",
      )
      parser.add_argument("--original_ckpt", default=None, type=str, help="Path to the original model checkpoint.")

      A:   str								=		parser.parse_args()
      convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)
