code: 
  
  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    SCREAMING_SNAKE_CASE__      :
  
  
  
  
  
      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=False		,     a=None		,     ):
           lowercase__					:     List[str]   = parent
           lowercase__					:     str   = batch_size
           lowercase__					:     Optional[Any]   = image_size
           lowercase__					:     Any   = patch_size
           lowercase__					:     Optional[Any]   = num_channels
           lowercase__					:     str   = is_training
           lowercase__					:     int   = use_labels
           lowercase__					:     Dict   = hidden_size
           lowercase__					:     Union[str, Any]   = num_hidden_layers
           lowercase__					:     Dict   = backbone_out_indices
           lowercase__					:     List[Any]   = num_attention_heads
           lowercase__					:     Any   = intermediate_size
           lowercase__					:     Dict   = hidden_act
           lowercase__					:     int   = hidden_dropout_prob
           lowercase__					:     List[str]   = attention_probs_dropout_prob
           lowercase__					:     Optional[int]   = initializer_range
           lowercase__					:     int   = num_labels
           lowercase__					:     Union[str, Any]   = scope
           lowercase__					:     Dict   = is_hybrid
           # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
           lowercase__					:     Any   = (image_size // patch_size) ** 2
           lowercase__					:     str   = num_patches + 1
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     List[Any]   = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
  
           lowercase__					:     str   = None
           if self.use_labels:
                lowercase__					:     List[Any]   = ids_tensor([self.batch_size, self.image_size, self.image_size]		,     self.num_labels)
  
           lowercase__					:     int   = self.get_config()
  
           return config, pixel_values, labels
  
  
  
  
  
      def    snake_case_       (   self):
           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		,     )
  
  
  
  
  
      def    snake_case_       (   self		,     a		,     a		,     a):
           lowercase__					:     int   = DPTModel(config=a)
           model.to(a)
           model.eval()
           lowercase__					:     str   = 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):
           lowercase__					:     Tuple   = self.num_labels
           lowercase__					:     int   = DPTForDepthEstimation(a)
           model.to(a)
           model.eval()
           lowercase__					:     Dict   = 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):
           lowercase__					:     Union[str, Any]   = self.num_labels
           lowercase__					:     Dict   = DPTForSemanticSegmentation(a)
           model.to(a)
           model.eval()
           lowercase__					:     Optional[Any]   = 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):
           lowercase__					:     Dict   = self.prepare_config_and_inputs()
           lowercase__					:     Any   = config_and_inputs
           lowercase__					:     Optional[int]   = {'pixel_values': pixel_values}
           return config, inputs_dict
  
  
  
  @require_torch
  class    SCREAMING_SNAKE_CASE__      (__snake_case	, __snake_case	, unittest.TestCase  ):
      __lowerCamelCase		: int														=  (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
      __lowerCamelCase		: int														=  (
          {
              """depth-estimation""": DPTForDepthEstimation,
              """feature-extraction""": DPTModel,
              """image-segmentation""": DPTForSemanticSegmentation,
          }
          if is_torch_available()
          else {}
      )
  
      __lowerCamelCase		: List[str]														=  False
      __lowerCamelCase		: Any														=  False
      __lowerCamelCase		: Any														=  False
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     List[Any]   = DPTModelTester(self)
           lowercase__					:     Dict   = ConfigTester(self		,     config_class=a		,     has_text_modality=a		,     hidden_size=37)
  
  
  
  
  
      def    snake_case_       (   self):
           self.config_tester.run_common_tests()
  
  
  
  
  
      @unittest.skip(reason='DPT does not use inputs_embeds')
      def    snake_case_       (   self):
           pass
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     Any   = self.model_tester.prepare_config_and_inputs_for_common()
  
           for model_class in self.all_model_classes:
                lowercase__					:     List[Any]   = model_class(a)
                self.assertIsInstance(model.get_input_embeddings()		,     (nn.Module))
                lowercase__					:     Any   = model.get_output_embeddings()
                self.assertTrue(x is None or isinstance(a		,     nn.Linear))
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     List[Any]   = self.model_tester.prepare_config_and_inputs_for_common()
  
           for model_class in self.all_model_classes:
                lowercase__					:     Tuple   = model_class(a)
                lowercase__					:     Optional[int]   = inspect.signature(model.forward)
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                lowercase__					:     List[Any]   = [*signature.parameters.keys()]
  
                lowercase__					:     Tuple   = ['pixel_values']
                self.assertListEqual(arg_names[:1]		,     a)
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     List[str]   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*a)
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     int   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_depth_estimation(*a)
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     List[str]   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_semantic_segmentation(*a)
  
  
  
  
  
      def    snake_case_       (   self):
           for model_class in self.all_model_classes:
                if model_class.__name__ == "DPTForDepthEstimation":
                     continue
  
                lowercase__					:     Tuple   = self.model_tester.prepare_config_and_inputs_for_common()
                lowercase__					:     Optional[Any]   = True
  
                if model_class in get_values(a):
                     continue
  
                lowercase__					:     Dict   = model_class(a)
                model.to(a)
                model.train()
                lowercase__					:     str   = self._prepare_for_class(a		,     a		,     return_labels=a)
                lowercase__					:     Tuple   = model(**a).loss
                loss.backward()
  
  
  
  
  
      def    snake_case_       (   self):
           for model_class in self.all_model_classes:
                if model_class.__name__ == "DPTForDepthEstimation":
                     continue
  
                lowercase__					:     int   = self.model_tester.prepare_config_and_inputs_for_common()
                lowercase__					:     Union[str, Any]   = False
                lowercase__					:     List[Any]   = True
  
                if model_class in get_values(a) or not model_class.supports_gradient_checkpointing:
                     continue
                lowercase__					:     List[Any]   = model_class(a)
                model.to(a)
                model.gradient_checkpointing_enable()
                model.train()
                lowercase__					:     Optional[int]   = self._prepare_for_class(a		,     a		,     return_labels=a)
                lowercase__					:     int   = model(**a).loss
                loss.backward()
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     Tuple   = self.model_tester.prepare_config_and_inputs_for_common()
  
           lowercase__					:     Optional[int]   = _config_zero_init(a)
           for model_class in self.all_model_classes:
                lowercase__					:     Any   = model_class(config=a)
                # Skip the check for the backbone
                lowercase__					:     Optional[Any]   = []
                for name, module in model.named_modules():
                     if module.__class__.__name__ == "DPTViTHybridEmbeddings":
                          lowercase__					:     str   = [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):
           pass
  
  
  
  
  
      @slow
      def    snake_case_       (   self):
           for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                lowercase__					:     Dict   = DPTModel.from_pretrained(a)
                self.assertIsNotNone(a)
  
  
  
  def 			snake_case__    (					):
  
  
  
       '''simple docstring'''
  
  
  
  
  
       lowercase__					:     Optional[int]   = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
       return image
  
  
  @require_torch
  @require_vision
  @slow
  class    SCREAMING_SNAKE_CASE__      (unittest.TestCase  ):
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     List[str]   = DPTImageProcessor.from_pretrained('Intel/dpt-large')
           lowercase__					:     Any   = DPTForDepthEstimation.from_pretrained('Intel/dpt-large').to(a)
  
           lowercase__					:     Optional[int]   = prepare_img()
           lowercase__					:     int   = image_processor(images=a		,     return_tensors='pt').to(a)
  
           # forward pass
           with torch.no_grad():
                lowercase__					:     Tuple   = model(**a)
                lowercase__					:     Union[str, Any]   = outputs.predicted_depth
  
           # verify the predicted depth
           lowercase__					:     int   = torch.Size((1, 384, 384))
           self.assertEqual(predicted_depth.shape		,     a)
  
           lowercase__					:     Dict   = 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(a)
  
           self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]		,     a		,     atol=1e-4))
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     str   = DPTImageProcessor.from_pretrained('Intel/dpt-large-ade')
           lowercase__					:     List[Any]   = DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade').to(a)
  
           lowercase__					:     Optional[int]   = prepare_img()
           lowercase__					:     Dict   = image_processor(images=a		,     return_tensors='pt').to(a)
  
           # forward pass
           with torch.no_grad():
                lowercase__					:     List[str]   = model(**a)
  
           # verify the logits
           lowercase__					:     Optional[Any]   = torch.Size((1, 150, 480, 480))
           self.assertEqual(outputs.logits.shape		,     a)
  
           lowercase__					:     Any   = 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(a)
  
           self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]		,     a		,     atol=1e-4))
  
  
  
  
  
      def    snake_case_       (   self):
           lowercase__					:     List[str]   = DPTImageProcessor.from_pretrained('Intel/dpt-large-ade')
           lowercase__					:     Tuple   = DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade').to(a)
  
           lowercase__					:     str   = prepare_img()
           lowercase__					:     Union[str, Any]   = image_processor(images=a		,     return_tensors='pt').to(a)
  
           # forward pass
           with torch.no_grad():
                lowercase__					:     List[str]   = model(**a)
  
           lowercase__					:     List[str]   = outputs.logits.detach().cpu()
  
           lowercase__					:     Any   = image_processor.post_process_semantic_segmentation(outputs=a		,     target_sizes=[(500, 300)])
           lowercase__					:     Optional[int]   = torch.Size((500, 300))
           self.assertEqual(segmentation[0].shape		,     a)
  
           lowercase__					:     str   = image_processor.post_process_semantic_segmentation(outputs=a)
           lowercase__					:     str   = torch.Size((480, 480))
           self.assertEqual(segmentation[0].shape		,     a)
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available
  
  
  snake_case_    						=				{
      '''configuration_donut_swin''': ['''DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DonutSwinConfig'''],
      '''processing_donut''': ['''DonutProcessor'''],
  }
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				[
             '''DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST''',
             '''DonutSwinModel''',
             '''DonutSwinPreTrainedModel''',
         ]
  
  try:
         if not is_vision_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				['''DonutFeatureExtractor''']
         snake_case_    						=				['''DonutImageProcessor''']
  
  
  if TYPE_CHECKING:
         from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
         from .processing_donut import DonutProcessor
  
         try:
                if not is_torch_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_donut_swin import (
                    DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
                    DonutSwinModel,
                    DonutSwinPreTrainedModel,
                )
  
         try:
                if not is_vision_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .feature_extraction_donut import DonutFeatureExtractor
                from .image_processing_donut import DonutImageProcessor
  
  else:
         import sys
  
         snake_case_    						=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  