





"""simple docstring"""




import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, slow, torch_device

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin

class 					_UpperCAmelCase    (  _a     ,  _a     ,  unittest.TestCase						):



      '''simple docstring'''
      lowercase_ :					int             =  UNetaDModel
      lowercase_ :					Optional[Any]             =  'sample'

      @property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Dict									=    4
        A_    :			Any									=    1_4
        A_    :			Optional[Any]									=    1_6

        A_    :			Optional[Any]									=    floats_tensor((batch_size, num_features, seq_len)    ).to(snake_case_    )
        A_    :			List[str]									=    torch.tensor([1_0] * batch_size    ).to(snake_case_    )

        return {"sample": noise, "timestep": time_step}

      @property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return (4, 1_4, 1_6)

      @property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return (4, 1_4, 1_6)

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_determinism()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_outputs_equivalence()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_from_save_pretrained()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_from_save_pretrained_variant()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_model_from_pretrained()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_output()

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Optional[int]									=    {
            'block_out_channels': (3_2, 6_4, 1_2_8, 2_5_6),
            'in_channels': 1_4,
            'out_channels': 1_4,
            'time_embedding_type': 'positional',
            'use_timestep_embedding': True,
            'flip_sin_to_cos': False,
            'freq_shift': 1.0,
            'out_block_type': 'OutConv1DBlock',
            'mid_block_type': 'MidResTemporalBlock1D',
            'down_block_types': ('DownResnetBlock1D', 'DownResnetBlock1D', 'DownResnetBlock1D', 'DownResnetBlock1D'),
            'up_block_types': ('UpResnetBlock1D', 'UpResnetBlock1D', 'UpResnetBlock1D'),
            'act_fn': 'mish',
        }
        A_    :			List[Any]									=    self.dummy_input
        return init_dict, inputs_dict

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_		,			A_    :			str									=    UNetaDModel.from_pretrained(
            'bglick13/hopper-medium-v2-value-function-hor32'   , output_loading_info=snake_case_   , subfolder='unet'    )
        self.assertIsNotNone(snake_case_    )
        self.assertEqual(len(loading_info['missing_keys']    )   , 0    )

        model.to(snake_case_    )
        A_    :			Optional[int]									=    model(**self.dummy_input    )

        assert image is not None, "Make sure output is not None"

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			List[Any]									=    UNetaDModel.from_pretrained('bglick13/hopper-medium-v2-value-function-hor32'   , subfolder='unet'    )
        torch.manual_seed(0    )
        if torch.cuda.is_available():
          torch.cuda.manual_seed_all(0    )

        A_    :			Dict									=    model.config.in_channels
        A_    :			Dict									=    1_6
        A_    :			Any									=    torch.randn((1, seq_len, num_features)    ).permute(
            0   , 2   , 1    )  # match original, we can update values and remove
        A_    :			str									=    torch.full((num_features,)   , 0    )

        with torch.no_grad():
          A_    :			Tuple									=    model(snake_case_   , snake_case_    ).sample.permute(0   , 2   , 1    )

        A_    :			str									=    output[0, -3:, -3:].flatten()
        # fmt: off
        A_    :			Dict									=    torch.tensor([-2.13_71_72, 1.1_42_60_16, 0.3_68_86_87, -0.76_69_22, 0.7_30_31_46, 0.11_03_88_64, -0.4_76_06_33, 0.13_27_01_72, 0.02_59_13_48]    )
        # fmt: on
        self.assertTrue(torch.allclose(snake_case_   , snake_case_   , rtol=1E-3    )    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass

      @slow
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Dict									=    'harmonai/maestro-150k'
        A_    :			Optional[Any]									=    UNetaDModel.from_pretrained(snake_case_   , subfolder='unet'    )
        model.to(snake_case_    )

        A_    :			int									=    6_5_5_3_6
        A_    :			Dict									=    torch.sin(torch.arange(snake_case_    )[None, None, :].repeat(1   , 2   , 1    )    ).to(snake_case_    )
        A_    :			Tuple									=    torch.tensor([1]    ).to(snake_case_    )

        with torch.no_grad():
          A_    :			str									=    model(snake_case_   , snake_case_    ).sample

        A_    :			int									=    output.abs().sum()
        A_    :			int									=    output.abs().max()

        assert (output_sum - 2_24.08_96).abs() < 0.5
        assert (output_max - 0.06_07).abs() < 4E-4


class 					_UpperCAmelCase    (  _a     ,  _a     ,  unittest.TestCase						):



      '''simple docstring'''
      lowercase_ :					Optional[Any]             =  UNetaDModel
      lowercase_ :					int             =  'sample'

      @property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Union[str, Any]									=    4
        A_    :			List[Any]									=    1_4
        A_    :			List[Any]									=    1_6

        A_    :			int									=    floats_tensor((batch_size, num_features, seq_len)    ).to(snake_case_    )
        A_    :			Tuple									=    torch.tensor([1_0] * batch_size    ).to(snake_case_    )

        return {"sample": noise, "timestep": time_step}

      @property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return (4, 1_4, 1_6)

      @property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return (4, 1_4, 1)

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_determinism()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_outputs_equivalence()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_from_save_pretrained()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_from_save_pretrained_variant()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_model_from_pretrained()

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_		,			A_    :			Tuple									=    self.prepare_init_args_and_inputs_for_common()
        A_    :			Optional[int]									=    self.model_class(**snake_case_    )
        model.to(snake_case_    )
        model.eval()

        with torch.no_grad():
          A_    :			Optional[Any]									=    model(**snake_case_    )

          if isinstance(snake_case_   , snake_case_    ):
            A_    :			int									=    output.sample

        self.assertIsNotNone(snake_case_    )
        A_    :			Optional[Any]									=    torch.Size((inputs_dict['sample'].shape[0], 1)    )
        self.assertEqual(output.shape   , snake_case_   , 'Input and output shapes do not match'    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			int									=    {
            'in_channels': 1_4,
            'out_channels': 1_4,
            'down_block_types': ['DownResnetBlock1D', 'DownResnetBlock1D', 'DownResnetBlock1D', 'DownResnetBlock1D'],
            'up_block_types': [],
            'out_block_type': 'ValueFunction',
            'mid_block_type': 'ValueFunctionMidBlock1D',
            'block_out_channels': [3_2, 6_4, 1_2_8, 2_5_6],
            'layers_per_block': 1,
            'downsample_each_block': True,
            'use_timestep_embedding': True,
            'freq_shift': 1.0,
            'flip_sin_to_cos': False,
            'time_embedding_type': 'positional',
            'act_fn': 'mish',
        }
        A_    :			List[Any]									=    self.dummy_input
        return init_dict, inputs_dict

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_		,			A_    :			Optional[Any]									=    UNetaDModel.from_pretrained(
            'bglick13/hopper-medium-v2-value-function-hor32'   , output_loading_info=snake_case_   , subfolder='value_function'    )
        self.assertIsNotNone(snake_case_    )
        self.assertEqual(len(vf_loading_info['missing_keys']    )   , 0    )

        value_function.to(snake_case_    )
        A_    :			Optional[int]									=    value_function(**self.dummy_input    )

        assert image is not None, "Make sure output is not None"

      @unittest.skipIf(torch_device == 'mps'   , 'mish op not supported in MPS'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_		,			A_    :			Any									=    UNetaDModel.from_pretrained(
            'bglick13/hopper-medium-v2-value-function-hor32'   , output_loading_info=snake_case_   , subfolder='value_function'    )
        torch.manual_seed(0    )
        if torch.cuda.is_available():
          torch.cuda.manual_seed_all(0    )

        A_    :			Dict									=    value_function.config.in_channels
        A_    :			List[str]									=    1_4
        A_    :			Dict									=    torch.randn((1, seq_len, num_features)    ).permute(
            0   , 2   , 1    )  # match original, we can update values and remove
        A_    :			int									=    torch.full((num_features,)   , 0    )

        with torch.no_grad():
          A_    :			Dict									=    value_function(snake_case_   , snake_case_    ).sample

        # fmt: off
        A_    :			Any									=    torch.tensor([1_65.25] * seq_len    )
        # fmt: on
        self.assertTrue(torch.allclose(snake_case_   , snake_case_   , rtol=1E-3    )    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass
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	: int   ,   lowerCAmelCase	: Tuple   ,   lowerCAmelCase	: Dict=2   ,   lowerCAmelCase	: Dict=32   ,   lowerCAmelCase	: Optional[int]=16   ,   lowerCAmelCase	: Tuple=3   ,   lowerCAmelCase	: Tuple=True   ,   lowerCAmelCase	: str=True   ,   lowerCAmelCase	: int=32   ,   lowerCAmelCase	: int=4   ,   lowerCAmelCase	: Tuple=[0, 1, 2, 3]   ,   lowerCAmelCase	: Dict=4   ,   lowerCAmelCase	: Optional[int]=37   ,   lowerCAmelCase	: Tuple="gelu"   ,   lowerCAmelCase	: Optional[int]=0.1   ,   lowerCAmelCase	: Dict=0.1   ,   lowerCAmelCase	: Tuple=0.02   ,   lowerCAmelCase	: List[str]=3   ,   lowerCAmelCase	: Dict=False   ,   lowerCAmelCase	: str=None   ,   )						->			Tuple:
      a__  		=  parent
      a__  		=  batch_size
      a__  		=  image_size
      a__  		=  patch_size
      a__  		=  num_channels
      a__  		=  is_training
      a__  		=  use_labels
      a__  		=  hidden_size
      a__  		=  num_hidden_layers
      a__  		=  backbone_out_indices
      a__  		=  num_attention_heads
      a__  		=  intermediate_size
      a__  		=  hidden_act
      a__  		=  hidden_dropout_prob
      a__  		=  attention_probs_dropout_prob
      a__  		=  initializer_range
      a__  		=  num_labels
      a__  		=  scope
      a__  		=  is_hybrid
      # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
      a__  		=  (image_size // patch_size) ** 2
      a__  		=  num_patches + 1




    def     __lowerCamelCase			(       self	: List[Any] )						->			str:
      a__  		=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

      a__  		=  self.get_config()

      return config, pixel_values, labels




    def     __lowerCamelCase			(       self	: List[Any] )						->			Union[str, Any]:
      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     __lowerCamelCase			(       self	: Optional[int]   ,   lowerCAmelCase	: Any   ,   lowerCAmelCase	: Optional[Any]   ,   lowerCAmelCase	: Optional[Any] )						->			Optional[Any]:
      a__  		=  DPTModel(config=lowerCAmelCase )
      model.to(lowerCAmelCase )
      model.eval()
      a__  		=  model(lowerCAmelCase )
      self.parent.assertEqual(result.last_hidden_state.shape   ,   (self.batch_size, self.seq_length, self.hidden_size) )




    def     __lowerCamelCase			(       self	: Union[str, Any]   ,   lowerCAmelCase	: Any   ,   lowerCAmelCase	: Dict   ,   lowerCAmelCase	: str )						->			Optional[Any]:
      a__  		=  self.num_labels
      a__  		=  DPTForDepthEstimation(lowerCAmelCase )
      model.to(lowerCAmelCase )
      model.eval()
      a__  		=  model(lowerCAmelCase )
      self.parent.assertEqual(result.predicted_depth.shape   ,   (self.batch_size, self.image_size, self.image_size) )




    def     __lowerCamelCase			(       self	: str   ,   lowerCAmelCase	: Any   ,   lowerCAmelCase	: Any   ,   lowerCAmelCase	: Optional[int] )						->			List[str]:
      a__  		=  self.num_labels
      a__  		=  DPTForSemanticSegmentation(lowerCAmelCase )
      model.to(lowerCAmelCase )
      model.eval()
      a__  		=  model(lowerCAmelCase   ,   labels=lowerCAmelCase )
      self.parent.assertEqual(
          result.logits.shape   ,   (self.batch_size, self.num_labels, self.image_size, self.image_size) )




    def     __lowerCamelCase			(       self	: int )						->			Any:
      a__  		=  self.prepare_config_and_inputs()
      a__		,a__		,a__  		=  config_and_inputs
      a__  		=  {"pixel_values": pixel_values}
      return config, inputs_dict







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

    UpperCAmelCase_      :							List[str]    			=				False
    UpperCAmelCase_      :							int    			=				False
    UpperCAmelCase_      :							Optional[Any]    			=				False




    def     __lowerCamelCase			(       self	: List[Any] )						->			Any:
      a__  		=  DPTModelTester(self )
      a__  		=  ConfigTester(self   ,   config_class=lowerCAmelCase   ,   has_text_modality=lowerCAmelCase   ,   hidden_size=37 )




    def     __lowerCamelCase			(       self	: int )						->			List[Any]:
      self.config_tester.run_common_tests()




    @unittest.skip(reason="DPT does not use inputs_embeds" )
    def     __lowerCamelCase			(       self	: str )						->			Dict:
      pass




    def     __lowerCamelCase			(       self	: List[str] )						->			int:
      a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()

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




    def     __lowerCamelCase			(       self	: Union[str, Any] )						->			Any:
      a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        a__  		=  model_class(lowerCAmelCase )
        a__  		=  inspect.signature(model.forward )
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        a__  		=  [*signature.parameters.keys()]

        a__  		=  ["pixel_values"]
        self.assertListEqual(arg_names[:1]   ,   lowerCAmelCase )




    def     __lowerCamelCase			(       self	: Optional[int] )						->			Optional[Any]:
      a__  		=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase )




    def     __lowerCamelCase			(       self	: Tuple )						->			List[str]:
      a__  		=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_depth_estimation(*lowerCAmelCase )




    def     __lowerCamelCase			(       self	: List[Any] )						->			Any:
      a__  		=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase )




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

        a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()
        a__  		=  True

        if model_class in get_values(lowerCAmelCase ):
          continue

        a__  		=  model_class(lowerCAmelCase )
        model.to(lowerCAmelCase )
        model.train()
        a__  		=  self._prepare_for_class(lowerCAmelCase   ,   lowerCAmelCase   ,   return_labels=lowerCAmelCase )
        a__  		=  model(**lowerCAmelCase ).loss
        loss.backward()




    def     __lowerCamelCase			(       self	: Any )						->			Dict:
      for model_class in self.all_model_classes:
        if model_class.__name__ == "DPTForDepthEstimation":
          continue

        a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()
        a__  		=  False
        a__  		=  True

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




    def     __lowerCamelCase			(       self	: List[str] )						->			int:
      a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()

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




    @slow
    def     __lowerCamelCase			(       self	: List[str] )						->			Dict:
      for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        a__  		=  DPTModel.from_pretrained(lowerCAmelCase )
        self.assertIsNotNone(lowerCAmelCase )

def 					__lowercase						(    )					->int:

  '''simple docstring'''




  a__  		=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
  return image







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




    def     __lowerCamelCase			(       self	: Any )						->			Union[str, Any]:
      a__  		=  DPTImageProcessor.from_pretrained("Intel/dpt-large" )
      a__  		=  DPTForDepthEstimation.from_pretrained("Intel/dpt-large" ).to(lowerCAmelCase )

      a__  		=  prepare_img()
      a__  		=  image_processor(images=lowerCAmelCase   ,   return_tensors="pt" ).to(lowerCAmelCase )

      # forward pass
      with torch.no_grad():
        a__  		=  model(**lowerCAmelCase )
        a__  		=  outputs.predicted_depth

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

      a__  		=  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(lowerCAmelCase )

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




    def     __lowerCamelCase			(       self	: Union[str, Any] )						->			str:
      a__  		=  DPTImageProcessor.from_pretrained("Intel/dpt-large-ade" )
      a__  		=  DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade" ).to(lowerCAmelCase )

      a__  		=  prepare_img()
      a__  		=  image_processor(images=lowerCAmelCase   ,   return_tensors="pt" ).to(lowerCAmelCase )

      # forward pass
      with torch.no_grad():
        a__  		=  model(**lowerCAmelCase )

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

      a__  		=  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(lowerCAmelCase )

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




    def     __lowerCamelCase			(       self	: str )						->			Optional[int]:
      a__  		=  DPTImageProcessor.from_pretrained("Intel/dpt-large-ade" )
      a__  		=  DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade" ).to(lowerCAmelCase )

      a__  		=  prepare_img()
      a__  		=  image_processor(images=lowerCAmelCase   ,   return_tensors="pt" ).to(lowerCAmelCase )

      # forward pass
      with torch.no_grad():
        a__  		=  model(**lowerCAmelCase )

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

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

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

