




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  :

      """simple docstring"""

      def __init__(   self    :       Union[str, Any]       ,				snake_case    :       Tuple       ,				snake_case    :       str=2       ,				snake_case    :       List[Any]=32       ,				snake_case    :       Union[str, Any]=16       ,				snake_case    :       Dict=3       ,				snake_case    :       int=True       ,				snake_case    :       str=True       ,				snake_case    :       Tuple=32       ,				snake_case    :       List[Any]=4       ,				snake_case    :       List[Any]=[0, 1, 2, 3]       ,				snake_case    :       Optional[Any]=4       ,				snake_case    :       Tuple=37       ,				snake_case    :       Optional[Any]="gelu"       ,				snake_case    :       List[Any]=0.1       ,				snake_case    :       Dict=0.1       ,				snake_case    :       Optional[Any]=0.02       ,				snake_case    :       Optional[int]=3       ,				snake_case    :       List[Any]=False       ,				snake_case    :       str=None       ,				):
          __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 					snake_case		(   self    :       int ):
          __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 					snake_case		(   self    :       str ):
          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=_lowerCamelCase       ,				initializer_range=self.initializer_range       ,				is_hybrid=self.is_hybrid       ,				)







      def 					snake_case		(   self    :       List[Any]       ,				snake_case    :       List[str]       ,				snake_case    :       Optional[Any]       ,				snake_case    :       Tuple ):
          __UpperCamelCase     						=  DPTModel(config=_lowerCamelCase )
          model.to(_lowerCamelCase )
          model.eval()
          __UpperCamelCase     						=  model(_lowerCamelCase )
          self.parent.assertEqual(result.last_hidden_state.shape       ,				(self.batch_size, self.seq_length, self.hidden_size) )







      def 					snake_case		(   self    :       Optional[Any]       ,				snake_case    :       Optional[int]       ,				snake_case    :       Any       ,				snake_case    :       List[str] ):
          __UpperCamelCase     						=  self.num_labels
          __UpperCamelCase     						=  DPTForDepthEstimation(_lowerCamelCase )
          model.to(_lowerCamelCase )
          model.eval()
          __UpperCamelCase     						=  model(_lowerCamelCase )
          self.parent.assertEqual(result.predicted_depth.shape       ,				(self.batch_size, self.image_size, self.image_size) )







      def 					snake_case		(   self    :       Any       ,				snake_case    :       List[Any]       ,				snake_case    :       List[Any]       ,				snake_case    :       Optional[Any] ):
          __UpperCamelCase     						=  self.num_labels
          __UpperCamelCase     						=  DPTForSemanticSegmentation(_lowerCamelCase )
          model.to(_lowerCamelCase )
          model.eval()
          __UpperCamelCase     						=  model(_lowerCamelCase       ,				labels=_lowerCamelCase )
          self.parent.assertEqual(
              result.logits.shape       ,				(self.batch_size, self.num_labels, self.image_size, self.image_size) )







      def 					snake_case		(   self    :       Any ):
          __UpperCamelCase     						=  self.prepare_config_and_inputs()
          __UpperCamelCase     						=  config_and_inputs
          __UpperCamelCase     						=  {'''pixel_values''': pixel_values}
          return config, inputs_dict







@require_torch
class        _lowerCamelCase  (	__UpperCAmelCase							,	__UpperCAmelCase							,	unittest.TestCase      ):

      """simple docstring"""

      lowerCAmelCase__	:       Tuple			=    (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
      lowerCAmelCase__	:       str			=    (
          {
              "depth-estimation": DPTForDepthEstimation,
              "feature-extraction": DPTModel,
              "image-segmentation": DPTForSemanticSegmentation,
          }
          if is_torch_available()
          else {}
      )

      lowerCAmelCase__	:       Any			=    False
      lowerCAmelCase__	:       List[Any]			=    False
      lowerCAmelCase__	:       int			=    False







      def 					snake_case		(   self    :       Any ):
          __UpperCamelCase     						=  DPTModelTester(self )
          __UpperCamelCase     						=  ConfigTester(self       ,				config_class=_lowerCamelCase       ,				has_text_modality=_lowerCamelCase       ,				hidden_size=37 )







      def 					snake_case		(   self    :       Any ):
          self.config_tester.run_common_tests()







      @unittest.skip(reason='''DPT does not use inputs_embeds''' )
      def 					snake_case		(   self    :       List[str] ):
          pass







      def 					snake_case		(   self    :       List[Any] ):
          __UpperCamelCase     						=  self.model_tester.prepare_config_and_inputs_for_common()

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







      def 					snake_case		(   self    :       str ):
          __UpperCamelCase     						=  self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              __UpperCamelCase     						=  model_class(_lowerCamelCase )
              __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]       ,				_lowerCamelCase )







      def 					snake_case		(   self    :       List[str] ):
          __UpperCamelCase     						=  self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*_lowerCamelCase )







      def 					snake_case		(   self    :       Optional[Any] ):
          __UpperCamelCase     						=  self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_depth_estimation(*_lowerCamelCase )







      def 					snake_case		(   self    :       Union[str, Any] ):
          __UpperCamelCase     						=  self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_semantic_segmentation(*_lowerCamelCase )







      def 					snake_case		(   self    :       Tuple ):
          for model_class in self.all_model_classes:
              if model_class.__name__ == "DPTForDepthEstimation":
                  continue

              __UpperCamelCase     						=  self.model_tester.prepare_config_and_inputs_for_common()
              __UpperCamelCase     						=  True

              if model_class in get_values(_lowerCamelCase ):
                  continue

              __UpperCamelCase     						=  model_class(_lowerCamelCase )
              model.to(_lowerCamelCase )
              model.train()
              __UpperCamelCase     						=  self._prepare_for_class(_lowerCamelCase       ,				_lowerCamelCase       ,				return_labels=_lowerCamelCase )
              __UpperCamelCase     						=  model(**_lowerCamelCase ).loss
              loss.backward()







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

              __UpperCamelCase     						=  self.model_tester.prepare_config_and_inputs_for_common()
              __UpperCamelCase     						=  False
              __UpperCamelCase     						=  True

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







      def 					snake_case		(   self    :       Optional[Any] ):
          __UpperCamelCase     						=  self.model_tester.prepare_config_and_inputs_for_common()

          __UpperCamelCase     						=  _config_zero_init(_lowerCamelCase )
          for model_class in self.all_model_classes:
              __UpperCamelCase     						=  model_class(config=_lowerCamelCase )
              # 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 					snake_case		(   self    :       int ):
          pass







      @slow
      def 					snake_case		(   self    :       Optional[Any] ):
          for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              __UpperCamelCase     						=  DPTModel.from_pretrained(_lowerCamelCase )
              self.assertIsNotNone(_lowerCamelCase )







def     __SCREAMING_SNAKE_CASE      (     )				->		Dict:

    """simple docstring"""


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


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

      """simple docstring"""

      def 					snake_case		(   self    :       Optional[Any] ):
          __UpperCamelCase     						=  DPTImageProcessor.from_pretrained('''Intel/dpt-large''' )
          __UpperCamelCase     						=  DPTForDepthEstimation.from_pretrained('''Intel/dpt-large''' ).to(_lowerCamelCase )

          __UpperCamelCase     						=  prepare_img()
          __UpperCamelCase     						=  image_processor(images=_lowerCamelCase       ,				return_tensors='''pt''' ).to(_lowerCamelCase )

          # forward pass
          with torch.no_grad():
              __UpperCamelCase     						=  model(**_lowerCamelCase )
              __UpperCamelCase     						=  outputs.predicted_depth

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

          __UpperCamelCase     						=  torch.tensor(
              [[6.31_99, 6.36_29, 6.41_48], [6.38_50, 6.36_15, 6.41_66], [6.35_19, 6.31_76, 6.35_75]] ).to(_lowerCamelCase )

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







      def 					snake_case		(   self    :       Dict ):
          __UpperCamelCase     						=  DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade''' )
          __UpperCamelCase     						=  DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade''' ).to(_lowerCamelCase )

          __UpperCamelCase     						=  prepare_img()
          __UpperCamelCase     						=  image_processor(images=_lowerCamelCase       ,				return_tensors='''pt''' ).to(_lowerCamelCase )

          # forward pass
          with torch.no_grad():
              __UpperCamelCase     						=  model(**_lowerCamelCase )

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

          __UpperCamelCase     						=  torch.tensor(
              [[4.04_80, 4.24_20, 4.43_60], [4.31_24, 4.56_93, 4.82_61], [4.57_68, 4.89_65, 5.21_63]] ).to(_lowerCamelCase )

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







      def 					snake_case		(   self    :       Any ):
          __UpperCamelCase     						=  DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade''' )
          __UpperCamelCase     						=  DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade''' ).to(_lowerCamelCase )

          __UpperCamelCase     						=  prepare_img()
          __UpperCamelCase     						=  image_processor(images=_lowerCamelCase       ,				return_tensors='''pt''' ).to(_lowerCamelCase )

          # forward pass
          with torch.no_grad():
              __UpperCamelCase     						=  model(**_lowerCamelCase )

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

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

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













"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_lowerCamelCase       =	{
    '''configuration_mobilenet_v1''': [
        '''MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''MobileNetV1Config''',
        '''MobileNetV1OnnxConfig''',
    ],
}

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _lowerCamelCase       =	['''MobileNetV1FeatureExtractor''']
    _lowerCamelCase       =	['''MobileNetV1ImageProcessor''']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _lowerCamelCase       =	[
        '''MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''MobileNetV1ForImageClassification''',
        '''MobileNetV1Model''',
        '''MobileNetV1PreTrainedModel''',
        '''load_tf_weights_in_mobilenet_v1''',
    ]


if TYPE_CHECKING:
    from .configuration_mobilenet_va import (
        MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP,
        MobileNetVaConfig,
        MobileNetVaOnnxConfig,
    )

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_mobilenet_va import MobileNetVaFeatureExtractor
        from .image_processing_mobilenet_va import MobileNetVaImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_mobilenet_va import (
            MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST,
            MobileNetVaForImageClassification,
            MobileNetVaModel,
            MobileNetVaPreTrainedModel,
            load_tf_weights_in_mobilenet_va,
        )


else:
    import sys

    _lowerCamelCase       =	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

