



'''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  snake_case__						:
 def __init__(   self						:							str      ,     __a						:							Optional[Any]      ,     __a						:							Dict=2      ,     __a						:							Tuple=32      ,     __a						:							List[Any]=16      ,     __a						:							Union[str, Any]=3      ,     __a						:							Tuple=True      ,     __a						:							List[Any]=True      ,     __a						:							Optional[Any]=32      ,     __a						:							Optional[Any]=4      ,     __a						:							Optional[int]=[0, 1, 2, 3]      ,     __a						:							Dict=4      ,     __a						:							int=37      ,     __a						:							Union[str, Any]="gelu"      ,     __a						:							int=0.1      ,     __a						:							Tuple=0.1      ,     __a						:							Optional[Any]=0.0_2      ,     __a						:							Any=3      ,     __a						:							Any=[1, 384, 24, 24]      ,     __a						:							Any=True      ,     __a						:							Dict=None      ,     )      ->   str:







       '''simple docstring'''
       __snake_case :   int													=    parent
       __snake_case :   Dict													=    batch_size
       __snake_case :   int													=    image_size
       __snake_case :   Optional[Any]													=    patch_size
       __snake_case :   str													=    num_channels
       __snake_case :   Any													=    is_training
       __snake_case :   Any													=    use_labels
       __snake_case :   Optional[Any]													=    hidden_size
       __snake_case :   List[Any]													=    num_hidden_layers
       __snake_case :   Any													=    backbone_out_indices
       __snake_case :   Union[str, Any]													=    num_attention_heads
       __snake_case :   Tuple													=    intermediate_size
       __snake_case :   int													=    hidden_act
       __snake_case :   Dict													=    hidden_dropout_prob
       __snake_case :   str													=    attention_probs_dropout_prob
       __snake_case :   List[str]													=    initializer_range
       __snake_case :   Optional[int]													=    num_labels
       __snake_case :   List[str]													=    backbone_featmap_shape
       __snake_case :   Optional[Any]													=    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 :   List[str]													=    num_patches + 1
 def A_   (   self						:							Optional[int]  )      ->   Union[str, Any]:







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

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

       __snake_case :   Optional[int]													=    self.get_config()

       return config, pixel_values, labels
 def A_   (   self						:							str  )      ->   Any:







       '''simple docstring'''
       __snake_case :   Tuple													=    {
           'global_padding': 'same',
           'layer_type': 'bottleneck',
           'depths': [3, 4, 9],
           'out_features': ['stage1', 'stage2', 'stage3'],
           'embedding_dynamic_padding': True,
           'hidden_sizes': [96, 192, 384, 768],
           '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 A_   (   self						:							List[Any]      ,     __a						:							Optional[Any]      ,     __a						:							Optional[int]      ,     __a						:							Any  )      ->   Tuple:







       '''simple docstring'''
       __snake_case :   List[Any]													=    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 A_   (   self						:							Optional[int]      ,     __a						:							List[Any]      ,     __a						:							int      ,     __a						:							int  )      ->   Union[str, Any]:







       '''simple docstring'''
       __snake_case :   Tuple													=    self.num_labels
       __snake_case :   Optional[Any]													=    DPTForDepthEstimation(__a  )
       model.to(__a  )
       model.eval()
       __snake_case :   Any													=    model(__a  )
       self.parent.assertEqual(result.predicted_depth.shape      ,     (self.batch_size, self.image_size, self.image_size)  )
 def A_   (   self						:							Dict      ,     __a						:							Optional[Any]      ,     __a						:							Dict      ,     __a						:							Any  )      ->   Optional[Any]:







       '''simple docstring'''
       __snake_case :   Union[str, Any]													=    self.num_labels
       __snake_case :   Optional[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 A_   (   self						:							str  )      ->   Any:







       '''simple docstring'''
       __snake_case :   Tuple													=    self.prepare_config_and_inputs()
       __snake_case							,     __snake_case							,     __snake_case :   str													=    config_and_inputs
       __snake_case :   Optional[Any]													=    {'pixel_values': pixel_values}
       return config, inputs_dict



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

 A__				= False
 A__				= False
 A__				= False
 def A_   (   self						:							Optional[int]  )      ->   Dict:







       '''simple docstring'''
       __snake_case :   List[str]													=    DPTModelTester(self  )
       __snake_case :   int													=    ConfigTester(self      ,     config_class=__a      ,     has_text_modality=__a      ,     hidden_size=37  )
 def A_   (   self						:							Optional[int]  )      ->   List[Any]:







       '''simple docstring'''
       self.config_tester.run_common_tests()
 @unittest.skip(reason='DPT does not use inputs_embeds'  )
 def A_   (   self						:							Tuple  )      ->   Union[str, Any]:







       '''simple docstring'''
       pass
 def A_   (   self						:							int  )      ->   int:







       '''simple docstring'''
       __snake_case							,     __snake_case :   Optional[int]													=    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             __snake_case :   Optional[Any]													=    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 A_   (   self						:							Union[str, Any]  )      ->   Dict:







       '''simple docstring'''
       __snake_case							,     __snake_case :   List[Any]													=    self.model_tester.prepare_config_and_inputs_for_common()

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

             __snake_case :   int													=    ['pixel_values']
             self.assertListEqual(arg_names[:1]      ,     __a  )
 def A_   (   self						:							Optional[int]  )      ->   str:







       '''simple docstring'''
       __snake_case :   List[Any]													=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__a  )
 def A_   (   self						:							Tuple  )      ->   Tuple:







       '''simple docstring'''
       __snake_case :   Tuple													=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_depth_estimation(*__a  )
 def A_   (   self						:							Optional[int]  )      ->   List[Any]:







       '''simple docstring'''
       __snake_case :   Dict													=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_semantic_segmentation(*__a  )
 def A_   (   self						:							Union[str, Any]  )      ->   List[str]:







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

             __snake_case							,     __snake_case :   List[str]													=    self.model_tester.prepare_config_and_inputs_for_common()
             __snake_case :   Union[str, Any]													=    True

             if model_class in get_values(__a  ):
                   continue

             __snake_case :   Tuple													=    model_class(__a  )
             model.to(__a  )
             model.train()
             __snake_case :   str													=    self._prepare_for_class(__a      ,     __a      ,     return_labels=__a  )
             __snake_case :   str													=    model(**__a  ).loss
             loss.backward()
 def A_   (   self						:							Optional[int]  )      ->   List[Any]:







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

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

             if model_class in get_values(__a  ) or not model_class.supports_gradient_checkpointing:
                   continue
             __snake_case :   Optional[Any]													=    model_class(__a  )
             model.to(__a  )
             model.gradient_checkpointing_enable()
             model.train()
             __snake_case :   Union[str, Any]													=    self._prepare_for_class(__a      ,     __a      ,     return_labels=__a  )
             __snake_case :   Union[str, Any]													=    model(**__a  ).loss
             loss.backward()
 def A_   (   self						:							Tuple  )      ->   List[Any]:







       '''simple docstring'''
       __snake_case							,     __snake_case :   List[str]													=    self.model_tester.prepare_config_and_inputs_for_common()

       __snake_case :   Any													=    _config_zero_init(__a  )
       for model_class in self.all_model_classes:
             __snake_case :   Any													=    model_class(config=__a  )
             # Skip the check for the backbone
             __snake_case :   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 A_   (   self						:							Union[str, Any]  )      ->   str:







       '''simple docstring'''
       pass
 @slow
 def A_   (   self						:							Optional[int]  )      ->   Optional[Any]:







       '''simple docstring'''
       for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
             __snake_case :   Dict													=    DPTModel.from_pretrained(__a  )
             self.assertIsNotNone(__a  )





 def A_   (   self						:							Tuple  )      ->   Dict:







       '''simple docstring'''
       # We do this test only for DPTForDepthEstimation since it is the only model that uses readout_type
       __snake_case							,     __snake_case :   Optional[Any]													=    self.model_tester.prepare_config_and_inputs_for_common()
       __snake_case :   Tuple													=    'add'
       with self.assertRaises(__a  ):
             __snake_case :   Union[str, Any]													=    DPTForDepthEstimation(__a  )





def   a_   (		)    ->  List[Any]:
      __snake_case :   str													=    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
      return image





@require_torch
@require_vision
@slow
class  snake_case__						(    unittest.TestCase				):
 def A_   (   self						:							Any  )      ->   Any:







       '''simple docstring'''
       __snake_case :   Tuple													=    DPTImageProcessor.from_pretrained('Intel/dpt-hybrid-midas'  )
       __snake_case :   List[Any]													=    DPTForDepthEstimation.from_pretrained('Intel/dpt-hybrid-midas'  ).to(__a  )

       __snake_case :   str													=    prepare_img()
       __snake_case :   Optional[Any]													=    image_processor(images=__a      ,     return_tensors='pt'  ).to(__a  )

       # forward pass
       with torch.no_grad():
             __snake_case :   Optional[int]													=    model(**__a  )
             __snake_case :   Any													=    outputs.predicted_depth

       # verify the predicted depth
       __snake_case :   Any													=    torch.Size((1, 384, 384)  )
       self.assertEqual(predicted_depth.shape      ,     __a  )

       __snake_case :   Dict													=    torch.tensor(
           [[[5.6_4_3_7, 5.6_1_4_6, 5.6_5_1_1], [5.4_3_7_1, 5.5_6_4_9, 5.5_9_5_8], [5.5_2_1_5, 5.5_1_8_4, 5.5_2_9_3]]]  ).to(__a  )

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








'''simple docstring'''





from __future__ import annotations





def   a_   (		_UpperCAmelCase    :      list[int]				)    ->  bool:
      return len(set(_UpperCAmelCase				)				) == len(_UpperCAmelCase				)


if __name__ == "__main__":
    import doctest

    doctest.testmod()



