Transformers 文档

DPT

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

DPT

概述

DPT 模型在 Vision Transformers for Dense Prediction 中提出,作者是 René Ranftl、Alexey Bochkovskiy、Vladlen Koltun。DPT 是一种利用 Vision Transformer (ViT) 作为骨干的模型,用于密集预测任务,如语义分割和深度估计。

该论文的摘要如下

我们介绍了密集视觉Transformer,这是一种架构,它利用视觉Transformer代替卷积网络作为密集预测任务的骨干网络。我们从视觉Transformer的各个阶段组装tokens,形成各种分辨率的类图像表示,并使用卷积解码器逐步将它们组合成全分辨率预测。Transformer骨干网络以恒定且相对较高的分辨率处理表示,并在每个阶段都具有全局感受野。与全卷积网络相比,这些特性使密集视觉Transformer能够提供更精细和更全局连贯的预测。我们的实验表明,这种架构在密集预测任务上产生了显著的改进,尤其是在有大量训练数据可用的情况下。对于单目深度估计,我们观察到与最先进的全卷积网络相比,相对性能提高了高达 28%。当应用于语义分割时,密集视觉Transformer在 ADE20K 上创下了 49.02% mIoU 的新state-of-the-art。我们进一步表明,该架构可以在较小的数据集(如 NYUv2、KITTI 和 Pascal Context)上进行微调,并在这些数据集上也创下了新的state-of-the-art。

drawing DPT 架构。摘自原始论文

此模型由 nielsr 贡献。 原始代码可以在这里找到。

使用技巧

DPT 与 AutoBackbone 类兼容。这允许将 DPT 框架与库中提供的各种计算机视觉骨干网络一起使用,例如 VitDetBackboneDinov2Backbone。可以按如下方式创建它

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。

如果您有兴趣提交资源以包含在此处,请随时打开 Pull Request,我们将对其进行审核!该资源应理想地展示一些新的内容,而不是重复现有的资源。

DPTConfig

class 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 (strfunction, 可选, 默认为 "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 (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
  • image_size (int, 可选, 默认为 384) — 每张图片的大小(分辨率)。
  • patch_size (int, 可选, 默认为 16) — 每个 patch 的大小(分辨率)。
  • num_channels (int, 可选, 默认为 3) — 输入通道数。
  • is_hybrid (bool, 可选, 默认为 False) — 是否使用混合骨干网络。在加载 DPT-Hybrid 模型时很有用。
  • qkv_bias (bool, 可选, 默认为 True) — 是否向 queries, keys 和 values 添加偏差。
  • backbone_out_indices (List[int], 可选, 默认为 [2, 5, 8, 11]) — 从骨干网络使用的中间隐藏状态的索引。
  • readout_type (str, 可选, 默认为 "project") — 处理 ViT 骨干网络中间隐藏状态的 readout token (CLS token) 时使用的 readout 类型。可以是 ["ignore", "add", "project"] 之一。

    • “ignore” 只是忽略 CLS token。
    • “add” 通过添加表示将 CLS token 中的信息传递给所有其他 tokens。
    • “project” 通过在将表示投影到原始特征维度 D 之前,将 readout 连接到所有其他 tokens,然后使用线性层和 GELU 非线性激活函数,将信息传递给其他 tokens。
  • reassemble_factors (List[int], 可选, 默认为 [4, 2, 1, 0.5]) — 重新组装层的上/下采样因子。
  • neck_hidden_sizes (List[str], 可选, 默认为 [96, 192, 384, 768]) — 骨干网络特征图要投影到的隐藏大小。
  • fusion_hidden_size (int, 可选, 默认为 256) — 融合之前的通道数。
  • head_in_index (int, 可选, 默认为 -1) — 头中要使用的特征的索引。
  • use_batch_norm_in_fusion_residual (bool, 可选, 默认为 False) — 是否在融合块的预激活残差单元中使用批归一化。
  • use_bias_in_fusion_residual (bool, 可选, 默认为 True) — 是否在融合块的预激活残差单元中使用偏置。
  • add_projection (bool, 可选, 默认为 False) — 是否在深度估计头之前添加一个投影层。
  • use_auxiliary_head (bool, 可选, 默认为 True) — 是否在训练期间使用辅助头。
  • auxiliary_loss_weight (float, 可选, 默认为 0.4) — 辅助头的交叉熵损失的权重。
  • semantic_loss_ignore_index (int, 可选, 默认为 255) — 语义分割模型的损失函数忽略的索引。
  • semantic_classifier_dropout (float, 可选, 默认为 0.1) — 语义分类头的 dropout 比率。
  • backbone_featmap_shape (List[int], 可选, 默认为 [1, 1024, 24, 24]) — 仅用于 hybrid 嵌入类型。主干网络特征图的形状。
  • neck_ignore_stages (List[int], 可选, 默认为 [0, 1]) — 仅用于 hybrid 嵌入类型。要忽略的读取层阶段。
  • backbone_config (Union[Dict[str, Any], PretrainedConfig], 可选) — 主干模型的配置。仅在 is_hybridTrue 或您想利用 AutoBackbone API 的情况下使用。
  • backbone (str, 可选) — 当 backbone_configNone 时,要使用的主干网络的名称。如果 use_pretrained_backboneTrue,这将从 timm 或 transformers 库加载相应的预训练权重。如果 use_pretrained_backboneFalse,这将加载主干网络的配置并使用它来初始化具有随机权重的主干网络。
  • use_pretrained_backbone (bool, 可选, 默认为 False) — 是否为主干网络使用预训练权重。
  • use_timm_backbone (bool, 可选, 默认为 False) — 是否从 timm 库加载 backbone。如果为 False,则从 transformers 库加载主干网络。
  • backbone_kwargs (dict, 可选) — 从检查点加载时要传递给 AutoBackbone 的关键字参数,例如 {'out_indices': (0, 1, 2, 3)}。如果设置了 backbone_config,则无法指定。

这是用于存储 DPTModel 配置的配置类。它用于根据指定的参数实例化 DPT 模型,定义模型架构。使用默认值实例化配置将产生与 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.config

to_dict

< >

( )

将此实例序列化为 Python 字典。覆盖默认的 to_dict()。 返回: Dict[str, any]: 构成此配置实例的所有属性的字典,

DPTFeatureExtractor

class transformers.DPTFeatureExtractor

< >

( *args **kwargs )

__call__

< >

( images **kwargs )

预处理图像或一批图像。

post_process_semantic_segmentation

< >

( outputs target_sizes: List = None ) semantic_segmentation

参数

  • outputs (DPTForSemanticSegmentation) — 模型的原始输出。
  • target_sizes (长度为 batch_sizeList[Tuple], 可选) — 与每个预测请求的最终尺寸(高度,宽度)相对应的元组列表。如果未设置,则不会调整预测大小。

返回

semantic_segmentation

长度为 batch_sizeList[torch.Tensor],其中每个项目是形状为 (height, width) 的语义分割图,对应于 target_sizes 条目(如果指定了 target_sizes)。每个 torch.Tensor 的每个条目对应于一个语义类 ID。

DPTForSemanticSegmentation 的输出转换为语义分割图。仅支持 PyTorch。

DPTImageProcessor

class 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_resizeTrue,则将图像调整为该值的倍数的大小。 可以被 preprocess 中的 ensure_multiple_of 参数覆盖。
  • do_rescale (bool, 可选, 默认为 True) — 是否通过指定的比例 rescale_factor 缩放图像。 可以被 preprocess 中的 do_rescale 参数覆盖。
  • rescale_factor (intfloat, 可选, 默认为 1/255) — 如果缩放图像,则使用的缩放因子。 可以被 preprocess 中的 rescale_factor 参数覆盖。
  • do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。 可以被 preprocess 方法中的 do_normalize 参数覆盖。
  • image_mean (floatList[float], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化,则使用的均值。 这是一个浮点数或浮点数列表,其长度是图像中通道的数量。 可以被 preprocess 方法中的 image_mean 参数覆盖。
  • image_std (floatList[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 如果对图像进行归一化,则使用的标准差。 这是一个浮点数或浮点数列表,其长度是图像中通道的数量。 可以被 preprocess 方法中的 image_std 参数覆盖。
  • do_pad (bool, 可选, 默认为 False) — 是否应用中心填充。 这是在 DINOv2 论文中引入的,该论文将模型与 DPT 结合使用。
  • size_divisor (int, 可选) — 如果 do_padTrue,则将图像尺寸填充为可被该值整除。 这是在 DINOv2 论文中引入的,该论文将模型与 DPT 结合使用。

构建 DPT 图像处理器。

preprocess

< >

( images: Union do_resize: bool = None size: int = None keep_aspect_ratio: bool = None ensure_multiple_of: int = None resample: Resampling = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None do_pad: bool = None size_divisor: int = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None )

参数

  • images (ImageInput) — 要预处理的图像。 期望是像素值范围从 0 到 255 的单个或一批图像。 如果传入的图像像素值在 0 和 1 之间,请设置 do_rescale=False
  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
  • size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后图像的尺寸。 如果 keep_aspect_ratioTrue,则将图像调整为尽可能大的尺寸,以保持宽高比。 如果设置了 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 (floatList[float], 可选, 默认为 self.image_mean) — 图像均值。
  • image_std (floatList[float], 可选, 默认为 self.image_std) — 图像标准差。
  • return_tensors (strTensorType, 可选) — 返回的张量类型。 可以是以下之一:
    • Unset: 返回 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 (ChannelDimensionstr, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。 可以是以下之一:
    • ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。 如果未设置,则通道维度格式将从输入图像中推断。 可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE: 图像格式为 (height, width)。

预处理单个图像或一批图像。

post_process_semantic_segmentation

< >

( outputs target_sizes: List = None ) semantic_segmentation

参数

  • 输出 (outputs) (DPTForSemanticSegmentation) — 模型的原始输出。
  • target_sizes (List[Tuple],长度为 batch_size可选) — 元组列表,对应于每个预测的请求最终尺寸(高度,宽度)。如果未设置,则不会调整预测大小。

返回

semantic_segmentation

长度为 batch_sizeList[torch.Tensor],其中每个项目是形状为 (height, width) 的语义分割图,对应于 target_sizes 条目(如果指定了 target_sizes)。每个 torch.Tensor 的每个条目对应于一个语义类 ID。

DPTForSemanticSegmentation 的输出转换为语义分割图。仅支持 PyTorch。

DPTModel

class transformers.DPTModel

< >

( config add_pooling_layer = True )

参数

  • config (ViTConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。

裸 DPT 模型 Transformer 输出原始隐藏状态,顶部没有任何特定的头部。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

< >

( 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.BaseModelOutputWithPoolingAndIntermediateActivationstuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为 (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 而不是普通元组。

返回

transformers.models.dpt.modeling_dpt.BaseModelOutputWithPoolingAndIntermediateActivationstuple(torch.FloatTensor)

一个 transformers.models.dpt.modeling_dpt.BaseModelOutputWithPoolingAndIntermediateActivations 或一个 torch.FloatTensor 元组 (如果传递 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (DPTConfig) 和输入。

  • last_hidden_state (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • pooler_output (torch.FloatTensor,形状为 (batch_size, hidden_size)) — 序列的第一个 token(分类 token)的最后一层隐藏状态,在通过用于辅助预训练任务的层进行进一步处理之后。例如,对于 BERT 系列模型,这返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重从预训练期间的下一句预测(分类)目标中训练而来。

  • hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组(如果模型具有嵌入层,则为嵌入输出一个,加上每层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。

  • 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 forward 方法,覆盖了 __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]

DPTForDepthEstimation

class transformers.DPTForDepthEstimation

< >

( config )

参数

  • config (ViTConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。

DPT 模型,顶部带有深度估计头(由 3 个卷积层组成),例如用于 KITTI、NYUv2。

此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

< >

( 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.DepthEstimatorOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为 (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.DepthEstimatorOutputtuple(torch.FloatTensor)

一个 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 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则为嵌入层的输出 + 每层输出一个),形状为 (batch_size, num_channels, height, width)

    模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_heads, patch_size, sequence_length)

    注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

DPTForDepthEstimation 的 forward 方法重写了 __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

class transformers.DPTForSemanticSegmentation

< >

( config )

参数

  • config (ViTConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。

带有语义分割头的 DPT 模型,例如用于 ADE20k、CityScapes。

此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

< >

( pixel_values: Optional = None head_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_outputs.SemanticSegmenterOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为 (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)可选) — 用于计算损失的语义分割图的真值。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回

transformers.modeling_outputs.SemanticSegmenterOutputtuple(torch.FloatTensor)

一个 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 时返回) — torch.FloatTensor 的元组(如果模型有嵌入层,则为嵌入层的输出 + 每层输出一个),形状为 (batch_size, patch_size, hidden_size)

    模型在每一层输出的隐藏状态,加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_heads, patch_size, sequence_length)

    注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。

DPTForSemanticSegmentation 的 forward 方法重写了 __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
< > 在 GitHub 上更新