






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_						:



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

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

          UpperCamelCase	:Dict     							=       self.get_config()

          return config, pixel_values, labels
      def    UpperCAmelCase						(    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=__UpperCamelCase   ,    initializer_range=self.initializer_range   ,    is_hybrid=self.is_hybrid   ,    )
      def    UpperCAmelCase						(    self   ,    SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_			)    ->				Tuple:
          UpperCamelCase	:Union[str, Any]     							=       DPTModel(config=__UpperCamelCase			)
          model.to(__UpperCamelCase			)
          model.eval()
          UpperCamelCase	:Union[str, Any]     							=       model(__UpperCamelCase			)
          self.parent.assertEqual(result.last_hidden_state.shape   ,    (self.batch_size, self.seq_length, self.hidden_size)			)
      def    UpperCAmelCase						(    self   ,    SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_			)    ->				Optional[Any]:
          UpperCamelCase	:int     							=       self.num_labels
          UpperCamelCase	:Any     							=       DPTForDepthEstimation(__UpperCamelCase			)
          model.to(__UpperCamelCase			)
          model.eval()
          UpperCamelCase	:Dict     							=       model(__UpperCamelCase			)
          self.parent.assertEqual(result.predicted_depth.shape   ,    (self.batch_size, self.image_size, self.image_size)			)
      def    UpperCAmelCase						(    self   ,    SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_			)    ->				List[Any]:
          UpperCamelCase	:Union[str, Any]     							=       self.num_labels
          UpperCamelCase	:List[str]     							=       DPTForSemanticSegmentation(__UpperCamelCase			)
          model.to(__UpperCamelCase			)
          model.eval()
          UpperCamelCase	:Optional[int]     							=       model(__UpperCamelCase   ,    labels=__UpperCamelCase			)
          self.parent.assertEqual(
              result.logits.shape   ,    (self.batch_size, self.num_labels, self.image_size, self.image_size)			)




      def    UpperCAmelCase						(    self			)    ->				List[Any]:
          UpperCamelCase	:Tuple     							=       self.prepare_config_and_inputs()
          UpperCamelCase							,       UpperCamelCase							,       UpperCamelCase	:List[Any]     							=       config_and_inputs
          UpperCamelCase	:Dict     							=       {'''pixel_values''': pixel_values}
          return config, inputs_dict







@require_torch
class       UpperCAmelCase_						( lowercase_,     lowercase_,     unittest.TestCase			):



      """simple docstring"""
      UpperCamelCase_    : List[Any]									=(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
      UpperCamelCase_    : List[str]									=(
          {
              'depth-estimation': DPTForDepthEstimation,
              'feature-extraction': DPTModel,
              'image-segmentation': DPTForSemanticSegmentation,
          }
          if is_torch_available()
          else {}
      )

      UpperCamelCase_    : Any									=False
      UpperCamelCase_    : Optional[int]									=False
      UpperCamelCase_    : str									=False
      def    UpperCAmelCase						(    self			)    ->				List[Any]:
          UpperCamelCase	:List[Any]     							=       DPTModelTester(self			)
          UpperCamelCase	:str     							=       ConfigTester(self   ,    config_class=__UpperCamelCase   ,    has_text_modality=__UpperCamelCase   ,    hidden_size=37			)
      def    UpperCAmelCase						(    self			)    ->				Union[str, Any]:
          self.config_tester.run_common_tests()
      @unittest.skip(reason='''DPT does not use inputs_embeds'''			)
      def    UpperCAmelCase						(    self			)    ->				Optional[int]:
          pass
      def    UpperCAmelCase						(    self			)    ->				Optional[Any]:
          UpperCamelCase							,       UpperCamelCase	:Any     							=       self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              UpperCamelCase	:Union[str, Any]     							=       model_class(__UpperCamelCase			)
              self.assertIsInstance(model.get_input_embeddings()   ,    (nn.Module)			)
              UpperCamelCase	:Optional[int]     							=       model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(__UpperCamelCase   ,    nn.Linear			)			)
      def    UpperCAmelCase						(    self			)    ->				List[str]:
          UpperCamelCase							,       UpperCamelCase	:str     							=       self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              UpperCamelCase	:int     							=       model_class(__UpperCamelCase			)
              UpperCamelCase	:Dict     							=       inspect.signature(model.forward			)
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              UpperCamelCase	:List[Any]     							=       [*signature.parameters.keys()]

              UpperCamelCase	:Tuple     							=       ['''pixel_values''']
              self.assertListEqual(arg_names[:1]   ,    __UpperCamelCase			)
      def    UpperCAmelCase						(    self			)    ->				int:
          UpperCamelCase	:int     							=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*__UpperCamelCase			)
      def    UpperCAmelCase						(    self			)    ->				List[Any]:
          UpperCamelCase	:Optional[int]     							=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_depth_estimation(*__UpperCamelCase			)
      def    UpperCAmelCase						(    self			)    ->				Optional[int]:
          UpperCamelCase	:Tuple     							=       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCamelCase			)
      def    UpperCAmelCase						(    self			)    ->				int:
          for model_class in self.all_model_classes:
              if model_class.__name__ == "DPTForDepthEstimation":
                  continue

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

              if model_class in get_values(__UpperCamelCase			):
                  continue

              UpperCamelCase	:Optional[int]     							=       model_class(__UpperCamelCase			)
              model.to(__UpperCamelCase			)
              model.train()
              UpperCamelCase	:List[Any]     							=       self._prepare_for_class(__UpperCamelCase   ,    __UpperCamelCase   ,    return_labels=__UpperCamelCase			)
              UpperCamelCase	:Any     							=       model(**__UpperCamelCase			).loss
              loss.backward()
      def    UpperCAmelCase						(    self			)    ->				Any:
          for model_class in self.all_model_classes:
              if model_class.__name__ == "DPTForDepthEstimation":
                  continue

              UpperCamelCase							,       UpperCamelCase	:List[Any]     							=       self.model_tester.prepare_config_and_inputs_for_common()
              UpperCamelCase	:Tuple     							=       False
              UpperCamelCase	:List[Any]     							=       True

              if model_class in get_values(__UpperCamelCase			) or not model_class.supports_gradient_checkpointing:
                  continue
              UpperCamelCase	:Optional[Any]     							=       model_class(__UpperCamelCase			)
              model.to(__UpperCamelCase			)
              model.gradient_checkpointing_enable()
              model.train()
              UpperCamelCase	:List[Any]     							=       self._prepare_for_class(__UpperCamelCase   ,    __UpperCamelCase   ,    return_labels=__UpperCamelCase			)
              UpperCamelCase	:Optional[Any]     							=       model(**__UpperCamelCase			).loss
              loss.backward()
      def    UpperCAmelCase						(    self			)    ->				Optional[int]:
          UpperCamelCase							,       UpperCamelCase	:Optional[int]     							=       self.model_tester.prepare_config_and_inputs_for_common()

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




      @slow
      def    UpperCAmelCase						(    self			)    ->				Dict:
          for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCamelCase	:Dict     							=       DPTModel.from_pretrained(__UpperCamelCase			)
              self.assertIsNotNone(__UpperCamelCase			)







def   _A       (    ):
    UpperCamelCase	:str     							=       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
    return image







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



      """simple docstring"""
      def    UpperCAmelCase						(    self			)    ->				str:
          UpperCamelCase	:Optional[Any]     							=       DPTImageProcessor.from_pretrained('''Intel/dpt-large'''			)
          UpperCamelCase	:List[str]     							=       DPTForDepthEstimation.from_pretrained('''Intel/dpt-large'''			).to(__UpperCamelCase			)

          UpperCamelCase	:Optional[int]     							=       prepare_img()
          UpperCamelCase	:List[Any]     							=       image_processor(images=__UpperCamelCase   ,    return_tensors='''pt'''			).to(__UpperCamelCase			)

          # forward pass
          with torch.no_grad():
              UpperCamelCase	:Union[str, Any]     							=       model(**__UpperCamelCase			)
              UpperCamelCase	:Tuple     							=       outputs.predicted_depth

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

          UpperCamelCase	:Tuple     							=       torch.tensor(
              [[6.3199, 6.3629, 6.4148], [6.3850, 6.3615, 6.4166], [6.3519, 6.3176, 6.3575]]			).to(__UpperCamelCase			)

          self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]   ,    __UpperCamelCase   ,    atol=1e-4			)			)
      def    UpperCAmelCase						(    self			)    ->				Dict:
          UpperCamelCase	:Dict     							=       DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''			)
          UpperCamelCase	:Tuple     							=       DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''			).to(__UpperCamelCase			)

          UpperCamelCase	:Union[str, Any]     							=       prepare_img()
          UpperCamelCase	:List[str]     							=       image_processor(images=__UpperCamelCase   ,    return_tensors='''pt'''			).to(__UpperCamelCase			)

          # forward pass
          with torch.no_grad():
              UpperCamelCase	:Union[str, Any]     							=       model(**__UpperCamelCase			)

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

          UpperCamelCase	:List[Any]     							=       torch.tensor(
              [[4.0480, 4.2420, 4.4360], [4.3124, 4.5693, 4.8261], [4.5768, 4.8965, 5.2163]]			).to(__UpperCamelCase			)

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




      def    UpperCAmelCase						(    self			)    ->				str:
          UpperCamelCase	:Optional[int]     							=       DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''			)
          UpperCamelCase	:Dict     							=       DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''			).to(__UpperCamelCase			)

          UpperCamelCase	:Union[str, Any]     							=       prepare_img()
          UpperCamelCase	:Tuple     							=       image_processor(images=__UpperCamelCase   ,    return_tensors='''pt'''			).to(__UpperCamelCase			)

          # forward pass
          with torch.no_grad():
              UpperCamelCase	:Optional[Any]     							=       model(**__UpperCamelCase			)

          UpperCamelCase	:Optional[int]     							=       outputs.logits.detach().cpu()

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

          UpperCamelCase	:str     							=       image_processor.post_process_semantic_segmentation(outputs=__UpperCamelCase			)
          UpperCamelCase	:int     							=       torch.Size((480, 480)			)
          self.assertEqual(segmentation[0].shape   ,    __UpperCamelCase			)













def   _A       (    SCREAMING_SNAKE_CASE__  :     float					,  SCREAMING_SNAKE_CASE__  :     float	):
    UpperCamelCase	:Tuple     							=       float()
    try:
        UpperCamelCase	:Union[str, Any]     							=       mass * acceleration
    except Exception:
        return -0.0
    return force


if __name__ == "__main__":
 import doctest

 # run doctest
 doctest.testmod()

 # demo
 __snake_case							 =  1_2.5
 __snake_case							 =  10
 __snake_case							 =  newtons_second_law_of_motion(mass, acceleration)
 print("""The force is """, force, """N""")





