

import pickle

import numpy as np
from matplotlib import pyplot as plt



class       __snake_case  :

		def __init__(					self						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A=0.2						,		_A=0.2):
						SCREAMING_SNAKE_CASE_									=						bp_numa
						SCREAMING_SNAKE_CASE_									=						bp_numa
						SCREAMING_SNAKE_CASE_									=						bp_numa
						SCREAMING_SNAKE_CASE_									=						conva_get[:2]
						SCREAMING_SNAKE_CASE_									=						conva_get[2]
						SCREAMING_SNAKE_CASE_									=						size_pa
						SCREAMING_SNAKE_CASE_									=						rate_w
						SCREAMING_SNAKE_CASE_									=						rate_t
						SCREAMING_SNAKE_CASE_									=						[
						    np.mat(-1 * np.random.rand(self.conva[0]						,		self.conva[0]) + 0.5)
						    for i in range(self.conva[1])
						]
						SCREAMING_SNAKE_CASE_									=						np.mat(-1 * np.random.rand(self.num_bpa						,		self.num_bpa) + 0.5)
						SCREAMING_SNAKE_CASE_									=						np.mat(-1 * np.random.rand(self.num_bpa						,		self.num_bpa) + 0.5)
						SCREAMING_SNAKE_CASE_									=						-2 * np.random.rand(self.conva[1]) + 1
						SCREAMING_SNAKE_CASE_									=						-2 * np.random.rand(self.num_bpa) + 1
						SCREAMING_SNAKE_CASE_									=						-2 * np.random.rand(self.num_bpa) + 1

		def 						lowerCAmelCase__     (					self						,		_A):
						# save model dict with pickle
						SCREAMING_SNAKE_CASE_									=						{
						    'num_bp1': self.num_bpa,
						    'num_bp2': self.num_bpa,
						    'num_bp3': self.num_bpa,
						    'conv1': self.conva,
						    'step_conv1': self.step_conva,
						    'size_pooling1': self.size_poolinga,
						    'rate_weight': self.rate_weight,
						    'rate_thre': self.rate_thre,
						    'w_conv1': self.w_conva,
						    'wkj': self.wkj,
						    'vji': self.vji,
						    'thre_conv1': self.thre_conva,
						    'thre_bp2': self.thre_bpa,
						    'thre_bp3': self.thre_bpa,
						}
						with open(_A						,		'wb') as f:
										pickle.dump(_A						,		_A)

						print(f"""Model saved： {save_path}""")

		@classmethod
		def 						lowerCAmelCase__     (					cls						,		_A):
						# read saved model
						with open(_A						,		'rb') as f:
										SCREAMING_SNAKE_CASE_									=						pickle.load(_A)  # noqa: S301

						SCREAMING_SNAKE_CASE_									=						model_dic.get('conv1')
						conv_get.append(model_dic.get('step_conv1'))
						SCREAMING_SNAKE_CASE_									=						model_dic.get('size_pooling1')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('num_bp1')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('num_bp2')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('num_bp3')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('rate_weight')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('rate_thre')
						# create model instance
						SCREAMING_SNAKE_CASE_									=						CNN(_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A)
						# modify model parameter
						SCREAMING_SNAKE_CASE_									=						model_dic.get('w_conv1')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('wkj')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('vji')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('thre_conv1')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('thre_bp2')
						SCREAMING_SNAKE_CASE_									=						model_dic.get('thre_bp3')
						return conv_ins

		def 						lowerCAmelCase__     (					self						,		_A):
						return 1 / (1 + np.exp(-1 * x))

		def 						lowerCAmelCase__     (					self						,		_A):
						return round(_A						,		3)

		def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A						,		_A):
						# convolution process
						SCREAMING_SNAKE_CASE_									=						convs[0]
						SCREAMING_SNAKE_CASE_									=						convs[1]
						SCREAMING_SNAKE_CASE_									=						np.shape(_A)[0]
						# get the data slice of original image data, data_focus
						SCREAMING_SNAKE_CASE_									=						[]
						for i_focus in range(0						,		size_data - size_conv + 1						,		_A):
										for j_focus in range(0						,		size_data - size_conv + 1						,		_A):
														SCREAMING_SNAKE_CASE_									=						data[
														    i_focus : i_focus + size_conv, j_focus : j_focus + size_conv
														]
														data_focus.append(_A)
        # calculate the feature map of every single kernel, and saved as list of matrix
						SCREAMING_SNAKE_CASE_									=						[]
						SCREAMING_SNAKE_CASE_									=						int((size_data - size_conv) / conv_step + 1)
						for i_map in range(_A):
										SCREAMING_SNAKE_CASE_									=						[]
										for i_focus in range(len(_A)):
														SCREAMING_SNAKE_CASE_									=						(
														    np.sum(np.multiply(data_focus[i_focus]						,		w_convs[i_map]))
														    - thre_convs[i_map]
														)
														featuremap.append(self.sig(_A))
										SCREAMING_SNAKE_CASE_									=						np.asmatrix(_A).reshape(
										    _A						,		_A)
										data_featuremap.append(_A)

						# expanding the data slice to One dimenssion
						SCREAMING_SNAKE_CASE_									=						[]
						for each_focus in data_focus:
										focusa_list.extend(self.Expand_Mat(_A))
						SCREAMING_SNAKE_CASE_									=						np.asarray(_A)
						return focus_list, data_featuremap

		def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A="average_pool"):
						# pooling process
						SCREAMING_SNAKE_CASE_									=						len(featuremaps[0])
						SCREAMING_SNAKE_CASE_									=						int(size_map / size_pooling)
						SCREAMING_SNAKE_CASE_									=						[]
						for i_map in range(len(_A)):
										SCREAMING_SNAKE_CASE_									=						featuremaps[i_map]
										SCREAMING_SNAKE_CASE_									=						[]
										for i_focus in range(0						,		_A						,		_A):
														for j_focus in range(0						,		_A						,		_A):
																		SCREAMING_SNAKE_CASE_									=						feature_map[
																		    i_focus : i_focus + size_pooling,
																		    j_focus : j_focus + size_pooling,
																		]
																		if pooling_type == "average_pool":
																						# average pooling
																						map_pooled.append(np.average(_A))
																		elif pooling_type == "max_pooling":
																						# max pooling
																						map_pooled.append(np.max(_A))
										SCREAMING_SNAKE_CASE_									=						np.asmatrix(_A).reshape(_A						,		_A)
										featuremap_pooled.append(_A)
						return featuremap_pooled

		def 						lowerCAmelCase__     (					self						,		_A):
						# expanding three dimension data to one dimension list
						SCREAMING_SNAKE_CASE_									=						[]
						for i in range(len(_A)):
										SCREAMING_SNAKE_CASE_									=						np.shape(data[i])
										SCREAMING_SNAKE_CASE_									=						data[i].reshape(1						,		shapes[0] * shapes[1])
										SCREAMING_SNAKE_CASE_									=						data_listed.getA().tolist()[0]
										data_expanded.extend(_A)
						SCREAMING_SNAKE_CASE_									=						np.asarray(_A)
						return data_expanded

		def 						lowerCAmelCase__     (					self						,		_A):
						# expanding matrix to one dimension list
						SCREAMING_SNAKE_CASE_									=						np.asarray(_A)
						SCREAMING_SNAKE_CASE_									=						np.shape(_A)
						SCREAMING_SNAKE_CASE_									=						data_mat.reshape(1						,		shapes[0] * shapes[1])
						return data_expanded

		def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A						,		_A):
						SCREAMING_SNAKE_CASE_									=						[]
						SCREAMING_SNAKE_CASE_									=						0
						for i_map in range(_A):
										SCREAMING_SNAKE_CASE_									=						np.ones((size_map, size_map))
										for i in range(0						,		_A						,		_A):
														for j in range(0						,		_A						,		_A):
																		SCREAMING_SNAKE_CASE_									=						pd_pool[
																		    i_pool
																		]
																		SCREAMING_SNAKE_CASE_									=						i_pool + 1
										SCREAMING_SNAKE_CASE_									=						np.multiply(
										    _A						,		np.multiply(out_map[i_map]						,		(1 - out_map[i_map])))
										pd_all.append(_A)
						return pd_all

		def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A=bool):
						# model traning
						print('----------------------Start Training-------------------------')
						print((' - - Shape: Train_Data  ', np.shape(_A)))
						print((' - - Shape: Teach_Data  ', np.shape(_A)))
						SCREAMING_SNAKE_CASE_									=						0
						SCREAMING_SNAKE_CASE_									=						[]
						SCREAMING_SNAKE_CASE_									=						10000
						while rp < n_repeat and mse >= error_accuracy:
										SCREAMING_SNAKE_CASE_									=						0
										print(f"""-------------Learning Time {rp}--------------""")
										for p in range(len(_A)):
														# print('------------Learning Image: %d--------------'%p)
														SCREAMING_SNAKE_CASE_									=						np.asmatrix(datas_train[p])
														SCREAMING_SNAKE_CASE_									=						np.asarray(datas_teach[p])
														SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.convolute(
														    _A						,		self.conva						,		self.w_conva						,		self.thre_conva						,		conv_step=self.step_conva						,		)
														SCREAMING_SNAKE_CASE_									=						self.pooling(_A						,		self.size_poolinga)
														SCREAMING_SNAKE_CASE_									=						np.shape(_A)
														SCREAMING_SNAKE_CASE_									=						self._expand(_A)
														SCREAMING_SNAKE_CASE_									=						data_bp_input

														SCREAMING_SNAKE_CASE_									=						np.dot(_A						,		self.vji.T) - self.thre_bpa
														SCREAMING_SNAKE_CASE_									=						self.sig(_A)
														SCREAMING_SNAKE_CASE_									=						np.dot(_A						,		self.wkj.T) - self.thre_bpa
														SCREAMING_SNAKE_CASE_									=						self.sig(_A)

														# --------------Model Leaning ------------------------
														# calculate error and gradient---------------
														SCREAMING_SNAKE_CASE_									=						np.multiply(
														    (data_teach - bp_outa)						,		np.multiply(_A						,		(1 - bp_outa)))
														SCREAMING_SNAKE_CASE_									=						np.multiply(
														    np.dot(_A						,		self.wkj)						,		np.multiply(_A						,		(1 - bp_outa)))
														SCREAMING_SNAKE_CASE_									=						np.dot(_A						,		self.vji)

														SCREAMING_SNAKE_CASE_									=						pd_i_all / (self.size_poolinga * self.size_poolinga)
														SCREAMING_SNAKE_CASE_									=						pd_conva_pooled.T.getA().tolist()
														SCREAMING_SNAKE_CASE_									=						self._calculate_gradient_from_pool(
														    _A						,		_A						,		shape_featuremapa[0]						,		shape_featuremapa[1]						,		self.size_poolinga						,		)
														# weight and threshold learning process---------
														# convolution layer
														for k_conv in range(self.conva[1]):
																		SCREAMING_SNAKE_CASE_									=						self._expand_mat(pd_conva_all[k_conv])
																		SCREAMING_SNAKE_CASE_									=						self.rate_weight * np.dot(_A						,		_A)

																		SCREAMING_SNAKE_CASE_									=						self.w_conva[k_conv] + delta_w.reshape(
																		    (self.conva[0], self.conva[0]))

																		SCREAMING_SNAKE_CASE_									=						(
																		    self.thre_conva[k_conv]
																		    - np.sum(pd_conva_all[k_conv]) * self.rate_thre
																		)
														# all connected layer
														SCREAMING_SNAKE_CASE_									=						self.wkj + pd_k_all.T * bp_outa * self.rate_weight
														SCREAMING_SNAKE_CASE_									=						self.vji + pd_j_all.T * bp_outa * self.rate_weight
														SCREAMING_SNAKE_CASE_									=						self.thre_bpa - pd_k_all * self.rate_thre
														SCREAMING_SNAKE_CASE_									=						self.thre_bpa - pd_j_all * self.rate_thre
														# calculate the sum error of all single image
														SCREAMING_SNAKE_CASE_									=						np.sum(abs(data_teach - bp_outa))
														error_count += errors
														# print('   ----Teach      ',data_teach)
														# print('   ----BP_output  ',bp_out3)
										SCREAMING_SNAKE_CASE_									=						rp + 1
										SCREAMING_SNAKE_CASE_									=						error_count / patterns
										all_mse.append(_A)

						def draw_error():
										SCREAMING_SNAKE_CASE_									=						[error_accuracy for i in range(int(n_repeat * 1.2))]
										plt.plot(_A						,		'+-')
										plt.plot(_A						,		'r--')
										plt.xlabel('Learning Times')
										plt.ylabel('All_mse')
										plt.grid(_A						,		alpha=0.5)
										plt.show()

						print('------------------Training Complished---------------------')
						print((' - - Training epoch: ', rp, f"""     - - Mse: {mse:.6f}"""))
						if draw_e:
										draw_error()
						return mse

		def 						lowerCAmelCase__     (					self						,		_A):
						# model predict
						SCREAMING_SNAKE_CASE_									=						[]
						print('-------------------Start Testing-------------------------')
						print((' - - Shape: Test_Data  ', np.shape(_A)))
						for p in range(len(_A)):
										SCREAMING_SNAKE_CASE_									=						np.asmatrix(datas_test[p])
										SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.convolute(
										    _A						,		self.conva						,		self.w_conva						,		self.thre_conva						,		conv_step=self.step_conva						,		)
										SCREAMING_SNAKE_CASE_									=						self.pooling(_A						,		self.size_poolinga)
										SCREAMING_SNAKE_CASE_									=						self._expand(_A)

										SCREAMING_SNAKE_CASE_									=						data_bp_input
										SCREAMING_SNAKE_CASE_									=						bp_outa * self.vji.T - self.thre_bpa
										SCREAMING_SNAKE_CASE_									=						self.sig(_A)
										SCREAMING_SNAKE_CASE_									=						bp_outa * self.wkj.T - self.thre_bpa
										SCREAMING_SNAKE_CASE_									=						self.sig(_A)
										produce_out.extend(bp_outa.getA().tolist())
						SCREAMING_SNAKE_CASE_									=						[list(map(self.do_round						,		_A)) for each in produce_out]
						return np.asarray(_A)


		def 						lowerCAmelCase__     (					self						,		_A):
						# return the data of image after convoluting process so we can check it out
						SCREAMING_SNAKE_CASE_									=						np.asmatrix(_A)
						SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.convolute(
						    _A						,		self.conva						,		self.w_conva						,		self.thre_conva						,		conv_step=self.step_conva						,		)
						SCREAMING_SNAKE_CASE_									=						self.pooling(_A						,		self.size_poolinga)

						return data_conveda, data_pooleda


if __name__ == "__main__":
							pass





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()
UpperCamelCase__  :      Optional[int]			=    logging.get_logger(__name__)

UpperCamelCase__  :      List[Any]			=    torch.device("cpu")


def 					_UpperCAmelCase       (  ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						'http://images.cocodataset.org/val2017/000000039769.jpg'
    SCREAMING_SNAKE_CASE_									=						Image.open(requests.get(_SCREAMING_SNAKE_CASE ,   stream=_SCREAMING_SNAKE_CASE       ).raw       )
    return im


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		int       ):





    """simple docstring"""


    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 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Optional[int] ,   _SCREAMING_SNAKE_CASE					:		Union[str, Any] ,   _SCREAMING_SNAKE_CASE					:		Optional[Any]       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						dct.pop(_SCREAMING_SNAKE_CASE       )
    SCREAMING_SNAKE_CASE_									=						val


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Dict       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						[]
    for k in state_dict.keys():
        SCREAMING_SNAKE_CASE_									=						k
        if ".pwconv" in k:
            SCREAMING_SNAKE_CASE_									=						k_new.replace('.pwconv' ,   '.point_wise_conv'       )
        if ".dwconv" in k:
            SCREAMING_SNAKE_CASE_									=						k_new.replace('.dwconv' ,   '.depth_wise_conv'       )
        if ".Proj." in k:
            SCREAMING_SNAKE_CASE_									=						k_new.replace('.Proj.' ,   '.proj.'       )
        if "patch_embed" in k_new:
            SCREAMING_SNAKE_CASE_									=						k_new.replace('patch_embed' ,   'swiftformer.patch_embed.patch_embedding'       )
        if "network" in k_new:
            SCREAMING_SNAKE_CASE_									=						k_new.split('.'       )
            if ls[2].isdigit():
                SCREAMING_SNAKE_CASE_									=						'swiftformer.encoder.network.' + ls[1] + '.blocks.' + ls[2] + '.' + '.'.join(ls[3:]       )
            else:
                SCREAMING_SNAKE_CASE_									=						k_new.replace('network' ,   'swiftformer.encoder.network'       )
        rename_keys.append((k, k_new)       )
    return rename_keys


@torch.no_grad()
def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		Optional[Any] ,   _SCREAMING_SNAKE_CASE					:		str ,   _SCREAMING_SNAKE_CASE					:		Optional[Any]       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						SwiftFormerConfig()

    # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
    SCREAMING_SNAKE_CASE_									=						1_000
    SCREAMING_SNAKE_CASE_									=						'huggingface/label-files'
    SCREAMING_SNAKE_CASE_									=						'imagenet-1k-id2label.json'
    SCREAMING_SNAKE_CASE_									=						json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE ,   _SCREAMING_SNAKE_CASE ,   repo_type='dataset'       ) ,   'r'       )       )
    SCREAMING_SNAKE_CASE_									=						{int(_SCREAMING_SNAKE_CASE       ): v for k, v in idalabel.items()}
    SCREAMING_SNAKE_CASE_									=						idalabel
    SCREAMING_SNAKE_CASE_									=						{v: k for k, v in idalabel.items()}

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

    elif swiftformer_name == "swiftformer_s":
        SCREAMING_SNAKE_CASE_									=						[3, 3, 9, 6]
        SCREAMING_SNAKE_CASE_									=						[48, 64, 168, 224]

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

    elif swiftformer_name == "swiftformer_l3":
        SCREAMING_SNAKE_CASE_									=						[4, 4, 12, 6]
        SCREAMING_SNAKE_CASE_									=						[64, 128, 320, 512]

    # load state_dict of original model, remove and rename some keys
    if original_ckpt:
        if original_ckpt.startswith('https'       ):
            SCREAMING_SNAKE_CASE_									=						torch.hub.load_state_dict_from_url(_SCREAMING_SNAKE_CASE ,   map_location='cpu' ,   check_hash=_SCREAMING_SNAKE_CASE       )
        else:
            SCREAMING_SNAKE_CASE_									=						torch.load(_SCREAMING_SNAKE_CASE ,   map_location='cpu'       )
    SCREAMING_SNAKE_CASE_									=						checkpoint

    SCREAMING_SNAKE_CASE_									=						create_rename_keys(_SCREAMING_SNAKE_CASE       )
    for rename_key_src, rename_key_dest in rename_keys:
        rename_key(_SCREAMING_SNAKE_CASE ,   _SCREAMING_SNAKE_CASE ,   _SCREAMING_SNAKE_CASE       )

    # load HuggingFace model
    SCREAMING_SNAKE_CASE_									=						SwiftFormerForImageClassification(_SCREAMING_SNAKE_CASE       ).eval()
    hf_model.load_state_dict(_SCREAMING_SNAKE_CASE       )

    # prepare test inputs
    SCREAMING_SNAKE_CASE_									=						prepare_img()
    SCREAMING_SNAKE_CASE_									=						ViTImageProcessor.from_pretrained('preprocessor_config'       )
    SCREAMING_SNAKE_CASE_									=						processor(images=_SCREAMING_SNAKE_CASE ,   return_tensors='pt'       )

    # compare outputs from both models
    SCREAMING_SNAKE_CASE_									=						get_expected_output(_SCREAMING_SNAKE_CASE       )
    SCREAMING_SNAKE_CASE_									=						hf_model(inputs['pixel_values']       ).logits

    assert hf_logits.shape == torch.Size([1, 1_000]       )
    assert torch.allclose(hf_logits[0, 0:5] ,   _SCREAMING_SNAKE_CASE ,   atol=1E-3       )

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


if __name__ == "__main__":
       UpperCamelCase__  :      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.")

       UpperCamelCase__  :      Union[str, Any]			=    parser.parse_args()
       convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)


