





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


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


					def       lowerCamelCase			(   self     :int						):
												A						=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

												A						=    self.get_config()

												return config, pixel_values, labels


					def       lowerCamelCase			(   self     :Tuple						):
												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=snake_case_	,			initializer_range=self.initializer_range	,			is_hybrid=self.is_hybrid	,			)


					def       lowerCamelCase			(   self     :str	,			__UpperCamelCase     :Dict	,			__UpperCamelCase     :Any	,			__UpperCamelCase     :str						):
												A						=    DPTModel(config=snake_case_						)
												model.to(snake_case_						)
												model.eval()
												A						=    model(snake_case_						)
												self.parent.assertEqual(result.last_hidden_state.shape	,			(self.batch_size, self.seq_length, self.hidden_size)						)


					def       lowerCamelCase			(   self     :Optional[Any]	,			__UpperCamelCase     :Optional[int]	,			__UpperCamelCase     :List[Any]	,			__UpperCamelCase     :Tuple						):
												A						=    self.num_labels
												A						=    DPTForDepthEstimation(snake_case_						)
												model.to(snake_case_						)
												model.eval()
												A						=    model(snake_case_						)
												self.parent.assertEqual(result.predicted_depth.shape	,			(self.batch_size, self.image_size, self.image_size)						)


					def       lowerCamelCase			(   self     :str	,			__UpperCamelCase     :Tuple	,			__UpperCamelCase     :str	,			__UpperCamelCase     :Union[str, Any]						):
												A						=    self.num_labels
												A						=    DPTForSemanticSegmentation(snake_case_						)
												model.to(snake_case_						)
												model.eval()
												A						=    model(snake_case_	,			labels=snake_case_						)
												self.parent.assertEqual(
												    result.logits.shape	,			(self.batch_size, self.num_labels, self.image_size, self.image_size)						)


					def       lowerCamelCase			(   self     :Union[str, Any]						):
												A						=    self.prepare_config_and_inputs()
												A,      A,      A						=    config_and_inputs
												A						=    {"pixel_values": pixel_values}
												return config, inputs_dict







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

					UpperCamelCase						=				False
					UpperCamelCase						=				False
					UpperCamelCase						=				False


					def       lowerCamelCase			(   self     :int						):
												A						=    DPTModelTester(self						)
												A						=    ConfigTester(self	,			config_class=snake_case_	,			has_text_modality=snake_case_	,			hidden_size=37						)


					def       lowerCamelCase			(   self     :Optional[Any]						):
												self.config_tester.run_common_tests()


					@unittest.skip(reason="DPT does not use inputs_embeds"						)
					def       lowerCamelCase			(   self     :Union[str, Any]						):
												pass


					def       lowerCamelCase			(   self     :Optional[Any]						):
												A,      A						=    self.model_tester.prepare_config_and_inputs_for_common()

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


					def       lowerCamelCase			(   self     :Dict						):
												A,      A						=    self.model_tester.prepare_config_and_inputs_for_common()

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

																			A						=    ["pixel_values"]
																			self.assertListEqual(arg_names[:1]	,			snake_case_						)


					def       lowerCamelCase			(   self     :str						):
												A						=    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*snake_case_						)


					def       lowerCamelCase			(   self     :Optional[Any]						):
												A						=    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_depth_estimation(*snake_case_						)


					def       lowerCamelCase			(   self     :Optional[int]						):
												A						=    self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_semantic_segmentation(*snake_case_						)


					def       lowerCamelCase			(   self     :Any						):

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

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

																			if model_class in get_values(snake_case_						):
																										continue

																			A						=    model_class(snake_case_						)
																			model.to(snake_case_						)
																			model.train()
																			A						=    self._prepare_for_class(snake_case_	,			snake_case_	,			return_labels=snake_case_						)
																			A						=    model(**snake_case_						).loss
																			loss.backward()


					def       lowerCamelCase			(   self     :Any						):

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

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

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


					def       lowerCamelCase			(   self     :Dict						):
												A,      A						=    self.model_tester.prepare_config_and_inputs_for_common()

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


					@slow
					def       lowerCamelCase			(   self     :int						):

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







def    A__							(     ):
							A						=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
							return image






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


					def       lowerCamelCase			(   self     :Tuple						):
												A						=    DPTImageProcessor.from_pretrained("Intel/dpt-large"						)
												A						=    DPTForDepthEstimation.from_pretrained("Intel/dpt-large"						).to(snake_case_						)

												A						=    prepare_img()
												A						=    image_processor(images=snake_case_	,			return_tensors="pt"						).to(snake_case_						)

												# forward pass
												with torch.no_grad():
																			A						=    model(**snake_case_						)
																			A						=    outputs.predicted_depth

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

												A						=    torch.tensor(
												    [[6.3_199, 6.3_629, 6.4_148], [6.3_850, 6.3_615, 6.4_166], [6.3_519, 6.3_176, 6.3_575]]						).to(snake_case_						)

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


					def       lowerCamelCase			(   self     :List[str]						):
												A						=    DPTImageProcessor.from_pretrained("Intel/dpt-large-ade"						)
												A						=    DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade"						).to(snake_case_						)

												A						=    prepare_img()
												A						=    image_processor(images=snake_case_	,			return_tensors="pt"						).to(snake_case_						)

												# forward pass
												with torch.no_grad():
																			A						=    model(**snake_case_						)

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

												A						=    torch.tensor(
												    [[4.0_480, 4.2_420, 4.4_360], [4.3_124, 4.5_693, 4.8_261], [4.5_768, 4.8_965, 5.2_163]]						).to(snake_case_						)

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


					def       lowerCamelCase			(   self     :str						):
												A						=    DPTImageProcessor.from_pretrained("Intel/dpt-large-ade"						)
												A						=    DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade"						).to(snake_case_						)

												A						=    prepare_img()
												A						=    image_processor(images=snake_case_	,			return_tensors="pt"						).to(snake_case_						)

												# forward pass
												with torch.no_grad():
																			A						=    model(**snake_case_						)

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

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

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








"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE							=			{
    "configuration_dpr": ["DPR_PRETRAINED_CONFIG_ARCHIVE_MAP", "DPRConfig"],
    "tokenization_dpr": [
        "DPRContextEncoderTokenizer",
        "DPRQuestionEncoderTokenizer",
        "DPRReaderOutput",
        "DPRReaderTokenizer",
    ],
}


try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE							=			[
          "DPRContextEncoderTokenizerFast",
          "DPRQuestionEncoderTokenizerFast",
          "DPRReaderTokenizerFast",
      ]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE							=			[
          "DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "DPRContextEncoder",
          "DPRPretrainedContextEncoder",
          "DPRPreTrainedModel",
          "DPRPretrainedQuestionEncoder",
          "DPRPretrainedReader",
          "DPRQuestionEncoder",
          "DPRReader",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE							=			[
          "TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TFDPRContextEncoder",
          "TFDPRPretrainedContextEncoder",
          "TFDPRPretrainedQuestionEncoder",
          "TFDPRPretrainedReader",
          "TFDPRQuestionEncoder",
          "TFDPRReader",
      ]


if TYPE_CHECKING:
      from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
      from .tokenization_dpr import (
          DPRContextEncoderTokenizer,
          DPRQuestionEncoderTokenizer,
          DPRReaderOutput,
          DPRReaderTokenizer,
      )

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_dpr_fast import (
                DPRContextEncoderTokenizerFast,
                DPRQuestionEncoderTokenizerFast,
                DPRReaderTokenizerFast,
            )

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_dpr import (
                DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
                DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
                DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
                DPRContextEncoder,
                DPRPretrainedContextEncoder,
                DPRPreTrainedModel,
                DPRPretrainedQuestionEncoder,
                DPRPretrainedReader,
                DPRQuestionEncoder,
                DPRReader,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_dpr import (
                TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFDPRContextEncoder,
                TFDPRPretrainedContextEncoder,
                TFDPRPretrainedQuestionEncoder,
                TFDPRPretrainedReader,
                TFDPRQuestionEncoder,
                TFDPRReader,
            )

else:
      import sys

      SCREAMING_SNAKE_CASE							=			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





