



import argparse
import os
import re

import numpy as np
import PIL
import torch
from timm import create_model
from torch.optim.lr_scheduler import OneCycleLR
from torch.utils.data import DataLoader, Dataset
from torchvision.transforms import Compose, RandomResizedCrop, Resize, ToTensor

from accelerate import Accelerator

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			List[str]    ):
				"""simple docstring"""







				__a       =		fname.split(os.path.sep    )[-1]
				return re.search(r"""^(.*)_\d+\.jpg$"""				,     _SCREAMING_SNAKE_CASE    ).groups()[0]






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__					):





							def __init__(   self		:		Union[str, Any]      ,				__lowercase		:		Any      ,				__lowercase		:		Optional[int]=None      ,				__lowercase		:		Any=None	):

											'''simple docstring'''
											__a       =		file_names
											__a       =		image_transform
											__a       =		label_to_id





							def __len__(   self		:		Any	):

											'''simple docstring'''
											return len(self.file_names	)







							def __getitem__(   self		:		Optional[Any]      ,				__lowercase		:		Any	):

											'''simple docstring'''
											__a       =		self.file_names[idx]
											__a       =		PIL.Image.open(__lowercase	)
											__a       =		raw_image.convert("""RGB"""	)
											if self.image_transform is not None:
															__a       =		self.image_transform(__lowercase	)
											__a       =		extract_label(__lowercase	)
											if self.label_to_id is not None:
															__a       =		self.label_to_id[label]
											return {"image": image, "label": label}



def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			List[str]				,     _SCREAMING_SNAKE_CASE       :			Optional[Any]    ):
				"""simple docstring"""







				if args.with_tracking:
								__a       =		Accelerator(
								    cpu=args.cpu				,     mixed_precision=args.mixed_precision				,     log_with="""all"""				,     project_dir=args.project_dir    )
				else:
								__a       =		Accelerator(cpu=args.cpu				,     mixed_precision=args.mixed_precision    )

				# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
				__a       =		config["""lr"""]
				__a       =		int(config["""num_epochs"""]    )
				__a       =		int(config["""seed"""]    )
				__a       =		int(config["""batch_size"""]    )
				__a       =		config["""image_size"""]
				if not isinstance(_SCREAMING_SNAKE_CASE				,     (list, tuple)    ):
								__a       =		(image_size, image_size)

				# Parse out whether we are saving every epoch or after a certain number of batches
				if hasattr(args.checkpointing_steps				,     """isdigit"""    ):
								if args.checkpointing_steps == "epoch":
												__a       =		args.checkpointing_steps
								elif args.checkpointing_steps.isdigit():
												__a       =		int(args.checkpointing_steps    )
								else:
												raise ValueError(
												    f"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed."    )
				else:
								__a       =		None

				# We need to initialize the trackers we use, and also store our configuration
				if args.with_tracking:
								__a       =		os.path.split(_SCREAMING_SNAKE_CASE    )[-1].split("""."""    )[0]
								accelerator.init_trackers(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )

				# Grab all the image filenames
				__a       =		[os.path.join(args.data_dir				,     _SCREAMING_SNAKE_CASE    ) for fname in os.listdir(args.data_dir    ) if fname.endswith(""".jpg"""    )]

				# Build the label correspondences
				__a       =		[extract_label(_SCREAMING_SNAKE_CASE    ) for fname in file_names]
				__a       =		list(set(_SCREAMING_SNAKE_CASE    )    )
				id_to_label.sort()
				__a       =		{lbl: i for i, lbl in enumerate(_SCREAMING_SNAKE_CASE    )}

				# Set the seed before splitting the data.
				np.random.seed(_SCREAMING_SNAKE_CASE    )
				torch.manual_seed(_SCREAMING_SNAKE_CASE    )
				torch.cuda.manual_seed_all(_SCREAMING_SNAKE_CASE    )

				# Split our filenames between train and validation
				__a       =		np.random.permutation(len(_SCREAMING_SNAKE_CASE    )    )
				__a       =		int(0.8 * len(_SCREAMING_SNAKE_CASE    )    )
				__a       =		random_perm[:cut]
				__a       =		random_perm[cut:]

				# For training we use a simple RandomResizedCrop
				__a       =		Compose([RandomResizedCrop(_SCREAMING_SNAKE_CASE				,     scale=(0.5, 1.0)    ), ToTensor()]    )
				__a       =		PetsDataset(
				    [file_names[i] for i in train_split]				,     image_transform=_SCREAMING_SNAKE_CASE				,     label_to_id=_SCREAMING_SNAKE_CASE    )

				# For evaluation, we use a deterministic Resize
				__a       =		Compose([Resize(_SCREAMING_SNAKE_CASE    ), ToTensor()]    )
				__a       =		PetsDataset([file_names[i] for i in eval_split]				,     image_transform=_SCREAMING_SNAKE_CASE				,     label_to_id=_SCREAMING_SNAKE_CASE    )

				# Instantiate dataloaders.
				__a       =		DataLoader(_SCREAMING_SNAKE_CASE				,     shuffle=_SCREAMING_SNAKE_CASE				,     batch_size=_SCREAMING_SNAKE_CASE				,     num_workers=4    )
				__a       =		DataLoader(_SCREAMING_SNAKE_CASE				,     shuffle=_SCREAMING_SNAKE_CASE				,     batch_size=_SCREAMING_SNAKE_CASE				,     num_workers=4    )

				# Instantiate the model (we build the model here so that the seed also control new weights initialization)
				__a       =		create_model("""resnet50d"""				,     pretrained=_SCREAMING_SNAKE_CASE				,     num_classes=len(_SCREAMING_SNAKE_CASE    )    )

				# We could avoid this line since the accelerator is set with `device_placement=True` (default value).
				# Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
				# creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
				__a       =		model.to(accelerator.device    )

				# Freezing the base model
				for param in model.parameters():
								__a       =		False
				for param in model.get_classifier().parameters():
								__a       =		True

				# We normalize the batches of images to be a bit faster.
				__a       =		torch.tensor(model.default_cfg["""mean"""]    )[None, :, None, None].to(accelerator.device    )
				__a       =		torch.tensor(model.default_cfg["""std"""]    )[None, :, None, None].to(accelerator.device    )

				# Instantiate optimizer
				__a       =		torch.optim.Adam(params=model.parameters()				,     lr=lr / 25    )

				# Instantiate learning rate scheduler
				__a       =		OneCycleLR(optimizer=_SCREAMING_SNAKE_CASE				,     max_lr=_SCREAMING_SNAKE_CASE				,     epochs=_SCREAMING_SNAKE_CASE				,     steps_per_epoch=len(_SCREAMING_SNAKE_CASE    )    )

				# Prepare everything
				# There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
				# prepare method.
				__a     ,					__a     ,					__a     ,					__a     ,					__a       =		accelerator.prepare(
				    _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )
				# We need to keep track of how many total steps we have iterated over
				__a       =		0
				# We also need to keep track of the starting epoch so files are named properly
				__a       =		0

				# Potentially load in the weights and states from a previous save
				if args.resume_from_checkpoint:
								if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
												accelerator.print(f"Resumed from checkpoint: {args.resume_from_checkpoint}"    )
												accelerator.load_state(args.resume_from_checkpoint    )
												__a       =		os.path.basename(args.resume_from_checkpoint    )
								else:
												# Get the most recent checkpoint
												__a       =		[f.name for f in os.scandir(os.getcwd()    ) if f.is_dir()]
												dirs.sort(key=os.path.getctime    )
												__a       =		dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
								# Extract `epoch_{i}` or `step_{i}`
								__a       =		os.path.splitext(_SCREAMING_SNAKE_CASE    )[0]

								if "epoch" in training_difference:
												__a       =		int(training_difference.replace("""epoch_"""				,     """"""    )    ) + 1
												__a       =		None
								else:
												__a       =		int(training_difference.replace("""step_"""				,     """"""    )    )
												__a       =		resume_step // len(_SCREAMING_SNAKE_CASE    )
												resume_step -= starting_epoch * len(_SCREAMING_SNAKE_CASE    )

    # Now we train the model
				for epoch in range(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    ):
								model.train()
								if args.with_tracking:
												__a       =		0
								if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
												# We need to skip steps until we reach the resumed step
												__a       =		accelerator.skip_first_batches(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )
												overall_step += resume_step
								else:
												# After the first iteration though, we need to go back to the original dataloader
												__a       =		train_dataloader
								for batch in active_dataloader:
												# We could avoid this line since we set the accelerator with `device_placement=True`.
												__a       =		{k: v.to(accelerator.device    ) for k, v in batch.items()}
												__a       =		(batch["""image"""] - mean) / std
												__a       =		model(_SCREAMING_SNAKE_CASE    )
												__a       =		torch.nn.functional.cross_entropy(_SCREAMING_SNAKE_CASE				,     batch["""label"""]    )
												# We keep track of the loss at each epoch
												if args.with_tracking:
																total_loss += loss.detach().float()
												accelerator.backward(_SCREAMING_SNAKE_CASE    )
												optimizer.step()
												lr_scheduler.step()
												optimizer.zero_grad()
												overall_step += 1
												if isinstance(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    ):
																__a       =		f"step_{overall_step}"
																if overall_step % checkpointing_steps == 0:
																				if args.output_dir is not None:
																								__a       =		os.path.join(args.output_dir				,     _SCREAMING_SNAKE_CASE    )
																				accelerator.save_state(_SCREAMING_SNAKE_CASE    )
								model.eval()
								__a       =		0
								__a       =		0
								for step, batch in enumerate(_SCREAMING_SNAKE_CASE    ):
												# We could avoid this line since we set the accelerator with `device_placement=True`.
												__a       =		{k: v.to(accelerator.device    ) for k, v in batch.items()}
												__a       =		(batch["""image"""] - mean) / std
												with torch.no_grad():
																__a       =		model(_SCREAMING_SNAKE_CASE    )
												__a       =		outputs.argmax(dim=-1    )
												__a     ,					__a       =		accelerator.gather_for_metrics((predictions, batch["""label"""])    )
												__a       =		predictions == references
												num_elems += accurate_preds.shape[0]
												accurate += accurate_preds.long().sum()

								__a       =		accurate.item() / num_elems
								# Use accelerator.print to print only on the main process.
								accelerator.print(f"epoch {epoch}: {100 * eval_metric:.2f}"    )
								if args.with_tracking:
												accelerator.log(
												    {
												        """accuracy""": 100 * eval_metric,
												        """train_loss""": total_loss.item() / len(_SCREAMING_SNAKE_CASE    ),
												        """epoch""": epoch,
												    }				,     step=_SCREAMING_SNAKE_CASE				,     )
								if checkpointing_steps == "epoch":
												__a       =		f"epoch_{epoch}"
												if args.output_dir is not None:
																__a       =		os.path.join(args.output_dir				,     _SCREAMING_SNAKE_CASE    )
												accelerator.save_state(_SCREAMING_SNAKE_CASE    )

				if args.with_tracking:
								accelerator.end_training()

def   lowerCAmelCase__						(							):
				"""simple docstring"""







				__a       =		argparse.ArgumentParser(description="""Simple example of training script."""    )
				parser.add_argument("""--data_dir"""				,     required=_SCREAMING_SNAKE_CASE				,     help="""The data folder on disk."""    )
				parser.add_argument("""--fp16"""				,     action="""store_true"""				,     help="""If passed, will use FP16 training."""    )
				parser.add_argument(
				    """--mixed_precision"""				,     type=_SCREAMING_SNAKE_CASE				,     default=_SCREAMING_SNAKE_CASE				,     choices=["""no""", """fp16""", """bf16""", """fp8"""]				,     help="""Whether to use mixed precision. Choose"""
				    """between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."""
				    """and an Nvidia Ampere GPU."""				,     )
				parser.add_argument("""--cpu"""				,     action="""store_true"""				,     help="""If passed, will train on the CPU."""    )
				parser.add_argument(
				    """--checkpointing_steps"""				,     type=_SCREAMING_SNAKE_CASE				,     default=_SCREAMING_SNAKE_CASE				,     help="""Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch."""				,     )
				parser.add_argument(
				    """--output_dir"""				,     type=_SCREAMING_SNAKE_CASE				,     default="""."""				,     help="""Optional save directory where all checkpoint folders will be stored. Default is the current working directory."""				,     )
				parser.add_argument(
				    """--resume_from_checkpoint"""				,     type=_SCREAMING_SNAKE_CASE				,     default=_SCREAMING_SNAKE_CASE				,     help="""If the training should continue from a checkpoint folder."""				,     )
				parser.add_argument(
				    """--with_tracking"""				,     action="""store_true"""				,     help="""Whether to load in all available experiment trackers from the environment and use them for logging."""				,     )
				parser.add_argument(
				    """--project_dir"""				,     type=_SCREAMING_SNAKE_CASE				,     default="""logs"""				,     help="""Location on where to store experiment tracking logs` and relevent project information"""				,     )
				__a       =		parser.parse_args()
				__a       =		{"""lr""": 3e-2, """num_epochs""": 3, """seed""": 42, """batch_size""": 64, """image_size""": 224}
				training_function(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )


if __name__ == "__main__":
						main()









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 BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase__			= logging.get_logger(__name__)

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Dict				,     _SCREAMING_SNAKE_CASE       :			str=False				,     _SCREAMING_SNAKE_CASE       :			Tuple=False    ):
				"""simple docstring"""







				__a       =		"""backbone.""" if is_semantic else """"""

				__a       =		[]
				for i in range(config.num_hidden_layers    ):
								# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
								rename_keys.append((f"{prefix}blocks.{i}.norm1.weight", f"beit.encoder.layer.{i}.layernorm_before.weight")    )
								rename_keys.append((f"{prefix}blocks.{i}.norm1.bias", f"beit.encoder.layer.{i}.layernorm_before.bias")    )
								rename_keys.append(
								    (f"{prefix}blocks.{i}.attn.proj.weight", f"beit.encoder.layer.{i}.attention.output.dense.weight")    )
								rename_keys.append(
								    (f"{prefix}blocks.{i}.attn.proj.bias", f"beit.encoder.layer.{i}.attention.output.dense.bias")    )
								rename_keys.append((f"{prefix}blocks.{i}.norm2.weight", f"beit.encoder.layer.{i}.layernorm_after.weight")    )
								rename_keys.append((f"{prefix}blocks.{i}.norm2.bias", f"beit.encoder.layer.{i}.layernorm_after.bias")    )
								rename_keys.append((f"{prefix}blocks.{i}.mlp.fc1.weight", f"beit.encoder.layer.{i}.intermediate.dense.weight")    )
								rename_keys.append((f"{prefix}blocks.{i}.mlp.fc1.bias", f"beit.encoder.layer.{i}.intermediate.dense.bias")    )
								rename_keys.append((f"{prefix}blocks.{i}.mlp.fc2.weight", f"beit.encoder.layer.{i}.output.dense.weight")    )
								rename_keys.append((f"{prefix}blocks.{i}.mlp.fc2.bias", f"beit.encoder.layer.{i}.output.dense.bias")    )

				# projection layer + position embeddings
				rename_keys.extend(
				    [
				        (f"{prefix}cls_token", """beit.embeddings.cls_token"""),
				        (f"{prefix}patch_embed.proj.weight", """beit.embeddings.patch_embeddings.projection.weight"""),
				        (f"{prefix}patch_embed.proj.bias", """beit.embeddings.patch_embeddings.projection.bias"""),
				        (f"{prefix}pos_embed", """beit.embeddings.position_embeddings"""),
				    ]    )

				if has_lm_head:
								# mask token + layernorm
								rename_keys.extend(
								    [
								        ("""mask_token""", """beit.embeddings.mask_token"""),
								        ("""norm.weight""", """layernorm.weight"""),
								        ("""norm.bias""", """layernorm.bias"""),
								    ]    )
				else:
								# layernorm + classification head
								rename_keys.extend(
								    [
								        ("""fc_norm.weight""", """beit.pooler.layernorm.weight"""),
								        ("""fc_norm.bias""", """beit.pooler.layernorm.bias"""),
								        ("""head.weight""", """classifier.weight"""),
								        ("""head.bias""", """classifier.bias"""),
								    ]    )

				return rename_keys

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Optional[Any]				,     _SCREAMING_SNAKE_CASE       :			str				,     _SCREAMING_SNAKE_CASE       :			Optional[Any]=False				,     _SCREAMING_SNAKE_CASE       :			Any=False    ):
				"""simple docstring"""







				for i in range(config.num_hidden_layers    ):
								__a       =		"""backbone.""" if is_semantic else """"""
								# queries, keys and values
								__a       =		state_dict.pop(f"{prefix}blocks.{i}.attn.qkv.weight"    )
								__a       =		state_dict.pop(f"{prefix}blocks.{i}.attn.q_bias"    )
								__a       =		state_dict.pop(f"{prefix}blocks.{i}.attn.v_bias"    )

								__a       =		in_proj_weight[
								    : config.hidden_size, :
								]
								__a       =		q_bias
								__a       =		in_proj_weight[
								    config.hidden_size : config.hidden_size * 2, :
								]
								__a       =		in_proj_weight[
								    -config.hidden_size :, :
								]
								__a       =		v_bias

								# gamma_1 and gamma_2
								# we call them lambda because otherwise they are renamed when using .from_pretrained
								__a       =		state_dict.pop(f"{prefix}blocks.{i}.gamma_1"    )
								__a       =		state_dict.pop(f"{prefix}blocks.{i}.gamma_2"    )

								__a       =		gamma_a
								__a       =		gamma_a

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Optional[int]				,     _SCREAMING_SNAKE_CASE       :			Dict				,     _SCREAMING_SNAKE_CASE       :			Optional[int]    ):
				"""simple docstring"""







				__a       =		dct.pop(_SCREAMING_SNAKE_CASE    )
				__a       =		val

def   lowerCAmelCase__						(							):
				"""simple docstring"""







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

@torch.no_grad()
def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Dict				,     _SCREAMING_SNAKE_CASE       :			List[Any]				,     _SCREAMING_SNAKE_CASE       :			str=False    ):
				"""simple docstring"""







				__a       =		False if """rvlcdip""" in checkpoint_url else True
				__a       =		BeitConfig(use_absolute_position_embeddings=_SCREAMING_SNAKE_CASE				,     use_mask_token=_SCREAMING_SNAKE_CASE    )

				# size of the architecture
				if "large" in checkpoint_url or "dit-l" in checkpoint_url:
								__a       =		1024
								__a       =		4096
								__a       =		24
								__a       =		16

				# labels
				if "rvlcdip" in checkpoint_url:
								__a       =		16
								__a       =		"""huggingface/label-files"""
								__a       =		"""rvlcdip-id2label.json"""
								__a       =		json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     repo_type="""dataset"""    )				,     """r"""    )    )
								__a       =		{int(_SCREAMING_SNAKE_CASE    ): v for k, v in idalabel.items()}
								__a       =		idalabel
								__a       =		{v: k for k, v in idalabel.items()}

				# load state_dict of original model, remove and rename some keys
				__a       =		torch.hub.load_state_dict_from_url(_SCREAMING_SNAKE_CASE				,     map_location="""cpu"""    )["""model"""]

				__a       =		create_rename_keys(_SCREAMING_SNAKE_CASE				,     has_lm_head=_SCREAMING_SNAKE_CASE    )
				for src, dest in rename_keys:
								rename_key(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )
				read_in_q_k_v(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     has_lm_head=_SCREAMING_SNAKE_CASE    )

				# load HuggingFace model
				__a       =		BeitForMaskedImageModeling(_SCREAMING_SNAKE_CASE    ) if has_lm_head else BeitForImageClassification(_SCREAMING_SNAKE_CASE    )
				model.eval()
				model.load_state_dict(_SCREAMING_SNAKE_CASE    )

				# Check outputs on an image
				__a       =		BeitImageProcessor(
				    size=config.image_size				,     resample=PILImageResampling.BILINEAR				,     do_center_crop=_SCREAMING_SNAKE_CASE    )
				__a       =		prepare_img()

				__a       =		image_processor(images=_SCREAMING_SNAKE_CASE				,     return_tensors="""pt"""    )
				__a       =		encoding["""pixel_values"""]

				__a       =		model(_SCREAMING_SNAKE_CASE    )
				__a       =		outputs.logits

				# verify logits
				__a       =		[1, 16] if """rvlcdip""" in checkpoint_url else [1, 196, 8192]
				assert logits.shape == torch.Size(_SCREAMING_SNAKE_CASE    ), "Shape of logits not as expected"

				Path(_SCREAMING_SNAKE_CASE    ).mkdir(exist_ok=_SCREAMING_SNAKE_CASE    )
				print(f"Saving model 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    )

				if push_to_hub:
								if has_lm_head:
												__a       =		"""dit-base""" if """base""" in checkpoint_url else """dit-large"""
								else:
												__a       =		"""dit-base-finetuned-rvlcdip""" if """dit-b""" in checkpoint_url else """dit-large-finetuned-rvlcdip"""
								image_processor.push_to_hub(
								    repo_path_or_name=Path(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )				,     organization="""nielsr"""				,     commit_message="""Add image processor"""				,     use_temp_dir=_SCREAMING_SNAKE_CASE				,     )
								model.push_to_hub(
								    repo_path_or_name=Path(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )				,     organization="""nielsr"""				,     commit_message="""Add model"""				,     use_temp_dir=_SCREAMING_SNAKE_CASE				,     )


if __name__ == "__main__":
						lowerCamelCase__			= argparse.ArgumentParser()

						parser.add_argument(
						    """--checkpoint_url""",
						    default="""https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth""",
						    type=str,
						    help="""URL to the original PyTorch checkpoint (.pth file).""",
						)
						parser.add_argument(
						    """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model."""
						)
						parser.add_argument(
						    """--push_to_hub""",
						    action="""store_true""",
						)
						lowerCamelCase__			= parser.parse_args()
						convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
