
from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import DeiTConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import (
						    TFDeiTForImageClassification,
						    TFDeiTForImageClassificationWithTeacher,
						    TFDeiTForMaskedImageModeling,
						    TFDeiTModel,
						)
						from transformers.models.deit.modeling_tf_deit import TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import DeiTImageProcessor






class    SCREAMING_SNAKE_CASE			:





							def __init__(   self		:		Optional[int]      ,				__lowercase		:		str      ,				__lowercase		:		Optional[int]=13      ,				__lowercase		:		str=30      ,				__lowercase		:		Optional[int]=2      ,				__lowercase		:		List[Any]=3      ,				__lowercase		:		List[Any]=True      ,				__lowercase		:		str=True      ,				__lowercase		:		Optional[Any]=32      ,				__lowercase		:		int=2      ,				__lowercase		:		Optional[Any]=4      ,				__lowercase		:		str=37      ,				__lowercase		:		Union[str, Any]="gelu"      ,				__lowercase		:		Union[str, Any]=0.1      ,				__lowercase		:		Dict=0.1      ,				__lowercase		:		Tuple=10      ,				__lowercase		:		List[Any]=0.02      ,				__lowercase		:		int=3      ,				__lowercase		:		List[Any]=None      ,				__lowercase		:		Union[str, Any]=2      ,				):

											'''simple docstring'''
											__a       =		parent
											__a       =		batch_size
											__a       =		image_size
											__a       =		patch_size
											__a       =		num_channels
											__a       =		is_training
											__a       =		use_labels
											__a       =		hidden_size
											__a       =		num_hidden_layers
											__a       =		num_attention_heads
											__a       =		intermediate_size
											__a       =		hidden_act
											__a       =		hidden_dropout_prob
											__a       =		attention_probs_dropout_prob
											__a       =		type_sequence_label_size
											__a       =		initializer_range
											__a       =		scope
											__a       =		encoder_stride

											# in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
											__a       =		(image_size // patch_size) ** 2
											__a       =		num_patches + 2





							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											__a       =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

											__a       =		None
											if self.use_labels:
															__a       =		ids_tensor([self.batch_size]      ,				self.type_sequence_label_size	)

											__a       =		self.get_config()

											return config, pixel_values, labels





							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											return DeiTConfig(
											    image_size=self.image_size      ,				patch_size=self.patch_size      ,				num_channels=self.num_channels      ,				hidden_size=self.hidden_size      ,				num_hidden_layers=self.num_hidden_layers      ,				num_attention_heads=self.num_attention_heads      ,				intermediate_size=self.intermediate_size      ,				hidden_act=self.hidden_act      ,				hidden_dropout_prob=self.hidden_dropout_prob      ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,				is_decoder=__lowercase      ,				initializer_range=self.initializer_range      ,				encoder_stride=self.encoder_stride      ,				)





							def 						UpperCamelCase_					(   self		:		str      ,				__lowercase		:		Any      ,				__lowercase		:		Union[str, Any]      ,				__lowercase		:		Dict	):

											'''simple docstring'''
											__a       =		TFDeiTModel(config=__lowercase	)
											__a       =		model(__lowercase	)
											self.parent.assertEqual(result.last_hidden_state.shape      ,				(self.batch_size, self.seq_length, self.hidden_size)	)





							def 						UpperCamelCase_					(   self		:		int      ,				__lowercase		:		Union[str, Any]      ,				__lowercase		:		Any      ,				__lowercase		:		List[str]	):

											'''simple docstring'''
											__a       =		TFDeiTForMaskedImageModeling(config=__lowercase	)
											__a       =		model(__lowercase	)
											self.parent.assertEqual(
											    result.reconstruction.shape      ,				(self.batch_size, self.num_channels, self.image_size, self.image_size)	)

											# test greyscale images
											__a       =		1
											__a       =		TFDeiTForMaskedImageModeling(__lowercase	)

											__a       =		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
											__a       =		model(__lowercase	)
											self.parent.assertEqual(result.reconstruction.shape      ,				(self.batch_size, 1, self.image_size, self.image_size)	)





							def 						UpperCamelCase_					(   self		:		Optional[int]      ,				__lowercase		:		Any      ,				__lowercase		:		Any      ,				__lowercase		:		Union[str, Any]	):

											'''simple docstring'''
											__a       =		self.type_sequence_label_size
											__a       =		TFDeiTForImageClassification(__lowercase	)
											__a       =		model(__lowercase      ,				labels=__lowercase	)
											self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.type_sequence_label_size)	)

											# test greyscale images
											__a       =		1
											__a       =		TFDeiTForImageClassification(__lowercase	)

											__a       =		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
											__a       =		model(__lowercase      ,				labels=__lowercase	)
											self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.type_sequence_label_size)	)







							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											__a       =		self.prepare_config_and_inputs()
											__a     ,					__a     ,					__a       =		config_and_inputs
											__a       =		{"""pixel_values""": pixel_values}
											return config, inputs_dict






@require_tf
class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Dict    =(
							    (
							        TFDeiTModel,
							        TFDeiTForImageClassification,
							        TFDeiTForImageClassificationWithTeacher,
							        TFDeiTForMaskedImageModeling,
							    )
							    if is_tf_available()
							    else ()
							)
							__lowerCamelCase	:	Union[str, Any]    =(
							    {
							        'feature-extraction': TFDeiTModel,
							        'image-classification': (TFDeiTForImageClassification, TFDeiTForImageClassificationWithTeacher),
							    }
							    if is_tf_available()
							    else {}
							)

							__lowerCamelCase	:	Any    =False
							__lowerCamelCase	:	Tuple    =False
							__lowerCamelCase	:	Dict    =False
							__lowerCamelCase	:	List[Any]    =False





							def 						UpperCamelCase_					(   self		:		Optional[Any]	):

											'''simple docstring'''
											__a       =		TFDeiTModelTester(self	)
											__a       =		ConfigTester(self      ,				config_class=__lowercase      ,				has_text_modality=__lowercase      ,				hidden_size=37	)





							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											self.config_tester.run_common_tests()





							@unittest.skip(reason="""DeiT does not use inputs_embeds"""	)
							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											pass





							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a     ,					__a       =		self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															__a       =		model_class(__lowercase	)
															self.assertIsInstance(model.get_input_embeddings()      ,				(tf.keras.layers.Layer)	)
															__a       =		model.get_output_embeddings()
															self.assertTrue(x is None or isinstance(__lowercase      ,				tf.keras.layers.Dense	)	)





							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											__a     ,					__a       =		self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															__a       =		model_class(__lowercase	)
															__a       =		inspect.signature(model.call	)
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															__a       =		[*signature.parameters.keys()]

															__a       =		["""pixel_values"""]
															self.assertListEqual(arg_names[:1]      ,				__lowercase	)





							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											__a       =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__lowercase	)





							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											__a       =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*__lowercase	)





							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a       =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*__lowercase	)





							def 						UpperCamelCase_					(   self		:		int      ,				__lowercase		:		Dict      ,				__lowercase		:		Any      ,				__lowercase		:		Tuple=False	):

											'''simple docstring'''
											__a       =		super()._prepare_for_class(__lowercase      ,				__lowercase      ,				return_labels=__lowercase	)

											if return_labels:
															if "labels" in inputs_dict and "labels" not in inspect.signature(model_class.call	).parameters:
																			del inputs_dict["labels"]

											return inputs_dict







							@slow
							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											for model_name in TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															__a       =		TFDeiTModel.from_pretrained(__lowercase	)
															self.assertIsNotNone(__lowercase	)



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







				__a       =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
				return image






@require_tf
@require_vision
class    SCREAMING_SNAKE_CASE			(							unittest.TestCase					):





							@cached_property
							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											return (
											    DeiTImageProcessor.from_pretrained("""facebook/deit-base-distilled-patch16-224"""	)
											    if is_vision_available()
											    else None
											)







							@slow
							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											__a       =		TFDeiTForImageClassificationWithTeacher.from_pretrained("""facebook/deit-base-distilled-patch16-224"""	)

											__a       =		self.default_image_processor
											__a       =		prepare_img()
											__a       =		image_processor(images=__lowercase      ,				return_tensors="""tf"""	)

											# forward pass
											__a       =		model(**__lowercase	)

											# verify the logits
											__a       =		tf.TensorShape((1, 1000)	)
											self.assertEqual(outputs.logits.shape      ,				__lowercase	)

											__a       =		tf.constant([-1.0266, 0.1912, -1.2861]	)

											self.assertTrue(np.allclose(outputs.logits[0, :3]      ,				__lowercase      ,				atol=1E-4	)	)





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__			= logging.get_logger(__name__)

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







				__a       =		DPTConfig(embedding_type="""hybrid"""    )

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

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

				if "ade" in checkpoint_url:
								__a       =		True
								__a       =		768
								__a       =		[1, 1, 1, 0.5]
								__a       =		150
								__a       =		16
								__a       =		"""huggingface/label-files"""
								__a       =		"""ade20k-id2label.json"""
								__a       =		json.load(open(cached_download(hf_hub_url(_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()}
								__a       =		[1, 150, 480, 480]

				return config, expected_shape

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







				__a       =		["""pretrained.model.head.weight""", """pretrained.model.head.bias"""]
				for k in ignore_keys:
								state_dict.pop(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )

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

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

				if ".." in name:
								__a       =		name.replace(""".."""				,     """."""    )

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

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

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       :			Any				,     _SCREAMING_SNAKE_CASE       :			int				,     _SCREAMING_SNAKE_CASE       :			Union[str, Any]				,     _SCREAMING_SNAKE_CASE       :			Optional[int]				,     _SCREAMING_SNAKE_CASE       :			int    ):
				"""simple docstring"""







				__a     ,					__a       =		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")
				__a       =		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():
								__a       =		state_dict.pop(_SCREAMING_SNAKE_CASE    )
								__a       =		val
				# read in qkv matrices
				read_in_q_k_v(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )

				# load HuggingFace model
				__a       =		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
				__a       =		480 if """ade""" in checkpoint_url else 384
				__a       =		DPTImageProcessor(size=_SCREAMING_SNAKE_CASE    )

				__a       =		prepare_img()
				__a       =		image_processor(_SCREAMING_SNAKE_CASE				,     return_tensors="""pt"""    )

				# forward pass
				__a       =		model(**_SCREAMING_SNAKE_CASE    ).logits if """ade""" in checkpoint_url else model(**_SCREAMING_SNAKE_CASE    ).predicted_depth

				if show_prediction:
								__a       =		(
								    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__			= 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__			= parser.parse_args()
						convert_dpt_checkpoint(
						    args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name, args.show_prediction
						)
