




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				,     lowerCamelCase				,     lowerCamelCase=2				,     lowerCamelCase=32				,     lowerCamelCase=16				,     lowerCamelCase=3				,     lowerCamelCase=True				,     lowerCamelCase=True				,     lowerCamelCase=32				,     lowerCamelCase=4				,     lowerCamelCase=[0, 1, 2, 3]				,     lowerCamelCase=4				,     lowerCamelCase=37				,     lowerCamelCase="gelu"				,     lowerCamelCase=0.1				,     lowerCamelCase=0.1				,     lowerCamelCase=0.0_2				,     lowerCamelCase=3				,     lowerCamelCase=False				,     lowerCamelCase=None				,     )      ->   List[str]:




						"""simple docstring"""






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






	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						__magic_name__					:							Optional[Any]		   =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

						__magic_name__					:							Union[str, Any]		   =							self.get_config()

						return config, pixel_values, labels






	def  lowercase      (	self						)      ->   List[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=UpperCAmelCase_				,     initializer_range=self.initializer_range				,     is_hybrid=self.is_hybrid				,     )






	def  lowercase      (	self				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase						)      ->   Union[str, Any]:




						"""simple docstring"""






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






	def  lowercase      (	self				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase						)      ->   List[Any]:




						"""simple docstring"""






						__magic_name__					:							str		   =							self.num_labels
						__magic_name__					:							Optional[int]		   =							DPTForDepthEstimation(UpperCAmelCase_						)
						model.to(UpperCAmelCase_						)
						model.eval()
						__magic_name__					:							str		   =							model(UpperCAmelCase_						)
						self.parent.assertEqual(result.predicted_depth.shape				,     (self.batch_size, self.image_size, self.image_size)						)






	def  lowercase      (	self				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							Optional[Any]		   =							self.num_labels
						__magic_name__					:							str		   =							DPTForSemanticSegmentation(UpperCAmelCase_						)
						model.to(UpperCAmelCase_						)
						model.eval()
						__magic_name__					:							List[Any]		   =							model(UpperCAmelCase_				,     labels=UpperCAmelCase_						)
						self.parent.assertEqual(
						    result.logits.shape				,     (self.batch_size, self.num_labels, self.image_size, self.image_size)						)






	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						__magic_name__					:							int		   =							self.prepare_config_and_inputs()
						__magic_name__					:							List[str]		   =							config_and_inputs
						__magic_name__					:							int		   =							{'pixel_values': pixel_values}
						return config, inputs_dict





@require_torch
class 		A__				(   __UpperCAmelCase		,     __UpperCAmelCase		,     unittest.TestCase ):
	lowerCamelCase__		: List[str]				    =(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
	lowerCamelCase__		: List[str]				    =(
	    {
	        "depth-estimation": DPTForDepthEstimation,
	        "feature-extraction": DPTModel,
	        "image-segmentation": DPTForSemanticSegmentation,
	    }
	    if is_torch_available()
	    else {}
	)

	lowerCamelCase__		: List[Any]				    =False
	lowerCamelCase__		: Union[str, Any]				    =False
	lowerCamelCase__		: Union[str, Any]				    =False






	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						__magic_name__					:							Optional[Any]		   =							DPTModelTester(self						)
						__magic_name__					:							Optional[int]		   =							ConfigTester(self				,     config_class=UpperCAmelCase_				,     has_text_modality=UpperCAmelCase_				,     hidden_size=37						)






	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						self.config_tester.run_common_tests()






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




						"""simple docstring"""






						pass






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




						"""simple docstring"""






						__magic_name__					:							Optional[Any]		   =							self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__magic_name__					:							Union[str, Any]		   =							model_class(UpperCAmelCase_						)
											self.assertIsInstance(model.get_input_embeddings()				,     (nn.Module)						)
											__magic_name__					:							Optional[int]		   =							model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(UpperCAmelCase_				,     nn.Linear						)						)






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




						"""simple docstring"""






						__magic_name__					:							str		   =							self.model_tester.prepare_config_and_inputs_for_common()

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

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






	def  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							str		   =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCAmelCase_						)






	def  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






						__magic_name__					:							Tuple		   =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_depth_estimation(*UpperCAmelCase_						)






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




						"""simple docstring"""






						__magic_name__					:							int		   =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*UpperCAmelCase_						)






	def  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






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

											__magic_name__					:							str		   =							self.model_tester.prepare_config_and_inputs_for_common()
											__magic_name__					:							Optional[int]		   =							True

											if model_class in get_values(UpperCAmelCase_						):
																continue

											__magic_name__					:							Tuple		   =							model_class(UpperCAmelCase_						)
											model.to(UpperCAmelCase_						)
											model.train()
											__magic_name__					:							Tuple		   =							self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_				,     return_labels=UpperCAmelCase_						)
											__magic_name__					:							int		   =							model(**UpperCAmelCase_						).loss
											loss.backward()






	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






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

											__magic_name__					:							List[Any]		   =							self.model_tester.prepare_config_and_inputs_for_common()
											__magic_name__					:							List[str]		   =							False
											__magic_name__					:							int		   =							True

											if model_class in get_values(UpperCAmelCase_						) or not model_class.supports_gradient_checkpointing:
																continue
											__magic_name__					:							Optional[int]		   =							model_class(UpperCAmelCase_						)
											model.to(UpperCAmelCase_						)
											model.gradient_checkpointing_enable()
											model.train()
											__magic_name__					:							Optional[Any]		   =							self._prepare_for_class(UpperCAmelCase_				,     UpperCAmelCase_				,     return_labels=UpperCAmelCase_						)
											__magic_name__					:							str		   =							model(**UpperCAmelCase_						).loss
											loss.backward()






	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						__magic_name__					:							Optional[Any]		   =							self.model_tester.prepare_config_and_inputs_for_common()

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




						"""simple docstring"""






						pass






	@slow
	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






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







def  lowerCAmelCase  (	)  ->str:






					"""simple docstring"""






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





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






	def  lowercase      (	self						)      ->   int:




						"""simple docstring"""






						__magic_name__					:							int		   =							DPTImageProcessor.from_pretrained('''Intel/dpt-large'''						)
						__magic_name__					:							List[str]		   =							DPTForDepthEstimation.from_pretrained('''Intel/dpt-large'''						).to(UpperCAmelCase_						)

						__magic_name__					:							str		   =							prepare_img()
						__magic_name__					:							Tuple		   =							image_processor(images=UpperCAmelCase_				,     return_tensors='''pt'''						).to(UpperCAmelCase_						)

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

						# verify the predicted depth
						__magic_name__					:							List[str]		   =							torch.Size((1, 384, 384)						)
						self.assertEqual(predicted_depth.shape				,     UpperCAmelCase_						)

						__magic_name__					:							Dict		   =							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  lowercase      (	self						)      ->   Tuple:




						"""simple docstring"""






						__magic_name__					:							int		   =							DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''						)
						__magic_name__					:							Optional[Any]		   =							DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''						).to(UpperCAmelCase_						)

						__magic_name__					:							List[Any]		   =							prepare_img()
						__magic_name__					:							Tuple		   =							image_processor(images=UpperCAmelCase_				,     return_tensors='''pt'''						).to(UpperCAmelCase_						)

						# forward pass
						with torch.no_grad():
											__magic_name__					:							List[str]		   =							model(**UpperCAmelCase_						)

						# verify the logits
						__magic_name__					:							int		   =							torch.Size((1, 150, 480, 480)						)
						self.assertEqual(outputs.logits.shape				,     UpperCAmelCase_						)

						__magic_name__					:							Tuple		   =							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  lowercase      (	self						)      ->   List[Any]:




						"""simple docstring"""






						__magic_name__					:							Dict		   =							DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''						)
						__magic_name__					:							str		   =							DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''						).to(UpperCAmelCase_						)

						__magic_name__					:							Any		   =							prepare_img()
						__magic_name__					:							Any		   =							image_processor(images=UpperCAmelCase_				,     return_tensors='''pt'''						).to(UpperCAmelCase_						)

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

						__magic_name__					:							int		   =							outputs.logits.detach().cpu()

						__magic_name__					:							int		   =							image_processor.post_process_semantic_segmentation(outputs=UpperCAmelCase_				,     target_sizes=[(500, 300)]						)
						__magic_name__					:							Optional[Any]		   =							torch.Size((500, 300)						)
						self.assertEqual(segmentation[0].shape				,     UpperCAmelCase_						)

						__magic_name__					:							List[Any]		   =							image_processor.post_process_semantic_segmentation(outputs=UpperCAmelCase_						)
						__magic_name__					:							Any		   =							torch.Size((480, 480)						)
						self.assertEqual(segmentation[0].shape				,     UpperCAmelCase_						)





"""simple docstring"""

from transformers import (
    DPRContextEncoderTokenizer,
    DPRContextEncoderTokenizerFast,
    DPRQuestionEncoderTokenizer,
    DPRQuestionEncoderTokenizerFast,
    DPRReaderOutput,
    DPRReaderTokenizer,
    DPRReaderTokenizerFast,
)
from transformers.testing_utils import require_tokenizers, slow
from transformers.tokenization_utils_base import BatchEncoding

from ..bert.test_tokenization_bert import BertTokenizationTest






@require_tokenizers
class        _lowercase   (				__UpperCAmelCase		):
	lowercase_        =	DPRContextEncoderTokenizer
	lowercase_        =	DPRContextEncoderTokenizerFast
	lowercase_        =	True






@require_tokenizers
class        _lowercase   (				__UpperCAmelCase		):
	lowercase_        =	DPRQuestionEncoderTokenizer
	lowercase_        =	DPRQuestionEncoderTokenizerFast
	lowercase_        =	True






@require_tokenizers
class        _lowercase   (				__UpperCAmelCase		):
	lowercase_        =	DPRReaderTokenizer
	lowercase_        =	DPRReaderTokenizerFast
	lowercase_        =	True




	@slow
	def 			_UpperCamelCase    ( self					)		->							Any:
			lowerCamelCase     :			str		=    self.tokenizer_class.from_pretrained('bert-base-uncased'					)

			lowerCamelCase     :			int		=    tokenizer.encode('question sequence'		, add_special_tokens=UpperCAmelCase_					)
			lowerCamelCase     :			List[Any]		=    tokenizer.encode('title sequence'		, add_special_tokens=UpperCAmelCase_					)
			lowerCamelCase     :			Optional[int]		=    tokenizer.encode('text sequence ' * 4		, add_special_tokens=UpperCAmelCase_					)
			lowerCamelCase     :			Union[str, Any]		=    [[101] + text_a + [102] + text_a + [102] + text_a]
			lowerCamelCase     :			List[str]		=    BatchEncoding({'input_ids': input_ids}					)

			lowerCamelCase     :			Optional[int]		=    [[0] * len(input_ids[0]					)]
			lowerCamelCase     :			str		=    [[0] * len(input_ids[0]					)]
			lowerCamelCase     :			List[Any]		=    [0]
			lowerCamelCase     :			Tuple		=    DPRReaderOutput(UpperCAmelCase_		, UpperCAmelCase_		, UpperCAmelCase_					)

			lowerCamelCase	,    lowerCamelCase     :			Optional[int]		=    8, 9
			lowerCamelCase     :			Optional[int]		=    10
			lowerCamelCase     :			int		=    10
			lowerCamelCase     :			List[Any]		=    tokenizer.decode_best_spans(UpperCAmelCase_		, UpperCAmelCase_					)
			self.assertEqual(predicted_spans[0].start_index		, UpperCAmelCase_					)
			self.assertEqual(predicted_spans[0].end_index		, UpperCAmelCase_					)
			self.assertEqual(predicted_spans[0].doc_id		, 0					)




	@slow
	def 			_UpperCamelCase    ( self					)		->							List[Any]:
			lowerCamelCase     :			Union[str, Any]		=    self.tokenizer_class.from_pretrained('bert-base-uncased'					)

			lowerCamelCase     :			List[str]		=    tokenizer.encode('question sequence'		, add_special_tokens=UpperCAmelCase_					)
			lowerCamelCase     :			List[str]		=    tokenizer.encode('title sequence'		, add_special_tokens=UpperCAmelCase_					)
			lowerCamelCase     :			List[Any]		=    tokenizer.encode('text sequence'		, add_special_tokens=UpperCAmelCase_					)
			lowerCamelCase     :			List[Any]		=    [101] + text_a + [102] + text_a + [102] + text_a
			lowerCamelCase     :			Optional[Any]		=    tokenizer(questions=['question sequence']		, titles=['title sequence']		, texts=['text sequence']					)
			self.assertIn('input_ids'		, UpperCAmelCase_					)
			self.assertIn('attention_mask'		, UpperCAmelCase_					)
			self.assertListEqual(encoded_input['input_ids'][0]		, UpperCAmelCase_					)






