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 			a_					:
  
  
  
  
  
  	def __init__(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE=2			,    SCREAMING_SNAKE_CASE=32			,    SCREAMING_SNAKE_CASE=16			,    SCREAMING_SNAKE_CASE=3			,    SCREAMING_SNAKE_CASE=True			,    SCREAMING_SNAKE_CASE=True			,    SCREAMING_SNAKE_CASE=32			,    SCREAMING_SNAKE_CASE=4			,    SCREAMING_SNAKE_CASE=[0, 1, 2, 3]			,    SCREAMING_SNAKE_CASE=4			,    SCREAMING_SNAKE_CASE=37			,    SCREAMING_SNAKE_CASE="gelu"			,    SCREAMING_SNAKE_CASE=0.1			,    SCREAMING_SNAKE_CASE=0.1			,    SCREAMING_SNAKE_CASE=0.0_2			,    SCREAMING_SNAKE_CASE=3			,    SCREAMING_SNAKE_CASE=False			,    SCREAMING_SNAKE_CASE=None			,    )     ->				Any:
  
  
  
  
  				"""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 	A_(       self			)     ->				Any:
  
  
  
  
  				"""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 	A_(       self			)     ->				str:
  
  
  
  
  				"""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=SCREAMING_SNAKE_CASE			,    initializer_range=self.initializer_range			,    is_hybrid=self.is_hybrid			,    )
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)     ->				List[str]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	DPTModel(config=SCREAMING_SNAKE_CASE			)
  				model.to(SCREAMING_SNAKE_CASE			)
  				model.eval()
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
  				self.parent.assertEqual(result.last_hidden_state.shape			,    (self.batch_size, self.seq_length, self.hidden_size)			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)     ->				Any:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.num_labels
  				SCREAMING_SNAKE_CASE_			=	DPTForDepthEstimation(SCREAMING_SNAKE_CASE			)
  				model.to(SCREAMING_SNAKE_CASE			)
  				model.eval()
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			)
  				self.parent.assertEqual(result.predicted_depth.shape			,    (self.batch_size, self.image_size, self.image_size)			)
  
  
  
  
  
  	def 	A_(       self			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			)     ->				Any:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.num_labels
  				SCREAMING_SNAKE_CASE_			=	DPTForSemanticSegmentation(SCREAMING_SNAKE_CASE			)
  				model.to(SCREAMING_SNAKE_CASE			)
  				model.eval()
  				SCREAMING_SNAKE_CASE_			=	model(SCREAMING_SNAKE_CASE			,    labels=SCREAMING_SNAKE_CASE			)
  				self.parent.assertEqual(
  				    result.logits.shape			,    (self.batch_size, self.num_labels, self.image_size, self.image_size)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				List[str]:
  
  
  
  
  				"""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 			a_					(    SCREAMING_SNAKE_CASE__     ,						SCREAMING_SNAKE_CASE__     ,						unittest.TestCase    ):
  	A						       =   (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
  	A						       =   (
  	    {
  	        '''depth-estimation''': DPTForDepthEstimation,
  	        '''feature-extraction''': DPTModel,
  	        '''image-segmentation''': DPTForSemanticSegmentation,
  	    }
  	    if is_torch_available()
  	    else {}
  	)
  
  	A						       =   False
  	A						       =   False
  	A						       =   False
  
  
  
  
  
  	def 	A_(       self			)     ->				int:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	DPTModelTester(self			)
  				SCREAMING_SNAKE_CASE_			=	ConfigTester(self			,    config_class=SCREAMING_SNAKE_CASE			,    has_text_modality=SCREAMING_SNAKE_CASE			,    hidden_size=37			)
  
  
  
  
  
  	def 	A_(       self			)     ->				int:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				self.config_tester.run_common_tests()
  
  
  
  
  
  	@unittest.skip(reason='DPT does not use inputs_embeds'			)
  	def 	A_(       self			)     ->				Any:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				pass
  
  
  
  
  
  	def 	A_(       self			)     ->				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(SCREAMING_SNAKE_CASE			)
  							self.assertIsInstance(model.get_input_embeddings()			,    (nn.Module)			)
  							SCREAMING_SNAKE_CASE_			=	model.get_output_embeddings()
  							self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE			,    nn.Linear			)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Optional[Any]:
  
  
  
  
  				"""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(SCREAMING_SNAKE_CASE			)
  							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]			,    SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Tuple:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			)     ->				List[str]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_for_depth_estimation(*SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Tuple:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs()
  				self.model_tester.create_and_check_for_semantic_segmentation(*SCREAMING_SNAKE_CASE			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Tuple:
  
  
  
  
  				"""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(SCREAMING_SNAKE_CASE			):
  										continue
  
  							SCREAMING_SNAKE_CASE_			=	model_class(SCREAMING_SNAKE_CASE			)
  							model.to(SCREAMING_SNAKE_CASE			)
  							model.train()
  							SCREAMING_SNAKE_CASE_			=	self._prepare_for_class(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    return_labels=SCREAMING_SNAKE_CASE			)
  							SCREAMING_SNAKE_CASE_			=	model(**SCREAMING_SNAKE_CASE			).loss
  							loss.backward()
  
  
  
  
  
  	def 	A_(       self			)     ->				Tuple:
  
  
  
  
  				"""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(SCREAMING_SNAKE_CASE			) or not model_class.supports_gradient_checkpointing:
  										continue
  							SCREAMING_SNAKE_CASE_			=	model_class(SCREAMING_SNAKE_CASE			)
  							model.to(SCREAMING_SNAKE_CASE			)
  							model.gradient_checkpointing_enable()
  							model.train()
  							SCREAMING_SNAKE_CASE_			=	self._prepare_for_class(SCREAMING_SNAKE_CASE			,    SCREAMING_SNAKE_CASE			,    return_labels=SCREAMING_SNAKE_CASE			)
  							SCREAMING_SNAKE_CASE_			=	model(**SCREAMING_SNAKE_CASE			).loss
  							loss.backward()
  
  
  
  
  
  	def 	A_(       self			)     ->				int:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_	,		SCREAMING_SNAKE_CASE_			=	self.model_tester.prepare_config_and_inputs_for_common()
  
  				SCREAMING_SNAKE_CASE_			=	_config_zero_init(SCREAMING_SNAKE_CASE			)
  				for model_class in self.all_model_classes:
  							SCREAMING_SNAKE_CASE_			=	model_class(config=SCREAMING_SNAKE_CASE			)
  							# 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 	A_(       self			)     ->				Optional[int]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				pass
  
  
  
  
  
  	@slow
  	def 	A_(       self			)     ->				str:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  							SCREAMING_SNAKE_CASE_			=	DPTModel.from_pretrained(SCREAMING_SNAKE_CASE			)
  							self.assertIsNotNone(SCREAMING_SNAKE_CASE			)
  
  
  
  
  def lowercase						(     ) ->       List[str]:
  
  
  			'''simple docstring'''
  
  
  
  
  
  
  
  			SCREAMING_SNAKE_CASE_			=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
  			return image
  
  
  
  @require_torch
  @require_vision
  @slow
  class 			a_					(    unittest.TestCase    ):
  
  
  
  
  
  	def 	A_(       self			)     ->				List[Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	DPTImageProcessor.from_pretrained('Intel/dpt-large'			)
  				SCREAMING_SNAKE_CASE_			=	DPTForDepthEstimation.from_pretrained('Intel/dpt-large'			).to(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	prepare_img()
  				SCREAMING_SNAKE_CASE_			=	image_processor(images=SCREAMING_SNAKE_CASE			,    return_tensors='pt'			).to(SCREAMING_SNAKE_CASE			)
  
  				# forward pass
  				with torch.no_grad():
  							SCREAMING_SNAKE_CASE_			=	model(**SCREAMING_SNAKE_CASE			)
  							SCREAMING_SNAKE_CASE_			=	outputs.predicted_depth
  
  				# verify the predicted depth
  				SCREAMING_SNAKE_CASE_			=	torch.Size((1, 384, 384)			)
  				self.assertEqual(predicted_depth.shape			,    SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	torch.tensor(
  				    [[6.3_1_9_9, 6.3_6_2_9, 6.4_1_4_8], [6.3_8_5_0, 6.3_6_1_5, 6.4_1_6_6], [6.3_5_1_9, 6.3_1_7_6, 6.3_5_7_5]]			).to(SCREAMING_SNAKE_CASE			)
  
  				self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]			,    SCREAMING_SNAKE_CASE			,    atol=1e-4			)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				Union[str, Any]:
  
  
  
  
  				"""simple docstring"""
  
  
  
  				SCREAMING_SNAKE_CASE_			=	DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'			)
  				SCREAMING_SNAKE_CASE_			=	DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'			).to(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	prepare_img()
  				SCREAMING_SNAKE_CASE_			=	image_processor(images=SCREAMING_SNAKE_CASE			,    return_tensors='pt'			).to(SCREAMING_SNAKE_CASE			)
  
  				# forward pass
  				with torch.no_grad():
  							SCREAMING_SNAKE_CASE_			=	model(**SCREAMING_SNAKE_CASE			)
  
  				# verify the logits
  				SCREAMING_SNAKE_CASE_			=	torch.Size((1, 150, 480, 480)			)
  				self.assertEqual(outputs.logits.shape			,    SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	torch.tensor(
  				    [[4.0_4_8_0, 4.2_4_2_0, 4.4_3_6_0], [4.3_1_2_4, 4.5_6_9_3, 4.8_2_6_1], [4.5_7_6_8, 4.8_9_6_5, 5.2_1_6_3]]			).to(SCREAMING_SNAKE_CASE			)
  
  				self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]			,    SCREAMING_SNAKE_CASE			,    atol=1e-4			)			)
  
  
  
  
  
  	def 	A_(       self			)     ->				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(SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	prepare_img()
  				SCREAMING_SNAKE_CASE_			=	image_processor(images=SCREAMING_SNAKE_CASE			,    return_tensors='pt'			).to(SCREAMING_SNAKE_CASE			)
  
  				# forward pass
  				with torch.no_grad():
  							SCREAMING_SNAKE_CASE_			=	model(**SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	outputs.logits.detach().cpu()
  
  				SCREAMING_SNAKE_CASE_			=	image_processor.post_process_semantic_segmentation(outputs=SCREAMING_SNAKE_CASE			,    target_sizes=[(500, 300)]			)
  				SCREAMING_SNAKE_CASE_			=	torch.Size((500, 300)			)
  				self.assertEqual(segmentation[0].shape			,    SCREAMING_SNAKE_CASE			)
  
  				SCREAMING_SNAKE_CASE_			=	image_processor.post_process_semantic_segmentation(outputs=SCREAMING_SNAKE_CASE			)
  				SCREAMING_SNAKE_CASE_			=	torch.Size((480, 480)			)
  				self.assertEqual(segmentation[0].shape			,    SCREAMING_SNAKE_CASE			)
  
style_context: 
  
  
  
  
  from dataclasses import dataclass
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  
  from ...utils import BaseOutput, is_invisible_watermark_available, is_torch_available, is_transformers_available
  
  
  
  @dataclass
  class 			a_					(    SCREAMING_SNAKE_CASE__    ):
  	A						       =   42
  
  
  if is_transformers_available() and is_torch_available() and is_invisible_watermark_available():
  				from .pipeline_stable_diffusion_xl import StableDiffusionXLPipeline
  				from .pipeline_stable_diffusion_xl_imgaimg import StableDiffusionXLImgaImgPipeline
  