

'''simple docstring'''

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 					__UpperCamelCase				(						lowercase__    :	Any			):






     '''simple docstring'''





     __lowercase      		=fname.split(os.path.sep			)[-1]
     return re.search(R'^(.*)_\d+\.jpg$',       lowercase__			).groups()[0]


class 	lowerCAmelCase  (   A ):







       def __init__(				self      :			Tuple    ,   __lowercase      :			List[str]    ,   __lowercase      :			Optional[Any]=None    ,   __lowercase      :			Optional[Any]=None   ):







            """simple docstring"""







            __lowercase      		=file_names
            __lowercase      		=image_transform
            __lowercase      		=label_to_id







       def __len__(				self      :			Optional[Any]   ):







            """simple docstring"""







            return len(self.file_names   )







       def __getitem__(				self      :			List[Any]    ,   __lowercase      :			str   ):







            """simple docstring"""







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






def 					__UpperCamelCase				(						lowercase__    :	Dict,       lowercase__    :	int			):






     '''simple docstring'''





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

     # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
     __lowercase      		=config['lr']
     __lowercase      		=int(config['num_epochs']			)
     __lowercase      		=int(config['seed']			)
     __lowercase      		=int(config['batch_size']			)
     __lowercase      		=config['image_size']
     if not isinstance(lowercase__,       (list, tuple)			):
          __lowercase      		=(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":
               __lowercase      		=args.checkpointing_steps
          elif args.checkpointing_steps.isdigit():
               __lowercase      		=int(args.checkpointing_steps			)
          else:
               raise ValueError(
                   F'''Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.'''			)
     else:
          __lowercase      		=None

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

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

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

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

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

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

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

     # Instantiate dataloaders.
     __lowercase      		=DataLoader(lowercase__,       shuffle=lowercase__,       batch_size=lowercase__,       num_workers=4			)
     __lowercase      		=DataLoader(lowercase__,       shuffle=lowercase__,       batch_size=lowercase__,       num_workers=4			)

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

     # 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).
     __lowercase      		=model.to(accelerator.device			)

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

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

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

     # Instantiate learning rate scheduler
     __lowercase      		=OneCycleLR(optimizer=lowercase__,       max_lr=lowercase__,       epochs=lowercase__,       steps_per_epoch=len(lowercase__			)			)

     # 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.
     __lowercase		,  __lowercase		,  __lowercase		,  __lowercase		,  __lowercase      		=accelerator.prepare(
         lowercase__,       lowercase__,       lowercase__,       lowercase__,       lowercase__			)
     # We need to keep track of how many total steps we have iterated over
     __lowercase      		=0
     # We also need to keep track of the starting epoch so files are named properly
     __lowercase      		=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			)
               __lowercase      		=os.path.basename(args.resume_from_checkpoint			)
          else:
               # Get the most recent checkpoint
               __lowercase      		=[f.name for f in os.scandir(os.getcwd()			) if f.is_dir()]
               dirs.sort(key=os.path.getctime			)
               __lowercase      		=dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
          # Extract `epoch_{i}` or `step_{i}`
          __lowercase      		=os.path.splitext(lowercase__			)[0]

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

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

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

     if args.with_tracking:
          accelerator.end_training()

def 					__UpperCamelCase				(						):






     '''simple docstring'''





     __lowercase      		=argparse.ArgumentParser(description='Simple example of training script.'			)
     parser.add_argument('--data_dir',       required=lowercase__,       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=lowercase__,       default=lowercase__,       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=lowercase__,       default=lowercase__,       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=lowercase__,       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=lowercase__,       default=lowercase__,       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=lowercase__,       default='logs',       help='Location on where to store experiment tracking logs` and relevent project information',       )
     __lowercase      		=parser.parse_args()
     __lowercase      		={'lr': 3E-2, 'num_epochs': 3, 'seed': 42, 'batch_size': 64, 'image_size': 2_24}
     training_function(lowercase__,       lowercase__			)


if __name__ == "__main__":
       main()





'''simple docstring'''

import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_url
from PIL import Image

from transformers import DPTConfig, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTImageProcessor
from transformers.utils import logging


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

def 					__UpperCamelCase				(						lowercase__    :	Dict			):






     '''simple docstring'''





     __lowercase      		=DPTConfig()

     if "large" in checkpoint_url:
          __lowercase      		=10_24
          __lowercase      		=40_96
          __lowercase      		=24
          __lowercase      		=16
          __lowercase      		=[5, 11, 17, 23]
          __lowercase      		=[2_56, 5_12, 10_24, 10_24]
          __lowercase      		=(1, 3_84, 3_84)

     if "ade" in checkpoint_url:
          __lowercase      		=True

          __lowercase      		=1_50
          __lowercase      		='huggingface/label-files'
          __lowercase      		='ade20k-id2label.json'
          __lowercase      		=json.load(open(cached_download(hf_hub_url(lowercase__,       lowercase__,       repo_type='dataset'			)			),       'r'			)			)
          __lowercase      		={int(lowercase__			): v for k, v in idalabel.items()}
          __lowercase      		=idalabel
          __lowercase      		={v: k for k, v in idalabel.items()}
          __lowercase      		=[1, 1_50, 4_80, 4_80]

     return config, expected_shape

def 					__UpperCamelCase				(						lowercase__    :	Optional[int]			):






     '''simple docstring'''





     __lowercase      		=['pretrained.model.head.weight', 'pretrained.model.head.bias']
     for k in ignore_keys:
          state_dict.pop(lowercase__,       lowercase__			)

def 					__UpperCamelCase				(						lowercase__    :	Union[str, Any]			):






     '''simple docstring'''





     if (
         "pretrained.model" in name
         and "cls_token" not in name
         and "pos_embed" not in name
         and "patch_embed" not in name
     ):
          __lowercase      		=name.replace('pretrained.model',       'dpt.encoder'			)
     if "pretrained.model" in name:
          __lowercase      		=name.replace('pretrained.model',       'dpt.embeddings'			)
     if "patch_embed" in name:
          __lowercase      		=name.replace('patch_embed',       'patch_embeddings'			)
     if "pos_embed" in name:
          __lowercase      		=name.replace('pos_embed',       'position_embeddings'			)
     if "attn.proj" in name:
          __lowercase      		=name.replace('attn.proj',       'attention.output.dense'			)
     if "proj" in name and "project" not in name:
          __lowercase      		=name.replace('proj',       'projection'			)
     if "blocks" in name:
          __lowercase      		=name.replace('blocks',       'layer'			)
     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 "norm1" in name:
          __lowercase      		=name.replace('norm1',       'layernorm_before'			)
     if "norm2" in name:
          __lowercase      		=name.replace('norm2',       'layernorm_after'			)
     if "scratch.output_conv" in name:
          __lowercase      		=name.replace('scratch.output_conv',       'head'			)
     if "scratch" in name:
          __lowercase      		=name.replace('scratch',       'neck'			)
     if "layer1_rn" in name:
          __lowercase      		=name.replace('layer1_rn',       'convs.0'			)
     if "layer2_rn" in name:
          __lowercase      		=name.replace('layer2_rn',       'convs.1'			)
     if "layer3_rn" in name:
          __lowercase      		=name.replace('layer3_rn',       'convs.2'			)
     if "layer4_rn" in name:
          __lowercase      		=name.replace('layer4_rn',       'convs.3'			)
     if "refinenet" in name:
          __lowercase      		=int(name[len('neck.refinenet'			) : len('neck.refinenet'			) + 1]			)
          # tricky here: we need to map 4 to 0, 3 to 1, 2 to 2 and 1 to 3
          __lowercase      		=name.replace(F'''refinenet{layer_idx}''',       F'''fusion_stage.layers.{abs(layer_idx-4			)}'''			)
     if "out_conv" in name:
          __lowercase      		=name.replace('out_conv',       'projection'			)
     if "resConfUnit1" in name:
          __lowercase      		=name.replace('resConfUnit1',       'residual_layer1'			)
     if "resConfUnit2" in name:
          __lowercase      		=name.replace('resConfUnit2',       'residual_layer2'			)
     if "conv1" in name:
          __lowercase      		=name.replace('conv1',       'convolution1'			)
     if "conv2" in name:
          __lowercase      		=name.replace('conv2',       'convolution2'			)
     # readout blocks
     if "pretrained.act_postprocess1.0.project.0" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess1.0.project.0',       'neck.reassemble_stage.readout_projects.0.0'			)
     if "pretrained.act_postprocess2.0.project.0" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess2.0.project.0',       'neck.reassemble_stage.readout_projects.1.0'			)
     if "pretrained.act_postprocess3.0.project.0" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess3.0.project.0',       'neck.reassemble_stage.readout_projects.2.0'			)
     if "pretrained.act_postprocess4.0.project.0" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess4.0.project.0',       'neck.reassemble_stage.readout_projects.3.0'			)
     # resize blocks
     if "pretrained.act_postprocess1.3" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess1.3',       'neck.reassemble_stage.layers.0.projection'			)
     if "pretrained.act_postprocess1.4" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess1.4',       'neck.reassemble_stage.layers.0.resize'			)
     if "pretrained.act_postprocess2.3" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess2.3',       'neck.reassemble_stage.layers.1.projection'			)
     if "pretrained.act_postprocess2.4" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess2.4',       'neck.reassemble_stage.layers.1.resize'			)
     if "pretrained.act_postprocess3.3" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess3.3',       'neck.reassemble_stage.layers.2.projection'			)
     if "pretrained.act_postprocess4.3" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess4.3',       'neck.reassemble_stage.layers.3.projection'			)
     if "pretrained.act_postprocess4.4" in name:
          __lowercase      		=name.replace('pretrained.act_postprocess4.4',       'neck.reassemble_stage.layers.3.resize'			)
     if "pretrained" in name:
          __lowercase      		=name.replace('pretrained',       'dpt'			)
     if "bn" in name:
          __lowercase      		=name.replace('bn',       'batch_norm'			)
     if "head" in name:
          __lowercase      		=name.replace('head',       'head.head'			)
     if "encoder.norm" in name:
          __lowercase      		=name.replace('encoder.norm',       'layernorm'			)
     if "auxlayer" in name:
          __lowercase      		=name.replace('auxlayer',       'auxiliary_head.head'			)

     return name

def 					__UpperCamelCase				(						lowercase__    :	Any,       lowercase__    :	Optional[Any]			):






     '''simple docstring'''





     for i in range(config.num_hidden_layers			):
          # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
          __lowercase      		=state_dict.pop(F'''dpt.encoder.layer.{i}.attn.qkv.weight'''			)
          __lowercase      		=state_dict.pop(F'''dpt.encoder.layer.{i}.attn.qkv.bias'''			)
          # next, add query, keys and values (in that order) to the state dict
          __lowercase      		=in_proj_weight[: config.hidden_size, :]
          __lowercase      		=in_proj_bias[: config.hidden_size]
          __lowercase      		=in_proj_weight[
              config.hidden_size : config.hidden_size * 2, :
          ]
          __lowercase      		=in_proj_bias[
              config.hidden_size : config.hidden_size * 2
          ]
          __lowercase      		=in_proj_weight[
              -config.hidden_size :, :
          ]
          __lowercase      		=in_proj_bias[-config.hidden_size :]

def 					__UpperCamelCase				(						):






     '''simple docstring'''





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

@torch.no_grad()
def 					__UpperCamelCase				(						lowercase__    :	Optional[Any],       lowercase__    :	str,       lowercase__    :	List[str],       lowercase__    :	List[str]			):






     '''simple docstring'''





     __lowercase		,  __lowercase      		=get_dpt_config(lowercase__			)
     # load original state_dict from URL
     __lowercase      		=torch.hub.load_state_dict_from_url(lowercase__,       map_location='cpu'			)
     # remove certain keys
     remove_ignore_keys_(lowercase__			)
     # rename keys
     for key in state_dict.copy().keys():
          __lowercase      		=state_dict.pop(lowercase__			)
          __lowercase      		=val
     # read in qkv matrices
     read_in_q_k_v(lowercase__,       lowercase__			)

     # load HuggingFace model
     __lowercase      		=DPTForSemanticSegmentation(lowercase__			) if 'ade' in checkpoint_url else DPTForDepthEstimation(lowercase__			)
     model.load_state_dict(lowercase__			)
     model.eval()

     # Check outputs on an image
     __lowercase      		=4_80 if 'ade' in checkpoint_url else 3_84
     __lowercase      		=DPTImageProcessor(size=lowercase__			)

     __lowercase      		=prepare_img()
     __lowercase      		=image_processor(lowercase__,       return_tensors='pt'			)

     # forward pass
     __lowercase      		=model(**lowercase__			).logits if 'ade' in checkpoint_url else model(**lowercase__			).predicted_depth

     # Assert logits
     __lowercase      		=torch.tensor([[6.3199, 6.3629, 6.4148], [6.3850, 6.3615, 6.4166], [6.3519, 6.3176, 6.3575]]			)
     if "ade" in checkpoint_url:
          __lowercase      		=torch.tensor([[4.0480, 4.2420, 4.4360], [4.3124, 4.5693, 4.8261], [4.5768, 4.8965, 5.2163]]			)
     assert outputs.shape == torch.Size(lowercase__			)
     assert (
         torch.allclose(outputs[0, 0, :3, :3],       lowercase__,       atol=1E-4			)
         if "ade" in checkpoint_url
         else torch.allclose(outputs[0, :3, :3],       lowercase__			)
     )

     Path(lowercase__			).mkdir(exist_ok=lowercase__			)
     print(F'''Saving model to {pytorch_dump_folder_path}'''			)
     model.save_pretrained(lowercase__			)
     print(F'''Saving image processor to {pytorch_dump_folder_path}'''			)
     image_processor.save_pretrained(lowercase__			)

     if push_to_hub:
          print('Pushing model to hub...'			)
          model.push_to_hub(
              repo_path_or_name=Path(lowercase__,       lowercase__			),       organization='nielsr',       commit_message='Add model',       use_temp_dir=lowercase__,       )
          image_processor.push_to_hub(
              repo_path_or_name=Path(lowercase__,       lowercase__			),       organization='nielsr',       commit_message='Add image processor',       use_temp_dir=lowercase__,       )


if __name__ == "__main__":
       UpperCAmelCase					 =	argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '''--checkpoint_url''',
           default='''https://github.com/intel-isl/DPT/releases/download/1_0/dpt_large-midas-2f21e586.pt''',
           type=str,
           help='''URL of the original DPT checkpoint you\'d like to convert.''',
       )
       parser.add_argument(
           '''--pytorch_dump_folder_path''',
           default=None,
           type=str,
           required=True,
           help='''Path to the output PyTorch model directory.''',
       )
       parser.add_argument(
           '''--push_to_hub''',
           action='''store_true''',
       )
       parser.add_argument(
           '''--model_name''',
           default='''dpt-large''',
           type=str,
           help='''Name of the model, in case you\'re pushing to the hub.''',
       )

       UpperCAmelCase					 =	parser.parse_args()
       convert_dpt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)


