

"""simple docstring"""

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     :







						def __init__(self     ,							UpperCAmelCase_     ,							UpperCAmelCase_=2     ,							UpperCAmelCase_=3_2     ,							UpperCAmelCase_=1_6     ,							UpperCAmelCase_=3     ,							UpperCAmelCase_=True     ,							UpperCAmelCase_=True     ,							UpperCAmelCase_=3_2     ,							UpperCAmelCase_=4     ,							UpperCAmelCase_=[0, 1, 2, 3]     ,							UpperCAmelCase_=4     ,							UpperCAmelCase_=3_7     ,							UpperCAmelCase_="gelu"     ,							UpperCAmelCase_=0.1     ,							UpperCAmelCase_=0.1     ,							UpperCAmelCase_=0.0_2     ,							UpperCAmelCase_=3     ,							UpperCAmelCase_=False     ,							UpperCAmelCase_=None     ,							)			->						Any:
											__lowercase												=			parent
											__lowercase												=			batch_size
											__lowercase												=			image_size
											__lowercase												=			patch_size
											__lowercase												=			num_channels
											__lowercase												=			is_training
											__lowercase												=			use_labels
											__lowercase												=			hidden_size
											__lowercase												=			num_hidden_layers
											__lowercase												=			backbone_out_indices
											__lowercase												=			num_attention_heads
											__lowercase												=			intermediate_size
											__lowercase												=			hidden_act
											__lowercase												=			hidden_dropout_prob
											__lowercase												=			attention_probs_dropout_prob
											__lowercase												=			initializer_range
											__lowercase												=			num_labels
											__lowercase												=			scope
											__lowercase												=			is_hybrid
											# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
											__lowercase												=			(image_size // patch_size) ** 2
											__lowercase												=			num_patches + 1







						def        _UpperCamelCase    (self							)			->						Any:
											__lowercase												=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

											__lowercase												=			None
											if self.use_labels:
																__lowercase												=			ids_tensor([self.batch_size, self.image_size, self.image_size]     ,							self.num_labels							)

											__lowercase												=			self.get_config()

											return config, pixel_values, labels







						def        _UpperCamelCase    (self							)			->						str:
											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=UpperCAmelCase_     ,							initializer_range=self.initializer_range     ,							is_hybrid=self.is_hybrid     ,							)







						def        _UpperCamelCase    (self     ,							UpperCAmelCase_     ,							UpperCAmelCase_     ,							UpperCAmelCase_							)			->						List[str]:
											__lowercase												=			DPTModel(config=UpperCAmelCase_							)
											model.to(UpperCAmelCase_							)
											model.eval()
											__lowercase												=			model(UpperCAmelCase_							)
											self.parent.assertEqual(result.last_hidden_state.shape     ,							(self.batch_size, self.seq_length, self.hidden_size)							)







						def        _UpperCamelCase    (self     ,							UpperCAmelCase_     ,							UpperCAmelCase_     ,							UpperCAmelCase_							)			->						Any:
											__lowercase												=			self.num_labels
											__lowercase												=			DPTForDepthEstimation(UpperCAmelCase_							)
											model.to(UpperCAmelCase_							)
											model.eval()
											__lowercase												=			model(UpperCAmelCase_							)
											self.parent.assertEqual(result.predicted_depth.shape     ,							(self.batch_size, self.image_size, self.image_size)							)







						def        _UpperCamelCase    (self     ,							UpperCAmelCase_     ,							UpperCAmelCase_     ,							UpperCAmelCase_							)			->						Any:
											__lowercase												=			self.num_labels
											__lowercase												=			DPTForSemanticSegmentation(UpperCAmelCase_							)
											model.to(UpperCAmelCase_							)
											model.eval()
											__lowercase												=			model(UpperCAmelCase_     ,							labels=UpperCAmelCase_							)
											self.parent.assertEqual(
											    result.logits.shape     ,							(self.batch_size, self.num_labels, self.image_size, self.image_size)							)







						def        _UpperCamelCase    (self							)			->						List[str]:
											__lowercase												=			self.prepare_config_and_inputs()
											__lowercase						, __lowercase						, __lowercase												=			config_and_inputs
											__lowercase												=			{'''pixel_values''': pixel_values}
											return config, inputs_dict



@require_torch
class 			_snake_case     (						SCREAMING_SNAKE_CASE__						,			SCREAMING_SNAKE_CASE__						,			unittest.TestCase       ):
						__snake_case 			=     (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
						__snake_case 			=     (
						    {
						        'depth-estimation': DPTForDepthEstimation,
						        'feature-extraction': DPTModel,
						        'image-segmentation': DPTForSemanticSegmentation,
						    }
						    if is_torch_available()
						    else {}
						)

						__snake_case 			=     False
						__snake_case 			=     False
						__snake_case 			=     False







						def        _UpperCamelCase    (self							)			->						int:
											__lowercase												=			DPTModelTester(self							)
											__lowercase												=			ConfigTester(self     ,							config_class=UpperCAmelCase_     ,							has_text_modality=UpperCAmelCase_     ,							hidden_size=3_7							)







						def        _UpperCamelCase    (self							)			->						int:
											self.config_tester.run_common_tests()







						@unittest.skip(reason='''DPT does not use inputs_embeds'''							)
						def        _UpperCamelCase    (self							)			->						Any:
											pass







						def        _UpperCamelCase    (self							)			->						str:
											__lowercase						, __lowercase												=			self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																__lowercase												=			model_class(UpperCAmelCase_							)
																self.assertIsInstance(model.get_input_embeddings()     ,							(nn.Module)							)
																__lowercase												=			model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(UpperCAmelCase_     ,							nn.Linear							)							)







						def        _UpperCamelCase    (self							)			->						Optional[Any]:
											__lowercase						, __lowercase												=			self.model_tester.prepare_config_and_inputs_for_common()

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

																__lowercase												=			['''pixel_values''']
																self.assertListEqual(arg_names[:1]     ,							UpperCAmelCase_							)







						def        _UpperCamelCase    (self							)			->						Tuple:
											__lowercase												=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*UpperCAmelCase_							)







						def        _UpperCamelCase    (self							)			->						List[str]:
											__lowercase												=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_depth_estimation(*UpperCAmelCase_							)







						def        _UpperCamelCase    (self							)			->						Tuple:
											__lowercase												=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_semantic_segmentation(*UpperCAmelCase_							)







						def        _UpperCamelCase    (self							)			->						Tuple:



											for model_class in self.all_model_classes:
																if model_class.__name__ == "DPTForDepthEstimation":
																					continue

																__lowercase						, __lowercase												=			self.model_tester.prepare_config_and_inputs_for_common()
																__lowercase												=			True

																if model_class in get_values(UpperCAmelCase_							):
																					continue

																__lowercase												=			model_class(UpperCAmelCase_							)
																model.to(UpperCAmelCase_							)
																model.train()
																__lowercase												=			self._prepare_for_class(UpperCAmelCase_     ,							UpperCAmelCase_     ,							return_labels=UpperCAmelCase_							)
																__lowercase												=			model(**UpperCAmelCase_							).loss
																loss.backward()







						def        _UpperCamelCase    (self							)			->						Tuple:



											for model_class in self.all_model_classes:
																if model_class.__name__ == "DPTForDepthEstimation":
																					continue

																__lowercase						, __lowercase												=			self.model_tester.prepare_config_and_inputs_for_common()
																__lowercase												=			False
																__lowercase												=			True

																if model_class in get_values(UpperCAmelCase_							) or not model_class.supports_gradient_checkpointing:
																					continue
																__lowercase												=			model_class(UpperCAmelCase_							)
																model.to(UpperCAmelCase_							)
																model.gradient_checkpointing_enable()
																model.train()
																__lowercase												=			self._prepare_for_class(UpperCAmelCase_     ,							UpperCAmelCase_     ,							return_labels=UpperCAmelCase_							)
																__lowercase												=			model(**UpperCAmelCase_							).loss
																loss.backward()







						def        _UpperCamelCase    (self							)			->						int:
											__lowercase						, __lowercase												=			self.model_tester.prepare_config_and_inputs_for_common()

											__lowercase												=			_config_zero_init(UpperCAmelCase_							)
											for model_class in self.all_model_classes:
																__lowercase												=			model_class(config=UpperCAmelCase_							)
																# Skip the check for the backbone
																__lowercase												=			[]
																for name, module in model.named_modules():
																					if module.__class__.__name__ == "DPTViTHybridEmbeddings":
																										__lowercase												=			[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        _UpperCamelCase    (self							)			->						Optional[int]:
											pass







						@slow
						def        _UpperCamelCase    (self							)			->						str:



											for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__lowercase												=			DPTModel.from_pretrained(UpperCAmelCase_							)
																self.assertIsNotNone(UpperCAmelCase_							)





def 				__UpperCamelCase   (    )				->			List[str]:




					"""simple docstring"""



					__lowercase												=			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
					return image


@require_torch
@require_vision
@slow
class 			_snake_case     (						unittest.TestCase       ):







						def        _UpperCamelCase    (self							)			->						List[Any]:
											__lowercase												=			DPTImageProcessor.from_pretrained('''Intel/dpt-large'''							)
											__lowercase												=			DPTForDepthEstimation.from_pretrained('''Intel/dpt-large'''							).to(UpperCAmelCase_							)

											__lowercase												=			prepare_img()
											__lowercase												=			image_processor(images=UpperCAmelCase_     ,							return_tensors='''pt'''							).to(UpperCAmelCase_							)

											# forward pass
											with torch.no_grad():
																__lowercase												=			model(**UpperCAmelCase_							)
																__lowercase												=			outputs.predicted_depth

											# verify the predicted depth
											__lowercase												=			torch.Size((1, 3_8_4, 3_8_4)							)
											self.assertEqual(predicted_depth.shape     ,							UpperCAmelCase_							)

											__lowercase												=			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(UpperCAmelCase_							)

											self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]     ,							UpperCAmelCase_     ,							atol=1e-4							)							)







						def        _UpperCamelCase    (self							)			->						Union[str, Any]:
											__lowercase												=			DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''							)
											__lowercase												=			DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''							).to(UpperCAmelCase_							)

											__lowercase												=			prepare_img()
											__lowercase												=			image_processor(images=UpperCAmelCase_     ,							return_tensors='''pt'''							).to(UpperCAmelCase_							)

											# forward pass
											with torch.no_grad():
																__lowercase												=			model(**UpperCAmelCase_							)

											# verify the logits
											__lowercase												=			torch.Size((1, 1_5_0, 4_8_0, 4_8_0)							)
											self.assertEqual(outputs.logits.shape     ,							UpperCAmelCase_							)

											__lowercase												=			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(UpperCAmelCase_							)

											self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]     ,							UpperCAmelCase_     ,							atol=1e-4							)							)







						def        _UpperCamelCase    (self							)			->						Optional[int]:
											__lowercase												=			DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''							)
											__lowercase												=			DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''							).to(UpperCAmelCase_							)

											__lowercase												=			prepare_img()
											__lowercase												=			image_processor(images=UpperCAmelCase_     ,							return_tensors='''pt'''							).to(UpperCAmelCase_							)

											# forward pass
											with torch.no_grad():
																__lowercase												=			model(**UpperCAmelCase_							)

											__lowercase												=			outputs.logits.detach().cpu()

											__lowercase												=			image_processor.post_process_semantic_segmentation(outputs=UpperCAmelCase_     ,							target_sizes=[(5_0_0, 3_0_0)]							)
											__lowercase												=			torch.Size((5_0_0, 3_0_0)							)
											self.assertEqual(segmentation[0].shape     ,							UpperCAmelCase_							)

											__lowercase												=			image_processor.post_process_semantic_segmentation(outputs=UpperCAmelCase_							)
											__lowercase												=			torch.Size((4_8_0, 4_8_0)							)
											self.assertEqual(segmentation[0].shape     ,							UpperCAmelCase_							)


"""simple docstring"""

def 				__UpperCamelCase   (    a__: list ,	a__: list ,	a__: list ,	a__: int ,	a__: int			)				->			None:




					"""simple docstring"""



					if target == 0:
										answer.append(path.copy()			)
					else:
										for index in range(a__ ,	len(a__			)			):
															if target >= candidates[index]:
																				path.append(candidates[index]			)
																				backtrack(a__ ,	a__ ,	a__ ,	target - candidates[index] ,	a__			)
																				path.pop(len(a__			) - 1			)





def 				__UpperCamelCase   (    a__: list ,	a__: int			)				->			list:




					"""simple docstring"""



					__lowercase												=			[]  # type: list[int]
					__lowercase												=			[]  # type: list[int]
					backtrack(a__ ,	a__ ,	a__ ,	a__ ,	0			)
					return answer





def 				__UpperCamelCase   (    )				->			None:




					"""simple docstring"""



					print(combination_sum([-8, 2.3, 0] ,	1			)			)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							main()


