Hugging Face 的 logo

Transformers 文档

Mask2Former

Hugging Face's logo
加入 Hugging Face 社区

并获得增强文档体验的权限

开始使用

Mask2Former

概述

Mask2Former 模型由 Bowen Cheng、Ishan Misra、Alexander G. Schwing、Alexander Kirillov 和 Rohit Girdhar 在《Masked-attention Mask Transformer for Universal Image Segmentation》（用于通用图像分割的掩码注意力掩码 Transformer）一文中提出。Mask2Former 是一个用于全景、实例和语义分割的统一框架，与MaskFormer相比，其性能和效率都有显著提高。

该论文的摘要是:

图像分割将具有不同语义的像素分组，例如类别或实例成员资格。每个语义选择都定义了一个任务。虽然每个任务的语义不同，但目前的研究重点是为每个任务设计专门的架构。我们提出了掩码注意力掩码 Transformer (Mask2Former)，这是一种能够处理任何图像分割任务（全景、实例或语义）的新架构。其关键组件包括掩码注意力，它通过将交叉注意力限制在预测的掩码区域内来提取局部特征。除了将研究工作量减少至少三倍之外，它在四个流行的数据集上的表现也明显优于最好的专业架构。最值得注意的是，Mask2Former 为全景分割（COCO 上的 PQ 为 57.8）、实例分割（COCO 上的 AP 为 50.1）和语义分割（ADE20K 上的 mIoU 为 57.7）设定了新的最先进水平。

drawing Mask2Former 架构。摘自原始论文。

该模型由Shivalika Singh和Alara Dirik贡献。原始代码可以在此处找到。

使用技巧

资源

Hugging Face 官方和社区 (🌎 表示) 资源列表，可帮助您开始使用 Mask2Former。

  • 有关在自定义数据上进行推理 + 微调 Mask2Former 的演示笔记本，请参见此处。
  • 使用 Trainer 或 Accelerate 微调 Mask2Former 的脚本可以在此处找到。

如果您有兴趣提交资源以包含在此处，请随时打开拉取请求，我们会进行审核。理想情况下，该资源应该展示新的内容，而不是重复现有的资源。

Mask2FormerConfig

类 transformers.Mask2FormerConfig

< >

( backbone_config: Optional = None feature_size: int = 256 mask_feature_size: int = 256 hidden_dim: int = 256 encoder_feedforward_dim: int = 1024 activation_function: str = 'relu' encoder_layers: int = 6 decoder_layers: int = 10 num_attention_heads: int = 8 dropout: float = 0.0 dim_feedforward: int = 2048 pre_norm: bool = False enforce_input_projection: bool = False common_stride: int = 4 ignore_value: int = 255 num_queries: int = 100 no_object_weight: float = 0.1 class_weight: float = 2.0 mask_weight: float = 5.0 dice_weight: float = 5.0 train_num_points: int = 12544 oversample_ratio: float = 3.0 importance_sample_ratio: float = 0.75 init_std: float = 0.02 init_xavier_std: float = 1.0 use_auxiliary_loss: bool = True feature_strides: List = [4, 8, 16, 32] output_auxiliary_logits: bool = None backbone: Optional = None use_pretrained_backbone: bool = False use_timm_backbone: bool = False backbone_kwargs: Optional = None **kwargs )

参数

  • backbone_config (PretrainedConfig 或 dict, 可选, 默认值 SwinConfig()) — 骨干模型的配置。如果未设置，将使用与 swin-base-patch4-window12-384 对应的配置。
  • backbone (str, 可选) — 当 backbone_config 为 None 时要使用的骨干网络名称。如果 use_pretrained_backbone 为 True，将从 timm 或 transformers 库加载相应的预训练权重。如果 use_pretrained_backbone 为 False，则加载骨干网络的配置，并使用它来初始化具有随机权重的骨干网络。
  • use_pretrained_backbone (bool, 可选, False) — 是否对骨干网络使用预训练权重。
  • use_timm_backbone (bool, 可选, False) — 是否从 timm 库加载 backbone。如果为 False，则从 transformers 库加载 backbone。
  • backbone_kwargs (dict, 可选) — 要传递给 AutoBackbone 的关键字参数（例如，从检查点加载时），例如 {'out_indices': (0, 1, 2, 3)}。如果设置了 backbone_config，则无法指定。
  • feature_size (int, 可选, 默认值为 256) — 生成的特征图的特征（通道）。
  • mask_feature_size (int, 可选, 默认值为 256) — 掩码的特征大小，该值也将用于指定特征金字塔网络特征的大小。
  • hidden_dim (int, 可选, 默认值为 256) — 编码器层的维度。
  • encoder_feedforward_dim (int, 可选, 默认值为 1024) — 用作像素解码器一部分的可变形 DETR 编码器的 Feedforward 网络的维度。
  • encoder_layers (int, 可选, 默认值为 6) — 用作像素解码器一部分的可变形 DETR 编码器中的层数。
  • decoder_layers (int, 可选, 默认值为 10) — Transformer 解码器中的层数。
  • num_attention_heads (int, 可选, 默认值为 8) — 每个注意力层的注意力头数。
  • dropout (float, 可选, 默认值为 0.1) — 嵌入、编码器中所有全连接层的丢弃概率。
  • dim_feedforward (int, 可选, 默认值为 2048) — Transformer 解码器中前馈网络的特征维度。
  • pre_norm (bool, 可选, 默认值为 False) — 是否对 Transformer 解码器使用前置层归一化。
  • enforce_input_projection (bool, 可选, 默认值为 False) — 是否添加输入投影 1x1 卷积，即使 Transformer 解码器中的输入通道和隐藏维度相同。
  • common_stride (int, 可选, 默认值为 4) — 用于确定用作像素解码器一部分的 FPN 层数的参数。
  • ignore_value (int, 可选, 默认值为 255) — 训练期间要忽略的类别 ID。
  • num_queries (int, 可选, 默认值为 100) — 解码器的查询数。
  • no_object_weight (int, 可选, 默认值为 0.1) — 应用于空（无对象）类的权重。
  • class_weight (int, 可选, 默认值为 2.0) — 交叉熵损失的权重。
  • mask_weight (int, 可选, 默认值为 5.0) — 掩码损失的权重。
  • dice_weight (int, 可选, 默认值为 5.0) — Dice 损失的权重。
  • train_num_points (str 或 function, 可选, 默认值为 12544) — 损失计算过程中用于采样的点数。
  • oversample_ratio (float, 可选, 默认值为 3.0) — 用于计算采样点数量的过采样参数
  • importance_sample_ratio (float, 可选, 默认值为 0.75) — 通过重要性采样采样的点的比率。
  • init_std (float, 可选, 默认值为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • **init_xavier_std** (float，*可选*, 默认值为 1.0) — 在 HM 注意力图模块中用于 Xavier 初始化增益的缩放因子。
  • **use_auxiliary_loss** (boolean，*可选*, 默认值为 True) -- 如果为 True，则 Mask2FormerForUniversalSegmentationOutput` 将包含使用每个解码器阶段的 logits 计算出的辅助损失。
  • **feature_strides** (List[int]，*可选*, 默认值为 [4, 8, 16, 32]) — 与从骨干网络生成的特征相对应的特征步幅。
  • **output_auxiliary_logits** (bool，*可选*) — 模型是否应输出其 auxiliary_logits。

这是用于存储 Mask2FormerModel 配置的配置类。它用于根据指定的参数实例化 Mask2Former 模型，定义模型架构。使用默认值实例化配置将产生与 Mask2Former facebook/mask2former-swin-small-coco-instance 架构类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。

目前，Mask2Former 仅支持 Swin Transformer 作为骨干网络。

示例

>>> from transformers import Mask2FormerConfig, Mask2FormerModel

>>> # Initializing a Mask2Former facebook/mask2former-swin-small-coco-instance configuration
>>> configuration = Mask2FormerConfig()

>>> # Initializing a model (with random weights) from the facebook/mask2former-swin-small-coco-instance style configuration
>>> model = Mask2FormerModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

from_backbone_config

< >

( backbone_config: PretrainedConfig **kwargs ) → Mask2FormerConfig

参数

返回值

Mask2FormerConfig

配置对象的实例

从预训练的骨干网络模型配置实例化 Mask2FormerConfig（或派生类）。

MaskFormer 特定输出

class transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput

< >

( encoder_last_hidden_state: FloatTensor = None pixel_decoder_last_hidden_state: FloatTensor = None transformer_decoder_last_hidden_state: FloatTensor = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None transformer_decoder_intermediate_states: Tuple = None masks_queries_logits: Tuple = None attentions: Optional = None )

参数

  • encoder_last_hidden_state (torch.FloatTensor ， 形状为 (batch_size, num_channels, height, width)， 可选) — 编码器模型（主干）最后一层的最后一个隐藏状态（最终特征图）。当传递 output_hidden_states=True 时返回。
  • encoder_hidden_states (tuple(torch.FloatTensor)， 可选) — torch.FloatTensor 的元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为 (batch_size, num_channels, height, width)。编码器模型在每个阶段输出处的隐藏状态（也称为特征图）。当传递 output_hidden_states=True 时返回。
  • pixel_decoder_last_hidden_state (torch.FloatTensor ， 形状为 (batch_size, num_channels, height, width)， 可选) — 像素解码器模型最后一层的最后一个隐藏状态（最终特征图）。
  • pixel_decoder_hidden_states (tuple(torch.FloatTensor)， , 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为 (batch_size, num_channels, height, width)。像素解码器模型在每个阶段输出处的隐藏状态（也称为特征图）。当传递 output_hidden_states=True 时返回。
  • transformer_decoder_last_hidden_state (tuple(torch.FloatTensor)) — Transformer 解码器的最终输出 (batch_size, sequence_length, hidden_size)。
  • transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选) — torch.FloatTensor 的元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为 (batch_size, sequence_length, hidden_size)。Transformer 解码器在每个阶段输出处的隐藏状态（也称为特征图）。当传递 output_hidden_states=True 时返回。
  • transformer_decoder_intermediate_states (形状为 (num_queries, 1, hidden_size) 的 tuple(torch.FloatTensor)) — 中间解码器激活，即每个解码器层的输出，每个输出都经过了层归一化。
  • masks_queries_logits (形状为 (batch_size, num_queries, height, width) 的 tuple(torch.FloatTensor)) — Transformer 解码器中每一层的掩码预测。
  • attentions (tuple(tuple(torch.FloatTensor)), 可选，当传递 output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tuple(torch.FloatTensor) 元组（每层一个）。来自 Transformer 解码器的自注意力权重。

Mask2FormerModel 输出的类。此类返回计算 logits 所需的所有隐藏状态。

类 transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput

< >

( loss: Optional = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_logits: Optional = None encoder_last_hidden_state: FloatTensor = None pixel_decoder_last_hidden_state: FloatTensor = None transformer_decoder_last_hidden_state: FloatTensor = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None attentions: Optional = None )

参数

  • loss (torch.Tensor, 可选) — 计算得到的损失，当标签存在时返回。
  • class_queries_logits (torch.FloatTensor) — 形状为 (batch_size, num_queries, num_labels + 1) 的张量，表示每个查询的建议类别。请注意，需要 + 1 是因为我们加入了空类别。
  • masks_queries_logits (torch.FloatTensor) — 形状为 (batch_size, num_queries, height, width) 的张量，表示每个查询的建议掩码。
  • auxiliary_logits (List[Dict(str, torch.FloatTensor)], 可选) — 来自 Transformer 解码器每一层的类别和掩码预测列表。
  • encoder_last_hidden_state (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 编码器模型（骨干网络）最后一层的最后一个隐藏状态（最终特征图）。
  • encoder_hidden_states (tuple(torch.FloatTensor), *可选*, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形式为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。
  • pixel_decoder_last_hidden_state (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素解码器模型最后一层的最后一个隐藏状态（最终特征图）。
  • pixel_decoder_hidden_states (tuple(torch.FloatTensor), *可选*, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形式为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。
  • transformer_decoder_last_hidden_state (tuple(torch.FloatTensor)) — Transformer 解码器的最终输出 (batch_size, sequence_length, hidden_size)。
  • transformer_decoder_hidden_states (tuple(torch.FloatTensor), *可选*, 当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形式为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。Transformer 解码器在每个阶段输出的隐藏状态（也称为特征图）。
  • attentions (tuple(tuple(torch.FloatTensor)), *可选*, 当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tuple(torch.FloatTensor) 元组（每层一个）。来自 Transformer 解码器的自注意力和交叉注意力权重。

用于 Mask2FormerForUniversalSegmentationOutput 输出的类。

此输出可以直接传递给 post_process_semantic_segmentation() 或 post_process_instance_segmentation() 或 post_process_panoptic_segmentation() 以计算最终的分割图。有关使用详情，请参阅 [`~Mask2FormerImageProcessor]`。

Mask2FormerModel

类 transformers.Mask2FormerModel

< >

( config: Mask2FormerConfig )

参数

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

基础 Mask2Former 模型，输出原始的隐藏状态，顶部没有任何特定的头部。此模型是 PyTorch torch.nn.Module 子类。 将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

< >

( pixel_values: Tensor pixel_mask: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 AutoImageProcessor.preprocess。
  • **pixel_mask** (`torch.LongTensor` 类型，形状为 `(batch_size, height, width)`，*可选*) — 避免对填充像素值执行注意力的掩码。在 `[0, 1]` 中选择的掩码值：

    • 1 表示真实像素（即**未被掩盖**），
    • 0 表示填充像素（即**已被掩盖**）。

    什么是注意力掩码？

  • **output_hidden_states** (`bool` 类型，*可选*) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的 `hidden_states`。
  • **output_attentions** (`bool` 类型，*可选*) — 是否返回 Detr 解码器注意力层的注意力张量。
  • **return_dict** (`bool` 类型，*可选*) — 是否返回 `~Mask2FormerModelOutput` 而不是普通元组。

返回值

transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput 或 `tuple(torch.FloatTensor)`

一个 transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput 或一个 `torch.FloatTensor` 元组（如果传递了 `return_dict=False` 或 `config.return_dict=False`），包含根据配置 (Mask2FormerConfig) 和输入而定的各种元素。

  • **encoder_last_hidden_state** (`torch.FloatTensor` 类型，形状为 `(batch_size, num_channels, height, width)`，*可选*) — 编码器模型（骨干网络）最后一级的最后一个隐藏状态（最终特征图）。当传递 `output_hidden_states=True` 时返回。
  • **encoder_hidden_states** (`tuple(torch.FloatTensor)` 类型，*可选*) — `torch.FloatTensor` 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为 `(batch_size, num_channels, height, width)`。编码器模型在每个阶段输出处的隐藏状态（也称为特征图）。当传递 `output_hidden_states=True` 时返回。
  • **pixel_decoder_last_hidden_state** (`torch.FloatTensor` 类型，形状为 `(batch_size, num_channels, height, width)`，*可选*) — 像素解码器模型最后一级的最后一个隐藏状态（最终特征图）。
  • **pixel_decoder_hidden_states** (`tuple(torch.FloatTensor)` 类型，*可选*，当传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — `torch.FloatTensor` 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为 `(batch_size, num_channels, height, width)`。像素解码器模型在每个阶段输出处的隐藏状态（也称为特征图）。当传递 `output_hidden_states=True` 时返回。
  • **transformer_decoder_last_hidden_state** (`tuple(torch.FloatTensor)` 类型) — 变压器解码器的最终输出 `(batch_size, sequence_length, hidden_size)`。
  • **transformer_decoder_hidden_states** (`tuple(torch.FloatTensor)` 类型，*可选*) — `torch.FloatTensor` 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为 `(batch_size, sequence_length, hidden_size)`。变压器解码器在每个阶段输出处的隐藏状态（也称为特征图）。当传递 `output_hidden_states=True` 时返回。
  • **transformer_decoder_intermediate_states** (`tuple(torch.FloatTensor)` 类型，形状为 `(num_queries, 1, hidden_size)`) — 中间解码器激活，即每个解码器层的输出，每个输出都经过了层归一化。
  • **masks_queries_logits** (`tuple(torch.FloatTensor)` 类型，形状为 `(batch_size, num_queries, height, width)`) 变压器解码器中每一层的掩码预测。
  • **attentions** (`tuple(tuple(torch.FloatTensor))` 类型，*可选*，当传递 `output_attentions=True` 时返回) — `tuple(torch.FloatTensor)` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。来自变压器解码器的自注意力权重。

Mask2FormerModelOutput

Mask2FormerModel forward 方法，重写了 `__call__` 特殊方法。

尽管前向传递的方案需要在此函数中定义，但之后应该调用 `Module` 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例

>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoImageProcessor, Mask2FormerModel

>>> # load image
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # load image preprocessor and Mask2FormerModel trained on COCO instance segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> model = Mask2FormerModel.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> inputs = image_processor(image, return_tensors="pt")

>>> # forward pass
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # model outputs last hidden states of shape (batch_size, num_queries, hidden_size)
>>> print(outputs.transformer_decoder_last_hidden_state.shape)
torch.Size([1, 100, 256])

Mask2FormerForUniversalSegmentation

类 transformers.Mask2FormerForUniversalSegmentation

< >

( config: Mask2FormerConfig )

参数

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

Mask2Former 模型，顶部带有用于实例/语义/全景分割的头部。该模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解有关一般使用和行为的所有事项。

forward

< >

( pixel_values: Tensor mask_labels: Optional[torch.LongTensor] = None class_labels: Optional[torch.LongTensor] = None pixel_mask: Optional[torch.LongTensor] = None output_hidden_states: Optional[bool] = None output_auxiliary_logits: Optional[bool] = None output_attentions: Optional[bool] = None return_dict: Optional[bool] = None ) → transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput 或 tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 AutoImageProcessor.preprocess。
  • pixel_mask (torch.LongTensor 形状为 (batch_size, height, width), *可选*) — 掩码，用于避免对填充像素值执行注意力。在 [0, 1] 中选择的掩码值：

    • 1 表示真实的像素（即未被掩码），
    • 0 表示填充的像素（即已被掩码）。

    什么是注意力掩码？

  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • output_attentions (bool，可选) — 是否返回 Detr 解码器注意力层的注意力张量。
  • return_dict (bool，可选) — 是否返回 ~Mask2FormerModelOutput 而不是普通元组。
  • mask_labels (List[torch.Tensor]，可选) — 要馈送到模型的形状为 (num_labels, height, width) 的掩码标签列表
  • class_labels (List[torch.LongTensor]，可选) — 要馈送到模型的形状为 (num_labels, height, width) 的目标类标签列表。它们标识 mask_labels 的标签，例如，如果 class_labels[i][j]，则为 mask_labels[i][j] 的标签。

返回值

transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (Mask2FormerConfig) 和输入的不同元素。

  • loss (torch.Tensor，可选) — 计算的损失，在存在标签时返回。
  • class_queries_logits (torch.FloatTensor) — 形状为 (batch_size, num_queries, num_labels + 1) 的张量，表示每个查询的建议类。请注意，需要 + 1 是因为我们合并了空类。
  • masks_queries_logits (torch.FloatTensor) — 形状为 (batch_size, num_queries, height, width) 的张量，表示每个查询的建议掩码。
  • auxiliary_logits (List[Dict(str, torch.FloatTensor)]，可选) — 来自变压器解码器每一层的类和掩码预测列表。
  • encoder_last_hidden_state (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 编码器模型（骨干网络）最后阶段的最后隐藏状态（最终特征图）。
  • encoder_hidden_states (tuple(torch.FloatTensor)，可选，在传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段输出处的隐藏状态（也称为特征图）。
  • pixel_decoder_last_hidden_state (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素解码器模型最后阶段的最后隐藏状态（最终特征图）。
  • pixel_decoder_hidden_states (tuple(torch.FloatTensor)，可选，在传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段输出处的隐藏状态（也称为特征图）。
  • **transformer_decoder_last_hidden_state** (`tuple(torch.FloatTensor)` 类型) — 变压器解码器的最终输出 `(batch_size, sequence_length, hidden_size)`。
  • transformer_decoder_hidden_states (tuple(torch.FloatTensor)，可选，在传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。变压器解码器在每个阶段输出处的隐藏状态（也称为特征图）。
  • attentions （tuple(tuple(torch.FloatTensor))，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回）— 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tuple(torch.FloatTensor) 元组（每层一个）。来自 Transformer 解码器的自注意力和交叉注意力权重。

Mask2FormerUniversalSegmentationOutput

Mask2FormerForUniversalSegmentation 前向方法会覆盖 __call__ 特殊方法。

尽管前向传递的方案需要在此函数中定义，但之后应该调用 `Module` 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例

实例分割示例

>>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation
>>> from PIL import Image
>>> import requests
>>> import torch

>>> # Load Mask2Former trained on COCO instance segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained(
...     "facebook/mask2former-swin-small-coco-instance"
... )

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # Perform post-processing to get instance segmentation map
>>> pred_instance_map = image_processor.post_process_semantic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]
>>> print(pred_instance_map.shape)
torch.Size([480, 640])

语义分割示例

>>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation
>>> from PIL import Image
>>> import requests
>>> import torch

>>> # Load Mask2Former trained on ADE20k semantic segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-ade-semantic")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained("facebook/mask2former-swin-small-ade-semantic")

>>> url = (
...     "https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"
... )
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # Perform post-processing to get semantic segmentation map
>>> pred_semantic_map = image_processor.post_process_semantic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]
>>> print(pred_semantic_map.shape)
torch.Size([512, 683])

全景分割示例

>>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation
>>> from PIL import Image
>>> import requests
>>> import torch

>>> # Load Mask2Former trained on CityScapes panoptic segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-cityscapes-panoptic")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained(
...     "facebook/mask2former-swin-small-cityscapes-panoptic"
... )

>>> url = "https://cdn-media.huggingface.co/Inference-API/Sample-results-on-the-Cityscapes-dataset-The-above-images-show-how-our-method-can-handle.png"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # Perform post-processing to get panoptic segmentation map
>>> pred_panoptic_map = image_processor.post_process_panoptic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]["segmentation"]
>>> print(pred_panoptic_map.shape)
torch.Size([338, 676])

Mask2FormerImageProcessor

类 transformers.Mask2FormerImageProcessor

< >

( do_resize: bool = True size: Dict = None size_divisor: int = 32 resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: bool = False num_labels: Optional = None **kwargs )

参数

  • do_resize (bool, 可选, 默认值 True) — 是否将输入调整为某个 size。
  • size (int, 可选, 默认值 800) — 将输入调整为此大小。仅在 do_resize 设置为 True 时生效。如果 size 是一个序列，例如 (width, height)，则输出大小将与此匹配。如果 size 是一个整数，则图像的较短边将与此数字匹配。即，如果 height > width，则图像将被重新缩放为 (size * height / width, size)。
  • size_divisor (int, 可选, 默认值 32) — 一些骨干网络需要图像可被某个数字整除。如果未传递，则默认为 Swin Transformer 中使用的值。
  • resample (int, 可选, 默认值 Resampling.BILINEAR) — 可选的重采样过滤器。可以是 PIL.Image.Resampling.NEAREST、PIL.Image.Resampling.BOX、PIL.Image.Resampling.BILINEAR、PIL.Image.Resampling.HAMMING、PIL.Image.Resampling.BICUBIC 或 PIL.Image.Resampling.LANCZOS 之一。仅在 do_resize 设置为 True 时有效。
  • do_rescale (bool, 可选, 默认值 True) — 是否将输入重新缩放到某个 scale。
  • rescale_factor (float, 可选, 默认值 1/ 255) — 按给定因子重新缩放输入。仅在 do_rescale 设置为 True 时有效。
  • do_normalize (bool, 可选, 默认值 True) — 是否使用均值和标准差对输入进行归一化。
  • image_mean (int, 可选, 默认值 [0.485, 0.456, 0.406]) — 用于图像归一化的每个通道的均值序列。默认为 ImageNet 均值。
  • image_std (int, 可选, 默认值 [0.229, 0.224, 0.225]) — 用于图像归一化的每个通道的标准差序列。默认为 ImageNet 标准差。
  • ignore_index (int, 可选) — 在分割掩码中分配给背景像素的标签。如果提供，则用 0（背景）表示的分割掩码像素将替换为 ignore_index。
  • do_reduce_labels (bool，可选，默认为 False) — 是否将分割图的所有标签值减 1。通常用于 0 用于背景的数据集，并且背景本身不包含在数据集的所有类中（例如 ADE20k）。背景标签将被替换为 ignore_index。
  • num_labels (int，可选) — 分割图中的标签数量。

构造一个 Mask2Former 图像处理器。图像处理器可用于准备模型的图像和可选目标。

此图像处理器继承自 BaseImageProcessor，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

预处理

< >

( images: Union segmentation_maps: Union = None instance_id_to_semantic_id: Optional = None do_resize: Optional = None size: Optional = None size_divisor: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: Optional = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None )

编码输入

< >

( pixel_values_list: List segmentation_maps: Union = None instance_id_to_semantic_id: Union = None ignore_index: Optional = None do_reduce_labels: bool = False return_tensors: Union = None input_data_format: Union = None ) → BatchFeature

参数

  • pixel_values_list (List[ImageInput]) — 待填充的图像（像素值）列表。每个图像应为形状为 (channels, height, width) 的张量。
  • segmentation_maps (ImageInput, 可选) — 具有像素级注释的对应语义分割图。

    (bool, 可选, 默认值 True): 是否将图像填充到批处理中最大的图像并创建像素掩码。

    如果保留默认值，将返回一个像素掩码，其中：

    • 1 表示真实的像素（即未掩码），
    • 0 表示填充的像素（即掩码）。
  • instance_id_to_semantic_id (List[Dict[int, int]] 或 Dict[int, int], 可选) — 对象实例 ID 和类别 ID 之间的映射。如果传递，则 segmentation_maps 被视为实例分割图，其中每个像素表示一个实例 ID。可以作为单个字典（具有全局/数据集级映射）或字典列表（每个图像一个）提供，以分别映射每个图像中的实例 ID。
  • return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 NumPy 数组。如果设置为 'pt'，则返回 PyTorch torch.Tensor 对象。
  • input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。如果未提供，将进行推断。

返回值

BatchFeature

具有以下字段的 BatchFeature

  • pixel_values — 要输入到模型的像素值。
  • pixel_mask — 要输入到模型的像素掩码（当 =True 或 pixel_mask 在 self.model_input_names 中时）。
  • mask_labels — 要输入到模型的形状为 (labels, height, width) 的掩码标签的可选列表（当提供 annotations 时）。
  • class_labels — 要输入到模型的形状为 (labels) 的类别标签的可选列表（当提供 annotations 时）。它们标识 mask_labels 的标签，例如，如果 class_labels[i][j]，则为 mask_labels[i][j] 的标签。

将图像填充到批处理中最大的图像，并创建相应的 pixel_mask。

Mask2Former 使用掩码分类范式来解决语义分割问题，因此输入分割图将转换为二进制掩码列表及其各自的标签。让我们看一个例子，假设 segmentation_maps = [[2,6,7,9]]，输出将包含 mask_labels = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]（四个二进制掩码）和 class_labels = [2,6,7,9]，每个掩码的标签。

post_process_semantic_segmentation

< >

( outputs target_sizes: Optional = None ) → List[torch.Tensor]

参数

  • outputs (Mask2FormerForUniversalSegmentation) — 模型的原始输出。
  • target_sizes (List[Tuple[int, int]], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于每个预测的请求最终大小（高度、宽度）。如果保留为 None，则不会调整预测大小。

返回值

List[torch.Tensor]

长度为 batch_size 的列表，其中每个项都是形状为（高度，宽度）的语义分割图，对应于 target_sizes 条目（如果指定了 target_sizes）。每个 torch.Tensor 的每个条目对应于一个语义类 ID。

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

post_process_instance_segmentation

< >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False return_binary_maps: Optional = False ) → List[Dict]

参数

  • outputs (Mask2FormerForUniversalSegmentation) — 模型的原始输出。
  • threshold (浮点数，*可选*，默认为 0.5) — 用于保留预测的实例掩码的概率分数阈值。
  • mask_threshold (浮点数，*可选*，默认为 0.5) — 将预测的掩码转换为二进制值时使用的阈值。
  • overlap_mask_area_threshold (浮点数，*可选*，默认为 0.8) — 用于合并或丢弃每个二进制实例掩码中小的不连续部分的重叠掩码区域阈值。
  • target_sizes (列表[元组]，*可选*) — 长度为 (batch_size) 的列表，其中每个列表项 (元组[整数，整数]]) 对应于每个预测的请求最终大小（高度，宽度）。如果保留为 None，则不会调整预测的大小。
  • return_coco_annotation (布尔值，*可选*，默认为 False) — 如果设置为 True，则以 COCO 游程长度编码 (RLE) 格式返回分割图。
  • return_binary_maps (布尔值，*可选*，默认为 False) — 如果设置为 True，则分割图将作为二进制分割图的连接张量返回（每个检测到的实例一个）。

返回值

列表[字典]

一个字典列表，每个图像对应一个字典，每个字典包含两个键

  • segmentation — 形状为 (高度, 宽度) 的张量，其中每个像素表示一个 segment_id，如果 return_coco_annotation 设置为 True，则为分割图的 列表[列表] 游程长度编码 (RLE)。如果在 threshold 以上未找到掩码，则设置为 None。
  • segments_info — 包含每个分割段附加信息的字典。
    • id — 表示 segment_id 的整数。
    • label_id — 表示与 segment_id 对应的标签/语义类 ID 的整数。
    • score — 具有 segment_id 的分割段的预测分数。

将 Mask2FormerForUniversalSegmentationOutput 的输出转换为实例分割预测。仅支持 PyTorch。

post_process_panoptic_segmentation

< >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → List[Dict]

参数

  • outputs (Mask2FormerForUniversalSegmentationOutput) — 来自 Mask2FormerForUniversalSegmentation 的输出。
  • threshold (float, *可选*, 默认值为 0.5) — 用于保留预测实例掩码的概率分数阈值。
  • mask_threshold (float, *可选*, 默认值为 0.5) — 将预测掩码转换为二进制值时使用的阈值。
  • overlap_mask_area_threshold (float, *可选*, 默认值为 0.8) — 用于合并或丢弃每个二进制实例掩码中小的不连续部分的重叠掩码区域阈值。
  • label_ids_to_fuse (Set[int], *可选*) — 处于此状态的标签将把所有实例融合在一起。例如，我们可以说一张图片中只能有一片天空，但可以有几个人，所以天空的标签 ID 会在这个集合中，而人的标签 ID 不会。
  • target_sizes (List[Tuple]，可选) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于批处理中每个预测的请求最终大小（高度，宽度）。如果保留为 None，则不会调整预测的大小。

返回值

列表[字典]

一个字典列表，每个图像对应一个字典，每个字典包含两个键

  • segmentation — 形状为 (height, width) 的张量，其中每个像素代表一个 segment_id，如果在 threshold 以上未找到掩码，则设置为 None。如果指定了 target_sizes，则分割大小将调整为相应的 target_sizes 条目。
  • segments_info — 包含每个分割段附加信息的字典。
    • id — 表示 segment_id 的整数。
    • label_id — 表示与 segment_id 对应的标签/语义类 ID 的整数。
    • was_fused — 一个布尔值，如果 label_id 在 label_ids_to_fuse 中，则为 True，否则为 False。相同类/标签的多个实例被融合并分配了一个 segment_id。
    • score — 具有 segment_id 的分割段的预测分数。

将 Mask2FormerForUniversalSegmentationOutput 的输出转换为图像全景分割预测。仅支持 PyTorch。

< > 在 GitHub 上更新

←LeViT MaskFormer→