




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			)






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
