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 进行推理以及在自定义数据上微调的笔记本都可以在 此处 找到。
- 使用 Trainer 或 Accelerate 微调
MaskFormer的脚本可以在 此处 找到。
MaskFormer 特定输出
类 transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput
< 源代码 >( encoder_last_hidden_state: Optional = None pixel_decoder_last_hidden_state: Optional = None transformer_decoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None hidden_states: Optional = None attentions: Optional = 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时返回) — 形状为(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 解码器每个阶段输出的隐藏状态（也称为特征图）。 - 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元组。 - attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每一层一个）。注意力 softmax 后 Detr 解码器的注意力权重，用于计算自注意力头中的加权平均值。
MaskFormerModel 输出的类。此类返回计算 logits 所需的所有隐藏状态。
类 transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput
< 源代码 >( loss: Optional = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_logits: FloatTensor = None encoder_last_hidden_state: Optional = None pixel_decoder_last_hidden_state: Optional = None transformer_decoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None hidden_states: Optional = None attentions: Optional = None )
参数
- loss (
torch.Tensor, 可选) — 计算出的损失，当存在标签时返回。 - 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) — 像素解码器模型（FPN）最后一级的最后一个隐藏状态（最终特征图）。 - transformer_decoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — Transformer 解码器模型最后一级的最后一个隐藏状态（最终特征图）。 - 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 解码器的隐藏状态。 - 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元组。 - attentions (
tuple(torch.FloatTensor)，可选，在传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。注意力 softmax 之后 Detr 解码器的注意力权重，用于计算自注意力头中的加权平均值。
MaskFormerForInstanceSegmentation 输出的类。
此输出可以直接传递给 post_process_semantic_segmentation() 或 post_process_instance_segmentation() 或 post_process_panoptic_segmentation()，具体取决于任务。请参阅 [`~MaskFormerImageProcessor]` 以了解有关用法的详细信息。
MaskFormerConfig
类 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: Optional = None decoder_config: Optional = 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: Optional = None backbone: Optional = None use_pretrained_backbone: bool = False use_timm_backbone: bool = False backbone_kwargs: Optional = None **kwargs )
参数
- mask_feature_size (
int, 可选, 默认为 256) — 掩码的特征尺寸，此值也将用于指定特征金字塔网络特征的尺寸。 - 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) — 初始化所有权重矩阵的截断正态初始化的标准差。 - init_xavier_std (
float, 可选, 默认为 1) — 用于 HM Attention map 模块中 Xavier 初始化增益的缩放因子。 - dice_weight (
float, 可选, 默认为 1.0) — Dice 损失的权重。 - cross_entropy_weight (
float, 可选, 默认为 1.0) — 交叉熵损失的权重。 - mask_weight (
float, 可选, 默认为 20.0) — Mask 损失的权重。 - 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.configfrom_backbone_and_decoder_configs
< 源代码 >( backbone_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → MaskFormerConfig
从预训练的主干模型配置和 DETR 模型配置实例化一个 MaskFormerConfig（或其派生类）。
MaskFormerImageProcessor
类 transformers.MaskFormerImageProcessor
< 源代码 >( 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, 可选) — 分割图中的标签数量。
构建 MaskFormer 图像处理器。图像处理器可用于为模型准备图像和可选目标。
此图像处理器继承自 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: 列表 segmentation_maps: 联合类型 = None instance_id_to_semantic_id: 联合类型 = None ignore_index: 可选 = None do_reduce_labels: 布尔值 = False return_tensors: 联合类型 = None input_data_format: 联合类型 = None ) → BatchFeature
参数
- pixel_values_list (
ImageInput列表) — 需要填充的图像（像素值）列表。每个图像应为形状为(通道数, 高度, 宽度)的张量。 - segmentation_maps (
ImageInput, 可选) — 具有像素级标注的相应语义分割图。(
布尔值, 可选, 默认为True): 是否将图像填充到批次中最大的图像并创建像素掩码。如果保留默认值，则将返回一个像素掩码，该掩码为：
- 对于真实像素（即未掩盖），值为 1，
- 对于填充像素（即掩盖），值为 0。
- instance_id_to_semantic_id (
int到int的字典列表或int到int的字典, 可选) — 对象实例 ID 和类别 ID 之间的映射。如果传递，则segmentation_maps将被视为实例分割图，其中每个像素表示一个实例 ID。可以作为包含全局/数据集级映射的单个字典或字典列表（每个图像一个）提供，以分别映射每个图像中的实例 ID。 - return_tensors (
字符串或 TensorType, 可选) — 如果设置，则返回张量而不是 NumPy 数组。如果设置为'pt'，则返回 PyTorchtorch.Tensor对象。
返回
具有以下字段的 BatchFeature
- pixel_values — 要馈送到模型的像素值。
- pixel_mask — 要馈送到模型的像素掩码（当
=True或pixel_mask在self.model_input_names中时）。 - mask_labels — 形状为
(标签数, 高度, 宽度)的掩码标签可选列表，要馈送到模型（当提供annotations时）。 - class_labels — 形状为
(标签数)的类别标签可选列表，要馈送到模型（当提供annotations时）。它们识别mask_labels的标签，例如，如果class_labels[i][j]，则mask_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: 可选 = None ) → torch.Tensor列表
参数
- outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。
- target_sizes (
(整数, 整数)元组列表, 可选) — 长度为 (批次大小) 的列表，其中每个列表项 ((整数, 整数)元组) 对应于每个预测的请求最终大小 (高度, 宽度)。如果保留为 None，则预测不会调整大小。
返回
torch.Tensor列表
长度为 批次大小 的列表，其中每个项目都是形状为 (高度, 宽度) 的语义分割图，对应于 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: Optional = None return_coco_annotation: Optional = False return_binary_maps: Optional = 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或List[List]如果 return_coco_annotation 设置为True，则为分割图的运行长度编码 (RLE)。 如果未在threshold以上找到掩码，则设置为None。 - segments_info — 包含有关每个段的其他信息的字典。
- id — 表示
segment_id的整数。 - label_id — 表示与
segment_id对应的标签/语义类别 ID 的整数。 - score — 具有
segment_id的段的预测分数。
- id — 表示
将 MaskFormerForInstanceSegmentationOutput 的输出转换为实例分割预测。 仅支持 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 (
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，则 segmentation 将调整为相应的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的段的预测分数。
- id — 表示
将 MaskFormerForInstanceSegmentationOutput 的输出转换为图像全景分割预测。仅支持 PyTorch。
MaskFormerFeatureExtractor
编码输入
< 源代码 >( pixel_values_list: 列表 segmentation_maps: 联合类型 = None instance_id_to_semantic_id: 联合类型 = None ignore_index: 可选 = None do_reduce_labels: 布尔值 = False return_tensors: 联合类型 = None input_data_format: 联合类型 = None ) → BatchFeature
参数
- pixel_values_list (
List[ImageInput]) — 需要填充的图像（像素值）列表。每个图像应该是一个形状为(通道数, 高度, 宽度)的张量。 - 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'，则返回 PyTorchtorch.Tensor对象。
返回
具有以下字段的 BatchFeature
- pixel_values — 要馈送到模型的像素值。
- pixel_mask — 要馈送到模型的像素掩码（当
=True或pixel_mask在self.model_input_names中时）。 - mask_labels — 形状为
(标签数, 高度, 宽度)的掩码标签可选列表，要馈送到模型（当提供annotations时）。 - class_labels — 形状为
(标签数)的类别标签可选列表，要馈送到模型（当提供annotations时）。它们识别mask_labels的标签，例如，如果class_labels[i][j]，则mask_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: 可选 = None ) → torch.Tensor列表
参数
- outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。
- target_sizes (
List[Tuple[int, int]], 可选) — 长度为 (批次大小) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于每个预测所需的最终大小 (高度, 宽度)。如果保留为 None，则预测不会调整大小。
返回
torch.Tensor列表
长度为 批次大小 的列表，其中每个项目都是形状为 (高度, 宽度) 的语义分割图，对应于 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: Optional = None return_coco_annotation: Optional = False return_binary_maps: Optional = False ) → List[Dict]
参数
- 掩码阈值 (
float, 可选, 默认为 0.5) — 将预测掩码转换为二值时使用的阈值。 - 重叠掩码区域阈值 (
float, 可选, 默认为 0.8) — 用于合并或丢弃每个二值实例掩码内的小型断开部分的重叠掩码区域阈值。 - 目标尺寸 (
List[Tuple], 可选) — 长度为 (批大小) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于每个预测所需的最终尺寸 (高度，宽度)。如果留空，则预测不会调整大小。 - 返回COCO注释 (
bool, 可选, 默认为False) — 如果设置为True，则以COCO运行长度编码 (RLE) 格式返回分割图。 - 返回二值图 (
bool, 可选, 默认为False) — 如果设置为True，则将分割图作为二值分割图 (每个检测到的实例一个) 的连接张量返回。
返回
List[Dict]
每个图像一个字典的列表，每个字典包含两个键
- segmentation — 形状为
(height, width)的张量，其中每个像素表示一个segment_id或List[List]如果 return_coco_annotation 设置为True，则为分割图的运行长度编码 (RLE)。 如果未在threshold以上找到掩码，则设置为None。 - segments_info — 包含有关每个段的其他信息的字典。
- id — 表示
segment_id的整数。 - label_id — 表示与
segment_id对应的标签/语义类别 ID 的整数。 - score — 具有
segment_id的段的预测分数。
- id — 表示
将 MaskFormerForInstanceSegmentationOutput 的输出转换为实例分割预测。 仅支持 PyTorch。
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: Optional = None target_sizes: Optional = None ) → List[Dict]
参数
- 输出 (
MaskFormerForInstanceSegmentationOutput) — 来自 MaskFormerForInstanceSegmentation 的输出。 - 阈值 (
float, 可选, 默认为 0.5) — 保留预测实例掩码的概率得分阈值。 - 掩码阈值 (
float, 可选, 默认为 0.5) — 将预测掩码转换为二值时使用的阈值。 - target_sizes (
List[Tuple], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于批次中每个预测的请求最终大小 (高度，宽度)。如果保留为 None，则不会调整预测的大小。
返回
List[Dict]
每个图像一个字典的列表，每个字典包含两个键
- segmentation — 形状为
(height, width)的张量，其中每个像素表示一个segment_id，如果在threshold以上未找到掩码，则设置为None。如果指定了target_sizes，则 segmentation 将调整为相应的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的段的预测分数。
- id — 表示
将 MaskFormerForInstanceSegmentationOutput 的输出转换为图像全景分割预测。仅支持 PyTorch。
MaskFormerModel
类 transformers.MaskFormerModel
< 源代码 >( config: MaskFormerConfig )
参数
- config (MaskFormerConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
不带任何特定头的 MaskFormer 模型，输出原始隐藏状态。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
正向传播
< 源代码 >( pixel_values: Tensor pixel_mask: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 MaskFormerImageProcessor.call()。 - 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, 可选) — 是否返回~MaskFormerModelOutput而不是普通元组。
返回
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)) — 变换器解码器模型最后一阶段的最终隐藏状态（最终特征图）。 - 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)。变换器解码器在每个阶段输出处的隐藏状态（也称为特征图）。 - 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元组。 - attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。Detr 解码器注意力softmax后的注意力权重，用于计算自注意力头中的加权平均值。
MaskFormerModel 的前向方法覆盖了 __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
正向传播
< 源代码 >( pixel_values: Tensor mask_labels: Optional = None class_labels: Optional = None pixel_mask: Optional = None output_auxiliary_logits: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 MaskFormerImageProcessor.call()。 - 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，可选) — 是否返回~MaskFormerModelOutput而不是普通元组。 - 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.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) — 形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的预测类别。请注意，+ 1是必要的，因为我们包含了空类。 - masks_queries_logits (
torch.FloatTensor) — 形状为(batch_size, num_queries, height, width)的张量，表示每个查询的预测掩码。 - 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)) — 变换器解码器模型最后一阶段的最终隐藏状态（最终特征图）。 - 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时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，一个用于每个阶段的输出）。每个阶段 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元组。 - attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。Detr 解码器注意力softmax后的注意力权重，用于计算自注意力头中的加权平均值。
The MaskFormerForInstanceSegmentation 前向方法，重写了 __call__ 特殊方法。
虽然前向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
语义分割示例
>>> 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.size[::-1]]
... )[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.size[::-1]])[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]