



'''simple docstring'''




import argparse
import logging
import os
import re

import tensorflow as tf

from transformers import (
    AutoConfig,
    AutoTokenizer,
    DataCollatorForLanguageModeling,
    PushToHubCallback,
    TFAutoModelForMaskedLM,
    create_optimizer,
)


UpperCamelCase__ :			Union[str, Any]												=				logging.getLogger(__name__)

UpperCamelCase__ :			List[Any]												=				tf.data.AUTOTUNE


def        lowerCAmelCase_     (			):
		__SCREAMING_SNAKE_CASE :	Dict					 =	argparse.ArgumentParser(description="""Train a masked language model on TPU."""      )
		parser.add_argument(
		    """--pretrained_model_config""" ,   type=_lowerCamelCase ,   default="""roberta-base""" ,   help="""The model config to use. Note that we don't copy the model's weights, only the config!""" ,   )
		parser.add_argument(
		    """--tokenizer""" ,   type=_lowerCamelCase ,   default="""unigram-tokenizer-wikitext""" ,   help="""The name of the tokenizer to load. We use the pretrained tokenizer to initialize the model's vocab size.""" ,   )

		parser.add_argument(
		    """--per_replica_batch_size""" ,   type=_lowerCamelCase ,   default=8 ,   help="""Batch size per TPU core.""" ,   )

		parser.add_argument(
		    """--no_tpu""" ,   action="""store_true""" ,   help="""If set, run on CPU and don't try to initialize a TPU. Useful for debugging on non-TPU instances.""" ,   )

		parser.add_argument(
		    """--tpu_name""" ,   type=_lowerCamelCase ,   help="""Name of TPU resource to initialize. Should be blank on Colab, and 'local' on TPU VMs.""" ,   default="""local""" ,   )

		parser.add_argument(
		    """--tpu_zone""" ,   type=_lowerCamelCase ,   help="""Google cloud zone that TPU resource is located in. Only used for non-Colab TPU nodes.""" ,   )

		parser.add_argument(
		    """--gcp_project""" ,   type=_lowerCamelCase ,   help="""Google cloud project name. Only used for non-Colab TPU nodes."""      )

		parser.add_argument(
		    """--bfloat16""" ,   action="""store_true""" ,   help="""Use mixed-precision bfloat16 for training. This is the recommended lower-precision format for TPU.""" ,   )

		parser.add_argument(
		    """--train_dataset""" ,   type=_lowerCamelCase ,   help="""Path to training dataset to load. If the path begins with `gs://`"""
		    """ then the dataset will be loaded from a Google Cloud Storage bucket.""" ,   )

		parser.add_argument(
		    """--shuffle_buffer_size""" ,   type=_lowerCamelCase ,   default=2**18 ,   help="""Size of the shuffle buffer (in samples)""" ,   )

		parser.add_argument(
		    """--eval_dataset""" ,   type=_lowerCamelCase ,   help="""Path to evaluation dataset to load. If the path begins with `gs://`"""
		    """ then the dataset will be loaded from a Google Cloud Storage bucket.""" ,   )

		parser.add_argument(
		    """--num_epochs""" ,   type=_lowerCamelCase ,   default=1 ,   help="""Number of epochs to train for.""" ,   )

		parser.add_argument(
		    """--learning_rate""" ,   type=_lowerCamelCase ,   default=1E-4 ,   help="""Learning rate to use for training.""" ,   )

		parser.add_argument(
		    """--weight_decay_rate""" ,   type=_lowerCamelCase ,   default=1E-3 ,   help="""Weight decay rate to use for training.""" ,   )

		parser.add_argument(
		    """--max_length""" ,   type=_lowerCamelCase ,   default=5_12 ,   help="""Maximum length of tokenized sequences. Should match the setting used in prepare_tfrecord_shards.py""" ,   )

		parser.add_argument(
		    """--mlm_probability""" ,   type=_lowerCamelCase ,   default=0.15 ,   help="""Fraction of tokens to mask during training.""" ,   )

		parser.add_argument("""--output_dir""" ,   type=_lowerCamelCase ,   required=_lowerCamelCase ,   help="""Path to save model checkpoints to."""      )
		parser.add_argument("""--hub_model_id""" ,   type=_lowerCamelCase ,   help="""Model ID to upload to on the Hugging Face Hub."""      )

		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	parser.parse_args()
		return args


def        lowerCAmelCase_     (			_lowerCamelCase:     Optional[Any]      ):
		try:
				if args.tpu_name:
						__SCREAMING_SNAKE_CASE :	Tuple					 =	tf.distribute.cluster_resolver.TPUClusterResolver(
						    args.tpu_name ,   zone=args.tpu_zone ,   project=args.gcp_project      )
				else:
						__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	tf.distribute.cluster_resolver.TPUClusterResolver()
		except ValueError:
				raise RuntimeError(
				    """Couldn't connect to TPU! Most likely you need to specify --tpu_name, --tpu_zone, or """
				    """--gcp_project. When running on a TPU VM, use --tpu_name local."""      )

		tf.config.experimental_connect_to_cluster(_lowerCamelCase      )
		tf.tpu.experimental.initialize_tpu_system(_lowerCamelCase      )

		return tpu


def        lowerCAmelCase_     (			_lowerCamelCase:     str      ):
		__SCREAMING_SNAKE_CASE :	List[str]					 =	0
		for file in file_list:
				__SCREAMING_SNAKE_CASE :	List[Any]					 =	file.split("""/"""      )[-1]
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	re.search(r"""-\d+-(\d+)\.tfrecord""" ,   _lowerCamelCase      ).group(1      )
				__SCREAMING_SNAKE_CASE :	List[Any]					 =	int(_lowerCamelCase      )
				num_samples += sample_count

		return num_samples


def        lowerCAmelCase_     (			_lowerCamelCase:     Any ,   _lowerCamelCase:     Optional[int] ,   _lowerCamelCase:     int ,   _lowerCamelCase:     List[str] ,   _lowerCamelCase:     Optional[Any] ,   _lowerCamelCase:     List[Any]=None      ):
		__SCREAMING_SNAKE_CASE :	Optional[int]					 =	count_samples(_lowerCamelCase      )
		__SCREAMING_SNAKE_CASE :	Optional[int]					 =	tf.data.Dataset.from_tensor_slices(_lowerCamelCase      )
		if shuffle:
				__SCREAMING_SNAKE_CASE :	Tuple					 =	dataset.shuffle(len(_lowerCamelCase      )      )
		__SCREAMING_SNAKE_CASE :	str					 =	tf.data.TFRecordDataset(_lowerCamelCase ,   num_parallel_reads=_lowerCamelCase      )
		# TF can't infer the total sample count because it doesn't read all the records yet, so we assert it here
		__SCREAMING_SNAKE_CASE :	str					 =	dataset.apply(tf.data.experimental.assert_cardinality(_lowerCamelCase      )      )
		__SCREAMING_SNAKE_CASE :	Dict					 =	dataset.map(_lowerCamelCase ,   num_parallel_calls=_lowerCamelCase      )
		if shuffle:
				assert shuffle_buffer_size is not None
				__SCREAMING_SNAKE_CASE :	List[Any]					 =	dataset.shuffle(args.shuffle_buffer_size      )
		__SCREAMING_SNAKE_CASE :	str					 =	dataset.batch(_lowerCamelCase ,   drop_remainder=_lowerCamelCase      )
		__SCREAMING_SNAKE_CASE :	Tuple					 =	dataset.map(_lowerCamelCase ,   num_parallel_calls=_lowerCamelCase      )
		__SCREAMING_SNAKE_CASE :	str					 =	dataset.prefetch(_lowerCamelCase      )
		return dataset


def        lowerCAmelCase_     (			_lowerCamelCase:     int      ):
		if not args.no_tpu:
				__SCREAMING_SNAKE_CASE :	List[str]					 =	initialize_tpu(_lowerCamelCase      )
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	tf.distribute.TPUStrategy(_lowerCamelCase      )
		else:
				__SCREAMING_SNAKE_CASE :	int					 =	tf.distribute.OneDeviceStrategy(device="""/gpu:0"""      )

		if args.bfloataa:
				tf.keras.mixed_precision.set_global_policy("""mixed_bfloat16"""      )

		__SCREAMING_SNAKE_CASE :	int					 =	AutoTokenizer.from_pretrained(args.tokenizer      )
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	AutoConfig.from_pretrained(args.pretrained_model_config      )
		__SCREAMING_SNAKE_CASE :	int					 =	tokenizer.vocab_size

		__SCREAMING_SNAKE_CASE :	Optional[int]					 =	tf.io.gfile.glob(os.path.join(args.train_dataset ,   """*.tfrecord"""      )      )
		if not training_records:
				raise ValueError(F"No .tfrecord files found in {args.train_dataset}."      )
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	tf.io.gfile.glob(os.path.join(args.eval_dataset ,   """*.tfrecord"""      )      )
		if not eval_records:
				raise ValueError(F"No .tfrecord files found in {args.eval_dataset}."      )

		__SCREAMING_SNAKE_CASE :	List[str]					 =	count_samples(_lowerCamelCase      )

		__SCREAMING_SNAKE_CASE :	List[Any]					 =	num_train_samples // (args.per_replica_batch_size * strategy.num_replicas_in_sync)
		__SCREAMING_SNAKE_CASE :	Any					 =	steps_per_epoch * args.num_epochs

		with strategy.scope():
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	TFAutoModelForMaskedLM.from_config(_lowerCamelCase      )
				model(model.dummy_inputs      )  # Pass some dummy inputs through the model to ensure all the weights are built
				__SCREAMING_SNAKE_CASE ,		__SCREAMING_SNAKE_CASE :	Tuple					 =	create_optimizer(
				    num_train_steps=_lowerCamelCase ,   num_warmup_steps=total_train_steps // 20 ,   init_lr=args.learning_rate ,   weight_decay_rate=args.weight_decay_rate ,   )

				# Transformers models compute the right loss for their task by default when labels are passed, and will
				# use this for training unless you specify your own loss function in compile().
				model.compile(optimizer=_lowerCamelCase ,   metrics=["""accuracy"""]      )

		def decode_fn(_lowerCamelCase:     Optional[Any]      ):
				__SCREAMING_SNAKE_CASE :	str					 =	{
				    """input_ids""": tf.io.FixedLenFeature(dtype=tf.intaa ,   shape=(args.max_length,)      ),
				    """attention_mask""": tf.io.FixedLenFeature(dtype=tf.intaa ,   shape=(args.max_length,)      ),
				}
				return tf.io.parse_single_example(_lowerCamelCase ,   _lowerCamelCase      )

		# Many of the data collators in Transformers are TF-compilable when return_tensors == "tf", so we can
		# use their methods in our data pipeline.
		__SCREAMING_SNAKE_CASE :	Any					 =	DataCollatorForLanguageModeling(
		    tokenizer=_lowerCamelCase ,   mlm_probability=args.mlm_probability ,   mlm=_lowerCamelCase ,   return_tensors="""tf"""      )

		def mask_with_collator(_lowerCamelCase:     Tuple      ):
				# TF really needs an isin() function
				__SCREAMING_SNAKE_CASE :	Dict					 =	(
				    ~tf.cast(batch["""attention_mask"""] ,   tf.bool      )
				    | (batch["""input_ids"""] == tokenizer.cls_token_id)
				    | (batch["""input_ids"""] == tokenizer.sep_token_id)
				)
				__SCREAMING_SNAKE_CASE ,		__SCREAMING_SNAKE_CASE :	int					 =	data_collator.tf_mask_tokens(
				    batch["""input_ids"""] ,   vocab_size=len(_lowerCamelCase      ) ,   mask_token_id=tokenizer.mask_token_id ,   special_tokens_mask=_lowerCamelCase ,   )
				return batch

		__SCREAMING_SNAKE_CASE :	Tuple					 =	args.per_replica_batch_size * strategy.num_replicas_in_sync

		__SCREAMING_SNAKE_CASE :	Any					 =	prepare_dataset(
		    _lowerCamelCase ,   decode_fn=_lowerCamelCase ,   mask_fn=_lowerCamelCase ,   batch_size=_lowerCamelCase ,   shuffle=_lowerCamelCase ,   shuffle_buffer_size=args.shuffle_buffer_size ,   )

		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	prepare_dataset(
		    _lowerCamelCase ,   decode_fn=_lowerCamelCase ,   mask_fn=_lowerCamelCase ,   batch_size=_lowerCamelCase ,   shuffle=_lowerCamelCase ,   )

		__SCREAMING_SNAKE_CASE :	Dict					 =	[]
		if args.hub_model_id:
				callbacks.append(
				    PushToHubCallback(output_dir=args.output_dir ,   hub_model_id=args.hub_model_id ,   tokenizer=_lowerCamelCase      )      )

		model.fit(
		    _lowerCamelCase ,   validation_data=_lowerCamelCase ,   epochs=args.num_epochs ,   callbacks=_lowerCamelCase ,   )

		model.save_pretrained(args.output_dir      )


if __name__ == "__main__":
						UpperCamelCase__ :			Union[str, Any]												=				parse_args()
						main(args)




'''simple docstring'''




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        lowerCAmelCase_     (			_lowerCamelCase:     Tuple      ):
		__SCREAMING_SNAKE_CASE :	List[Any]					 =	SwinvaConfig()
		__SCREAMING_SNAKE_CASE :	List[Any]					 =	swinva_name.split("""_"""      )

		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	name_split[1]
		if "to" in name_split[3]:
				__SCREAMING_SNAKE_CASE :	Dict					 =	int(name_split[3][-3:]      )
		else:
				__SCREAMING_SNAKE_CASE :	str					 =	int(name_split[3]      )
		if "to" in name_split[2]:
				__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	int(name_split[2][-2:]      )
		else:
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	int(name_split[2][6:]      )

		if model_size == "tiny":
				__SCREAMING_SNAKE_CASE :	Dict					 =	96
				__SCREAMING_SNAKE_CASE :	List[str]					 =	(2, 2, 6, 2)
				__SCREAMING_SNAKE_CASE :	List[Any]					 =	(3, 6, 12, 24)
		elif model_size == "small":
				__SCREAMING_SNAKE_CASE :	List[str]					 =	96
				__SCREAMING_SNAKE_CASE :	int					 =	(2, 2, 18, 2)
				__SCREAMING_SNAKE_CASE :	int					 =	(3, 6, 12, 24)
		elif model_size == "base":
				__SCREAMING_SNAKE_CASE :	int					 =	1_28
				__SCREAMING_SNAKE_CASE :	str					 =	(2, 2, 18, 2)
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	(4, 8, 16, 32)
		else:
				__SCREAMING_SNAKE_CASE :	List[str]					 =	1_92
				__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	(2, 2, 18, 2)
				__SCREAMING_SNAKE_CASE :	Dict					 =	(6, 12, 24, 48)

		if "to" in swinva_name:
				__SCREAMING_SNAKE_CASE :	int					 =	(12, 12, 12, 6)

		if ("22k" in swinva_name) and ("to" not in swinva_name):
				__SCREAMING_SNAKE_CASE :	int					 =	2_18_41
				__SCREAMING_SNAKE_CASE :	str					 =	"""huggingface/label-files"""
				__SCREAMING_SNAKE_CASE :	List[str]					 =	"""imagenet-22k-id2label.json"""
				__SCREAMING_SNAKE_CASE :	List[str]					 =	json.load(open(hf_hub_download(_lowerCamelCase ,   _lowerCamelCase ,   repo_type="""dataset"""      ) ,   """r"""      )      )
				__SCREAMING_SNAKE_CASE :	List[Any]					 =	{int(_lowerCamelCase      ): v for k, v in idalabel.items()}
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	idalabel
				__SCREAMING_SNAKE_CASE :	str					 =	{v: k for k, v in idalabel.items()}

		else:
				__SCREAMING_SNAKE_CASE :	str					 =	10_00
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	"""huggingface/label-files"""
				__SCREAMING_SNAKE_CASE :	Any					 =	"""imagenet-1k-id2label.json"""
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	json.load(open(hf_hub_download(_lowerCamelCase ,   _lowerCamelCase ,   repo_type="""dataset"""      ) ,   """r"""      )      )
				__SCREAMING_SNAKE_CASE :	int					 =	{int(_lowerCamelCase      ): v for k, v in idalabel.items()}
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	idalabel
				__SCREAMING_SNAKE_CASE :	Dict					 =	{v: k for k, v in idalabel.items()}

		__SCREAMING_SNAKE_CASE :	Any					 =	img_size
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	num_classes
		__SCREAMING_SNAKE_CASE :	int					 =	embed_dim
		__SCREAMING_SNAKE_CASE :	Dict					 =	depths
		__SCREAMING_SNAKE_CASE :	str					 =	num_heads
		__SCREAMING_SNAKE_CASE :	int					 =	window_size

		return config


def        lowerCAmelCase_     (			_lowerCamelCase:     int      ):
		if "patch_embed.proj" in name:
				__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	name.replace("""patch_embed.proj""" ,   """embeddings.patch_embeddings.projection"""      )
		if "patch_embed.norm" in name:
				__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	name.replace("""patch_embed.norm""" ,   """embeddings.norm"""      )
		if "layers" in name:
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	"""encoder.""" + name
		if "attn.proj" in name:
				__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	name.replace("""attn.proj""" ,   """attention.output.dense"""      )
		if "attn" in name:
				__SCREAMING_SNAKE_CASE :	Any					 =	name.replace("""attn""" ,   """attention.self"""      )
		if "norm1" in name:
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	name.replace("""norm1""" ,   """layernorm_before"""      )
		if "norm2" in name:
				__SCREAMING_SNAKE_CASE :	Dict					 =	name.replace("""norm2""" ,   """layernorm_after"""      )
		if "mlp.fc1" in name:
				__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	name.replace("""mlp.fc1""" ,   """intermediate.dense"""      )
		if "mlp.fc2" in name:
				__SCREAMING_SNAKE_CASE :	List[Any]					 =	name.replace("""mlp.fc2""" ,   """output.dense"""      )
		if "q_bias" in name:
				__SCREAMING_SNAKE_CASE :	Tuple					 =	name.replace("""q_bias""" ,   """query.bias"""      )
		if "k_bias" in name:
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	name.replace("""k_bias""" ,   """key.bias"""      )
		if "v_bias" in name:
				__SCREAMING_SNAKE_CASE :	List[str]					 =	name.replace("""v_bias""" ,   """value.bias"""      )
		if "cpb_mlp" in name:
				__SCREAMING_SNAKE_CASE :	str					 =	name.replace("""cpb_mlp""" ,   """continuous_position_bias_mlp"""      )
		if name == "norm.weight":
				__SCREAMING_SNAKE_CASE :	Tuple					 =	"""layernorm.weight"""
		if name == "norm.bias":
				__SCREAMING_SNAKE_CASE :	Optional[int]					 =	"""layernorm.bias"""

		if "head" in name:
				__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	name.replace("""head""" ,   """classifier"""      )
		else:
				__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	"""swinv2.""" + name

		return name


def        lowerCAmelCase_     (			_lowerCamelCase:     int ,   _lowerCamelCase:     Optional[Any]      ):
		for key in orig_state_dict.copy().keys():
				__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	orig_state_dict.pop(_lowerCamelCase      )

				if "mask" in key:
						continue
				elif "qkv" in key:
						__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	key.split("""."""      )
						__SCREAMING_SNAKE_CASE :	List[str]					 =	int(key_split[1]      )
						__SCREAMING_SNAKE_CASE :	Dict					 =	int(key_split[3]      )
						__SCREAMING_SNAKE_CASE :	str					 =	model.swinva.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

						if "weight" in key:
								__SCREAMING_SNAKE_CASE :	Optional[int]					 =	val[:dim, :]
								__SCREAMING_SNAKE_CASE :	str					 =	val[dim : dim * 2, :]
								__SCREAMING_SNAKE_CASE :	Dict					 =	val[-dim:, :]
						else:
								__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	val[:dim]
								__SCREAMING_SNAKE_CASE :	int					 =	val[
								    dim : dim * 2
								]
								__SCREAMING_SNAKE_CASE :	int					 =	val[-dim:]
				else:
						__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	val

		return orig_state_dict


def        lowerCAmelCase_     (			_lowerCamelCase:     Tuple ,   _lowerCamelCase:     int      ):
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	timm.create_model(_lowerCamelCase ,   pretrained=_lowerCamelCase      )
		timm_model.eval()

		__SCREAMING_SNAKE_CASE :	int					 =	get_swinva_config(_lowerCamelCase      )
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	SwinvaForImageClassification(_lowerCamelCase      )
		model.eval()

		__SCREAMING_SNAKE_CASE :	Optional[int]					 =	convert_state_dict(timm_model.state_dict() ,   _lowerCamelCase      )
		model.load_state_dict(_lowerCamelCase      )

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

		__SCREAMING_SNAKE_CASE :	List[Any]					 =	AutoImageProcessor.from_pretrained("""microsoft/{}""".format(swinva_name.replace("""_""" ,   """-"""      )      )      )
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	Image.open(requests.get(_lowerCamelCase ,   stream=_lowerCamelCase      ).raw      )
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	image_processor(images=_lowerCamelCase ,   return_tensors="""pt"""      )

		__SCREAMING_SNAKE_CASE :	int					 =	timm_model(inputs["""pixel_values"""]      )
		__SCREAMING_SNAKE_CASE :	Dict					 =	model(**_lowerCamelCase      ).logits

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

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

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

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


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

						UpperCamelCase__ :			Optional[int]												=				parser.parse_args()
						convert_swinva_checkpoint(args.swinva_name, args.pytorch_dump_folder_path)