





'''simple docstring'''






import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference







class 		UpperCAmelCase   (				lowercase_   ,     unittest.TestCase):


  """simple docstring"""







  lowerCAmelCase_					=				ShapEPipeline
  lowerCAmelCase_					=				["prompt"]
  lowerCAmelCase_					=				["prompt"]
  lowerCAmelCase_					=				[
      "num_images_per_prompt",
      "num_inference_steps",
      "generator",
      "latents",
      "guidance_scale",
      "frame_size",
      "output_type",
      "return_dict",
  ]
  lowerCAmelCase_					=				False


  @property
  def   UpperCamelCase__      (				self    :					str  )     ->						Dict:
    return 32


  @property
  def   UpperCamelCase__      (				self    :					Any  )     ->						Union[str, Any]:
    return 32


  @property
  def   UpperCamelCase__      (				self    :					List[str]  )     ->						str:
    return self.time_input_dim * 4


  @property
  def   UpperCamelCase__      (				self    :					Dict  )     ->						Dict:
    return 8


  @property
  def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						List[Any]:
    _UpperCamelCase       			=CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )
    return tokenizer


  @property
  def   UpperCamelCase__      (				self    :					List[str]  )     ->						Tuple:
    torch.manual_seed(0  )
    _UpperCamelCase       			=CLIPTextConfig(
        bos_token_id=0							,	eos_token_id=2							,	hidden_size=self.text_embedder_hidden_size							,	projection_dim=self.text_embedder_hidden_size							,	intermediate_size=37							,	layer_norm_eps=1E-05							,	num_attention_heads=4							,	num_hidden_layers=5							,	pad_token_id=1							,	vocab_size=1000							,	)
    return CLIPTextModelWithProjection(UpperCamelCase__  )


  @property
  def   UpperCamelCase__      (				self    :					List[str]  )     ->						Tuple:
    torch.manual_seed(0  )

    _UpperCamelCase       			={
        '''num_attention_heads''': 2,
        '''attention_head_dim''': 16,
        '''embedding_dim''': self.time_input_dim,
        '''num_embeddings''': 32,
        '''embedding_proj_dim''': self.text_embedder_hidden_size,
        '''time_embed_dim''': self.time_embed_dim,
        '''num_layers''': 1,
        '''clip_embed_dim''': self.time_input_dim * 2,
        '''additional_embeddings''': 0,
        '''time_embed_act_fn''': '''gelu''',
        '''norm_in_type''': '''layer''',
        '''encoder_hid_proj_type''': None,
        '''added_emb_type''': None,
    }

    _UpperCamelCase       			=PriorTransformer(**UpperCamelCase__  )
    return model


  @property
  def   UpperCamelCase__      (				self    :					str  )     ->						List[Any]:
    torch.manual_seed(0  )

    _UpperCamelCase       			={
        '''param_shapes''': (
            (self.renderer_dim, 93),
            (self.renderer_dim, 8),
            (self.renderer_dim, 8),
            (self.renderer_dim, 8),
        ),
        '''d_latent''': self.time_input_dim,
        '''d_hidden''': self.renderer_dim,
        '''n_output''': 12,
        '''background''': (
            0.1,
            0.1,
            0.1,
        ),
    }
    _UpperCamelCase       			=ShapERenderer(**UpperCamelCase__  )
    return model


  def   UpperCamelCase__      (				self    :					str  )     ->						Optional[int]:
    _UpperCamelCase       			=self.dummy_prior
    _UpperCamelCase       			=self.dummy_text_encoder
    _UpperCamelCase       			=self.dummy_tokenizer
    _UpperCamelCase       			=self.dummy_renderer

    _UpperCamelCase       			=HeunDiscreteScheduler(
        beta_schedule='''exp'''							,	num_train_timesteps=1024							,	prediction_type='''sample'''							,	use_karras_sigmas=UpperCamelCase__							,	clip_sample=UpperCamelCase__							,	clip_sample_range=1.0							,	)
    _UpperCamelCase       			={
        '''prior''': prior,
        '''text_encoder''': text_encoder,
        '''tokenizer''': tokenizer,
        '''renderer''': renderer,
        '''scheduler''': scheduler,
    }

    return components


  def   UpperCamelCase__      (				self    :					List[str]							,	UpperCamelCase__    :					List[Any]							,	UpperCamelCase__    :					Optional[Any]=0  )     ->						Dict:





    if str(UpperCamelCase__  ).startswith('''mps'''  ):
      _UpperCamelCase       			=torch.manual_seed(UpperCamelCase__  )
    else:
      _UpperCamelCase       			=torch.Generator(device=UpperCamelCase__  ).manual_seed(UpperCamelCase__  )
    _UpperCamelCase       			={
        '''prompt''': '''horse''',
        '''generator''': generator,
        '''num_inference_steps''': 1,
        '''frame_size''': 32,
        '''output_type''': '''np''',
    }
    return inputs


  def   UpperCamelCase__      (				self    :					int  )     ->						Any:
    _UpperCamelCase       			='''cpu'''

    _UpperCamelCase       			=self.get_dummy_components()

    _UpperCamelCase       			=self.pipeline_class(**UpperCamelCase__  )
    _UpperCamelCase       			=pipe.to(UpperCamelCase__  )

    pipe.set_progress_bar_config(disable=UpperCamelCase__  )

    _UpperCamelCase       			=pipe(**self.get_dummy_inputs(UpperCamelCase__  )  )
    _UpperCamelCase       			=output.images[0]
    _UpperCamelCase       			=image[0, -3:, -3:, -1]

    assert image.shape == (20, 32, 32, 3)

    _UpperCamelCase       			=np.array(
        [
            0.00039216,
            0.00039216,
            0.00039216,
            0.00039216,
            0.00039216,
            0.00039216,
            0.00039216,
            0.00039216,
            0.00039216,
        ]  )

    assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-2


  def   UpperCamelCase__      (				self    :					Tuple  )     ->						List[Any]:
    self._test_inference_batch_consistent(batch_sizes=[1, 2]  )


  def   UpperCamelCase__      (				self    :					int  )     ->						Tuple:
    _UpperCamelCase       			=torch_device == '''cpu'''
    _UpperCamelCase       			=True

    self._test_inference_batch_single_identical(
        batch_size=2							,	test_max_difference=UpperCamelCase__							,	relax_max_difference=UpperCamelCase__							,	)




  def   UpperCamelCase__      (				self    :					Any  )     ->						Any:
    _UpperCamelCase       			=self.get_dummy_components()
    _UpperCamelCase       			=self.pipeline_class(**UpperCamelCase__  )
    _UpperCamelCase       			=pipe.to(UpperCamelCase__  )
    pipe.set_progress_bar_config(disable=UpperCamelCase__  )

    _UpperCamelCase       			=1
    _UpperCamelCase       			=2

    _UpperCamelCase       			=self.get_dummy_inputs(UpperCamelCase__  )

    for key in inputs.keys():
      if key in self.batch_params:
        _UpperCamelCase       			=batch_size * [inputs[key]]

    _UpperCamelCase       			=pipe(**UpperCamelCase__							,	num_images_per_prompt=UpperCamelCase__  )[0]

    assert images.shape[0] == batch_size * num_images_per_prompt







@slow
@require_torch_gpu
class 		UpperCAmelCase   (				unittest.TestCase):


  """simple docstring"""







  def   UpperCamelCase__      (				self    :					int  )     ->						List[Any]:
    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()




  def   UpperCamelCase__      (				self    :					Optional[Any]  )     ->						Tuple:
    _UpperCamelCase       			=load_numpy(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
        '''/shap_e/test_shap_e_np_out.npy'''  )
    _UpperCamelCase       			=ShapEPipeline.from_pretrained('''openai/shap-e'''  )
    _UpperCamelCase       			=pipe.to(UpperCamelCase__  )
    pipe.set_progress_bar_config(disable=UpperCamelCase__  )

    _UpperCamelCase       			=torch.Generator(device=UpperCamelCase__  ).manual_seed(0  )

    _UpperCamelCase       			=pipe(
        '''a shark'''							,	generator=UpperCamelCase__							,	guidance_scale=15.0							,	num_inference_steps=64							,	frame_size=64							,	output_type='''np'''							,	).images[0]

    assert images.shape == (20, 64, 64, 3)

    assert_mean_pixel_difference(UpperCamelCase__							,	UpperCamelCase__  )













'''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()
__lowerCamelCase						: Optional[Any]		=   logging.get_logger(__name__)


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

  _UpperCamelCase       			=DPTConfig(embedding_type='''hybrid'''   )

  if "large" in checkpoint_url:
    _UpperCamelCase       			=1024
    _UpperCamelCase       			=4096
    _UpperCamelCase       			=24
    _UpperCamelCase       			=16
    _UpperCamelCase       			=[5, 11, 17, 23]
    _UpperCamelCase       			=[256, 512, 1024, 1024]
    _UpperCamelCase       			=(1, 384, 384)

  if "nyu" or "midas" in checkpoint_url:
    _UpperCamelCase       			=768
    _UpperCamelCase       			=[1, 1, 1, 0.5]
    _UpperCamelCase       			=[256, 512, 768, 768]
    _UpperCamelCase       			=150
    _UpperCamelCase       			=16
    _UpperCamelCase       			=(1, 384, 384)
    _UpperCamelCase       			=False
    _UpperCamelCase       			='''project'''

  if "ade" in checkpoint_url:
    _UpperCamelCase       			=True
    _UpperCamelCase       			=768
    _UpperCamelCase       			=[1, 1, 1, 0.5]
    _UpperCamelCase       			=150
    _UpperCamelCase       			=16
    _UpperCamelCase       			='''huggingface/label-files'''
    _UpperCamelCase       			='''ade20k-id2label.json'''
    _UpperCamelCase       			=json.load(open(cached_download(hf_hub_url(__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      repo_type='''dataset'''   )   )  ,      '''r'''   )   )
    _UpperCamelCase       			={int(__SCREAMING_SNAKE_CASE   ): v for k, v in idalabel.items()}
    _UpperCamelCase       			=idalabel
    _UpperCamelCase       			={v: k for k, v in idalabel.items()}
    _UpperCamelCase       			=[1, 150, 480, 480]

  return config, expected_shape


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

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


def 					_a   (__SCREAMING_SNAKE_CASE   ):


  """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
  ):
    _UpperCamelCase       			=name.replace('''pretrained.model'''  ,      '''dpt.encoder'''   )
  if "pretrained.model" in name:
    _UpperCamelCase       			=name.replace('''pretrained.model'''  ,      '''dpt.embeddings'''   )
  if "patch_embed" in name:
    _UpperCamelCase       			=name.replace('''patch_embed'''  ,      ''''''   )
  if "pos_embed" in name:
    _UpperCamelCase       			=name.replace('''pos_embed'''  ,      '''position_embeddings'''   )
  if "attn.proj" in name:
    _UpperCamelCase       			=name.replace('''attn.proj'''  ,      '''attention.output.dense'''   )
  if "proj" in name and "project" not in name:
    _UpperCamelCase       			=name.replace('''proj'''  ,      '''projection'''   )
  if "blocks" in name:
    _UpperCamelCase       			=name.replace('''blocks'''  ,      '''layer'''   )
  if "mlp.fc1" in name:
    _UpperCamelCase       			=name.replace('''mlp.fc1'''  ,      '''intermediate.dense'''   )
  if "mlp.fc2" in name:
    _UpperCamelCase       			=name.replace('''mlp.fc2'''  ,      '''output.dense'''   )
  if "norm1" in name and "backbone" not in name:
    _UpperCamelCase       			=name.replace('''norm1'''  ,      '''layernorm_before'''   )
  if "norm2" in name and "backbone" not in name:
    _UpperCamelCase       			=name.replace('''norm2'''  ,      '''layernorm_after'''   )
  if "scratch.output_conv" in name:
    _UpperCamelCase       			=name.replace('''scratch.output_conv'''  ,      '''head'''   )
  if "scratch" in name:
    _UpperCamelCase       			=name.replace('''scratch'''  ,      '''neck'''   )
  if "layer1_rn" in name:
    _UpperCamelCase       			=name.replace('''layer1_rn'''  ,      '''convs.0'''   )
  if "layer2_rn" in name:
    _UpperCamelCase       			=name.replace('''layer2_rn'''  ,      '''convs.1'''   )
  if "layer3_rn" in name:
    _UpperCamelCase       			=name.replace('''layer3_rn'''  ,      '''convs.2'''   )
  if "layer4_rn" in name:
    _UpperCamelCase       			=name.replace('''layer4_rn'''  ,      '''convs.3'''   )
  if "refinenet" in name:
    _UpperCamelCase       			=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
    _UpperCamelCase       			=name.replace(f'''refinenet{layer_idx}'''  ,      f'''fusion_stage.layers.{abs(layer_idx-4   )}'''   )
  if "out_conv" in name:
    _UpperCamelCase       			=name.replace('''out_conv'''  ,      '''projection'''   )
  if "resConfUnit1" in name:
    _UpperCamelCase       			=name.replace('''resConfUnit1'''  ,      '''residual_layer1'''   )
  if "resConfUnit2" in name:
    _UpperCamelCase       			=name.replace('''resConfUnit2'''  ,      '''residual_layer2'''   )
  if "conv1" in name:
    _UpperCamelCase       			=name.replace('''conv1'''  ,      '''convolution1'''   )
  if "conv2" in name:
    _UpperCamelCase       			=name.replace('''conv2'''  ,      '''convolution2'''   )
  # readout blocks
  if "pretrained.act_postprocess1.0.project.0" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess1.0.project.0'''  ,      '''neck.reassemble_stage.readout_projects.0.0'''   )
  if "pretrained.act_postprocess2.0.project.0" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess2.0.project.0'''  ,      '''neck.reassemble_stage.readout_projects.1.0'''   )
  if "pretrained.act_postprocess3.0.project.0" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess3.0.project.0'''  ,      '''neck.reassemble_stage.readout_projects.2.0'''   )
  if "pretrained.act_postprocess4.0.project.0" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess4.0.project.0'''  ,      '''neck.reassemble_stage.readout_projects.3.0'''   )

  # resize blocks
  if "pretrained.act_postprocess1.3" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess1.3'''  ,      '''neck.reassemble_stage.layers.0.projection'''   )
  if "pretrained.act_postprocess1.4" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess1.4'''  ,      '''neck.reassemble_stage.layers.0.resize'''   )
  if "pretrained.act_postprocess2.3" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess2.3'''  ,      '''neck.reassemble_stage.layers.1.projection'''   )
  if "pretrained.act_postprocess2.4" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess2.4'''  ,      '''neck.reassemble_stage.layers.1.resize'''   )
  if "pretrained.act_postprocess3.3" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess3.3'''  ,      '''neck.reassemble_stage.layers.2.projection'''   )
  if "pretrained.act_postprocess4.3" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess4.3'''  ,      '''neck.reassemble_stage.layers.3.projection'''   )
  if "pretrained.act_postprocess4.4" in name:
    _UpperCamelCase       			=name.replace('''pretrained.act_postprocess4.4'''  ,      '''neck.reassemble_stage.layers.3.resize'''   )
  if "pretrained" in name:
    _UpperCamelCase       			=name.replace('''pretrained'''  ,      '''dpt'''   )
  if "bn" in name:
    _UpperCamelCase       			=name.replace('''bn'''  ,      '''batch_norm'''   )
  if "head" in name:
    _UpperCamelCase       			=name.replace('''head'''  ,      '''head.head'''   )
  if "encoder.norm" in name:
    _UpperCamelCase       			=name.replace('''encoder.norm'''  ,      '''layernorm'''   )
  if "auxlayer" in name:
    _UpperCamelCase       			=name.replace('''auxlayer'''  ,      '''auxiliary_head.head'''   )
  if "backbone" in name:
    _UpperCamelCase       			=name.replace('''backbone'''  ,      '''backbone.bit.encoder'''   )

  if ".." in name:
    _UpperCamelCase       			=name.replace('''..'''  ,      '''.'''   )

  if "stem.conv" in name:
    _UpperCamelCase       			=name.replace('''stem.conv'''  ,      '''bit.embedder.convolution'''   )
  if "blocks" in name:
    _UpperCamelCase       			=name.replace('''blocks'''  ,      '''layers'''   )
  if "convolution" in name and "backbone" in name:
    _UpperCamelCase       			=name.replace('''convolution'''  ,      '''conv'''   )
  if "layer" in name and "backbone" in name:
    _UpperCamelCase       			=name.replace('''layer'''  ,      '''layers'''   )
  if "backbone.bit.encoder.bit" in name:
    _UpperCamelCase       			=name.replace('''backbone.bit.encoder.bit'''  ,      '''backbone.bit'''   )
  if "embedder.conv" in name:
    _UpperCamelCase       			=name.replace('''embedder.conv'''  ,      '''embedder.convolution'''   )
  if "backbone.bit.encoder.stem.norm" in name:
    _UpperCamelCase       			=name.replace('''backbone.bit.encoder.stem.norm'''  ,      '''backbone.bit.embedder.norm'''   )
  return name


def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """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)
    _UpperCamelCase       			=state_dict.pop(f'''dpt.encoder.layer.{i}.attn.qkv.weight'''   )
    _UpperCamelCase       			=state_dict.pop(f'''dpt.encoder.layer.{i}.attn.qkv.bias'''   )
    # next, add query, keys and values (in that order) to the state dict
    _UpperCamelCase       			=in_proj_weight[: config.hidden_size, :]
    _UpperCamelCase       			=in_proj_bias[: config.hidden_size]
    _UpperCamelCase       			=in_proj_weight[
        config.hidden_size : config.hidden_size * 2, :
    ]
    _UpperCamelCase       			=in_proj_bias[
        config.hidden_size : config.hidden_size * 2
    ]
    _UpperCamelCase       			=in_proj_weight[
        -config.hidden_size :, :
    ]
    _UpperCamelCase       			=in_proj_bias[-config.hidden_size :]


def 					_a   ():


  """simple docstring"""

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


@torch.no_grad()
def 					_a   (__SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE  ,      __SCREAMING_SNAKE_CASE   ):


  """simple docstring"""

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

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

  # Check outputs on an image
  _UpperCamelCase       			=480 if '''ade''' in checkpoint_url else 384
  _UpperCamelCase       			=DPTImageProcessor(size=__SCREAMING_SNAKE_CASE   )

  _UpperCamelCase       			=prepare_img()
  _UpperCamelCase       			=image_processor(__SCREAMING_SNAKE_CASE  ,      return_tensors='''pt'''   )

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

  if show_prediction:
    _UpperCamelCase       			=(
        torch.nn.functional.interpolate(
            outputs.unsqueeze(1   )  ,      size=(image.size[1], image.size[0])  ,      mode='''bicubic'''  ,      align_corners=__SCREAMING_SNAKE_CASE  ,      )
        .squeeze()
        .cpu()
        .numpy()
    )

    Image.fromarray((prediction / prediction.max()) * 255   ).show()

  if pytorch_dump_folder_path is not None:
    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:
    model.push_to_hub('''ybelkada/dpt-hybrid-midas'''   )
    image_processor.push_to_hub('''ybelkada/dpt-hybrid-midas'''   )


if __name__ == "__main__":
      __lowerCamelCase						: List[str]		=   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=False,
          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.',
      )
      parser.add_argument(
          '--show_prediction',
          action='store_true',
      )

      __lowerCamelCase						: Dict		=   parser.parse_args()
      convert_dpt_checkpoint(
          args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name, args.show_prediction
      )






