Mask2Former

概述

Mask2Former 模型由 Bowen Cheng, Ishan Misra, Alexander G. Schwing, Alexander Kirillov, Rohit Girdhar 在Masked-attention Mask Transformer for Universal Image Segmentation中提出。Mask2Former 是一个用于全景、实例和语义分割的统一框架，与MaskFormer相比，其性能和效率都有显著提升。

论文摘要如下：

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

Mask2Former 架构。摘自原始论文。

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

使用技巧

Mask2Former 使用与MaskFormer相同的预处理和后处理步骤。使用Mask2FormerImageProcessor或AutoImageProcessor来准备图像以及可选的目标以供模型使用。
为了获得最终的分割结果，根据任务的不同，可以调用`post_process_semantic_segmentation()`或`post_process_instance_segmentation()`或`post_process_panoptic_segmentation()`。所有这三个任务都可以通过`Mask2FormerForUniversalSegmentation`的输出来解决，全景分割接受一个可选的`label_ids_to_fuse`参数，用于将目标对象（例如天空）的实例融合在一起。

资源

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

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

如果您有兴趣提交资源以供此处收录，请随时发起拉取请求，我们将对其进行审查。理想情况下，资源应展示新内容，而非重复现有资源。

Mask2FormerConfig

class transformers.Mask2FormerConfig

< 来源 >

( backbone_config: typing.Optional[dict] = 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: typing.Optional[bool] = None backbone: typing.Optional[str] = None use_pretrained_backbone: bool = False use_timm_backbone: bool = False backbone_kwargs: typing.Optional[dict] = 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_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 编码器的前馈网络的维度。
`encoder_layers` (`int`, *可选*, 默认为 6) — 作为像素解码器一部分使用的可变形 DETR 编码器中的层数。
`decoder_layers` (`int`, *可选*, 默认为 10) — Transformer 解码器中的层数。
`num_attention_heads` (`int`, *可选*, 默认为 8) — 每个注意力层的注意力头数。
`dropout` (`float`, *可选*, 默认为 0.1) — 嵌入、编码器中所有全连接层的 dropout 概率。
`dim_feedforward` (`int`, *可选*, 默认为 2048) — Transformer 解码器中前馈网络的特征维度。
`pre_norm` (`bool`, *可选*, 默认为 `False`) — Transformer 解码器是否使用 pre-LayerNorm。
`enforce_input_projection` (`bool`, *可选*, 默认为 `False`) — 即使 Transformer 解码器中的输入通道和隐藏维度相同，是否也添加输入投影 1x1 卷积。
`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

参数

`backbone_config` (PretrainedConfig) — 主干配置。

Mask2FormerConfig

一个配置对象的实例

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

MaskFormer 特定输出

class transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput

< 来源 >

( encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None pixel_decoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None transformer_decoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None pixel_decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None transformer_decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None transformer_decoder_intermediate_states: tuple = None masks_queries_logits: tuple = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None )

参数

`encoder_last_hidden_state` (`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)`，*可选*) — 像素解码器模型最后一阶段的最后一个隐藏状态（最终特征图）。
`transformer_decoder_last_hidden_state` (`tuple(torch.FloatTensor)`) — Transformer 解码器的最终输出 `(batch_size, sequence_length, hidden_size)`。
encoder_hidden_states (tuple(torch.FloatTensor), 可选) — 形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组（一个用于嵌入层输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。当传入 output_hidden_states=True 时返回。
pixel_decoder_hidden_states (tuple(torch.FloatTensor), , 可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组（一个用于嵌入层输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。当传入 output_hidden_states=True 时返回。
transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入层输出 + 一个用于每个阶段的输出）。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 解码器的自注意力权重。
attentions (tuple[torch.FloatTensor], 可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

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

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

class transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput

< source >

( loss: typing.Optional[torch.FloatTensor] = None class_queries_logits: typing.Optional[torch.FloatTensor] = None masks_queries_logits: typing.Optional[torch.FloatTensor] = None auxiliary_logits: typing.Optional[list[dict[str, torch.FloatTensor]]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None pixel_decoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None transformer_decoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None pixel_decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None transformer_decoder_hidden_states: typing.Optional[torch.FloatTensor] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None )

参数

loss (torch.Tensor, 可选) — 计算出的损失，当存在标签时返回。
class_queries_logits (torch.FloatTensor, 可选, 默认为 None) — 形状为 (batch_size, num_queries, num_labels + 1) 的张量，表示每个查询的建议类别。请注意，需要 + 1 是因为我们包含了空类别。
masks_queries_logits (torch.FloatTensor, 可选, 默认为 None) — 形状为 (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) — 编码器模型（主干）最后一阶段的最后隐藏状态（最终特征图）。
pixel_decoder_last_hidden_state (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素解码器模型最后一阶段的最后隐藏状态（最终特征图）。
transformer_decoder_last_hidden_state (tuple(torch.FloatTensor)) — Transformer 解码器的最终输出 (batch_size, sequence_length, hidden_size)。
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_hidden_states (tuple(torch.FloatTensor), 可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组（一个用于嵌入层输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。
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

class transformers.Mask2FormerModel

< source >

( config: Mask2FormerConfig )

参数

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

裸 Mask2Former 模型，直接输出原始隐藏状态，不带任何特定头部。

此模型继承自 PreTrainedModel。请查看父类文档，了解该库为所有模型实现的所有通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。

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

前向传播

< source >

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

参数

pixel_values (形状为 (batch_size, num_channels, image_size, image_size) 的 torch.Tensor) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息，请参阅 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
pixel_mask (形状为 (batch_size, height, width) 的 torch.Tensor, 可选) — 用于避免对填充像素值执行注意力的掩码。掩码值选择在 [0, 1] 之间：
- 1 表示真实像素（即未被遮蔽），
- 0 表示填充像素（即被遮蔽）。
什么是注意力掩码？
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

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 (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor, 可选) — 编码器模型（主干）最后一阶段的最后隐藏状态（最终特征图）。当传入 output_hidden_states=True 时返回。
pixel_decoder_last_hidden_state (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor, 可选) — 像素解码器模型最后一阶段的最后隐藏状态（最终特征图）。
transformer_decoder_last_hidden_state (tuple(torch.FloatTensor)) — Transformer 解码器的最终输出 (batch_size, sequence_length, hidden_size)。
encoder_hidden_states (tuple(torch.FloatTensor), 可选) — 形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组（一个用于嵌入层输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。当传入 output_hidden_states=True 时返回。
pixel_decoder_hidden_states (tuple(torch.FloatTensor), , 可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 元组（一个用于嵌入层输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。当传入 output_hidden_states=True 时返回。
transformer_decoder_hidden_states (tuple(torch.FloatTensor), 可选) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入层输出 + 一个用于每个阶段的输出）。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 解码器的自注意力权重。
attentions (tuple[torch.FloatTensor], 可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。

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

Mask2FormerModel 的前向传播方法，覆盖了 __call__ 特殊方法。

尽管前向传播的实现需要在该函数中定义，但随后应该调用 Module 实例而不是直接调用此函数，因为前者负责运行预处理和后处理步骤，而后者会静默忽略它们。

Mask2FormerForUniversalSegmentation

class transformers.Mask2FormerForUniversalSegmentation

< source >

( config: Mask2FormerConfig )

参数

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

带头部（用于实例/语义/全景分割）的 Mask2Former 模型。

此模型继承自 PreTrainedModel。请查看父类文档，了解该库为所有模型实现的所有通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。

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

前向传播

< source >

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

参数

pixel_values (形状为 (batch_size, num_channels, image_size, image_size) 的 torch.Tensor) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息，请参阅 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
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] 的标签。
pixel_mask (形状为 (batch_size, height, width) 的 torch.Tensor, 可选) — 用于避免对填充像素值执行注意力的掩码。掩码值选择在 [0, 1] 之间：
- 1 表示真实像素（即未被遮蔽），
- 0 表示填充像素（即被遮蔽）。
什么是注意力掩码？
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
output_auxiliary_logits (bool, 可选) — 是否输出辅助 logits。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

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，可选，默认为 None) — 形状为 (batch_size, num_queries, num_labels + 1) 的张量，表示每个查询的建议类别。请注意需要 + 1 是因为我们加入了空类别。
masks_queries_logits (torch.FloatTensor, 可选, 默认为 None) — 形状为 (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) — 编码器模型（骨干网络）最后一阶段的最后隐藏状态（最终特征图）。
pixel_decoder_last_hidden_state (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素解码器模型最后一阶段的最后隐藏状态（最终特征图）。
transformer_decoder_last_hidden_state (tuple(torch.FloatTensor)) — Transformer 解码器的最终输出 (batch_size, sequence_length, hidden_size)。
encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 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)。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。
transformer_decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入层输出 + 一个用于每个阶段的输出），形状为 (batch_size, sequence_length, hidden_size)。变压器解码器在每个阶段输出的隐藏状态（也称为特征图）。
attentions (tuple(tuple(torch.FloatTensor))，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tuple(torch.FloatTensor) 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。变压器解码器中的自注意和交叉注意权重。

Mask2FormerForUniversalSegmentation 的前向方法，覆盖了 __call__ 特殊方法。

示例

实例分割示例

>>> 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_instance_segmentation(
...     outputs, target_sizes=[(image.height, image.width)]
... )[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.height, image.width)]
... )[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.height, image.width)]
... )[0]["segmentation"]
>>> print(pred_panoptic_map.shape)
torch.Size([338, 676])

Mask2FormerImageProcessor

class transformers.Mask2FormerImageProcessor

< source 源文件 >

( do_resize: bool = True size: typing.Optional[dict[str, int]] = 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: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None ignore_index: typing.Optional[int] = None do_reduce_labels: bool = False num_labels: typing.Optional[int] = None **kwargs )

参数

do_resize (bool，可选，默认为 True) — 是否将输入图像调整为指定的 size。
size (int，可选，默认为 800) — 将输入图像调整为给定大小。仅当 do_resize 设置为 True 时有效。如果大小是像 (width, height) 这样的序列，则输出大小将匹配此序列。如果大小是整数，则图像的较短边将匹配此数字。例如，如果 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，可选) — 分割图中分配给背景像素的标签。如果提供，将用 ignore_index 替换标记为 0（背景）的分割图像素。
do_reduce_labels (bool，可选，默认为 False) — 是否将分割图中所有标签值减 1。通常用于背景用 0 表示，且背景本身不包含在数据集所有类别中的数据集（例如 ADE20k）。背景标签将被替换为 ignore_index。
num_labels (int，可选) — 分割图中的标签数量。

构建 Mask2Former 图像处理器。该图像处理器可用于为模型准备图像和可选目标。

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

preprocess

< source 源文件 >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None instance_id_to_semantic_id: typing.Optional[dict[int, int]] = None do_resize: typing.Optional[bool] = None size: typing.Optional[dict[str, int]] = None size_divisor: typing.Optional[int] = None resample: Resampling = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None ignore_index: typing.Optional[int] = None do_reduce_labels: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: typing.Union[str, transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )

编码输入

< source 源文件 >

( pixel_values_list: list segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] = None instance_id_to_semantic_id: typing.Union[list[dict[int, int]], dict[int, int], NoneType] = None ignore_index: typing.Optional[int] = None do_reduce_labels: bool = False return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = 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

pixel_values — 要输入到模型的像素值。
pixel_mask — 要输入到模型的像素掩码（当 =True 或 pixel_mask 在 self.model_input_names 中时）。
mask_labels — 可选的掩码标签列表，形状为 (labels, height, width)，用于输入到模型（当提供 annotations 时）。
class_labels — 可选的类别标签列表，形状为 (labels)，用于馈送到模型（当提供 annotations 时）。它们标识 mask_labels 的标签，例如 mask_labels[i][j] 的标签为 class_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

< source 源文件 >

( outputs target_sizes: typing.Optional[list[tuple[int, int]]] = None ) → list[torch.Tensor]

参数

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

list[torch.Tensor]

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

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

post_process_instance_segmentation

< source 源文件 >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: typing.Optional[list[tuple[int, int]]] = None return_coco_annotation: typing.Optional[bool] = False return_binary_maps: typing.Optional[bool] = False ) → list[Dict]

参数

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

list[Dict]

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

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

将 Mask2FormerForUniversalSegmentationOutput 的输出转换为实例分割预测。仅支持 PyTorch。如果实例可能重叠，则将 return_coco_annotation 或 return_binary_maps 设置为 True 以获得正确的分割结果。

post_process_panoptic_segmentation

< source 源文件 >

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: typing.Optional[set[int]] = None target_sizes: typing.Optional[list[tuple[int, int]]] = 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]]) 对应于批次中每个预测的请求最终大小（高度，宽度）。如果留空，则预测不会被调整大小。

list[Dict]

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

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 上更新

Transformers

Mask2Former

概述

使用技巧

资源

Mask2FormerConfig

class transformers.Mask2FormerConfig

from_backbone_config

MaskFormer 特定输出

class transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput

class transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput

Mask2FormerModel

class transformers.Mask2FormerModel

前向传播

Mask2FormerForUniversalSegmentation

class transformers.Mask2FormerForUniversalSegmentation

前向传播

Mask2FormerImageProcessor

class transformers.Mask2FormerImageProcessor

preprocess

编码输入

post_process_semantic_segmentation

post_process_instance_segmentation

post_process_panoptic_segmentation