
"""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    _lowerCAmelCase						:



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



							def       _a   (      self   )							->							List[str]:
								_UpperCAmelCase =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

								_UpperCAmelCase =						self.get_config()

								return config, pixel_values, labels



							def       _a   (      self   )							->							Optional[Any]:
								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=a_ ,						initializer_range=self.initializer_range ,						is_hybrid=self.is_hybrid ,						)



							def       _a   (      self ,						a_ ,						a_ ,						a_   )							->							List[Any]:
								_UpperCAmelCase =						DPTModel(config=a_   )
								model.to(a_   )
								model.eval()
								_UpperCAmelCase =						model(a_   )
								self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size)   )



							def       _a   (      self ,						a_ ,						a_ ,						a_   )							->							Any:
								_UpperCAmelCase =						self.num_labels
								_UpperCAmelCase =						DPTForDepthEstimation(a_   )
								model.to(a_   )
								model.eval()
								_UpperCAmelCase =						model(a_   )
								self.parent.assertEqual(result.predicted_depth.shape ,						(self.batch_size, self.image_size, self.image_size)   )



							def       _a   (      self ,						a_ ,						a_ ,						a_   )							->							str:
								_UpperCAmelCase =						self.num_labels
								_UpperCAmelCase =						DPTForSemanticSegmentation(a_   )
								model.to(a_   )
								model.eval()
								_UpperCAmelCase =						model(a_ ,						labels=a_   )
								self.parent.assertEqual(
								    result.logits.shape ,						(self.batch_size, self.num_labels, self.image_size, self.image_size)   )



							def       _a   (      self   )							->							Any:
								_UpperCAmelCase =						self.prepare_config_and_inputs()
								_UpperCAmelCase ,      _UpperCAmelCase ,      _UpperCAmelCase =						config_and_inputs
								_UpperCAmelCase =						{"pixel_values": pixel_values}
								return config, inputs_dict





@require_torch
class    _lowerCAmelCase						(						lowerCamelCase    ,       lowerCamelCase    ,       unittest.TestCase						):
							lowercase_     :     str       =							(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
							lowercase_     :     Any       =							(
							    {
							        '''depth-estimation''': DPTForDepthEstimation,
							        '''feature-extraction''': DPTModel,
							        '''image-segmentation''': DPTForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							lowercase_     :     Tuple       =							False
							lowercase_     :     Any       =							False
							lowercase_     :     Tuple       =							False



							def       _a   (      self   )							->							int:
								_UpperCAmelCase =						DPTModelTester(self   )
								_UpperCAmelCase =						ConfigTester(self ,						config_class=a_ ,						has_text_modality=a_ ,						hidden_size=37   )



							def       _a   (      self   )							->							Union[str, Any]:
								self.config_tester.run_common_tests()



							@unittest.skip(reason="DPT does not use inputs_embeds"   )
							def       _a   (      self   )							->							Dict:
								pass



							def       _a   (      self   )							->							int:
								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()

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



							def       _a   (      self   )							->							Any:
								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()

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

									_UpperCAmelCase =						["pixel_values"]
									self.assertListEqual(arg_names[:1] ,						a_   )



							def       _a   (      self   )							->							str:
								_UpperCAmelCase =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*a_   )



							def       _a   (      self   )							->							Optional[Any]:
								_UpperCAmelCase =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_depth_estimation(*a_   )



							def       _a   (      self   )							->							Optional[Any]:
								_UpperCAmelCase =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*a_   )



							def       _a   (      self   )							->							str:
								for model_class in self.all_model_classes:
									if model_class.__name__ == "DPTForDepthEstimation":
										continue

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

									if model_class in get_values(a_   ):
										continue

									_UpperCAmelCase =						model_class(a_   )
									model.to(a_   )
									model.train()
									_UpperCAmelCase =						self._prepare_for_class(a_ ,						a_ ,						return_labels=a_   )
									_UpperCAmelCase =						model(**a_   ).loss
									loss.backward()



							def       _a   (      self   )							->							List[Any]:
								for model_class in self.all_model_classes:
									if model_class.__name__ == "DPTForDepthEstimation":
										continue

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

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



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

								_UpperCAmelCase =						_config_zero_init(a_   )
								for model_class in self.all_model_classes:
									_UpperCAmelCase =						model_class(config=a_   )
									# Skip the check for the backbone
									_UpperCAmelCase =						[]
									for name, module in model.named_modules():
										if module.__class__.__name__ == "DPTViTHybridEmbeddings":
											_UpperCAmelCase =						[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   )							->							Union[str, Any]:
								pass



							@slow
							def       _a   (      self   )							->							Dict:
								for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_UpperCAmelCase =						DPTModel.from_pretrained(a_   )
									self.assertIsNotNone(a_   )





def     __lowerCamelCase  (		):


	"""simple docstring"""






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



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



							def       _a   (      self   )							->							Optional[int]:
								_UpperCAmelCase =						DPTImageProcessor.from_pretrained("Intel/dpt-large"   )
								_UpperCAmelCase =						DPTForDepthEstimation.from_pretrained("Intel/dpt-large"   ).to(a_   )

								_UpperCAmelCase =						prepare_img()
								_UpperCAmelCase =						image_processor(images=a_ ,						return_tensors="pt"   ).to(a_   )

								# forward pass
								with torch.no_grad():
									_UpperCAmelCase =						model(**a_   )
									_UpperCAmelCase =						outputs.predicted_depth

								# verify the predicted depth
								_UpperCAmelCase =						torch.Size((1, 384, 384)   )
								self.assertEqual(predicted_depth.shape ,						a_   )

								_UpperCAmelCase =						torch.tensor(
								    [[6.3199, 6.3629, 6.4148], [6.3850, 6.3615, 6.4166], [6.3519, 6.3176, 6.3575]]   ).to(a_   )

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



							def       _a   (      self   )							->							int:
								_UpperCAmelCase =						DPTImageProcessor.from_pretrained("Intel/dpt-large-ade"   )
								_UpperCAmelCase =						DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade"   ).to(a_   )

								_UpperCAmelCase =						prepare_img()
								_UpperCAmelCase =						image_processor(images=a_ ,						return_tensors="pt"   ).to(a_   )

								# forward pass
								with torch.no_grad():
									_UpperCAmelCase =						model(**a_   )

								# verify the logits
								_UpperCAmelCase =						torch.Size((1, 150, 480, 480)   )
								self.assertEqual(outputs.logits.shape ,						a_   )

								_UpperCAmelCase =						torch.tensor(
								    [[4.0480, 4.2420, 4.4360], [4.3124, 4.5693, 4.8261], [4.5768, 4.8965, 5.2163]]   ).to(a_   )

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



							def       _a   (      self   )							->							List[str]:
								_UpperCAmelCase =						DPTImageProcessor.from_pretrained("Intel/dpt-large-ade"   )
								_UpperCAmelCase =						DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade"   ).to(a_   )

								_UpperCAmelCase =						prepare_img()
								_UpperCAmelCase =						image_processor(images=a_ ,						return_tensors="pt"   ).to(a_   )

								# forward pass
								with torch.no_grad():
									_UpperCAmelCase =						model(**a_   )

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

								_UpperCAmelCase =						image_processor.post_process_semantic_segmentation(outputs=a_ ,						target_sizes=[(500, 300)]   )
								_UpperCAmelCase =						torch.Size((500, 300)   )
								self.assertEqual(segmentation[0].shape ,						a_   )

								_UpperCAmelCase =						image_processor.post_process_semantic_segmentation(outputs=a_   )
								_UpperCAmelCase =						torch.Size((480, 480)   )
								self.assertEqual(segmentation[0].shape ,						a_   )






"""simple docstring"""
def     __lowerCamelCase  (		UpperCamelCase__ = 400_0000      ):


	"""simple docstring"""






	_UpperCAmelCase =						1
	_UpperCAmelCase =						2
	_UpperCAmelCase =						0
	while j <= n:
		if j % 2 == 0:
			total += j
		_UpperCAmelCase ,      _UpperCAmelCase =						j, i + j

	return total


if __name__ == "__main__":
			print(f'''{solution() = }''')




