



"""simple docstring"""
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import (
          OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
          OpenAIGPTConfig,
          OpenAIGPTDoubleHeadsModel,
          OpenAIGPTForSequenceClassification,
          OpenAIGPTLMHeadModel,
          OpenAIGPTModel,
      )



class       SCREAMING_SNAKE_CASE__  :

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=13      ,     _SCREAMING_SNAKE_CASE=7      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=99      ,     _SCREAMING_SNAKE_CASE=32      ,     _SCREAMING_SNAKE_CASE=5      ,     _SCREAMING_SNAKE_CASE=4      ,     _SCREAMING_SNAKE_CASE=37      ,     _SCREAMING_SNAKE_CASE="gelu"      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=512      ,     _SCREAMING_SNAKE_CASE=16      ,     _SCREAMING_SNAKE_CASE=2      ,     _SCREAMING_SNAKE_CASE=0.02      ,     _SCREAMING_SNAKE_CASE=3      ,     _SCREAMING_SNAKE_CASE=4      ,     _SCREAMING_SNAKE_CASE=None      ,     )  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	parent
    UpperCAmelCase	:					Tuple	=	batch_size
    UpperCAmelCase	:					Optional[int]	=	seq_length
    UpperCAmelCase	:					int	=	is_training
    UpperCAmelCase	:					str	=	use_token_type_ids
    UpperCAmelCase	:					Optional[int]	=	use_labels
    UpperCAmelCase	:					List[Any]	=	vocab_size
    UpperCAmelCase	:					Optional[Any]	=	hidden_size
    UpperCAmelCase	:					Optional[Any]	=	num_hidden_layers
    UpperCAmelCase	:					int	=	num_attention_heads
    UpperCAmelCase	:					List[Any]	=	intermediate_size
    UpperCAmelCase	:					int	=	hidden_act
    UpperCAmelCase	:					Dict	=	hidden_dropout_prob
    UpperCAmelCase	:					List[Any]	=	attention_probs_dropout_prob
    UpperCAmelCase	:					Optional[int]	=	max_position_embeddings
    UpperCAmelCase	:					int	=	type_vocab_size
    UpperCAmelCase	:					Any	=	type_sequence_label_size
    UpperCAmelCase	:					Optional[Any]	=	initializer_range
    UpperCAmelCase	:					Union[str, Any]	=	num_labels
    UpperCAmelCase	:					Any	=	num_choices
    UpperCAmelCase	:					str	=	scope
    UpperCAmelCase	:					str	=	self.vocab_size - 1

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





    '''simple docstring'''




    UpperCAmelCase	:					str	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.vocab_size						)

    UpperCAmelCase	:					Any	=	None
    if self.use_token_type_ids:
     UpperCAmelCase	:					Union[str, Any]	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.type_vocab_size						)

    UpperCAmelCase	:					Union[str, Any]	=	None
    UpperCAmelCase	:					Dict	=	None
    UpperCAmelCase	:					Tuple	=	None
    if self.use_labels:
     UpperCAmelCase	:					Any	=	ids_tensor([self.batch_size]      ,     self.type_sequence_label_size						)
     UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size, self.seq_length]      ,     self.num_labels						)
     UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size]      ,     self.num_choices						)

    UpperCAmelCase	:					Union[str, Any]	=	OpenAIGPTConfig(
        vocab_size=self.vocab_size      ,     n_embd=self.hidden_size      ,     n_layer=self.num_hidden_layers      ,     n_head=self.num_attention_heads      ,     n_positions=self.max_position_embeddings      ,     pad_token_id=self.pad_token_id      ,     )

    UpperCAmelCase	:					str	=	ids_tensor([self.num_hidden_layers, self.num_attention_heads]      ,     2						)

    return (
        config,
        input_ids,
        head_mask,
        token_type_ids,
        sequence_labels,
        token_labels,
        choice_labels,
    )

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	OpenAIGPTModel(config=_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					List[str]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     head_mask=_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					List[Any]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Tuple	=	model(_SCREAMING_SNAKE_CASE						)

    self.parent.assertEqual(result.last_hidden_state.shape      ,     (self.batch_size, self.seq_length, self.hidden_size)						)

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





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	OpenAIGPTLMHeadModel(_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					Dict	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     labels=_SCREAMING_SNAKE_CASE						)
    self.parent.assertEqual(result.loss.shape      ,     ()						)
    self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.seq_length, self.vocab_size)						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      Dict:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	OpenAIGPTDoubleHeadsModel(_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					Optional[int]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     labels=_SCREAMING_SNAKE_CASE						)
    self.parent.assertEqual(result.loss.shape      ,     ()						)
    self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.seq_length, self.vocab_size)						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     *_SCREAMING_SNAKE_CASE						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	self.num_labels
    UpperCAmelCase	:					Optional[int]	=	OpenAIGPTForSequenceClassification(_SCREAMING_SNAKE_CASE						)
    model.to(_SCREAMING_SNAKE_CASE						)
    model.eval()

    UpperCAmelCase	:					Tuple	=	ids_tensor([self.batch_size]      ,     self.type_sequence_label_size						)
    UpperCAmelCase	:					Optional[int]	=	model(_SCREAMING_SNAKE_CASE      ,     token_type_ids=_SCREAMING_SNAKE_CASE      ,     labels=_SCREAMING_SNAKE_CASE						)
    self.parent.assertEqual(result.logits.shape      ,     (self.batch_size, self.num_labels)						)




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





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.prepare_config_and_inputs()
    (
        (
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		(
        UpperCAmelCase
    )	,		
    )	:					Any	=	config_and_inputs
    UpperCAmelCase	:					Dict	=	{
        """input_ids""": input_ids,
        """token_type_ids""": token_type_ids,
        """head_mask""": head_mask,
    }

    return config, inputs_dict



@require_torch
class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__      ,			UpperCAmelCase__      ,			UpperCAmelCase__      ,			unittest.TestCase ):
   __lowerCAmelCase  :   Union[str, Any]						=						(
       (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
       if is_torch_available()
       else ()
   )
   __lowerCAmelCase  :   Union[str, Any]						=						(
       (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
   )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
   __lowerCAmelCase  :   int						=						(
       {
           'feature-extraction': OpenAIGPTModel,
           'text-classification': OpenAIGPTForSequenceClassification,
           'text-generation': OpenAIGPTLMHeadModel,
           'zero-shot': OpenAIGPTForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )

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





    '''simple docstring'''




    if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
     # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
     # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
     # tiny config could not be created.
     return True

    return False

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=False						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	super()._prepare_for_class(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     return_labels=_SCREAMING_SNAKE_CASE						)

    if return_labels:
     if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
      UpperCAmelCase	:					Union[str, Any]	=	torch.zeros(
          (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)      ,     dtype=torch.long      ,     device=_SCREAMING_SNAKE_CASE      ,     )
      UpperCAmelCase	:					str	=	inputs_dict["""labels"""]
      UpperCAmelCase	:					List[Any]	=	inputs_dict["""labels"""]
      UpperCAmelCase	:					Union[str, Any]	=	torch.zeros(
          (self.model_tester.batch_size, self.model_tester.num_choices)      ,     dtype=torch.long      ,     device=_SCREAMING_SNAKE_CASE      ,     )
      UpperCAmelCase	:					str	=	torch.zeros(
          self.model_tester.batch_size      ,     dtype=torch.long      ,     device=_SCREAMING_SNAKE_CASE						)
    return inputs_dict

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





    '''simple docstring'''




    UpperCAmelCase	:					str	=	OpenAIGPTModelTester(self						)
    UpperCAmelCase	:					Any	=	ConfigTester(self      ,     config_class=_SCREAMING_SNAKE_CASE      ,     n_embd=37						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    self.config_tester.run_common_tests()

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      int:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_openai_gpt_model(*_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_lm_head_model(*_SCREAMING_SNAKE_CASE						)

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





    '''simple docstring'''




    UpperCAmelCase	:					List[str]	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_double_lm_head_model(*_SCREAMING_SNAKE_CASE						)

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





    '''simple docstring'''




    UpperCAmelCase	:					int	=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_SCREAMING_SNAKE_CASE						)




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





    '''simple docstring'''




    for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     UpperCAmelCase	:					Optional[Any]	=	OpenAIGPTModel.from_pretrained(_SCREAMING_SNAKE_CASE						)
     self.assertIsNotNone(_SCREAMING_SNAKE_CASE						)



@require_torch
class       SCREAMING_SNAKE_CASE__  (					unittest.TestCase ):

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





    '''simple docstring'''




    UpperCAmelCase	:					Union[str, Any]	=	OpenAIGPTLMHeadModel.from_pretrained("""openai-gpt"""						)
    model.to(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Dict	=	torch.tensor([[481, 4735, 544]]      ,     dtype=torch.long      ,     device=_SCREAMING_SNAKE_CASE						)  # the president is
    UpperCAmelCase	:					Optional[int]	=	[
        481,
        4735,
        544,
        246,
        963,
        870,
        762,
        239,
        244,
        40477,
        244,
        249,
        719,
        881,
        487,
        544,
        240,
        244,
        603,
        481,
    ]  # the president is a very good man. " \n " i\'m sure he is, " said the

    UpperCAmelCase	:					List[Any]	=	model.generate(_SCREAMING_SNAKE_CASE      ,     do_sample=_SCREAMING_SNAKE_CASE						)
    self.assertListEqual(output_ids[0].tolist()      ,     _SCREAMING_SNAKE_CASE						)





"""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)
