



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,    __a,    __a=2,    __a=32,    __a=16,    __a=3,    __a=True,    __a=True,    __a=32,    __a=4,    __a=[0, 1, 2, 3],    __a=4,    __a=37,    __a="gelu",    __a=0.1,    __a=0.1,    __a=0.02,    __a=3,    __a=[1, 384, 24, 24],    __a=True,    __a=None,    ):

              '''simple docstring'''

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







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Tuple				     =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

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

              return config, pixel_values, labels







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Optional[int]				     =					{
                  "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      snake_case__   (     self,    __a,    __a,    __a):

              '''simple docstring'''

              _lowerCAmelCase  :							str				     =					DPTModel(config=__a)
              model.to(__a)
              model.eval()
              _lowerCAmelCase  :							Optional[Any]				     =					model(__a)
              self.parent.assertEqual(result.last_hidden_state.shape,    (self.batch_size, self.seq_length, self.hidden_size))







       def      snake_case__   (     self,    __a,    __a,    __a):

              '''simple docstring'''

              _lowerCAmelCase  :							Any				     =					self.num_labels
              _lowerCAmelCase  :							Tuple				     =					DPTForDepthEstimation(__a)
              model.to(__a)
              model.eval()
              _lowerCAmelCase  :							int				     =					model(__a)
              self.parent.assertEqual(result.predicted_depth.shape,    (self.batch_size, self.image_size, self.image_size))







       def      snake_case__   (     self,    __a,    __a,    __a):

              '''simple docstring'''

              _lowerCAmelCase  :							Optional[int]				     =					self.num_labels
              _lowerCAmelCase  :							str				     =					DPTForSemanticSegmentation(__a)
              model.to(__a)
              model.eval()
              _lowerCAmelCase  :							Tuple				     =					model(__a,    labels=__a)
              self.parent.assertEqual(
                  result.logits.shape,    (self.batch_size, self.num_labels, self.image_size, self.image_size))







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							List[Any]				     =					self.prepare_config_and_inputs()
              _lowerCAmelCase  :							List[str]				     =					config_and_inputs
              _lowerCAmelCase  :							List[str]				     =					{"pixel_values": pixel_values}
              return config, inputs_dict



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

       lowerCamelCase__         =	False
       lowerCamelCase__         =	False
       lowerCamelCase__         =	False







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Optional[int]				     =					DPTModelTester(self)
              _lowerCAmelCase  :							int				     =					ConfigTester(self,    config_class=__a,    has_text_modality=__a,    hidden_size=37)







       def      snake_case__   (     self):

              '''simple docstring'''

              self.config_tester.run_common_tests()







       @unittest.skip(reason="DPT does not use inputs_embeds")
       def      snake_case__   (     self):

              '''simple docstring'''

              pass







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Any				     =					self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _lowerCAmelCase  :							List[str]				     =					model_class(__a)
                     self.assertIsInstance(model.get_input_embeddings(),    (nn.Module))
                     _lowerCAmelCase  :							List[Any]				     =					model.get_output_embeddings()
                     self.assertTrue(x is None or isinstance(__a,    nn.Linear))







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Union[str, Any]				     =					self.model_tester.prepare_config_and_inputs_for_common()

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

                     _lowerCAmelCase  :							int				     =					["pixel_values"]
                     self.assertListEqual(arg_names[:1],    __a)







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Any				     =					self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*__a)







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Any				     =					self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_depth_estimation(*__a)







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							List[Any]				     =					self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_semantic_segmentation(*__a)







       def      snake_case__   (     self):

              '''simple docstring'''

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

                     _lowerCAmelCase  :							List[Any]				     =					self.model_tester.prepare_config_and_inputs_for_common()
                     _lowerCAmelCase  :							Any				     =					True

                     if model_class in get_values(__a):
                            continue

                     _lowerCAmelCase  :							Any				     =					model_class(__a)
                     model.to(__a)
                     model.train()
                     _lowerCAmelCase  :							Union[str, Any]				     =					self._prepare_for_class(__a,    __a,    return_labels=__a)
                     _lowerCAmelCase  :							int				     =					model(**__a).loss
                     loss.backward()







       def      snake_case__   (     self):

              '''simple docstring'''

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

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

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







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							List[Any]				     =					self.model_tester.prepare_config_and_inputs_for_common()

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

              '''simple docstring'''

              pass







       @slow
       def      snake_case__   (     self):

              '''simple docstring'''

              for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
                     _lowerCAmelCase  :							List[Any]				     =					DPTModel.from_pretrained(__a)
                     self.assertIsNotNone(__a)







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							str				     =					self.model_tester.prepare_config_and_inputs_for_common()
              _lowerCAmelCase  :							int				     =					"add"
              with self.assertRaises(__a):
                     _lowerCAmelCase  :							Dict				     =					DPTForDepthEstimation(__a)






def        A       (      ):





       '''simple docstring'''




       _lowerCAmelCase  :							List[str]				     =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
       return image



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







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Dict				     =					DPTImageProcessor.from_pretrained("Intel/dpt-hybrid-midas")
              _lowerCAmelCase  :							Optional[int]				     =					DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas").to(__a)

              _lowerCAmelCase  :							Dict				     =					prepare_img()
              _lowerCAmelCase  :							List[str]				     =					image_processor(images=__a,    return_tensors="pt").to(__a)

              # forward pass
              with torch.no_grad():
                     _lowerCAmelCase  :							Union[str, Any]				     =					model(**__a)
                     _lowerCAmelCase  :							Optional[Any]				     =					outputs.predicted_depth

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

              _lowerCAmelCase  :							Tuple				     =					torch.tensor(
                  [[[5.6_437, 5.6_146, 5.6_511], [5.4_371, 5.5_649, 5.5_958], [5.5_215, 5.5_184, 5.5_293]]]).to(__a)

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





from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


_snake_case	=						logging.get_logger(__name__)

_snake_case	=						{
    "microsoft/focalnet-tiny": "https://huggingface.co/microsoft/focalnet-tiny/resolve/main/config.json",
}



class 						UpperCAmelCase_					( a     ,      a):
							lowerCamelCase__         =	'focalnet'







							def __init__(     self,    __a=224,    __a=4,    __a=3,    __a=96,    __a=False,    __a=[192, 384, 768, 768],    __a=[2, 2, 6, 2],    __a=[2, 2, 2, 2],    __a=[3, 3, 3, 3],    __a="gelu",    __a=4.0,    __a=0.0,    __a=0.1,    __a=False,    __a=1E-4,    __a=False,    __a=False,    __a=False,    __a=0.02,    __a=1E-5,    __a=32,    __a=None,    __a=None,    **__a,    ):

														'''simple docstring'''

														super().__init__(**__a)

														_lowerCAmelCase  :							str				     =					image_size
														_lowerCAmelCase  :							List[str]				     =					patch_size
														_lowerCAmelCase  :							List[Any]				     =					num_channels
														_lowerCAmelCase  :							Tuple				     =					embed_dim
														_lowerCAmelCase  :							List[Any]				     =					use_conv_embed
														_lowerCAmelCase  :							Any				     =					hidden_sizes
														_lowerCAmelCase  :							Tuple				     =					depths
														_lowerCAmelCase  :							Dict				     =					focal_levels
														_lowerCAmelCase  :							Optional[Any]				     =					focal_windows
														_lowerCAmelCase  :							str				     =					hidden_act
														_lowerCAmelCase  :							Union[str, Any]				     =					mlp_ratio
														_lowerCAmelCase  :							Any				     =					hidden_dropout_prob
														_lowerCAmelCase  :							Dict				     =					drop_path_rate
														_lowerCAmelCase  :							str				     =					use_layerscale
														_lowerCAmelCase  :							str				     =					layerscale_value
														_lowerCAmelCase  :							Union[str, Any]				     =					use_post_layernorm
														_lowerCAmelCase  :							Optional[int]				     =					use_post_layernorm_in_modulation
														_lowerCAmelCase  :							str				     =					normalize_modulator
														_lowerCAmelCase  :							Any				     =					initializer_range
														_lowerCAmelCase  :							Union[str, Any]				     =					layer_norm_eps
														_lowerCAmelCase  :							Any				     =					encoder_stride
														_lowerCAmelCase  :							List[str]				     =					["stem"] + [f"stage{idx}" for idx in range(1,    len(self.depths) + 1)]
														_lowerCAmelCase     ,					_lowerCAmelCase  :							List[str]				     =					get_aligned_output_features_output_indices(
														    out_features=__a,    out_indices=__a,    stage_names=self.stage_names)
