






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






						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.02    ,						_SCREAMING_SNAKE_CASE=3    ,						_SCREAMING_SNAKE_CASE=False    ,						_SCREAMING_SNAKE_CASE=None    ,						)			->  Union[str, Any]:




											"""simple docstring"""





											lowerCamelCase__				=parent
											lowerCamelCase__				=batch_size
											lowerCamelCase__				=image_size
											lowerCamelCase__				=patch_size
											lowerCamelCase__				=num_channels
											lowerCamelCase__				=is_training
											lowerCamelCase__				=use_labels
											lowerCamelCase__				=hidden_size
											lowerCamelCase__				=num_hidden_layers
											lowerCamelCase__				=backbone_out_indices
											lowerCamelCase__				=num_attention_heads
											lowerCamelCase__				=intermediate_size
											lowerCamelCase__				=hidden_act
											lowerCamelCase__				=hidden_dropout_prob
											lowerCamelCase__				=attention_probs_dropout_prob
											lowerCamelCase__				=initializer_range
											lowerCamelCase__				=num_labels
											lowerCamelCase__				=scope
											lowerCamelCase__				=is_hybrid
											# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
											lowerCamelCase__				=(image_size // patch_size) ** 2
											lowerCamelCase__				=num_patches + 1






						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





											lowerCamelCase__				=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

											lowerCamelCase__				=self.get_config()

											return config, pixel_values, labels






						def 		lowerCAmelCase   (					self)			->  List[Any]:




											"""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 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)			->  List[str]:




											"""simple docstring"""





											lowerCamelCase__				=DPTModel(config=_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()
											lowerCamelCase__				=model(_SCREAMING_SNAKE_CASE)
											self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, self.seq_length, self.hidden_size))






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)			->  Union[str, Any]:




											"""simple docstring"""





											lowerCamelCase__				=self.num_labels
											lowerCamelCase__				=DPTForDepthEstimation(_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()
											lowerCamelCase__				=model(_SCREAMING_SNAKE_CASE)
											self.parent.assertEqual(result.predicted_depth.shape    ,						(self.batch_size, self.image_size, self.image_size))






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)			->  List[str]:




											"""simple docstring"""





											lowerCamelCase__				=self.num_labels
											lowerCamelCase__				=DPTForSemanticSegmentation(_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()
											lowerCamelCase__				=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 		lowerCAmelCase   (					self)			->  List[str]:




											"""simple docstring"""





											lowerCamelCase__				=self.prepare_config_and_inputs()
											lowerCamelCase__				,     lowerCamelCase__				,     lowerCamelCase__				=config_and_inputs
											lowerCamelCase__				={'pixel_values': pixel_values}
											return config, inputs_dict




@require_torch
class        __lowercase(       _UpperCamelCase						,							_UpperCamelCase						,							unittest.TestCase  ):
						lowerCAmelCase_		:							List[Any]=       (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
						lowerCAmelCase_		:							Optional[Any]=       (
						    {
						        """depth-estimation""": DPTForDepthEstimation,
						        """feature-extraction""": DPTModel,
						        """image-segmentation""": DPTForSemanticSegmentation,
						    }
						    if is_torch_available()
						    else {}
						)

						lowerCAmelCase_		:							List[Any]=       False
						lowerCAmelCase_		:							Dict=       False
						lowerCAmelCase_		:							Optional[Any]=       False






						def 		lowerCAmelCase   (					self)			->  Tuple:




											"""simple docstring"""





											lowerCamelCase__				=DPTModelTester(self)
											lowerCamelCase__				=ConfigTester(self    ,						config_class=_SCREAMING_SNAKE_CASE    ,						has_text_modality=_SCREAMING_SNAKE_CASE    ,						hidden_size=37)






						def 		lowerCAmelCase   (					self)			->  Optional[int]:




											"""simple docstring"""





											self.config_tester.run_common_tests()






						@unittest.skip(reason='DPT does not use inputs_embeds')
						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





											pass






						def 		lowerCAmelCase   (					self)			->  Optional[int]:




											"""simple docstring"""





											lowerCamelCase__				,     lowerCamelCase__				=self.model_tester.prepare_config_and_inputs_for_common()

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






						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





											lowerCamelCase__				,     lowerCamelCase__				=self.model_tester.prepare_config_and_inputs_for_common()

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

																lowerCamelCase__				=['pixel_values']
																self.assertListEqual(arg_names[:1]    ,						_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase   (					self)			->  str:




											"""simple docstring"""





											lowerCamelCase__				=self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase   (					self)			->  Any:




											"""simple docstring"""





											lowerCamelCase__				=self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_depth_estimation(*_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase   (					self)			->  int:




											"""simple docstring"""





											lowerCamelCase__				=self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_semantic_segmentation(*_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase   (					self)			->  Optional[int]:




											"""simple docstring"""





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

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

																if model_class in get_values(_SCREAMING_SNAKE_CASE):
																					continue

																lowerCamelCase__				=model_class(_SCREAMING_SNAKE_CASE)
																model.to(_SCREAMING_SNAKE_CASE)
																model.train()
																lowerCamelCase__				=self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						return_labels=_SCREAMING_SNAKE_CASE)
																lowerCamelCase__				=model(**_SCREAMING_SNAKE_CASE).loss
																loss.backward()






						def 		lowerCAmelCase   (					self)			->  Optional[int]:




											"""simple docstring"""





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

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

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






						def 		lowerCAmelCase   (					self)			->  Optional[Any]:




											"""simple docstring"""





											lowerCamelCase__				,     lowerCamelCase__				=self.model_tester.prepare_config_and_inputs_for_common()

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




											"""simple docstring"""





											pass






						@slow
						def 		lowerCAmelCase   (					self)			->  str:




											"""simple docstring"""





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




def 						lowerCamelCase_				(  ):
					lowerCamelCase__				=Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
					return image




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






						def 		lowerCAmelCase   (					self)			->  Tuple:




											"""simple docstring"""





											lowerCamelCase__				=DPTImageProcessor.from_pretrained('Intel/dpt-large')
											lowerCamelCase__				=DPTForDepthEstimation.from_pretrained('Intel/dpt-large').to(_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				=prepare_img()
											lowerCamelCase__				=image_processor(images=_SCREAMING_SNAKE_CASE    ,						return_tensors='pt').to(_SCREAMING_SNAKE_CASE)

											# forward pass
											with torch.no_grad():
																lowerCamelCase__				=model(**_SCREAMING_SNAKE_CASE)
																lowerCamelCase__				=outputs.predicted_depth

											# verify the predicted depth
											lowerCamelCase__				=torch.Size((1, 3_84, 3_84))
											self.assertEqual(predicted_depth.shape    ,						_SCREAMING_SNAKE_CASE)

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

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






						def 		lowerCAmelCase   (					self)			->  List[str]:




											"""simple docstring"""





											lowerCamelCase__				=DPTImageProcessor.from_pretrained('Intel/dpt-large-ade')
											lowerCamelCase__				=DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade').to(_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				=prepare_img()
											lowerCamelCase__				=image_processor(images=_SCREAMING_SNAKE_CASE    ,						return_tensors='pt').to(_SCREAMING_SNAKE_CASE)

											# forward pass
											with torch.no_grad():
																lowerCamelCase__				=model(**_SCREAMING_SNAKE_CASE)

											# verify the logits
											lowerCamelCase__				=torch.Size((1, 1_50, 4_80, 4_80))
											self.assertEqual(outputs.logits.shape    ,						_SCREAMING_SNAKE_CASE)

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

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






						def 		lowerCAmelCase   (					self)			->  Optional[int]:




											"""simple docstring"""





											lowerCamelCase__				=DPTImageProcessor.from_pretrained('Intel/dpt-large-ade')
											lowerCamelCase__				=DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade').to(_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				=prepare_img()
											lowerCamelCase__				=image_processor(images=_SCREAMING_SNAKE_CASE    ,						return_tensors='pt').to(_SCREAMING_SNAKE_CASE)

											# forward pass
											with torch.no_grad():
																lowerCamelCase__				=model(**_SCREAMING_SNAKE_CASE)

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

											lowerCamelCase__				=image_processor.post_process_semantic_segmentation(outputs=_SCREAMING_SNAKE_CASE    ,						target_sizes=[(5_00, 3_00)])
											lowerCamelCase__				=torch.Size((5_00, 3_00))
											self.assertEqual(segmentation[0].shape    ,						_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				=image_processor.post_process_semantic_segmentation(outputs=_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=torch.Size((4_80, 4_80))
											self.assertEqual(segmentation[0].shape    ,						_SCREAMING_SNAKE_CASE)







"""simple docstring"""



from __future__ import annotations




def 						lowerCamelCase_				(  __A  :		int			,	__A  :		int			,	__A  :		int			):
					assert n > 1 and a > 0 and greatest_common_divisor(__A			,	__A			) == 1
					((lowerCamelCase__)				,     (lowerCamelCase__)				,     (lowerCamelCase__))				=extended_gcd(__A			,	__A			)  # Implemented below
					lowerCamelCase__				=(b * s) % n
					return x




def 						lowerCamelCase_				(  __A  :		int			,	__A  :		int			):
					((lowerCamelCase__)				,     (lowerCamelCase__))				=extended_euclid(__A			,	__A			)  # Implemented below
					if b < 0:
										lowerCamelCase__				=(b % n + n) % n
					return b




def 						lowerCamelCase_				(  __A  :		int			,	__A  :		int			,	__A  :		int			):
					lowerCamelCase__				=invert_modulo(__A			,	__A			)
					lowerCamelCase__				=(b * s) % n
					return x




def 						lowerCamelCase_				(  __A  :		int			,	__A  :		int			):
					assert a >= 0 and b >= 0

					if b == 0:
										lowerCamelCase__				,     lowerCamelCase__				,     lowerCamelCase__				=a, 1, 0
					else:
										((lowerCamelCase__)				,     (lowerCamelCase__)				,     (lowerCamelCase__))				=extended_gcd(__A			,	a % b			)
										lowerCamelCase__				=q
										lowerCamelCase__				=p - q * (a // b)

					assert a % d == 0 and b % d == 0
					assert d == a * x + b * y

					return (d, x, y)




def 						lowerCamelCase_				(  __A  :		int			,	__A  :		int			):
					if b == 0:
										return (1, 0)
					((lowerCamelCase__)				,     (lowerCamelCase__))				=extended_euclid(__A			,	a % b			)
					lowerCamelCase__				=a // b
					return (y, x - k * y)




def 						lowerCamelCase_				(  __A  :		int			,	__A  :		int			):
					if a < b:
										lowerCamelCase__				,     lowerCamelCase__				=b, a

					while a % b != 0:
										lowerCamelCase__				,     lowerCamelCase__				=b, a % b

					return b


if __name__ == "__main__":
						from doctest import testmod

						testmod(name="modular_division", verbose=True)
						testmod(name="modular_division2", verbose=True)
						testmod(name="invert_modulo", verbose=True)
						testmod(name="extended_gcd", verbose=True)
						testmod(name="extended_euclid", verbose=True)
						testmod(name="greatest_common_divisor", verbose=True)