






'''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 a_    :







			def __init__(self					,   __a					,   __a=2					,   __a=3_2					,   __a=1_6					,   __a=3					,   __a=True					,   __a=True					,   __a=3_2					,   __a=4					,   __a=[0, 1, 2, 3]					,   __a=4					,   __a=3_7					,   __a="gelu"					,   __a=0.1					,   __a=0.1					,   __a=0.02					,   __a=3					,   __a=[1, 3_8_4, 2_4, 2_4]					,   __a=True					,   __a=None					,   )			->      List[str]:
						"""simple docstring"""






						__snake_case				:      Dict     							= parent
						__snake_case				:      Optional[int]     							= batch_size
						__snake_case				:      Tuple     							= image_size
						__snake_case				:      Optional[int]     							= patch_size
						__snake_case				:      str     							= num_channels
						__snake_case				:      Tuple     							= is_training
						__snake_case				:      Dict     							= use_labels
						__snake_case				:      Union[str, Any]     							= hidden_size
						__snake_case				:      Optional[int]     							= num_hidden_layers
						__snake_case				:      str     							= backbone_out_indices
						__snake_case				:      Tuple     							= num_attention_heads
						__snake_case				:      int     							= intermediate_size
						__snake_case				:      str     							= hidden_act
						__snake_case				:      List[Any]     							= hidden_dropout_prob
						__snake_case				:      Any     							= attention_probs_dropout_prob
						__snake_case				:      Dict     							= initializer_range
						__snake_case				:      Dict     							= num_labels
						__snake_case				:      Union[str, Any]     							= backbone_featmap_shape
						__snake_case				:      Dict     							= scope
						__snake_case				:      Any     							= is_hybrid
						# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
						__snake_case				:      Any     							= (image_size // patch_size) ** 2
						__snake_case				:      Optional[int]     							= num_patches + 1







			def     SCREAMING_SNAKE_CASE__					(self)			->      str:
						"""simple docstring"""






						__snake_case				:      Dict     							= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

						__snake_case				:      Optional[int]     							= None
						if self.use_labels:
									__snake_case				:      str     							= ids_tensor([self.batch_size, self.image_size, self.image_size]					,   self.num_labels)

						__snake_case				:      Tuple     							= self.get_config()

						return config, pixel_values, labels







			def     SCREAMING_SNAKE_CASE__					(self)			->      Tuple:
						"""simple docstring"""






						__snake_case				:      List[str]     							= {
						    "global_padding": "same",
						    "layer_type": "bottleneck",
						    "depths": [3, 4, 9],
						    "out_features": ["stage1", "stage2", "stage3"],
						    "embedding_dynamic_padding": True,
						    "hidden_sizes": [9_6, 1_9_2, 3_8_4, 7_6_8],
						    "num_groups": 2,
						}

						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					,   backbone_config=A_					,   backbone_featmap_shape=self.backbone_featmap_shape					,   )







			def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      Tuple:
						"""simple docstring"""






						__snake_case				:      str     							= DPTModel(config=A_)
						model.to(A_)
						model.eval()
						__snake_case				:      List[Any]     							= model(A_)
						self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size))







			def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      int:
						"""simple docstring"""






						__snake_case				:      int     							= self.num_labels
						__snake_case				:      Dict     							= DPTForDepthEstimation(A_)
						model.to(A_)
						model.eval()
						__snake_case				:      Dict     							= model(A_)
						self.parent.assertEqual(result.predicted_depth.shape					,   (self.batch_size, self.image_size, self.image_size))







			def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a)			->      str:
						"""simple docstring"""






						__snake_case				:      Tuple     							= self.num_labels
						__snake_case				:      int     							= DPTForSemanticSegmentation(A_)
						model.to(A_)
						model.eval()
						__snake_case				:      Dict     							= model(A_					,   labels=A_)
						self.parent.assertEqual(
						    result.logits.shape					,   (self.batch_size, self.num_labels, self.image_size, self.image_size))







			def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
						"""simple docstring"""






						__snake_case				:      Tuple     							= self.prepare_config_and_inputs()
						__snake_case				:      Optional[Any]     							= config_and_inputs
						__snake_case				:      List[Any]     							= {"pixel_values": pixel_values}
						return config, inputs_dict




@require_torch
class a_    (    __snake_case		,      __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     SCREAMING_SNAKE_CASE__					(self)			->      Union[str, Any]:
						"""simple docstring"""






						__snake_case				:      Optional[int]     							= DPTModelTester(self)
						__snake_case				:      str     							= ConfigTester(self					,   config_class=A_					,   has_text_modality=A_					,   hidden_size=3_7)







			def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
						"""simple docstring"""






						self.config_tester.run_common_tests()







			@unittest.skip(reason='DPT does not use inputs_embeds')
			def     SCREAMING_SNAKE_CASE__					(self)			->      List[str]:
						"""simple docstring"""






						pass







			def     SCREAMING_SNAKE_CASE__					(self)			->      List[str]:
						"""simple docstring"""






						__snake_case				:      List[Any]     							= self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									__snake_case				:      Tuple     							= model_class(A_)
									self.assertIsInstance(model.get_input_embeddings()					,   (nn.Module))
									__snake_case				:      Optional[int]     							= model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(A_					,   nn.Linear))







			def     SCREAMING_SNAKE_CASE__					(self)			->      Any:
						"""simple docstring"""






						__snake_case				:      Tuple     							= self.model_tester.prepare_config_and_inputs_for_common()

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

									__snake_case				:      Optional[int]     							= ["pixel_values"]
									self.assertListEqual(arg_names[:1]					,   A_)







			def     SCREAMING_SNAKE_CASE__					(self)			->      str:
						"""simple docstring"""






						__snake_case				:      Optional[Any]     							= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*A_)







			def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[Any]:
						"""simple docstring"""






						__snake_case				:      Any     							= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_depth_estimation(*A_)







			def     SCREAMING_SNAKE_CASE__					(self)			->      Dict:
						"""simple docstring"""






						__snake_case				:      Union[str, Any]     							= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*A_)







			def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[Any]:
						"""simple docstring"""






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

									__snake_case				:      Optional[int]     							= self.model_tester.prepare_config_and_inputs_for_common()
									__snake_case				:      List[Any]     							= True

									if model_class in get_values(A_):
												continue

									__snake_case				:      Optional[int]     							= model_class(A_)
									model.to(A_)
									model.train()
									__snake_case				:      Optional[int]     							= self._prepare_for_class(A_					,   A_					,   return_labels=A_)
									__snake_case				:      Optional[int]     							= model(**A_).loss
									loss.backward()







			def     SCREAMING_SNAKE_CASE__					(self)			->      Dict:
						"""simple docstring"""






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

									__snake_case				:      Optional[Any]     							= self.model_tester.prepare_config_and_inputs_for_common()
									__snake_case				:      Any     							= False
									__snake_case				:      Optional[int]     							= True

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







			def     SCREAMING_SNAKE_CASE__					(self)			->      Dict:
						"""simple docstring"""






						__snake_case				:      str     							= self.model_tester.prepare_config_and_inputs_for_common()

						__snake_case				:      List[Any]     							= _config_zero_init(A_)
						for model_class in self.all_model_classes:
									__snake_case				:      List[str]     							= model_class(config=A_)
									# Skip the check for the backbone
									__snake_case				:      List[Any]     							= []
									for name, module in model.named_modules():
												if module.__class__.__name__ == "DPTViTHybridEmbeddings":
															__snake_case				:      Optional[Any]     							= [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     SCREAMING_SNAKE_CASE__					(self)			->      Any:
						"""simple docstring"""






						pass







			@slow
			def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[int]:
						"""simple docstring"""






						for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
									__snake_case				:      Dict     							= DPTModel.from_pretrained(A_)
									self.assertIsNotNone(A_)







			def     SCREAMING_SNAKE_CASE__					(self)			->      Dict:
						"""simple docstring"""






						__snake_case				:      int     							= self.model_tester.prepare_config_and_inputs_for_common()
						__snake_case				:      Dict     							= "add"
						with self.assertRaises(A_):
									__snake_case				:      Optional[int]     							= DPTForDepthEstimation(A_)




def        _SCREAMING_SNAKE_CASE  (				)    -> Optional[Any]:







			"""simple docstring"""
			__snake_case				:      List[Any]     							= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
			return image





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







			def     SCREAMING_SNAKE_CASE__					(self)			->      Any:
						"""simple docstring"""






						__snake_case				:      int     							= DPTImageProcessor.from_pretrained('Intel/dpt-hybrid-midas')
						__snake_case				:      Optional[Any]     							= DPTForDepthEstimation.from_pretrained('Intel/dpt-hybrid-midas').to(A_)

						__snake_case				:      int     							= prepare_img()
						__snake_case				:      Tuple     							= image_processor(images=A_					,   return_tensors='pt').to(A_)

						# forward pass
						with torch.no_grad():
									__snake_case				:      List[str]     							= model(**A_)
									__snake_case				:      int     							= outputs.predicted_depth

						# verify the predicted depth
						__snake_case				:      str     							= torch.Size((1, 3_8_4, 3_8_4))
						self.assertEqual(predicted_depth.shape					,   A_)

						__snake_case				:      str     							= torch.tensor(
						    [[[5.6_437, 5.6_146, 5.6_511], [5.4_371, 5.5_649, 5.5_958], [5.5_215, 5.5_184, 5.5_293]]]).to(A_)

						self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 1_0_0					,   A_					,   atol=1E-4))







'''simple docstring'''






__A    	=   {str(digit): digit**5 for digit in range(1_0)}




def        _SCREAMING_SNAKE_CASE  (				A  :       int  )    -> int:







   """simple docstring"""
   return sum(DIGITS_FIFTH_POWER[digit] for digit in str(A  )  )




def        _SCREAMING_SNAKE_CASE  (				)    -> int:







   """simple docstring"""
   return sum(
       number
       for number in range(10_00  ,		1_00_00_00  )
       if number == digits_fifth_powers_sum(A  )  )


if __name__ == "__main__":
      print(solution())