code: 
  
  
  import inspect
  import unittest
  
  from transformers import DPTConfig
  from transformers.file_utils import is_torch_available, is_vision_available
  from transformers.models.auto import get_values
  from transformers.testing_utils import require_torch, require_vision, slow, torch_device
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
  		import torch
  		from torch import nn
  
  		from transformers import MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel
  		from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  if is_vision_available():
  		from PIL import Image
  
  		from transformers import DPTImageProcessor
  
  class 						snake_case			:
  			'''simple docstring'''
  
  			def __init__(	self     :     List[Any]							,							lowerCAmelCase_     :     List[str]							,							lowerCAmelCase_     :     Any=2							,							lowerCAmelCase_     :     Tuple=32							,							lowerCAmelCase_     :     str=16							,							lowerCAmelCase_     :     List[str]=3							,							lowerCAmelCase_     :     Dict=True							,							lowerCAmelCase_     :     Optional[int]=True							,							lowerCAmelCase_     :     Optional[Any]=32							,							lowerCAmelCase_     :     int=4							,							lowerCAmelCase_     :     Union[str, Any]=[0, 1, 2, 3]							,							lowerCAmelCase_     :     Tuple=4							,							lowerCAmelCase_     :     Any=37							,							lowerCAmelCase_     :     Union[str, Any]="gelu"							,							lowerCAmelCase_     :     str=0.1							,							lowerCAmelCase_     :     Any=0.1							,							lowerCAmelCase_     :     Tuple=0.02							,							lowerCAmelCase_     :     Dict=3							,							lowerCAmelCase_     :     Union[str, Any]=False							,							lowerCAmelCase_     :     Union[str, Any]=None							,							)					->					Dict:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       parent
  								SCREAMING_SNAKE_CASE_	      =       batch_size
  								SCREAMING_SNAKE_CASE_	      =       image_size
  								SCREAMING_SNAKE_CASE_	      =       patch_size
  								SCREAMING_SNAKE_CASE_	      =       num_channels
  								SCREAMING_SNAKE_CASE_	      =       is_training
  								SCREAMING_SNAKE_CASE_	      =       use_labels
  								SCREAMING_SNAKE_CASE_	      =       hidden_size
  								SCREAMING_SNAKE_CASE_	      =       num_hidden_layers
  								SCREAMING_SNAKE_CASE_	      =       backbone_out_indices
  								SCREAMING_SNAKE_CASE_	      =       num_attention_heads
  								SCREAMING_SNAKE_CASE_	      =       intermediate_size
  								SCREAMING_SNAKE_CASE_	      =       hidden_act
  								SCREAMING_SNAKE_CASE_	      =       hidden_dropout_prob
  								SCREAMING_SNAKE_CASE_	      =       attention_probs_dropout_prob
  								SCREAMING_SNAKE_CASE_	      =       initializer_range
  								SCREAMING_SNAKE_CASE_	      =       num_labels
  								SCREAMING_SNAKE_CASE_	      =       scope
  								SCREAMING_SNAKE_CASE_	      =       is_hybrid
  								# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
  								SCREAMING_SNAKE_CASE_	      =       (image_size // patch_size) ** 2
  								SCREAMING_SNAKE_CASE_	      =       num_patches + 1
  
  			def _lowercase (	self     :     List[Any]					)					->					int:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)
  
  								SCREAMING_SNAKE_CASE_	      =       None
  								if self.use_labels:
  													SCREAMING_SNAKE_CASE_	      =       ids_tensor([self.batch_size, self.image_size, self.image_size]							,							self.num_labels					)
  
  								SCREAMING_SNAKE_CASE_	      =       self.get_config()
  
  								return config, pixel_values, labels
  
  			def _lowercase (	self     :     List[Any]					)					->					List[Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								return DPTConfig(
  								    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							,							backbone_out_indices=self.backbone_out_indices							,							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=lowerCAmelCase_							,							initializer_range=self.initializer_range							,							is_hybrid=self.is_hybrid							,							)
  
  			def _lowercase (	self     :     List[str]							,							lowerCAmelCase_     :     Optional[int]							,							lowerCAmelCase_     :     Tuple							,							lowerCAmelCase_     :     str					)					->					List[str]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       DPTModel(config=lowerCAmelCase_					)
  								model.to(lowerCAmelCase_					)
  								model.eval()
  								SCREAMING_SNAKE_CASE_	      =       model(lowerCAmelCase_					)
  								self.parent.assertEqual(result.last_hidden_state.shape							,							(self.batch_size, self.seq_length, self.hidden_size)					)
  
  			def _lowercase (	self     :     Tuple							,							lowerCAmelCase_     :     Union[str, Any]							,							lowerCAmelCase_     :     Optional[int]							,							lowerCAmelCase_     :     Optional[Any]					)					->					Dict:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.num_labels
  								SCREAMING_SNAKE_CASE_	      =       DPTForDepthEstimation(lowerCAmelCase_					)
  								model.to(lowerCAmelCase_					)
  								model.eval()
  								SCREAMING_SNAKE_CASE_	      =       model(lowerCAmelCase_					)
  								self.parent.assertEqual(result.predicted_depth.shape							,							(self.batch_size, self.image_size, self.image_size)					)
  
  			def _lowercase (	self     :     Tuple							,							lowerCAmelCase_     :     str							,							lowerCAmelCase_     :     Any							,							lowerCAmelCase_     :     Union[str, Any]					)					->					List[str]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.num_labels
  								SCREAMING_SNAKE_CASE_	      =       DPTForSemanticSegmentation(lowerCAmelCase_					)
  								model.to(lowerCAmelCase_					)
  								model.eval()
  								SCREAMING_SNAKE_CASE_	      =       model(lowerCAmelCase_							,							labels=lowerCAmelCase_					)
  								self.parent.assertEqual(
  								    result.logits.shape							,							(self.batch_size, self.num_labels, self.image_size, self.image_size)					)
  
  
  
  
  			def _lowercase (	self     :     int					)					->					Union[str, Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.prepare_config_and_inputs()
  								SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_	      =       config_and_inputs
  								SCREAMING_SNAKE_CASE_	      =       {'''pixel_values''': pixel_values}
  								return config, inputs_dict
  
  @require_torch
  class 						snake_case			(       lowerCAmelCase__	, lowerCAmelCase__	, unittest.TestCase	):
  			'''simple docstring'''
  
  			UpperCAmelCase       :       Any       = (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
  			UpperCAmelCase       :       Any       = (
  			    {
  			        """depth-estimation""": DPTForDepthEstimation,
  			        """feature-extraction""": DPTModel,
  			        """image-segmentation""": DPTForSemanticSegmentation,
  			    }
  			    if is_torch_available()
  			    else {}
  			)
  
  			UpperCAmelCase       :       Optional[Any]       = False
  			UpperCAmelCase       :       Tuple       = False
  			UpperCAmelCase       :       Any       = False
  
  			def _lowercase (	self     :     str					)					->					Dict:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       DPTModelTester(self					)
  								SCREAMING_SNAKE_CASE_	      =       ConfigTester(self							,							config_class=lowerCAmelCase_							,							has_text_modality=lowerCAmelCase_							,							hidden_size=37					)
  
  			def _lowercase (	self     :     int					)					->					List[Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								self.config_tester.run_common_tests()
  
  			@unittest.skip(reason='''DPT does not use inputs_embeds'''					)
  			def _lowercase (	self     :     Dict					)					->					Union[str, Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								pass
  
  			def _lowercase (	self     :     str					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_	      =       self.model_tester.prepare_config_and_inputs_for_common()
  
  								for model_class in self.all_model_classes:
  													SCREAMING_SNAKE_CASE_	      =       model_class(lowerCAmelCase_					)
  													self.assertIsInstance(model.get_input_embeddings()							,							(nn.Module)					)
  													SCREAMING_SNAKE_CASE_	      =       model.get_output_embeddings()
  													self.assertTrue(x is None or isinstance(lowerCAmelCase_							,							nn.Linear					)					)
  
  			def _lowercase (	self     :     Union[str, Any]					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_	      =       self.model_tester.prepare_config_and_inputs_for_common()
  
  								for model_class in self.all_model_classes:
  													SCREAMING_SNAKE_CASE_	      =       model_class(lowerCAmelCase_					)
  													SCREAMING_SNAKE_CASE_	      =       inspect.signature(model.forward					)
  													# signature.parameters is an OrderedDict => so arg_names order is deterministic
  													SCREAMING_SNAKE_CASE_	      =       [*signature.parameters.keys()]
  
  													SCREAMING_SNAKE_CASE_	      =       ['''pixel_values''']
  													self.assertListEqual(arg_names[:1]							,							lowerCAmelCase_					)
  
  			def _lowercase (	self     :     Dict					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.model_tester.prepare_config_and_inputs()
  								self.model_tester.create_and_check_model(*lowerCAmelCase_					)
  
  			def _lowercase (	self     :     Optional[int]					)					->					List[str]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.model_tester.prepare_config_and_inputs()
  								self.model_tester.create_and_check_for_depth_estimation(*lowerCAmelCase_					)
  
  			def _lowercase (	self     :     Any					)					->					Union[str, Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.model_tester.prepare_config_and_inputs()
  								self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase_					)
  
  			def _lowercase (	self     :     Optional[int]					)					->					Any:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								for model_class in self.all_model_classes:
  													if model_class.__name__ == "DPTForDepthEstimation":
  																		continue
  
  													SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_	      =       self.model_tester.prepare_config_and_inputs_for_common()
  													SCREAMING_SNAKE_CASE_	      =       True
  
  													if model_class in get_values(lowerCAmelCase_					):
  																		continue
  
  													SCREAMING_SNAKE_CASE_	      =       model_class(lowerCAmelCase_					)
  													model.to(lowerCAmelCase_					)
  													model.train()
  													SCREAMING_SNAKE_CASE_	      =       self._prepare_for_class(lowerCAmelCase_							,							lowerCAmelCase_							,							return_labels=lowerCAmelCase_					)
  													SCREAMING_SNAKE_CASE_	      =       model(**lowerCAmelCase_					).loss
  													loss.backward()
  
  			def _lowercase (	self     :     str					)					->					int:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								for model_class in self.all_model_classes:
  													if model_class.__name__ == "DPTForDepthEstimation":
  																		continue
  
  													SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_	      =       self.model_tester.prepare_config_and_inputs_for_common()
  													SCREAMING_SNAKE_CASE_	      =       False
  													SCREAMING_SNAKE_CASE_	      =       True
  
  													if model_class in get_values(lowerCAmelCase_					) or not model_class.supports_gradient_checkpointing:
  																		continue
  													SCREAMING_SNAKE_CASE_	      =       model_class(lowerCAmelCase_					)
  													model.to(lowerCAmelCase_					)
  													model.gradient_checkpointing_enable()
  													model.train()
  													SCREAMING_SNAKE_CASE_	      =       self._prepare_for_class(lowerCAmelCase_							,							lowerCAmelCase_							,							return_labels=lowerCAmelCase_					)
  													SCREAMING_SNAKE_CASE_	      =       model(**lowerCAmelCase_					).loss
  													loss.backward()
  
  			def _lowercase (	self     :     Dict					)					->					Any:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_      ,SCREAMING_SNAKE_CASE_	      =       self.model_tester.prepare_config_and_inputs_for_common()
  
  								SCREAMING_SNAKE_CASE_	      =       _config_zero_init(lowerCAmelCase_					)
  								for model_class in self.all_model_classes:
  													SCREAMING_SNAKE_CASE_	      =       model_class(config=lowerCAmelCase_					)
  													# Skip the check for the backbone
  													SCREAMING_SNAKE_CASE_	      =       []
  													for name, module in model.named_modules():
  																		if module.__class__.__name__ == "DPTViTHybridEmbeddings":
  																							SCREAMING_SNAKE_CASE_	      =       [F'''{name}.{key}''' for key in module.state_dict().keys()]
  																							break
  
  													for name, param in model.named_parameters():
  																		if param.requires_grad:
  																							if name in backbone_params:
  																												continue
  																							self.assertIn(
  																							    ((param.data.mean() * 1e9).round() / 1e9).item()							,							[0.0, 1.0]							,							msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''							,							)
  
  			@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''					)
  			def _lowercase (	self     :     int					)					->					List[str]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								pass
  
  
  
  
  			@slow
  			def _lowercase (	self     :     Union[str, Any]					)					->					List[str]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  													SCREAMING_SNAKE_CASE_	      =       DPTModel.from_pretrained(lowerCAmelCase_					)
  													self.assertIsNotNone(lowerCAmelCase_					)
  
  
  
  
  
  
  
  def 							UpperCAmelCase				(     )->		Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					SCREAMING_SNAKE_CASE_	      =       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
  					return image
  
  
  
  
  
  
  @require_torch
  @require_vision
  @slow
  class 						snake_case			(       unittest.TestCase	):
  			'''simple docstring'''
  
  			def _lowercase (	self     :     Union[str, Any]					)					->					Any:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       DPTImageProcessor.from_pretrained('''Intel/dpt-large'''					)
  								SCREAMING_SNAKE_CASE_	      =       DPTForDepthEstimation.from_pretrained('''Intel/dpt-large'''					).to(lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       prepare_img()
  								SCREAMING_SNAKE_CASE_	      =       image_processor(images=lowerCAmelCase_							,							return_tensors='''pt'''					).to(lowerCAmelCase_					)
  
  								# forward pass
  								with torch.no_grad():
  													SCREAMING_SNAKE_CASE_	      =       model(**lowerCAmelCase_					)
  													SCREAMING_SNAKE_CASE_	      =       outputs.predicted_depth
  
  								# verify the predicted depth
  								SCREAMING_SNAKE_CASE_	      =       torch.Size((1, 384, 384)					)
  								self.assertEqual(predicted_depth.shape							,							lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       torch.tensor(
  								    [[6.3_199, 6.3_629, 6.4_148], [6.3_850, 6.3_615, 6.4_166], [6.3_519, 6.3_176, 6.3_575]]					).to(lowerCAmelCase_					)
  
  								self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]							,							lowerCAmelCase_							,							atol=1e-4					)					)
  
  			def _lowercase (	self     :     List[str]					)					->					Optional[int]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''					)
  								SCREAMING_SNAKE_CASE_	      =       DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''					).to(lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       prepare_img()
  								SCREAMING_SNAKE_CASE_	      =       image_processor(images=lowerCAmelCase_							,							return_tensors='''pt'''					).to(lowerCAmelCase_					)
  
  								# forward pass
  								with torch.no_grad():
  													SCREAMING_SNAKE_CASE_	      =       model(**lowerCAmelCase_					)
  
  								# verify the logits
  								SCREAMING_SNAKE_CASE_	      =       torch.Size((1, 150, 480, 480)					)
  								self.assertEqual(outputs.logits.shape							,							lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       torch.tensor(
  								    [[4.0_480, 4.2_420, 4.4_360], [4.3_124, 4.5_693, 4.8_261], [4.5_768, 4.8_965, 5.2_163]]					).to(lowerCAmelCase_					)
  
  								self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]							,							lowerCAmelCase_							,							atol=1e-4					)					)
  
  
  
  
  			def _lowercase (	self     :     List[str]					)					->					Optional[int]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''					)
  								SCREAMING_SNAKE_CASE_	      =       DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''					).to(lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       prepare_img()
  								SCREAMING_SNAKE_CASE_	      =       image_processor(images=lowerCAmelCase_							,							return_tensors='''pt'''					).to(lowerCAmelCase_					)
  
  								# forward pass
  								with torch.no_grad():
  													SCREAMING_SNAKE_CASE_	      =       model(**lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       outputs.logits.detach().cpu()
  
  								SCREAMING_SNAKE_CASE_	      =       image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase_							,							target_sizes=[(500, 300)]					)
  								SCREAMING_SNAKE_CASE_	      =       torch.Size((500, 300)					)
  								self.assertEqual(segmentation[0].shape							,							lowerCAmelCase_					)
  
  								SCREAMING_SNAKE_CASE_	      =       image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase_					)
  								SCREAMING_SNAKE_CASE_	      =       torch.Size((480, 480)					)
  								self.assertEqual(segmentation[0].shape							,							lowerCAmelCase_					)
  
  
  
style_context: 
  
  
  def 							UpperCAmelCase				(     UpperCAmelCase      )->		bool:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					if not isinstance(UpperCAmelCase				,UpperCAmelCase      ):
  										SCREAMING_SNAKE_CASE_	      =       f'''Input value of [number={number}] must be an integer'''
  										raise TypeError(UpperCAmelCase      )
  					if number < 0 or number % 2 == 1:
  										return False
  					SCREAMING_SNAKE_CASE_	      =       int(number**0.5      )
  					return number == number_sqrt * (number_sqrt + 1)
  
  
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  
  