



import argparse
import json

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

from transformers import SegformerImageProcessor, SwinConfig, UperNetConfig, UperNetForSemanticSegmentation



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			3_8_4
	__lowercase		       =			7
	if "tiny" in model_name:
		__lowercase		       =			9_6
		__lowercase		       =			(2, 2, 6, 2)
		__lowercase		       =			(3, 6, 1_2, 2_4)
	elif "small" in model_name:
		__lowercase		       =			9_6
		__lowercase		       =			(2, 2, 1_8, 2)
		__lowercase		       =			(3, 6, 1_2, 2_4)
	elif "base" in model_name:
		__lowercase		       =			1_2_8
		__lowercase		       =			(2, 2, 1_8, 2)
		__lowercase		       =			(4, 8, 1_6, 3_2)
		__lowercase		       =			1_2
		__lowercase		       =			5_1_2
	elif "large" in model_name:
		__lowercase		       =			1_9_2
		__lowercase		       =			(2, 2, 1_8, 2)
		__lowercase		       =			(6, 1_2, 2_4, 4_8)
		__lowercase		       =			1_2
		__lowercase		       =			7_6_8

	# set label information
	__lowercase		       =			1_5_0
	__lowercase		       =			'huggingface/label-files'
	__lowercase		       =			'ade20k-id2label.json'
	__lowercase		       =			json.load(open(hf_hub_download(lowerCAmelCase__  ,	lowerCAmelCase__  ,	repo_type="dataset"   )  ,	"r"   )   )
	__lowercase		       =			{int(lowerCAmelCase__   ): v for k, v in idalabel.items()}
	__lowercase		       =			{v: k for k, v in idalabel.items()}

	__lowercase		       =			SwinConfig(
	    embed_dim=lowerCAmelCase__  ,	depths=lowerCAmelCase__  ,	num_heads=lowerCAmelCase__  ,	window_size=lowerCAmelCase__  ,	out_features=["stage1", "stage2", "stage3", "stage4"]  ,	)
	__lowercase		       =			UperNetConfig(
	    backbone_config=lowerCAmelCase__  ,	auxiliary_in_channels=lowerCAmelCase__  ,	num_labels=lowerCAmelCase__  ,	idalabel=lowerCAmelCase__  ,	labelaid=lowerCAmelCase__  ,	)

	return config



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			[]

	# fmt: off
	# stem
	rename_keys.append(("backbone.patch_embed.projection.weight", "backbone.embeddings.patch_embeddings.projection.weight")   )
	rename_keys.append(("backbone.patch_embed.projection.bias", "backbone.embeddings.patch_embeddings.projection.bias")   )
	rename_keys.append(("backbone.patch_embed.norm.weight", "backbone.embeddings.norm.weight")   )
	rename_keys.append(("backbone.patch_embed.norm.bias", "backbone.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.stages.{i}.blocks.{j}.norm1.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm1.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_bias_table""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_index""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm2.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm2.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.weight""")   )
			rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.bias""")   )

		if i < 3:
			rename_keys.append((F"""backbone.stages.{i}.downsample.reduction.weight""", F"""backbone.encoder.layers.{i}.downsample.reduction.weight""")   )
			rename_keys.append((F"""backbone.stages.{i}.downsample.norm.weight""", F"""backbone.encoder.layers.{i}.downsample.norm.weight""")   )
			rename_keys.append((F"""backbone.stages.{i}.downsample.norm.bias""", F"""backbone.encoder.layers.{i}.downsample.norm.bias""")   )
		rename_keys.append((F"""backbone.norm{i}.weight""", F"""backbone.hidden_states_norms.stage{i+1}.weight""")   )
		rename_keys.append((F"""backbone.norm{i}.bias""", F"""backbone.hidden_states_norms.stage{i+1}.bias""")   )

	# decode head
	rename_keys.extend(
	    [
	        ("decode_head.conv_seg.weight", "decode_head.classifier.weight"),
	        ("decode_head.conv_seg.bias", "decode_head.classifier.bias"),
	        ("auxiliary_head.conv_seg.weight", "auxiliary_head.classifier.weight"),
	        ("auxiliary_head.conv_seg.bias", "auxiliary_head.classifier.bias"),
	    ]   )
	# fmt: on

	return rename_keys



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			dct.pop(lowerCAmelCase__   )
	__lowercase		       =			val



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			[int(backbone_config.embed_dim * 2**i   ) for i in range(len(backbone_config.depths   )   )]
	for i in range(len(backbone_config.depths   )   ):
		__lowercase		       =			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)
			__lowercase		       =			state_dict.pop(F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight"""   )
			__lowercase		       =			state_dict.pop(F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.bias"""   )
			# next, add query, keys and values (in that order) to the state dict
			__lowercase		       =			in_proj_weight[:dim, :]
			__lowercase		       =			in_proj_bias[: dim]
			__lowercase		       =			in_proj_weight[
			    dim : dim * 2, :
			]
			__lowercase		       =			in_proj_bias[
			    dim : dim * 2
			]
			__lowercase		       =			in_proj_weight[
			    -dim :, :
			]
			__lowercase		       =			in_proj_bias[-dim :]
			# fmt: on



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			x.shape
	__lowercase		       =			x.reshape(lowerCAmelCase__  ,	4  ,	in_channel // 4   )
	__lowercase		       =			x[:, [0, 2, 1, 3], :].transpose(1  ,	2   ).reshape(lowerCAmelCase__  ,	lowerCAmelCase__   )
	return x



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			x.shape
	__lowercase		       =			x.reshape(lowerCAmelCase__  ,	in_channel // 4  ,	4   )
	__lowercase		       =			x[:, :, [0, 2, 1, 3]].transpose(1  ,	2   ).reshape(lowerCAmelCase__  ,	lowerCAmelCase__   )

	return x



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			x.shape[0]
	__lowercase		       =			x.reshape(4  ,	in_channel // 4   )
	__lowercase		       =			x[[0, 2, 1, 3], :].transpose(0  ,	1   ).reshape(lowerCAmelCase__   )
	return x



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			x.shape[0]
	__lowercase		       =			x.reshape(in_channel // 4  ,	4   )
	__lowercase		       =			x[:, [0, 2, 1, 3]].transpose(0  ,	1   ).reshape(lowerCAmelCase__   )
	return x



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			{
	    'upernet-swin-tiny': 'https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth',
	    'upernet-swin-small': 'https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth',
	    'upernet-swin-base': 'https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth',
	    'upernet-swin-large': 'https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k_20220318_091743-9ba68901.pth',
	}
	__lowercase		       =			model_name_to_url[model_name]
	__lowercase		       =			torch.hub.load_state_dict_from_url(lowerCAmelCase__  ,	map_location="cpu"  ,	file_name=lowerCAmelCase__   )[
	    'state_dict'
	]

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

	__lowercase		       =			get_upernet_config(lowerCAmelCase__   )
	__lowercase		       =			UperNetForSemanticSegmentation(lowerCAmelCase__   )
	model.eval()

	# replace "bn" => "batch_norm"
	for key in state_dict.copy().keys():
		__lowercase		       =			state_dict.pop(lowerCAmelCase__   )
		if "bn" in key:
			__lowercase		       =			key.replace("bn"  ,	"batch_norm"   )
		__lowercase		       =			val

	# rename keys
	__lowercase		       =			create_rename_keys(lowerCAmelCase__   )
	for src, dest in rename_keys:
		rename_key(lowerCAmelCase__  ,	lowerCAmelCase__  ,	lowerCAmelCase__   )
	read_in_q_k_v(lowerCAmelCase__  ,	config.backbone_config   )

	# fix downsample parameters
	for key, value in state_dict.items():
		if "downsample" in key:
			if "reduction" in key:
				__lowercase		       =			reverse_correct_unfold_reduction_order(lowerCAmelCase__   )
			if "norm" in key:
				__lowercase		       =			reverse_correct_unfold_norm_order(lowerCAmelCase__   )

	model.load_state_dict(lowerCAmelCase__   )

	# verify on image
	__lowercase		       =			'https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg'
	__lowercase		       =			Image.open(requests.get(lowerCAmelCase__  ,	stream=lowerCAmelCase__   ).raw   ).convert("RGB"   )

	__lowercase		       =			SegformerImageProcessor()
	__lowercase		       =			processor(lowerCAmelCase__  ,	return_tensors="pt"   ).pixel_values

	with torch.no_grad():
		__lowercase		       =			model(lowerCAmelCase__   )
		__lowercase		       =			outputs.logits

	print(logits.shape   )
	print("First values of logits:"  ,	logits[0, 0, :3, :3]   )
	# assert values
	if model_name == "upernet-swin-tiny":
		__lowercase		       =			torch.tensor(
		    [[-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.4_7_9_7, -7.4_7_9_7, -7.3_0_6_8]]   )
	elif model_name == "upernet-swin-small":
		__lowercase		       =			torch.tensor(
		    [[-7.1_9_2_1, -7.1_9_2_1, -6.9_5_3_2], [-7.1_9_2_1, -7.1_9_2_1, -6.9_5_3_2], [-7.0_9_0_8, -7.0_9_0_8, -6.8_5_3_4]]   )
	elif model_name == "upernet-swin-base":
		__lowercase		       =			torch.tensor(
		    [[-6.5_8_5_1, -6.5_8_5_1, -6.4_3_3_0], [-6.5_8_5_1, -6.5_8_5_1, -6.4_3_3_0], [-6.4_7_6_3, -6.4_7_6_3, -6.3_2_5_4]]   )
	elif model_name == "upernet-swin-large":
		__lowercase		       =			torch.tensor(
		    [[-7.5_2_9_7, -7.5_2_9_7, -7.3_8_0_2], [-7.5_2_9_7, -7.5_2_9_7, -7.3_8_0_2], [-7.4_0_4_4, -7.4_0_4_4, -7.2_5_8_6]]   )
	print("Logits:"  ,	outputs.logits[0, 0, :3, :3]   )
	assert torch.allclose(outputs.logits[0, 0, :3, :3]  ,	lowerCAmelCase__  ,	atol=1E-4   )
	print("Looks ok!"   )

	if pytorch_dump_folder_path is not None:
		print(F"""Saving model {model_name} to {pytorch_dump_folder_path}"""   )
		model.save_pretrained(lowerCAmelCase__   )
		print(F"""Saving processor to {pytorch_dump_folder_path}"""   )
		processor.save_pretrained(lowerCAmelCase__   )

	if push_to_hub:
		print(F"""Pushing model and processor for {model_name} to hub"""   )
		model.push_to_hub(F"""openmmlab/{model_name}"""   )
		processor.push_to_hub(F"""openmmlab/{model_name}"""   )


if __name__ == "__main__":
	snake_case__					:     Dict    		=   argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    """--model_name""",
	    default="""upernet-swin-tiny""",
	    type=str,
	    choices=[F'''upernet-swin-{size}''' for size in ["""tiny""", """small""", """base""", """large"""]],
	    help="""Name of the Swin + UperNet model you\'d like to convert.""",
	)
	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__					:     Any    		=   parser.parse_args()
	convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








import argparse
import json
from pathlib import Path

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

from transformers import AutoImageProcessor, SwinvaConfig, SwinvaForImageClassification



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			SwinvaConfig()
	__lowercase		       =			swinva_name.split("_"   )

	__lowercase		       =			name_split[1]
	if "to" in name_split[3]:
		__lowercase		       =			int(name_split[3][-3:]   )
	else:
		__lowercase		       =			int(name_split[3]   )
	if "to" in name_split[2]:
		__lowercase		       =			int(name_split[2][-2:]   )
	else:
		__lowercase		       =			int(name_split[2][6:]   )

	if model_size == "tiny":
		__lowercase		       =			9_6
		__lowercase		       =			(2, 2, 6, 2)
		__lowercase		       =			(3, 6, 1_2, 2_4)
	elif model_size == "small":
		__lowercase		       =			9_6
		__lowercase		       =			(2, 2, 1_8, 2)
		__lowercase		       =			(3, 6, 1_2, 2_4)
	elif model_size == "base":
		__lowercase		       =			1_2_8
		__lowercase		       =			(2, 2, 1_8, 2)
		__lowercase		       =			(4, 8, 1_6, 3_2)
	else:
		__lowercase		       =			1_9_2
		__lowercase		       =			(2, 2, 1_8, 2)
		__lowercase		       =			(6, 1_2, 2_4, 4_8)

	if "to" in swinva_name:
		__lowercase		       =			(1_2, 1_2, 1_2, 6)

	if ("22k" in swinva_name) and ("to" not in swinva_name):
		__lowercase		       =			2_1_8_4_1
		__lowercase		       =			"huggingface/label-files"
		__lowercase		       =			"imagenet-22k-id2label.json"
		__lowercase		       =			json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	repo_type="dataset"   )  ,	"r"   )   )
		__lowercase		       =			{int(_SCREAMING_SNAKE_CASE   ): v for k, v in idalabel.items()}
		__lowercase		       =			idalabel
		__lowercase		       =			{v: k for k, v in idalabel.items()}

	else:
		__lowercase		       =			1_0_0_0
		__lowercase		       =			"huggingface/label-files"
		__lowercase		       =			"imagenet-1k-id2label.json"
		__lowercase		       =			json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	repo_type="dataset"   )  ,	"r"   )   )
		__lowercase		       =			{int(_SCREAMING_SNAKE_CASE   ): v for k, v in idalabel.items()}
		__lowercase		       =			idalabel
		__lowercase		       =			{v: k for k, v in idalabel.items()}

	__lowercase		       =			img_size
	__lowercase		       =			num_classes
	__lowercase		       =			embed_dim
	__lowercase		       =			depths
	__lowercase		       =			num_heads
	__lowercase		       =			window_size

	return config



def    snake_case_				(    _SCREAMING_SNAKE_CASE   ):
	if "patch_embed.proj" in name:
		__lowercase		       =			name.replace("patch_embed.proj"  ,	"embeddings.patch_embeddings.projection"   )
	if "patch_embed.norm" in name:
		__lowercase		       =			name.replace("patch_embed.norm"  ,	"embeddings.norm"   )
	if "layers" in name:
		__lowercase		       =			"encoder." + name
	if "attn.proj" in name:
		__lowercase		       =			name.replace("attn.proj"  ,	"attention.output.dense"   )
	if "attn" in name:
		__lowercase		       =			name.replace("attn"  ,	"attention.self"   )
	if "norm1" in name:
		__lowercase		       =			name.replace("norm1"  ,	"layernorm_before"   )
	if "norm2" in name:
		__lowercase		       =			name.replace("norm2"  ,	"layernorm_after"   )
	if "mlp.fc1" in name:
		__lowercase		       =			name.replace("mlp.fc1"  ,	"intermediate.dense"   )
	if "mlp.fc2" in name:
		__lowercase		       =			name.replace("mlp.fc2"  ,	"output.dense"   )
	if "q_bias" in name:
		__lowercase		       =			name.replace("q_bias"  ,	"query.bias"   )
	if "k_bias" in name:
		__lowercase		       =			name.replace("k_bias"  ,	"key.bias"   )
	if "v_bias" in name:
		__lowercase		       =			name.replace("v_bias"  ,	"value.bias"   )
	if "cpb_mlp" in name:
		__lowercase		       =			name.replace("cpb_mlp"  ,	"continuous_position_bias_mlp"   )
	if name == "norm.weight":
		__lowercase		       =			"layernorm.weight"
	if name == "norm.bias":
		__lowercase		       =			"layernorm.bias"

	if "head" in name:
		__lowercase		       =			name.replace("head"  ,	"classifier"   )
	else:
		__lowercase		       =			"swinv2." + name

	return name



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   ):
	for key in orig_state_dict.copy().keys():
		__lowercase		       =			orig_state_dict.pop(_SCREAMING_SNAKE_CASE   )

		if "mask" in key:
			continue
		elif "qkv" in key:
			__lowercase		       =			key.split("."   )
			__lowercase		       =			int(key_split[1]   )
			__lowercase		       =			int(key_split[3]   )
			__lowercase		       =			model.swinva.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

			if "weight" in key:
				__lowercase		       =			val[:dim, :]
				__lowercase		       =			val[dim : dim * 2, :]
				__lowercase		       =			val[-dim:, :]
			else:
				__lowercase		       =			val[:dim]
				__lowercase		       =			val[
				    dim : dim * 2
				]
				__lowercase		       =			val[-dim:]
		else:
			__lowercase		       =			val

	return orig_state_dict



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			timm.create_model(_SCREAMING_SNAKE_CASE  ,	pretrained=_SCREAMING_SNAKE_CASE   )
	timm_model.eval()

	__lowercase		       =			get_swinva_config(_SCREAMING_SNAKE_CASE   )
	__lowercase		       =			SwinvaForImageClassification(_SCREAMING_SNAKE_CASE   )
	model.eval()

	__lowercase		       =			convert_state_dict(timm_model.state_dict()  ,	_SCREAMING_SNAKE_CASE   )
	model.load_state_dict(_SCREAMING_SNAKE_CASE   )

	__lowercase		       =			"http://images.cocodataset.org/val2017/000000039769.jpg"

	__lowercase		       =			AutoImageProcessor.from_pretrained("microsoft/{}".format(swinva_name.replace("_"  ,	"-"   )   )   )
	__lowercase		       =			Image.open(requests.get(_SCREAMING_SNAKE_CASE  ,	stream=_SCREAMING_SNAKE_CASE   ).raw   )
	__lowercase		       =			image_processor(images=_SCREAMING_SNAKE_CASE  ,	return_tensors="pt"   )

	__lowercase		       =			timm_model(inputs["pixel_values"]   )
	__lowercase		       =			model(**_SCREAMING_SNAKE_CASE   ).logits

	assert torch.allclose(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	atol=1E-3   )

	print(F"""Saving model {swinva_name} to {pytorch_dump_folder_path}"""   )
	model.save_pretrained(_SCREAMING_SNAKE_CASE   )

	print(F"""Saving image processor to {pytorch_dump_folder_path}"""   )
	image_processor.save_pretrained(_SCREAMING_SNAKE_CASE   )

	model.push_to_hub(
	    repo_path_or_name=Path(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   )  ,	organization="nandwalritik"  ,	commit_message="Add model"  ,	)


if __name__ == "__main__":
	snake_case__					:     Union[str, Any]    		=   argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    """--swinv2_name""",
	    default="""swinv2_tiny_patch4_window8_256""",
	    type=str,
	    help="""Name of the Swinv2 timm model you'd like to convert.""",
	)
	parser.add_argument(
	    """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
	)

	snake_case__					:     str    		=   parser.parse_args()
	convert_swinva_checkpoint(args.swinva_name, args.pytorch_dump_folder_path)



