MaskFormer

这是一个最近推出的模型，因此 API 尚未经过广泛测试。未来可能会有一些错误修复或轻微的破坏性更改。如果您发现任何异常情况，请提交 Github Issue。

概述

MaskFormer 模型由 Bowen Cheng、Alexander G. Schwing 和 Alexander Kirillov 在论文 Per-Pixel Classification is Not All You Need for Semantic Segmentation 中提出。MaskFormer 使用掩码分类范式来解决语义分割问题，而不是执行经典的像素级分类。

论文摘要如下：

现代方法通常将语义分割表述为逐像素分类任务，而实例级分割则通过另一种掩码分类方法来处理。我们的关键见解是：掩码分类足够通用，可以使用完全相同的模型、损失和训练过程，以统一的方式解决语义级和实例级分割任务。基于这一观察，我们提出了 MaskFormer，一个简单的掩码分类模型，它预测一组二进制掩码，每个掩码都与一个单一的全局类别标签预测相关联。总的来说，我们提出的基于掩码分类的方法简化了语义和全景分割任务的有效方法，并显示出优异的实验结果。特别地，我们观察到当类别数量较多时，MaskFormer 的性能优于逐像素分类基线。我们基于掩码分类的方法在语义分割（在 ADE20K 上达到 55.6 mIoU）和全景分割（在 COCO 上达到 52.7 PQ）方面均优于当前最先进的模型。

下图展示了 MaskFormer 的架构。图片来自原始论文。

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

使用技巧

MaskFormer 的 Transformer 解码器与 DETR 的解码器相同。在训练过程中，DETR 的作者发现，在解码器中使用辅助损失非常有帮助，特别是为了帮助模型输出每个类别的正确对象数量。如果您将 MaskFormerConfig 的参数 `use_auxiliary_loss` 设置为 `True`，那么在每个解码器层之后都会添加预测前馈神经网络和匈牙利损失（FFN 共享参数）。
如果你想在多节点分布式环境中训练模型，那么应该更新 `modeling_maskformer.py` 中 `MaskFormerLoss` 类里的 `get_num_masks` 函数。在多节点上训练时，应将其设置为所有节点上目标掩码的平均数，正如原始实现中所示，请参阅这里。
您可以使用 MaskFormerImageProcessor 为模型准备图像和可选的目标。
要获得最终的分割结果，根据任务的不同，您可以调用 post_process_semantic_segmentation() 或 post_process_panoptic_segmentation()。这两个任务都可以使用 MaskFormerForInstanceSegmentation 的输出解决，全景分割接受一个可选的 `label_ids_to_fuse` 参数，用于将目标对象的实例（例如天空）融合在一起。

资源

图像分割

所有展示使用 MaskFormer 进行推理以及在自定义数据上进行微调的 notebook 都可以在这里找到。
使用 Trainer 或 Accelerate 微调 `MaskFormer` 的脚本可以在这里找到。

MaskFormer 特定输出

class transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput

< 源代码 >

( 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 hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None )

参数

encoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 编码器模型（主干网络）最后一个阶段的最后隐藏状态（最终特征图）。
pixel_decoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后一个阶段的最后隐藏状态（最终特征图）。
transformer_decoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — transformer 解码器模型最后一个阶段的最后隐藏状态（最终特征图）。
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)`。transformer 解码器每个阶段输出的隐藏状态（也称为特征图）。
hidden_states `tuple(torch.FloatTensor)`，*可选*，在传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — 包含 `encoder_hidden_states`、`pixel_decoder_hidden_states` 和 `decoder_hidden_states` 的 `torch.FloatTensor` 元组。
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)`。

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

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

class transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput

< 源代码 >

( 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[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[tuple[torch.FloatTensor]] = None hidden_states: typing.Optional[tuple[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 (Dict[str, torch.FloatTensor]，*可选*，在 `output_auxiliary_logits=True` 时返回) — 包含每个解码器层的辅助预测的字典，当启用辅助损失时。
encoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 编码器模型（主干网络）最后一个阶段的最后隐藏状态（最终特征图）。
pixel_decoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后一个阶段的最后隐藏状态（最终特征图）。
transformer_decoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — transformer 解码器模型最后一个阶段的最后隐藏状态（最终特征图）。
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)`。transformer 解码器每个阶段输出的隐藏状态。
hidden_states `tuple(torch.FloatTensor)`，*可选*，在传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — 包含 `encoder_hidden_states`、`pixel_decoder_hidden_states` 和 `decoder_hidden_states` 的 `torch.FloatTensor` 元组。
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)`。

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

MaskFormerForInstanceSegmentation 的输出类。

此输出可以直接传递给 post_process_semantic_segmentation() 或 post_process_instance_segmentation() 或 post_process_panoptic_segmentation()，具体取决于任务。有关使用详情，请参阅 [`~MaskFormerImageProcessor]。

MaskFormerConfig

class transformers.MaskFormerConfig

< 源代码 >

( fpn_feature_size: int = 256 mask_feature_size: int = 256 no_object_weight: float = 0.1 use_auxiliary_loss: bool = False backbone_config: typing.Optional[dict] = None decoder_config: typing.Optional[dict] = None init_std: float = 0.02 init_xavier_std: float = 1.0 dice_weight: float = 1.0 cross_entropy_weight: float = 1.0 mask_weight: float = 20.0 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 )

参数

mask_feature_size (int，*可选*，默认为 256) — 掩码的特征大小，该值也将用于指定特征金字塔网络（Feature Pyramid Network）的特征大小。
no_object_weight (float，*可选*，默认为 0.1) — 应用于空（无对象）类别的权重。
use_auxiliary_loss(bool, *可选*，默认为 `False`) — 如果为 `True`，`MaskFormerForInstanceSegmentationOutput` 将包含使用每个解码器阶段的 logits 计算的辅助损失。
backbone_config (Dict，*可选*) — 传递给主干网络的配置，如果未设置，将使用对应于 `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`，则不能指定此参数。
decoder_config (Dict，*可选*) — 传递给 transformer 解码器模型的配置，如果未设置，将使用 `detr-resnet-50` 的基本配置。
init_std (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
init_xavier_std (float, 可选, 默认为 1) — 在 HM Attention 地图模块中，用于 Xavier 初始化增益的缩放因子。
dice_weight (float, 可选, 默认为 1.0) — Dice 损失的权重。
cross_entropy_weight (float, 可选, 默认为 1.0) — 交叉熵损失的权重。
mask_weight (float, 可选, 默认为 20.0) — 掩码损失的权重。
output_auxiliary_logits (bool, 可选) — 模型是否应输出其 `auxiliary_logits`。

引发

ValueError

ValueError — 如果选择的主干模型类型不在 `["swin"]` 中，或者选择的解码器模型类型不在 `["detr"]` 中，则会引发此错误。

这是用于存储 MaskFormerModel 配置的配置类。它用于根据指定的参数实例化一个 MaskFormer 模型，定义模型架构。使用默认值实例化配置将产生与在 ADE20k-150 上训练的 MaskFormer facebook/maskformer-swin-base-ade 架构相似的配置。

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

目前，MaskFormer 仅支持 Swin Transformer 作为主干。

示例

>>> from transformers import MaskFormerConfig, MaskFormerModel

>>> # Initializing a MaskFormer facebook/maskformer-swin-base-ade configuration
>>> configuration = MaskFormerConfig()

>>> # Initializing a model (with random weights) from the facebook/maskformer-swin-base-ade style configuration
>>> model = MaskFormerModel(configuration)

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

from_backbone_and_decoder_configs

< 源代码 >

( backbone_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → MaskFormerConfig

参数

backbone_config (PretrainedConfig) — 主干配置。
decoder_config (PretrainedConfig) — 要使用的 Transformer 解码器配置。

MaskFormerConfig

一个配置对象的实例

从一个预训练的主干模型配置和 DETR 模型配置中实例化一个 MaskFormerConfig（或其派生类）。

MaskFormerImageProcessor

class transformers.MaskFormerImageProcessor

< 源代码 >

( 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` 时有效。如果 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, 可选) — 分割图中的标签数量。

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

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

preprocess

< 源代码 >

( 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 )

编码输入

< 源代码 >

( 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` 对象。

批次特征

一个具有以下字段的 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。

MaskFormer 使用掩码分类范式来解决语义分割问题，因此输入分割图将被转换为二进制掩码列表及其各自的标签。举个例子，假设 `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: typing.Optional[list[tuple[int, int]]] = None ) → `list[torch.Tensor]`

参数

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

list[torch.Tensor]

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

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

post_process_instance_segmentation

< 源代码 >

( 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 (MaskFormerForInstanceSegmentation) — 模型的原始输出。
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]]`）对应每个预测请求的最终尺寸（高，宽）。如果为 None，则预测不会被调整大小。
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 的段的预测分数。

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

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: typing.Optional[set[int]] = None target_sizes: typing.Optional[list[tuple[int, int]]] = None ) → `list[Dict]`

参数

outputs (MaskFormerForInstanceSegmentationOutput) — 来自 MaskFormerForInstanceSegmentation 的输出。
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，则不会调整预测尺寸。

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 的段的预测分数。

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

MaskFormerFeatureExtractor

class transformers.MaskFormerFeatureExtractor

< source >

( *args **kwargs )

call

< source >

( images segmentation_maps = None **kwargs )

编码输入

< source >

参数

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 对象。

批次特征

一个具有以下字段的 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。

post_process_semantic_segmentation

< source >

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

参数

outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。
target_sizes (list[tuple[int, int]], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (tuple[int, int]]) 对应每个预测所需的最终尺寸（高，宽）。如果为 None，则不会调整预测尺寸。

list[torch.Tensor]

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

post_process_instance_segmentation

< source >

参数

outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。
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]) 对应批处理中每个预测所需的最终尺寸（高，宽）。如果为 None，则不会调整预测尺寸。
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 的段的预测分数。

post_process_panoptic_segmentation

< source >

参数

outputs (MaskFormerForInstanceSegmentationOutput) — 来自 MaskFormerForInstanceSegmentation 的输出。
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，则不会调整预测尺寸。

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 的段的预测分数。

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

MaskFormerModel

class transformers.MaskFormerModel

< source >

( config: MaskFormerConfig )

参数

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

基础的 Maskformer 模型，输出原始的隐藏状态，顶部没有任何特定的头部。

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< 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.maskformer.modeling_maskformer.MaskFormerModelOutput 或 tuple(torch.FloatTensor)

参数

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

transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（MaskFormerConfig）和输入，包含不同的元素。

encoder_last_hidden_state (torch.FloatTensor, 形状为 (batch_size, num_channels, height, width)) — 编码器模型（主干网络）最后一个阶段的最后隐藏状态（最终特征图）。
pixel_decoder_last_hidden_state (torch.FloatTensor, 形状为 (batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后一个阶段的最后隐藏状态（最终特征图）。
transformer_decoder_last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — Transformer 解码器模型最后一个阶段的最后隐藏状态（最终特征图）。
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)。Transformer 解码器在每个阶段输出的隐藏状态（也称为特征图）。
hidden_states tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 包含 encoder_hidden_states、pixel_decoder_hidden_states 和 decoder_hidden_states 的 torch.FloatTensor 元组。
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 后的注意力权重，用于计算自注意力头中的加权平均值。

MaskFormerModel 的 forward 方法，重写了 __call__ 特殊方法。

虽然前向传播的流程需要在这个函数中定义，但之后应该调用 `Module` 实例而不是这个函数，因为前者会处理预处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> from transformers import AutoImageProcessor, MaskFormerModel
>>> from PIL import Image
>>> import requests

>>> # load MaskFormer fine-tuned on ADE20k semantic segmentation
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-ade")
>>> model = MaskFormerModel.from_pretrained("facebook/maskformer-swin-base-ade")

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

>>> inputs = image_processor(image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> # the decoder of MaskFormer outputs hidden states of shape (batch_size, num_queries, hidden_size)
>>> transformer_decoder_last_hidden_state = outputs.transformer_decoder_last_hidden_state
>>> list(transformer_decoder_last_hidden_state.shape)
[1, 100, 256]

MaskFormerForInstanceSegmentation

class transformers.MaskFormerForInstanceSegmentation

< source >

( config: MaskFormerConfig )

forward

< 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_auxiliary_logits: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput 或 tuple(torch.FloatTensor)

参数

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

transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（MaskFormerConfig）和输入而变化的不同元素。

loss (torch.Tensor, 可选) — 计算出的损失，当存在标签时返回。
class_queries_logits (torch.FloatTensor, optional, defaults to None) — 形状为 (batch_size, num_queries, num_labels + 1) 的张量，表示每个查询的建议类别。请注意，需要 + 1 是因为我们包含了空类别。
masks_queries_logits (torch.FloatTensor, 可选, 默认为 None) — 形状为 (batch_size, num_queries, height, width) 的张量，表示每个查询的建议掩码。
auxiliary_logits (Dict[str, torch.FloatTensor], optional, returned when output_auxiliary_logits=True) — 字典，当启用辅助损失时，包含每个解码器层的辅助预测。
encoder_last_hidden_state (torch.FloatTensor, 形状为 (batch_size, num_channels, height, width)) — 编码器模型（主干网络）最后一个阶段的最后隐藏状态（最终特征图）。
pixel_decoder_last_hidden_state (torch.FloatTensor, 形状为 (batch_size, num_channels, height, width)) — 像素解码器模型（FPN）最后一个阶段的最后隐藏状态（最终特征图）。
transformer_decoder_last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — Transformer 解码器模型最后一个阶段的最后隐藏状态（最终特征图）。
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), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor 的元组（一个用于嵌入层的输出，每个阶段的输出各一个），形状为 (batch_size, sequence_length, hidden_size)。transformer 解码器在每个阶段输出的隐藏状态。
hidden_states tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor 的元组，包含 encoder_hidden_states、pixel_decoder_hidden_states 和 decoder_hidden_states。
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 后的注意力权重，用于计算自注意力头中的加权平均值。

MaskFormerForInstanceSegmentation 的 forward 方法，重写了 __call__ 特殊方法。

示例

语义分割示例

>>> from transformers import AutoImageProcessor, MaskFormerForInstanceSegmentation
>>> from PIL import Image
>>> import requests

>>> # load MaskFormer fine-tuned on ADE20k semantic segmentation
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-ade")
>>> model = MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-base-ade")

>>> 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(images=image, return_tensors="pt")

>>> 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

>>> # you can pass them to image_processor for postprocessing
>>> predicted_semantic_map = image_processor.post_process_semantic_segmentation(
...     outputs, target_sizes=[(image.height, image.width)]
... )[0]

>>> # we refer to the demo notebooks for visualization (see "Resources" section in the MaskFormer docs)
>>> list(predicted_semantic_map.shape)
[512, 683]

全景分割示例

>>> from transformers import AutoImageProcessor, MaskFormerForInstanceSegmentation
>>> from PIL import Image
>>> import requests

>>> # load MaskFormer fine-tuned on COCO panoptic segmentation
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/maskformer-swin-base-coco")
>>> model = MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-base-coco")

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

>>> 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

>>> # you can pass them to image_processor for postprocessing
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(image.height, image.width)])[0]

>>> # we refer to the demo notebooks for visualization (see "Resources" section in the MaskFormer docs)
>>> predicted_panoptic_map = result["segmentation"]
>>> list(predicted_panoptic_map.shape)
[480, 640]

< > 在 GitHub 上更新

Transformers

MaskFormer

概述

使用技巧

资源

MaskFormer 特定输出

class transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput

class transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput

MaskFormerConfig

class transformers.MaskFormerConfig

from_backbone_and_decoder_configs

MaskFormerImageProcessor

class transformers.MaskFormerImageProcessor

preprocess

编码输入

post_process_semantic_segmentation

post_process_instance_segmentation

post_process_panoptic_segmentation

MaskFormerFeatureExtractor

class transformers.MaskFormerFeatureExtractor

__call__

编码输入

post_process_semantic_segmentation

post_process_instance_segmentation

post_process_panoptic_segmentation

MaskFormerModel

class transformers.MaskFormerModel

forward

MaskFormerForInstanceSegmentation

class transformers.MaskFormerForInstanceSegmentation

forward

call