DPT模型由René Ranftl、Alexey Bochkovskiy、Vladlen Koltun在《Vision Transformers for Dense Prediction》[https://arxiv.org/abs/2103.13413](https://arxiv.org/abs/2103.13413)中提出。DPT是一种将视觉Transformer (ViT)用作密集预测任务（如语义分割和深度估计）主干的网络模型。
本论文的摘要如下
我们介绍了密集视觉变压器，这是一种以密集预测任务为骨干，用视觉变压器替代卷积网络的架构。我们将视觉变压器的各个阶段的标记组装成不同分辨率的图像样 Representation，并使用卷积解码器逐步将它们组合成完整分辨率的预测。变压器骨干在常规模拟和相对较高的分辨率上处理 Representation，每个阶段都具有全局感受野。这些属性使得密集视觉变压器在与其他完全卷积网络相比时，能够提供更精细和更加全局一致的预测。我们的实验表明，这种架构在密集预测任务上取得了显著的改进，尤其是在拥有大量训练数据时。对于单目深度估计，我们观察到相对于最先进的完全卷积网络，绝对性能提高了28%。当应用于语义分割时，密集视觉变压器在ADE20K上取得了49.02% mIoU的新突破。此外，我们还证明该架构可以在如NYUv2、KITTI和Pascal Context这样的较小数据集上进行微调，在这些数据集上也刷新了新的实验记录。
DPT架构。摘自原始论文。 使用提示
DPT与AutoBackbone类兼容。这允许使用库中可用的各种计算机视觉骨干，例如VitDetBackbone或Dinov2Backbone。可以按照以下方式创建它
from transformers import Dinov2Config, DPTConfig, DPTForDepthEstimation
# initialize with a Transformer-based backbone such as DINOv2
# in that case, we also specify `reshape_hidden_states=False` to get feature maps of shape (batch_size, num_channels, height, width)
backbone_config = Dinov2Config.from_pretrained("facebook/dinov2-base", out_features=["stage1", "stage2", "stage3", "stage4"], reshape_hidden_states=False)
config = DPTConfig(backbone_config=backbone_config)
model = DPTForDepthEstimation(config=config)资源
提供一系列官方Hugging Face和社区（由🌎指示）资源，以帮助您开始使用DPT。
DPTForDepthEstimation的演示笔记本可在此处找到：https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DPT。
如果您想提交资源以在此处发表，请随时提交Pull Request，我们将进行审查！资源应最好能够展示新内容，而不是 duplication 已有资源。
DPTConfig
类 transformers.DPTConfig
< 源代码 >( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 image_size = 384 patch_size = 16 num_channels = 3 is_hybrid = False qkv_bias = True backbone_out_indices = [2, 5, 8, 11] readout_type = 'project' reassemble_factors = [4, 2, 1, 0.5] neck_hidden_sizes = [96, 192, 384, 768] fusion_hidden_size = 256 head_in_index = -1 use_batch_norm_in_fusion_residual = False use_bias_in_fusion_residual = None add_projection = False use_auxiliary_head = True auxiliary_loss_weight = 0.4 semantic_loss_ignore_index = 255 semantic_classifier_dropout = 0.1 backbone_featmap_shape = [1, 1024, 24, 24] neck_ignore_stages = [0, 1] backbone_config = None backbone = None use_pretrained_backbone = False use_timm_backbone = False backbone_kwargs = None **kwargs )
参数
- hidden_size (
int, 可选, 默认为 768) — 编码器层和池化层的维度。 - num_hidden_layers (
int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。 - num_attention_heads （
int，可选的，默认为 12） — Transformer 编码器中每个注意力层的注意力头数。 - intermediate_size （
int，可选的，默认为 3072） — Transformer 编码器中“中间”层（即前馈层）的维度。 - hidden_act （
str或function，可选的，默认为"gelu"） — 编码器和解码器中的非线性激活函数（函数或字符串）。如果为字符串，支持"gelu"，"relu"，"selu"和"gelu_new"。 - hidden_dropout_prob (
float, 可选, 默认为0.0) — 嵌入层、编码器层和池化层的所有全连接层的dropout概率。 - attention_probs_dropout_prob (
float, 可选, 默认为0.0) — 注意力概率的dropout比率。 - initializer_range (
float, 可选, 默认为0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。 - layer_norm_eps (
浮点数, 可选, 默认为 1e-12) — 层归一化层的 epsilon 值。 - image_size (
整数, 可选, 默认为 384) — 每个图像的大小（分辨率）。 - patch_size (
整数, 可选, 默认为 16) — 每个补丁的大小（分辨率）。 -
num_channels ( 整数, 可选, 默认为 3) — 输入通道的数量。 - is_hybrid (
bool, 可选，默认为False) — 是否使用混合骨干。在加载 DPT-Hybrid 模型上下文中非常有用。 - qkv_bias (
bool, 可选，默认为True) — 是否对查询、键和值添加偏置。 - backbone_out_indices (
List[int], 可选，默认为[2, 5, 8, 11]) — 从骨干中使用的中间隐藏状态索引。 - readout_type (
str, 可选, 默认为"project") — 当处理 ViT 主干中中间隐藏状态（CLS token）的输出时使用的输出类型。可以是以下之一 ["ignore","add","project"]。- “ignore”简单地忽略 CLS 令牌。
- “add”通过添加表示形式将 CLS 令牌的信息传递给所有其他令牌。
- “project”通过将输出与所有其他令牌连接，并使用线性层随后加 GELU 非线性层将表示投影到原始特征维度 D 中，将信息传递给其他令牌。
- reassemble_factors (
int列表, 可选, 默认为[4, 2, 1, 0.5]) — 重组层上/下采样的系数。 - neck_hidden_sizes (
str列表, 可选, 默认为[96, 192, 384, 768]) — 将特征图投影到的隐藏维度。 - fusion_hidden_size (
int, 可选，默认为256) — 融合前的通道数量。 - head_in_index (
int, 可选，默认为-1) — 在heads中使用的特征的索引。 - use_batch_norm_in_fusion_residual (
bool, 可选，默认为False) — 是否在融合块的预激活残差单元中使用批量归一化。 - use_bias_in_fusion_residual (
bool, 可选，默认为True) — 是否在融合块的预激活残差单元中使用偏置。 -
bool，可选，默认为False）— 是否在深度估计头之前添加投影层。 -
-
float，可选，默认为 0.4）— 辅助头的交叉熵损失的权重。 -
- semantic_classifier_dropout (
float, 可选, 默认值为 0.1) —— 针对语义分类头的丢弃率。 - backbone_featmap_shape (
List[int], 可选, 默认值为[1, 1024, 24, 24]) —— 仅用于hybrid嵌入类型。骨干网络的特征图形状。 - neck_ignore_stages (
List[int], 可选, 默认值为[0, 1]) —— 仅用于hybrid嵌入类型。要忽略的读出层阶段。 - 骨干配置 (
Union[Dict[str, Any], PretrainedConfig], 可选) — 骨干模型的配置。仅在is_hybrid为True或您想使用AutoBackbone API时使用。 - 骨干 (
str, 可选) — 当backbone_config为None时使用的骨干名称。如果use_pretrained_backbone为True，则从timm或transformers库加载相应的预训练权重。如果use_pretrained_backbone为False，则加载骨干的配置并使用随机权重初始化骨干。 - use_pretrained_backbone (
bool, 可选, 默认为False) — 是否为骨干使用预训练权重。 - use_timm_backbone (
bool, 可选, 默认为False) — 是否从 timber 库加载backbone。如果为False，则从 transformers 库加载骨干网络。 - backbone_kwargs (
dict, 可选) — 加载检查点时要传递给 AutoBackbone 的关键字参数，例如{'out_indices': (0, 1, 2, 3)}。如果设置了backbone_config，则不能指定。
这是用于存储DPTModel配置的配置类。它用于根据指定的参数实例化 DPT 模型，定义模型架构。使用默认值创建配置将产生类似于Intel/dpt-large架构的配置。
配置对象继承自PretrainedConfig，可以用于控制模型输出。有关更多信息，请参阅PretrainedConfig文档。
示例
>>> from transformers import DPTModel, DPTConfig
>>> # Initializing a DPT dpt-large style configuration
>>> configuration = DPTConfig()
>>> # Initializing a model from the dpt-large style configuration
>>> model = DPTModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configDPTFeatureExtractor
预处理图像或图像的批量。
语义分割后处理
< 来源 >( outputs target_sizes: 列表 = None ) → semantic_segmentation
参数
- outputs (DPTForSemanticSegmentation) — 模型的原始输出。
-
target_sizes ( List[Tuple]of lengthbatch_size, 可选) — 与请求的每个预测的最终大小（高度、宽度）相对应的元组列表。如果未设置，则预测不会进行缩放。
返回
semantic_segmentation
长度为 batch_size 的 List[torch.Tensor]，其中每个项目是与 target_sizes 条目对应的形状为（高度，宽度）的语义分割图。每个 torch.Tensor 的每个条目对应一个语义类别 ID。
将 DPTForSemanticSegmentation 的输出转换为语义分割图。仅支持 PyTorch。
DPTImageProcessor
类 transformers.DPTImageProcessor
< 源代码 >( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> keep_aspect_ratio: bool = False ensure_multiple_of: int = 1 do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = False size_divisor: int = None **kwargs )
参数
- do_resize (
bool, 可选, 默认为True) — 是否调整图像的高度和宽度。可在preprocess中的do_resize中进行覆盖。 - size (
Dict[str, int]可选, 默认为{"height": 384, "width": 384})：调整图像后的尺寸。可在preprocess中的size中进行覆盖。 - resample (
PILImageResampling可选, 默认为Resampling.BICUBIC) — 如果调整图像大小则定义使用的重采样过滤器。可在preprocess中的resample中进行覆盖。 - keep_aspect_ratio (
bool, 可选项, 默认为False) — 如果为True，图像将被调整至最大的可能大小，使长宽比保持不变。可以通过preprocess中的keep_aspect_ratio进行覆盖。 - ensure_multiple_of (
int, 可选项, 默认为 1) — 如果do_resize为True，图像将被调整至符合该值倍数的尺寸。可以通过preprocess中的ensure_multiple_of进行覆盖。 - do_rescale (
bool, 可选项, 默认为True) — 是否根据特定的缩放比例rescale_factor对图像进行缩放。可以通过preprocess中的do_rescale进行覆盖。 - rescale_factor (
int或float，可选，默认为1/255）— 如果对图像进行缩放时使用的尺度因子。可以被preprocess中的rescale_factor覆盖。 - do_normalize (
bool，可选，默认为True）— 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。 - image_mean （
float或List[float]，可选，默认为IMAGENET_STANDARD_MEAN）— 如果对图像进行归一化时使用的均值。这是一个浮点数或浮点数列表，长度与图像的通道数相同。可以被preprocess方法中的image_mean参数覆盖。
构建一个 DPT 图像处理器。
preprocess
< 来源 >( images: 联合 do_resize: 布尔型 = None size: 整型 = None keep_aspect_ratio: 布尔型 = None ensure_multiple_of: 整型 = None resample: 重采样 = None do_rescale: 布尔型 = None rescale_factor: 浮点型 = None do_normalize: 布尔型 = None image_mean: 联合 = None image_std: 联合 = None do_pad: 布尔型 = None size_divisor: 整型 = None return_tensors: 联合 = None data_format: 通道维度 = <ChannelDimension.FIRST: 'channels_first'> input_data_format: 联合 = None )
参数
- images (
ImageInput) — 预处理图像。期望输入单个或一系列图像，像素值介于0到255之间。如果传递的图像像素值在0到1之间，请设置do_rescale=False。 - do_resize (
bool, 可选, 默认为self.do_resize) — 是否调整图像大小。 - size (
Dict[str, int], 可选, 默认为self.size) — 重置后图像的大小。如果keep_aspect_ratio为True，图像调整到能够保持原始宽高比的最大尺寸。如果设置了ensure_multiple_of，图像将调整到该值的一个倍数尺寸。 - keep_aspect_ratio (
bool, 可选，默认为self.keep_aspect_ratio) — 是否保持图像的宽高比。如果为 False，图像将按 (size, size) 大小进行缩放。如果为 True，图像将保持宽高比，大小将是最大可能值。 - ensure_multiple_of (
int, 可选，默认为self.ensure_multiple_of) — 确保图像大小为这个值的倍数。 - resample (
int, 可选，默认为self.resample) — 如果对图像进行缩放，则使用的重采样过滤器。这可以是枚举类型PILImageResampling之一。仅在将do_resize设置为True时有效。 - do_rescale （
bool，可选，默认为self.do_rescale） — 是否将图像值重新缩放至[0 - 1]范围内。 - rescale_factor （
float，可选，默认为self.rescale_factor） — 若将do_rescale设置为True，则进行图像缩放的缩放因子。 - do_normalize （
bool，可选，默认为self.do_normalize） — 是否对图像进行归一化。 - image_mean (
float或List[float]，可选，默认为self.image_mean） — 图片均值。 - image_std (
float或List[float]，可选，默认为self.image_std） — 图片标准差。 - return_tensors (
str或TensorType，可选） — 返回张量的类型。可以是以下之一：- 未设置：返回一个
np.ndarray列表。 TensorType.TENSORFLOW或'tf'：返回类型为tf.Tensor的批次。TensorType.PYTORCH或'pt'：返回类型为torch.Tensor的批次。TensorType.NUMPY或'np'：返回类型为np.ndarray的批次。TensorType.JAX或'jax'：返回类型为jax.numpy.ndarray的批次。
- 未设置：返回一个
- data_format (
ChannelDimension或str，可选，默认为ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。ChannelDimension.LAST：图像格式为 (height, width, num_channels)。
- input_data_format (
ChannelDimension或str，可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST：图像格式为 (height, width, num_channels)。"none"或ChannelDimension.NONE：图像格式为 (height, width)。
预处理图像或图像批。
语义分割后处理
< source >( outputs target_sizes: 列表 = None ) → semantic_segmentation
参数
- outputs (DPTForSemanticSegmentation) — 模型的原始输出。
- target_sizes (
List[Tuple]of lengthbatch_size, optional) — 与每项预测要求的最终大小（高度，宽度）对应的元组列表。如果未设置，则不会调整预测大小。
返回
semantic_segmentation
长度为 batch_size 的 List[torch.Tensor]，其中每个项目是与 target_sizes 条目对应的形状为（高度，宽度）的语义分割图。每个 torch.Tensor 的每个条目对应一个语义类别 ID。
将 DPTForSemanticSegmentation 的输出转换为语义分割图。仅支持 PyTorch。
DPTModel
类 transformers.DPTModel
继承自 < source >( config add_pooling_layer = True )
参数
- config (ViTConfig) — 模型配置类，包含所有模型参数。使用配置文件初始化模型时不会加载与模型相关的权重，只加载配置。请查看from_pretrained() 方法以加载模型权重。
一个裸露的DPT模型变换器，输出原始隐藏状态而无需任何特定的头部。该模型是PyTorch torch.nn.Module 的子类。将其作为常规PyTorch模块使用，并参考PyTorch文档以了解所有与通用使用和行为相关的问题。
forward
< source >( pixel_values: FloatTensor head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.dpt.modeling_dpt.BaseModelOutputWithPoolingAndIntermediateActivations or tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensorof shape(batch_size, num_channels, height, width)) — 像素值。像素值可以通过 AutoImageProcessor 获取。详细信息请见 DPTImageProcessor.call()。 - head_mask (
torch.FloatTensorof shape(num_heads,)or(num_layers, num_heads), optional) — 用于取消自注意力模块中选定头的掩码。掩码值选择在[0, 1]：- 1 表示头部未被掩码，
- 0 表示头部被掩码。
- output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。更多详情请见返回的张量中的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回ModelOutput而不是普通元组。
返回
transformers.models.dpt.modeling_dpt.BaseModelOutputWithPoolingAndIntermediateActivations或tuple(torch.FloatTensor)
如果传递了return_dict=False或当config.return_dict=False时，将返回一个包含根据配置（DPTConfig）和输入元素的变化的组合的transformers.models.dpt.modeling_dpt.BaseModelOutputWithPoolingAndIntermediateActivations或torch.FloatTensor元组。
-
last_hidden_state（
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)）—模型最后一层输出的序列隐藏状态。 -
pooler_output（
torch.FloatTensor形状为(batch_size, hidden_size)）—序列开头标记（分类标记）在通过用于辅助预训练任务的层进一步处理后，获得的最后一层隐藏状态。例如，对于BERT家族的模型，这将在通过一个线性层和一个tanh激活函数处理后返回分类标记。线性层权重在预训练期间从下一个句子预测（分类）目标中进行训练。 -
hidden_states（
tuple(torch.FloatTensor)，可选，在传递了output_hidden_states=True或当config.output_hidden_states=True时返回）—形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层的输出，如果模型有嵌入层，+一个用于每一层的输出）。每层的隐藏状态以及可选的初始嵌入输出。
-
attentions（
tuple(torch.FloatTensor)，可选，在传递了output_attentions=True或当config.output_attentions=True时返回）—每个层的torch.FloatTensor元组（形状为(batch_size, num_heads, sequence_length, sequence_length)）。注意权重：在注意力softmax之后的注意权重，用于在自注意力头中计算加权平均。
-
intermediate_activations （
tuple(torch.FloatTensor), 可选） — 中间激活，可以用来计算模型在不同层中的隐藏状态。
DPTModel 前向方法，覆盖了 __call__ 特殊方法。
尽管前向遍历的配方需要在函数内部定义，但之后应该调用 Module 实例而不是这个，因为前者处理了计算前后的处理步骤，而后者则默默地忽略了它们。
示例
>>> from transformers import AutoImageProcessor, DPTModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("Intel/dpt-large")
>>> model = DPTModel.from_pretrained("Intel/dpt-large")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 577, 1024]DPTModel
class transformers.DPTForDepthEstimation
< source >( config )
参数
- config （ViTConfig） — 模型配置类，包含所有模型参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看from_pretrained() 方法来加载模型权重。
DPT模型在顶部有一个深度估计头（由3个卷积层组成），例如用于KITTI、NYUv2。
该模型是 PyTorch 的 torch.nn.Module 子类。将其作为常规的 PyTorch 模块使用，并参考 PyTorch 文档了解有关一般用法和行为的所有相关事项。
forward
< source >( pixel_values: FloatTensor head_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.DepthEstimatorOutput or tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensorof shape(batch_size, num_channels, height, width)) — 像素值。可以通过 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DPTImageProcessor.call()。 - head_mask (
torch.FloatTensor的形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于取消自注意力模块中选定头的掩码。掩码值选中[0, 1]：- 1 表示头 未掩码，
- 0 表示头 掩码。
- output_attentions (
bool，可选) — 是否返回所有注意力层的张量。详见返回的张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。详见返回的张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。 - labels (
torch.LongTensor形状为(batch_size, height, width), 可选) — 计算损失的真实深度估计图。
返回
transformers.modeling_outputs.DepthEstimatorOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.DepthEstimatorOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False），包含根据配置（DPTConfig）和输入的不同元素。
-
loss (
torch.FloatTensor形状为(1,), 可选，当提供labels时返回) — 分类（或当 config.num_labels==1 时为回归）损失。 -
predicted_depth (
torch.FloatTensor形状为(batch_size, height, width)) — 预测的每个像素的深度。 -
hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 一个包含形状为(batch_size, num_channels, height, width)的torch.FloatTensor的元组（如果模型有嵌入层，则为嵌入层的输出加上每个层的输出）。每层的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 一个形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor的元组（每个层一个）。注意权重：在注意力softmax之后的注意权重，用于在自注意力头中计算加权平均。
The DPTForDepthEstimation 前向方法，覆盖了 __call__ 特殊方法。
尽管前向遍历的配方需要在函数内部定义，但之后应该调用 Module 实例而不是这个，因为前者处理了计算前后的处理步骤，而后者则默默地忽略了它们。
示例
>>> from transformers import AutoImageProcessor, DPTForDepthEstimation
>>> import torch
>>> import numpy as np
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("Intel/dpt-large")
>>> model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
... predicted_depth = outputs.predicted_depth
>>> # interpolate to original size
>>> prediction = torch.nn.functional.interpolate(
... predicted_depth.unsqueeze(1),
... size=image.size[::-1],
... mode="bicubic",
... align_corners=False,
... )
>>> # visualize the prediction
>>> output = prediction.squeeze().cpu().numpy()
>>> formatted = (output * 255 / np.max(output)).astype("uint8")
>>> depth = Image.fromarray(formatted)DPTForSemanticSegmentation
类 transformers.DPTForSemanticSegmentation
> 源码 >( config )
参数
- config (ViTConfig) — 模型参数的所有参数的配置类。使用配置文件初始化不加载模型相关的权重，只加载配置。请参阅 from_pretrained() 方法来加载模型权重。
具有语义分割头部顶部的 DPT 模型，例如用于 ADE20k、CityScapes。
该模型是 PyTorch 的 torch.nn.Module 子类。将其作为常规的 PyTorch 模块使用，并参考 PyTorch 文档了解有关一般用法和行为的所有相关事项。
forward
< 源代码 >( pixel_values: 可选 = None head_mask: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.SemanticSegmenterOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensorof shape(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 DPTImageProcessor.call() - return_dict (
布尔型，可选) — 是否返回ModelOutput而不是普通元组。 - labels (
torch.LongTensor，形状为(batch_size, height, width)，可选) — 用于计算损失的地面真实语义分割图。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回
transformers.modeling_outputs.SemanticSegmenterOutput或tuple(torch.FloatTensor)
C transformers.modeling_outputs.SemanticSegmenterOutput或包含一组元素的torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），这些元素取决于配置（DPTConfig）和输入。
-
loss (
torch.FloatTensor形状为(1,), 可选，当提供labels时返回) — 分类（或当 config.num_labels==1 时为回归）损失。 -
logits (
torch.FloatTensor的形状为(batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类得分。返回的
logits不一定与作为输入传递的pixel_values具有相同的尺寸。这是为了避免进行两次插值，并在用户需要将logits调整到原始图像大小时作为后处理而丢失一些质量。您应始终检查您的logits形状并按需调整大小。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递了output_hidden_states=True或当config.output_hidden_states=True时返回) — 一系列形状为(batch_size, patch_size, hidden_size)的torch.FloatTensor，依次为嵌入层（如果有的话）输出的输出+每层的输出。每层的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 一个形状为(batch_size, num_heads, patch_size, sequence_length)的torch.FloatTensor的元组（每个层一个）。注意权重：在注意力softmax之后的注意权重，用于在自注意力头中计算加权平均。
DPTForSemanticSegmentation的前向方法覆盖了__call__特殊方法。
尽管前向遍历的配方需要在函数内部定义，但之后应该调用 Module 实例而不是这个，因为前者处理了计算前后的处理步骤，而后者则默默地忽略了它们。
示例
>>> from transformers import AutoImageProcessor, DPTForSemanticSegmentation
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("Intel/dpt-large-ade")
>>> model = DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits