






"""simple docstring"""


from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


lowercase_								=	logging.get_logger(__name__)

# General docstring
lowercase_								=	'ResNetConfig'

# Base docstring
lowercase_								=	'microsoft/resnet-50'
lowercase_								=	[1, 2048, 7, 7]

# Image classification docstring
lowercase_								=	'microsoft/resnet-50'
lowercase_								=	'tiger cat'

lowercase_								=	[
    'microsoft/resnet-50',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]


class    snake_case						(				tf.keras.layers.Layer		):


   '''simple docstring'''

   def __init__(      self					:	Optional[int],			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 3,			_lowerCamelCase					:	int = 1,			_lowerCamelCase					:	str = "relu",			**_lowerCamelCase					:	List[Any]    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					kernel_size // 2
     __A		     =					tf.keras.layers.ConvaD(
         _lowerCamelCase,			kernel_size=_lowerCamelCase,			strides=_lowerCamelCase,			padding='''valid''',			use_bias=_lowerCamelCase,			name='''convolution'''    )
     # Use same default momentum and epsilon as PyTorch equivalent
     __A		     =					tf.keras.layers.BatchNormalization(epsilon=1e-5,			momentum=0.9,			name='''normalization'''    )
     __A		     =					ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('''linear'''    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int],			_lowerCamelCase					:	tf.Tensor    ):

     '''simple docstring'''
     # Pad to match that done in the PyTorch Conv2D model
     __A		     =					__A		     =					(self.pad_value, self.pad_value)
     __A		     =					tf.pad(_lowerCamelCase,			[(0, 0), height_pad, width_pad, (0, 0)]    )
     __A		     =					self.conv(_lowerCamelCase    )
     return hidden_state






   def 							_SCREAMING_SNAKE_CASE							(      self					:	Dict,			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A		     =					self.convolution(_lowerCamelCase    )
     __A		     =					self.normalization(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.activation(_lowerCamelCase    )
     return hidden_state





class    snake_case						(				tf.keras.layers.Layer		):


   '''simple docstring'''

   def __init__(      self					:	Union[str, Any],			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	str    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					TFResNetConvLayer(
         config.embedding_size,			kernel_size=7,			stride=2,			activation=config.hidden_act,			name='''embedder''',			)
     __A		     =					tf.keras.layers.MaxPoolaD(pool_size=3,			strides=2,			padding='''valid''',			name='''pooler'''    )
     __A		     =					config.num_channels






   def 							_SCREAMING_SNAKE_CASE							(      self					:	int,			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A     ,       __A     ,       __A     ,       __A		     =					shape_list(_lowerCamelCase    )
     if tf.executing_eagerly() and num_channels != self.num_channels:
       raise ValueError(
           '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.'''    )
     __A		     =					pixel_values
     __A		     =					self.embedder(_lowerCamelCase    )
     __A		     =					tf.pad(_lowerCamelCase,			[[0, 0], [1, 1], [1, 1], [0, 0]]    )
     __A		     =					self.pooler(_lowerCamelCase    )
     return hidden_state





class    snake_case						(				tf.keras.layers.Layer		):


   '''simple docstring'''

   def __init__(      self					:	Tuple,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 2,			**_lowerCamelCase					:	Dict    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					tf.keras.layers.ConvaD(
         _lowerCamelCase,			kernel_size=1,			strides=_lowerCamelCase,			use_bias=_lowerCamelCase,			name='''convolution'''    )
     # Use same default momentum and epsilon as PyTorch equivalent
     __A		     =					tf.keras.layers.BatchNormalization(epsilon=1e-5,			momentum=0.9,			name='''normalization'''    )






   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[Any],			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A		     =					x
     __A		     =					self.convolution(_lowerCamelCase    )
     __A		     =					self.normalization(_lowerCamelCase,			training=_lowerCamelCase    )
     return hidden_state





class    snake_case						(				tf.keras.layers.Layer		):


   '''simple docstring'''

   def __init__(      self					:	int,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 1,			_lowerCamelCase					:	str = "relu",			**_lowerCamelCase					:	Tuple    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					in_channels != out_channels or stride != 1
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			stride=_lowerCamelCase,			name='''layer.0'''    )
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			activation=_lowerCamelCase,			name='''layer.1'''    )
     __A		     =					(
         TFResNetShortCut(_lowerCamelCase,			stride=_lowerCamelCase,			name='''shortcut'''    )
         if should_apply_shortcut
         else tf.keras.layers.Activation('''linear''',			name='''shortcut'''    )
     )
     __A		     =					ACTaFN[activation]






   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[str],			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A		     =					hidden_state
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.shortcut(_lowerCamelCase,			training=_lowerCamelCase    )
     hidden_state += residual
     __A		     =					self.activation(_lowerCamelCase    )
     return hidden_state





class    snake_case						(				tf.keras.layers.Layer		):


   '''simple docstring'''

   def __init__(      self					:	List[str],			_lowerCamelCase					:	int,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 1,			_lowerCamelCase					:	str = "relu",			_lowerCamelCase					:	int = 4,			**_lowerCamelCase					:	List[Any],			):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					in_channels != out_channels or stride != 1
     __A		     =					out_channels // reduction
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			kernel_size=1,			name='''layer.0'''    )
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			stride=_lowerCamelCase,			name='''layer.1'''    )
     __A		     =					TFResNetConvLayer(_lowerCamelCase,			kernel_size=1,			activation=_lowerCamelCase,			name='''layer.2'''    )
     __A		     =					(
         TFResNetShortCut(_lowerCamelCase,			stride=_lowerCamelCase,			name='''shortcut'''    )
         if should_apply_shortcut
         else tf.keras.layers.Activation('''linear''',			name='''shortcut'''    )
     )
     __A		     =					ACTaFN[activation]






   def 							_SCREAMING_SNAKE_CASE							(      self					:	Any,			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     __A		     =					hidden_state
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.conva(_lowerCamelCase,			training=_lowerCamelCase    )
     __A		     =					self.shortcut(_lowerCamelCase,			training=_lowerCamelCase    )
     hidden_state += residual
     __A		     =					self.activation(_lowerCamelCase    )
     return hidden_state





class    snake_case						(				tf.keras.layers.Layer		):


   '''simple docstring'''

   def __init__(      self					:	List[str],			_lowerCamelCase					:	ResNetConfig,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int = 2,			_lowerCamelCase					:	int = 2,			**_lowerCamelCase					:	Tuple    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )

     __A		     =					TFResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else TFResNetBasicLayer

     __A		     =					[layer(_lowerCamelCase,			_lowerCamelCase,			stride=_lowerCamelCase,			activation=config.hidden_act,			name='''layers.0'''    )]
     layers += [
         layer(_lowerCamelCase,			_lowerCamelCase,			activation=config.hidden_act,			name=f'layers.{i + 1}'    )
         for i in range(depth - 1    )
     ]
     __A		     =					layers






   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int],			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False    ):

     '''simple docstring'''
     for layer in self.stage_layers:
       __A		     =					layer(_lowerCamelCase,			training=_lowerCamelCase    )
     return hidden_state





class    snake_case						(				tf.keras.layers.Layer		):


   '''simple docstring'''

   def __init__(      self					:	List[Any],			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	Tuple    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
     __A		     =					[
         TFResNetStage(
             _lowerCamelCase,			config.embedding_size,			config.hidden_sizes[0],			stride=2 if config.downsample_in_first_stage else 1,			depth=config.depths[0],			name='''stages.0''',			)
     ]
     for i, (in_channels, out_channels, depth) in enumerate(
         zip(config.hidden_sizes,			config.hidden_sizes[1:],			config.depths[1:]    )    ):
       self.stages.append(TFResNetStage(_lowerCamelCase,			_lowerCamelCase,			_lowerCamelCase,			depth=_lowerCamelCase,			name=f'stages.{i + 1}'    )    )






   def 							_SCREAMING_SNAKE_CASE							(      self					:	str,			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	bool = False,			_lowerCamelCase					:	bool = True,			_lowerCamelCase					:	bool = False,			):

     '''simple docstring'''
     __A		     =					() if output_hidden_states else None

     for stage_module in self.stages:
       if output_hidden_states:
         __A		     =					hidden_states + (hidden_state,)

       __A		     =					stage_module(_lowerCamelCase,			training=_lowerCamelCase    )

     if output_hidden_states:
       __A		     =					hidden_states + (hidden_state,)

     if not return_dict:
       return tuple(v for v in [hidden_state, hidden_states] if v is not None    )

     return TFBaseModelOutputWithNoAttention(last_hidden_state=_lowerCamelCase,			hidden_states=_lowerCamelCase    )





class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   A_		:      Dict							=					ResNetConfig
   A_		:      Dict							=					"resnet"
   A_		:      Tuple							=					"pixel_values"


   @property
   def 							_SCREAMING_SNAKE_CASE							(      self					:	Union[str, Any]    ):

     '''simple docstring'''
     return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24),			dtype=tf.floataa    )}





lowercase_								=	R'\n    This model is a TensorFlow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n'


lowercase_								=	R'\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n'


@keras_serializable
class    snake_case						(				tf.keras.layers.Layer		):


   '''simple docstring'''

   A_		:      Tuple							=					ResNetConfig


   def __init__(      self					:	str,			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	Dict    ):

     '''simple docstring'''
     super().__init__(**_lowerCamelCase    )
     __A		     =					config
     __A		     =					TFResNetEmbeddings(_lowerCamelCase,			name='''embedder'''    )
     __A		     =					TFResNetEncoder(_lowerCamelCase,			name='''encoder'''    )
     __A		     =					tf.keras.layers.GlobalAveragePoolingaD(keepdims=_lowerCamelCase    )






   @unpack_inputs
   def 							_SCREAMING_SNAKE_CASE							(      self					:	Union[str, Any],			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	Optional[bool] = None,			_lowerCamelCase					:	Optional[bool] = None,			_lowerCamelCase					:	bool = False,			):

     '''simple docstring'''
     __A		     =					(
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     __A		     =					return_dict if return_dict is not None else self.config.use_return_dict

     # TF 2.0 image layers can't use NCHW format when running on CPU.
     # We transpose to NHWC format and then transpose back after the full forward pass.
     # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
     __A		     =					tf.transpose(_lowerCamelCase,			perm=[0, 2, 3, 1]    )
     __A		     =					self.embedder(_lowerCamelCase,			training=_lowerCamelCase    )

     __A		     =					self.encoder(
         _lowerCamelCase,			output_hidden_states=_lowerCamelCase,			return_dict=_lowerCamelCase,			training=_lowerCamelCase    )

     __A		     =					encoder_outputs[0]

     __A		     =					self.pooler(_lowerCamelCase    )

     # Transpose all the outputs to the NCHW format
     # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
     __A		     =					tf.transpose(_lowerCamelCase,			(0, 3, 1, 2)    )
     __A		     =					tf.transpose(_lowerCamelCase,			(0, 3, 1, 2)    )
     __A		     =					()
     for hidden_state in encoder_outputs[1:]:
       __A		     =					hidden_states + tuple(tf.transpose(_lowerCamelCase,			(0, 3, 1, 2)    ) for h in hidden_state    )

     if not return_dict:
       return (last_hidden_state, pooled_output) + hidden_states

     __A		     =					hidden_states if output_hidden_states else None

     return TFBaseModelOutputWithPoolingAndNoAttention(
         last_hidden_state=_lowerCamelCase,			pooler_output=_lowerCamelCase,			hidden_states=_lowerCamelCase,			)





@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."  ,      _lowerCAmelCase  ,      )
class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   def __init__(      self					:	Any,			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	int    ):

     '''simple docstring'''
     super().__init__(_lowerCamelCase,			**_lowerCamelCase    )
     __A		     =					TFResNetMainLayer(config=_lowerCamelCase,			name='''resnet'''    )






   @add_start_docstrings_to_model_forward(_lowerCamelCase    )
   @add_code_sample_docstrings(
       checkpoint=_CHECKPOINT_FOR_DOC,			output_type=_lowerCamelCase,			config_class=_CONFIG_FOR_DOC,			modality='''vision''',			expected_output=_EXPECTED_OUTPUT_SHAPE,			)
   @unpack_inputs
   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[Any],			_lowerCamelCase					:	tf.Tensor,			_lowerCamelCase					:	Optional[bool] = None,			_lowerCamelCase					:	Optional[bool] = None,			_lowerCamelCase					:	bool = False,			):

     '''simple docstring'''
     __A		     =					(
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     __A		     =					return_dict if return_dict is not None else self.config.use_return_dict

     __A		     =					self.resnet(
         pixel_values=_lowerCamelCase,			output_hidden_states=_lowerCamelCase,			return_dict=_lowerCamelCase,			training=_lowerCamelCase,			)
     return resnet_outputs





@add_start_docstrings(
    "\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "  ,      _lowerCAmelCase  ,      )
class    snake_case						(				_lowerCAmelCase  ,      _lowerCAmelCase		):


   '''simple docstring'''

   def __init__(      self					:	str,			_lowerCamelCase					:	ResNetConfig,			**_lowerCamelCase					:	Any    ):

     '''simple docstring'''
     super().__init__(_lowerCamelCase,			**_lowerCamelCase    )
     __A		     =					config.num_labels
     __A		     =					TFResNetMainLayer(_lowerCamelCase,			name='''resnet'''    )
     # classification head
     __A		     =					(
         tf.keras.layers.Dense(config.num_labels,			name='''classifier.1'''    )
         if config.num_labels > 0
         else tf.keras.layers.Activation('''linear''',			name='''classifier.1'''    )
     )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int],			_lowerCamelCase					:	tf.Tensor    ):

     '''simple docstring'''
     __A		     =					tf.keras.layers.Flatten()(_lowerCamelCase    )
     __A		     =					self.classifier_layer(_lowerCamelCase    )
     return logits






   @add_start_docstrings_to_model_forward(_lowerCamelCase    )
   @add_code_sample_docstrings(
       checkpoint=_IMAGE_CLASS_CHECKPOINT,			output_type=_lowerCamelCase,			config_class=_CONFIG_FOR_DOC,			expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT,			)
   @unpack_inputs
   def 							_SCREAMING_SNAKE_CASE							(      self					:	str,			_lowerCamelCase					:	tf.Tensor = None,			_lowerCamelCase					:	tf.Tensor = None,			_lowerCamelCase					:	bool = None,			_lowerCamelCase					:	bool = None,			_lowerCamelCase					:	bool = False,			):

     '''simple docstring'''
     __A		     =					return_dict if return_dict is not None else self.config.use_return_dict

     __A		     =					self.resnet(
         _lowerCamelCase,			output_hidden_states=_lowerCamelCase,			return_dict=_lowerCamelCase,			training=_lowerCamelCase    )

     __A		     =					outputs.pooler_output if return_dict else outputs[1]

     __A		     =					self.classifier(_lowerCamelCase    )

     __A		     =					None if labels is None else self.hf_compute_loss(_lowerCamelCase,			_lowerCamelCase    )

     if not return_dict:
       __A		     =					(logits,) + outputs[2:]
       return (loss,) + output if loss is not None else output

     return TFImageClassifierOutputWithNoAttention(loss=_lowerCamelCase,			logits=_lowerCamelCase,			hidden_states=outputs.hidden_states    )





"""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 	lowerCAmelCase_     :



				"""simple docstring"""

				def __init__(					self		,     lowerCAmelCase		,     lowerCAmelCase=2		,     lowerCAmelCase=32		,     lowerCAmelCase=16		,     lowerCAmelCase=3		,     lowerCAmelCase=True		,     lowerCAmelCase=True		,     lowerCAmelCase=32		,     lowerCAmelCase=4		,     lowerCAmelCase=[0, 1, 2, 3]		,     lowerCAmelCase=4		,     lowerCAmelCase=37		,     lowerCAmelCase="gelu"		,     lowerCAmelCase=0.1		,     lowerCAmelCase=0.1		,     lowerCAmelCase=0.02		,     lowerCAmelCase=3		,     lowerCAmelCase=False		,     lowerCAmelCase=None		,     ):






										"""simple docstring"""

										snake_case             =      parent
										snake_case             =      batch_size
										snake_case             =      image_size
										snake_case             =      patch_size
										snake_case             =      num_channels
										snake_case             =      is_training
										snake_case             =      use_labels
										snake_case             =      hidden_size
										snake_case             =      num_hidden_layers
										snake_case             =      backbone_out_indices
										snake_case             =      num_attention_heads
										snake_case             =      intermediate_size
										snake_case             =      hidden_act
										snake_case             =      hidden_dropout_prob
										snake_case             =      attention_probs_dropout_prob
										snake_case             =      initializer_range
										snake_case             =      num_labels
										snake_case             =      scope
										snake_case             =      is_hybrid
										# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
										snake_case             =      (image_size // patch_size) ** 2
										snake_case             =      num_patches + 1

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

										snake_case             =      self.get_config()

										return config, pixel_values, labels

				def 		snake_case			(					self     ):






										"""simple docstring"""

										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 		snake_case			(					self		,     lowerCAmelCase		,     lowerCAmelCase		,     lowerCAmelCase     ):






										"""simple docstring"""

										snake_case             =      DPTModel(config=lowerCAmelCase     )
										model.to(lowerCAmelCase     )
										model.eval()
										snake_case             =      model(lowerCAmelCase     )
										self.parent.assertEqual(result.last_hidden_state.shape		,     (self.batch_size, self.seq_length, self.hidden_size)     )

				def 		snake_case			(					self		,     lowerCAmelCase		,     lowerCAmelCase		,     lowerCAmelCase     ):






										"""simple docstring"""

										snake_case             =      self.num_labels
										snake_case             =      DPTForDepthEstimation(lowerCAmelCase     )
										model.to(lowerCAmelCase     )
										model.eval()
										snake_case             =      model(lowerCAmelCase     )
										self.parent.assertEqual(result.predicted_depth.shape		,     (self.batch_size, self.image_size, self.image_size)     )

				def 		snake_case			(					self		,     lowerCAmelCase		,     lowerCAmelCase		,     lowerCAmelCase     ):






										"""simple docstring"""

										snake_case             =      self.num_labels
										snake_case             =      DPTForSemanticSegmentation(lowerCAmelCase     )
										model.to(lowerCAmelCase     )
										model.eval()
										snake_case             =      model(lowerCAmelCase		,     labels=lowerCAmelCase     )
										self.parent.assertEqual(
										    result.logits.shape		,     (self.batch_size, self.num_labels, self.image_size, self.image_size)     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      self.prepare_config_and_inputs()
										snake_case       ,snake_case       ,snake_case             =      config_and_inputs
										snake_case             =      {'pixel_values': pixel_values}
										return config, inputs_dict





@require_torch
class 	lowerCAmelCase_     (      lowerCAmelCase  ,     lowerCAmelCase  ,     unittest.TestCase       ):



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

				_lowerCAmelCase  :     str      	=    False
				_lowerCAmelCase  :     Any      	=    False
				_lowerCAmelCase  :     Dict      	=    False

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      DPTModelTester(self     )
										snake_case             =      ConfigTester(self		,     config_class=lowerCAmelCase		,     has_text_modality=lowerCAmelCase		,     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"""

										snake_case       ,snake_case             =      self.model_tester.prepare_config_and_inputs_for_common()

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

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case       ,snake_case             =      self.model_tester.prepare_config_and_inputs_for_common()

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

																snake_case             =      ['pixel_values']
																self.assertListEqual(arg_names[:1]		,     lowerCAmelCase     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_depth_estimation(*lowerCAmelCase     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase     )

				def 		snake_case			(					self     ):






										"""simple docstring"""

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

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

																if model_class in get_values(lowerCAmelCase     ):
																						continue

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

				def 		snake_case			(					self     ):






										"""simple docstring"""

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

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

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

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case       ,snake_case             =      self.model_tester.prepare_config_and_inputs_for_common()

										snake_case             =      _config_zero_init(lowerCAmelCase     )
										for model_class in self.all_model_classes:
																snake_case             =      model_class(config=lowerCAmelCase     )
																# Skip the check for the backbone
																snake_case             =      []
																for name, module in model.named_modules():
																						if module.__class__.__name__ == "DPTViTHybridEmbeddings":
																												snake_case             =      [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]:
																snake_case             =      DPTModel.from_pretrained(lowerCAmelCase     )
																self.assertIsNotNone(lowerCAmelCase     )





def  lowerCAmelCase__     (      )       ->					Union[str, Any]:





						"""simple docstring"""






						snake_case             =      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'       )
						return image



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



				"""simple docstring"""

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      DPTImageProcessor.from_pretrained('Intel/dpt-large'     )
										snake_case             =      DPTForDepthEstimation.from_pretrained('Intel/dpt-large'     ).to(lowerCAmelCase     )

										snake_case             =      prepare_img()
										snake_case             =      image_processor(images=lowerCAmelCase		,     return_tensors='pt'     ).to(lowerCAmelCase     )

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

										# verify the predicted depth
										snake_case             =      torch.Size((1, 3_84, 3_84)     )
										self.assertEqual(predicted_depth.shape		,     lowerCAmelCase     )

										snake_case             =      torch.tensor(
										    [[6.31_99, 6.36_29, 6.41_48], [6.38_50, 6.36_15, 6.41_66], [6.35_19, 6.31_76, 6.35_75]]     ).to(lowerCAmelCase     )

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

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'     )
										snake_case             =      DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'     ).to(lowerCAmelCase     )

										snake_case             =      prepare_img()
										snake_case             =      image_processor(images=lowerCAmelCase		,     return_tensors='pt'     ).to(lowerCAmelCase     )

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

										# verify the logits
										snake_case             =      torch.Size((1, 1_50, 4_80, 4_80)     )
										self.assertEqual(outputs.logits.shape		,     lowerCAmelCase     )

										snake_case             =      torch.tensor(
										    [[4.04_80, 4.24_20, 4.43_60], [4.31_24, 4.56_93, 4.82_61], [4.57_68, 4.89_65, 5.21_63]]     ).to(lowerCAmelCase     )

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

				def 		snake_case			(					self     ):






										"""simple docstring"""

										snake_case             =      DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'     )
										snake_case             =      DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'     ).to(lowerCAmelCase     )

										snake_case             =      prepare_img()
										snake_case             =      image_processor(images=lowerCAmelCase		,     return_tensors='pt'     ).to(lowerCAmelCase     )

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

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

										snake_case             =      image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase		,     target_sizes=[(5_00, 3_00)]     )
										snake_case             =      torch.Size((5_00, 3_00)     )
										self.assertEqual(segmentation[0].shape		,     lowerCAmelCase     )

										snake_case             =      image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase     )
										snake_case             =      torch.Size((4_80, 4_80)     )
										self.assertEqual(segmentation[0].shape		,     lowerCAmelCase     )


