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),这是一种能够处理任何图像分割任务(全景、实例或语义)的新架构。其关键组件包括掩码注意力,它通过将交叉注意力限制在预测的掩码区域内来提取局部特征。除了将研究工作量减少至少三倍外,它在四个流行数据集上的表现显著优于最好的专门架构。最值得注意的是,Mask2Former在全景分割(COCO上的57.8 PQ)、实例分割(COCO上的50.1 AP)和语义分割(ADE20K上的57.7 mIoU)上设定了新的最先进水平。
![drawing](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/mask2former_architecture.jpg)
该模型由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的演示笔记本可以在这里找到。
- 用于微调
Mask2Former
的脚本,可以使用 Trainer 或 Accelerate,可以在 这里 找到。
如果您有兴趣提交资源以包含在此处,请随时打开一个Pull Request,我们将对其进行审查。 理想情况下,资源应展示一些新的内容,而不是重复现有的资源。
Mask2FormerConfig
类 transformers.Mask2FormerConfig
< source >( backbone_config: typing.Optional[typing.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: typing.List[int] = [4, 8, 16, 32] output_auxiliary_logits: bool = None backbone: typing.Optional[str] = None use_pretrained_backbone: bool = False use_timm_backbone: bool = False backbone_kwargs: typing.Optional[typing.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
, optional,False
) — 是否使用预训练的权重作为骨干网络。 - use_timm_backbone (
bool
, optional,False
) — 是否从timm库加载backbone
。如果为False
,则从transformers库加载backbone。 - backbone_kwargs (
dict
, optional) — 从检查点加载时传递给AutoBackbone的关键字参数 例如{'out_indices': (0, 1, 2, 3)}
。如果设置了backbone_config
,则不能指定此参数。 - feature_size (
int
, optional, 默认为 256) — 生成的特征图的特征(通道)数。 - mask_feature_size (
int
, optional, defaults to 256) — 掩码的特征大小,此值也将用于指定特征金字塔网络特征的大小。 - hidden_dim (
int
, optional, 默认为 256) — 编码器层的维度。 - encoder_feedforward_dim (
int
, optional, defaults to 1024) — 用作像素解码器的一部分的可变形detr编码器的前馈网络维度。 - encoder_layers (
int
, optional, defaults to 6) — 用作像素解码器一部分的可变形detr编码器中的层数。 - decoder_layers (
int
, optional, defaults to 10) — Transformer解码器中的层数。 - num_attention_heads (
int
, 可选, 默认为 8) — 每个注意力层的注意力头数量。 - dropout (
float
, optional, defaults to 0.1) — 嵌入层和编码器中所有全连接层的dropout概率。 - dim_feedforward (
int
, optional, 默认为 2048) — Transformer 解码器中前馈网络的特征维度。 - pre_norm (
bool
, optional, defaults toFalse
) — 是否在transformer解码器中使用预层归一化。 - enforce_input_projection (
bool
, 可选, 默认为False
) — 是否添加一个输入投影1x1卷积,即使输入通道和隐藏维度在Transformer解码器中相同 - common_stride (
int
, optional, 默认为 4) — 用于确定作为像素解码器一部分使用的FPN级别数量的参数。 - ignore_value (
int
, optional, 默认为 255) — 在训练期间要忽略的类别 id。 - num_queries (
int
, optional, defaults to 100) — 解码器的查询数量。 - no_object_weight (
int
, optional, 默认为 0.1) — 应用于空(无对象)类的权重。 - class_weight (
int
, 可选, 默认为 2.0) — 交叉熵损失的权重。 - mask_weight (
int
, optional, defaults to 5.0) — 掩码损失的权重。 - dice_weight (
int
, optional, defaults to 5.0) — 用于dice损失的权重。 - train_num_points (
str
或function
, 可选, 默认为 12544) — 用于在损失计算期间进行采样的点数。 - oversample_ratio (
float
, optional, defaults to 3.0) — 用于计算采样点数量的过采样参数 - importance_sample_ratio (
float
, optional, defaults to 0.75) — 通过重要性采样采样的点的比例。 - init_std (
float
, 可选, 默认值为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - init_xavier_std (
float
, optional, 默认为 1.0) — 用于 HM 注意力图模块中 Xavier 初始化增益的缩放因子。 - use_auxiliary_loss (
boolean``, *optional*, defaults to
True) -- 如果
True - feature_strides (
List[int]
, 可选, 默认为[4, 8, 16, 32]
) — 与从骨干网络生成的特征相对应的特征步幅。 - output_auxiliary_logits (
bool
, optional) — 模型是否应该输出其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
< source >( backbone_config: PretrainedConfig **kwargs ) → Mask2FormerConfig
从预训练的主干模型配置中实例化一个Mask2FormerConfig(或派生类)。
MaskFormer 特定输出
类 transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput
< source >( encoder_last_hidden_state: FloatTensor = None pixel_decoder_last_hidden_state: FloatTensor = None transformer_decoder_last_hidden_state: FloatTensor = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None pixel_decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None transformer_decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None transformer_decoder_intermediate_states: typing.Tuple[torch.FloatTensor] = None masks_queries_logits: typing.Tuple[torch.FloatTensor] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None )
参数
- encoder_last_hidden_state (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
, optional) — 编码器模型(骨干)最后阶段的最后隐藏状态(最终特征图)。当传递output_hidden_states=True
时返回。 - encoder_hidden_states (
tuple(torch.FloatTensor)
, 可选) —torch.FloatTensor
的元组(一个用于嵌入的输出 + 一个用于每个阶段的输出),形状为(batch_size, num_channels, height, width)
。编码器模型在每个阶段输出的隐藏状态(也称为特征图)。当传递output_hidden_states=True
时返回。 - pixel_decoder_last_hidden_state (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
, optional) — 像素解码器模型最后阶段的最后隐藏状态(最终特征图)。 - pixel_decoder_hidden_states (
tuple(torch.FloatTensor)
, , 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(一个用于嵌入的输出 + 一个用于每个阶段的输出),形状为(batch_size, num_channels, height, width)
。像素解码器模型在每个阶段输出的隐藏状态(也称为特征图)。当传递output_hidden_states=True
时返回。 - transformer_decoder_last_hidden_state (
tuple(torch.FloatTensor)
) — transformer解码器的最终输出(batch_size, sequence_length, hidden_size)
. - transformer_decoder_hidden_states (
tuple(torch.FloatTensor)
, 可选) —torch.FloatTensor
的元组(一个用于嵌入的输出 + 一个用于每个阶段的输出)的形状为(batch_size, sequence_length, hidden_size)
。每个阶段输出时 transformer 解码器的隐藏状态(也称为特征图)。当传递output_hidden_states=True
时返回。 - transformer_decoder_intermediate_states (
tuple(torch.FloatTensor)
of shape(num_queries, 1, hidden_size)
) — 中间解码器激活状态,即每个解码器层的输出,每个输出都经过了一个层归一化处理。 - masks_queries_logits (
tuple(torch.FloatTensor)
of shape(batch_size, num_queries, height, width)
) — 来自变压器解码器每一层的掩码预测。 - 注意力 (
tuple(tuple(torch.FloatTensor))
, 可选, 当传递output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tuple(tuple(torch.FloatTensor))
元组(每层一个)。来自变压器解码器的自注意力权重。
用于Mask2FormerModel输出的类。此类返回计算logits所需的所有隐藏状态。
类 transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_logits: typing.Optional[typing.List[typing.Dict[str, torch.FloatTensor]]] = None encoder_last_hidden_state: FloatTensor = None pixel_decoder_last_hidden_state: FloatTensor = None transformer_decoder_last_hidden_state: FloatTensor = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None pixel_decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None transformer_decoder_hidden_states: typing.Optional[torch.FloatTensor] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None )
参数
- loss (
torch.Tensor
, optional) — 计算得到的损失,当存在标签时返回。 - class_queries_logits (
torch.FloatTensor
) — 一个形状为(batch_size, num_queries, num_labels + 1)
的张量,表示每个查询的提议类别。注意+ 1
是必要的,因为我们包含了空类。 - masks_queries_logits (
torch.FloatTensor
) — 一个形状为(batch_size, num_queries, height, width)
的张量,表示每个查询的提议掩码。 - auxiliary_logits (
List[Dict(str, torch.FloatTensor)]
, optional) — 来自变压器解码器每一层的类别和掩码预测列表。 - encoder_last_hidden_state (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 编码器模型(骨干)最后阶段的最后隐藏状态(最终特征图)。 - 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_last_hidden_state (
torch.FloatTensor
of shape(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_last_hidden_state (
tuple(torch.FloatTensor)
) — transformer解码器的最终输出(batch_size, sequence_length, hidden_size)
. - transformer_decoder_hidden_states (
tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) —torch.FloatTensor
的元组(一个用于嵌入的输出 + 一个用于每个阶段的输出),形状为(batch_size, sequence_length, hidden_size)
。Transformer 解码器在每个阶段输出的隐藏状态(也称为特征图)。 - 注意力 (
tuple(tuple(torch.FloatTensor))
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) —tuple(torch.FloatTensor)
的元组(每一层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。来自 transformer 解码器的自注意力和交叉注意力权重。
用于输出Mask2FormerForUniversalSegmentationOutput
的类。
此输出可以直接传递给 post_process_semantic_segmentation() 或 post_process_instance_segmentation() 或 post_process_panoptic_segmentation() 以计算最终的分割图。请参阅 [`~Mask2FormerImageProcessor] 了解使用详情。
Mask2FormerModel
类 transformers.Mask2FormerModel
< source >( config: Mask2FormerConfig )
参数
- config (Mask2FormerConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
裸的Mask2Former模型输出原始隐藏状态,没有任何特定的头部。 该模型是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 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用AutoImageProcessor获取。详情请参见AutoImageProcessor.preprocess
. - pixel_mask (
torch.LongTensor
of shape(batch_size, height, width)
, optional) — Mask to avoid performing attention on padding pixel values. Mask values selected in[0, 1]
:- 1 for pixels that are real (i.e. not masked),
- 0 for pixels that are padding (i.e. masked).
- output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - output_attentions (
bool
, optional) — 是否返回Detr解码器注意力层的注意力张量。 - return_dict (
bool
, 可选) — 是否返回一个~Mask2FormerModelOutput
而不是一个普通的元组。
返回
transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput 或一个由
torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种
元素,具体取决于配置(Mask2FormerConfig)和输入。
- encoder_last_hidden_state (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
, 可选) — 编码器模型(骨干)最后阶段的最后隐藏状态(最终特征图)。当传递output_hidden_states=True
时返回。 - encoder_hidden_states (
tuple(torch.FloatTensor)
, 可选) — 由torch.FloatTensor
组成的元组(一个用于嵌入的输出 + 一个用于每个阶段的输出),形状为(batch_size, num_channels, height, width)
。编码器模型在每个阶段输出的隐藏状态(也称为特征图)。当传递output_hidden_states=True
时返回。 - pixel_decoder_last_hidden_state (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
, 可选) — 像素解码器模型最后阶段的最后隐藏状态(最终特征图)。 - pixel_decoder_hidden_states (
tuple(torch.FloatTensor)
, , 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 由torch.FloatTensor
组成的元组(一个用于嵌入的输出 + 一个用于每个阶段的输出),形状为(batch_size, num_channels, height, width)
。像素解码器模型在每个阶段输出的隐藏状态(也称为特征图)。当传递output_hidden_states=True
时返回。 - transformer_decoder_last_hidden_state (
tuple(torch.FloatTensor)
) — 变压器解码器的最终输出(batch_size, sequence_length, hidden_size)
。 - transformer_decoder_hidden_states (
tuple(torch.FloatTensor)
, 可选) — 由torch.FloatTensor
组成的元组(一个用于嵌入的输出 + 一个用于每个阶段的输出),形状为(batch_size, sequence_length, hidden_size)
。变压器解码器在每个阶段输出的隐藏状态(也称为特征图)。当传递output_hidden_states=True
时返回。 - transformer_decoder_intermediate_states (
tuple(torch.FloatTensor)
形状为(num_queries, 1, hidden_size)
) — 中间解码器激活,即每个解码器层的输出,每个输出都经过了一个 layernorm。 - masks_queries_logits (
tuple(torch.FloatTensor)
形状为(batch_size, num_queries, height, width)
) 变压器解码器中每一层的掩码预测。 - attentions (
tuple(tuple(torch.FloatTensor))
, 可选, 当传递output_attentions=True
时返回) — 由tuple(torch.FloatTensor)
组成的元组(每个层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。变压器解码器的自注意力权重。
Mask2FormerModelOutput
Mask2FormerModel 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoImageProcessor, Mask2FormerModel
>>> # load image
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> # load image preprocessor and Mask2FormerModel trained on COCO instance segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> model = Mask2FormerModel.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> inputs = image_processor(image, return_tensors="pt")
>>> # forward pass
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> # model outputs last hidden states of shape (batch_size, num_queries, hidden_size)
>>> print(outputs.transformer_decoder_last_hidden_state.shape)
torch.Size([1, 100, 256])
Mask2FormerForUniversalSegmentation
类 transformers.Mask2FormerForUniversalSegmentation
< source >( config: Mask2FormerConfig )
参数
- config (Mask2FormerConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
Mask2Former模型,顶部带有用于实例/语义/全景分割的头。 该模型是PyTorch torch.nn.Module的子类。将其用作常规的PyTorch模块,并参考PyTorch文档以获取与一般使用和行为相关的所有事项。
前进
< source >( pixel_values: Tensor mask_labels: typing.Optional[typing.List[torch.Tensor]] = None class_labels: typing.Optional[typing.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 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用AutoImageProcessor获取。详情请参见AutoImageProcessor.preprocess
. - pixel_mask (
torch.LongTensor
of shape(batch_size, height, width)
, optional) — Mask to avoid performing attention on padding pixel values. Mask values selected in[0, 1]
:- 1 for pixels that are real (i.e. not masked),
- 0 for pixels that are padding (i.e. masked).
- output_hidden_states (
bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - output_attentions (
bool
, optional) — 是否返回Detr解码器注意力层的注意力张量。 - return_dict (
bool
, 可选) — 是否返回一个~Mask2FormerModelOutput
而不是一个普通的元组。 - mask_labels (
List[torch.Tensor]
, 可选) — 形状为(num_labels, height, width)
的掩码标签列表,用于输入模型 - class_labels (
List[torch.LongTensor]
, optional) — 要输入模型的形状为(num_labels, height, width)
的目标类别标签列表。它们标识了mask_labels
的标签,例如如果class_labels[i][j]
则标识mask_labels[i][j]
的标签。
返回
transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput 或一个由
torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含各种
元素,具体取决于配置(Mask2FormerConfig)和输入。
- loss (
torch.Tensor
, 可选) — 计算出的损失,当存在标签时返回。 - class_queries_logits (
torch.FloatTensor
) — 一个形状为(batch_size, num_queries, num_labels + 1)
的张量,表示每个 查询的提议类别。注意+ 1
是必要的,因为我们包含了空类。 - masks_queries_logits (
torch.FloatTensor
) — 一个形状为(batch_size, num_queries, height, width)
的张量,表示每个 查询的提议掩码。 - auxiliary_logits (
List[Dict(str, torch.FloatTensor)]
, 可选) — 来自变压器解码器每一层的类别和掩码预测列表。 - encoder_last_hidden_state (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 编码器模型(骨干)最后阶段的最后隐藏状态(最终特征图)。 - 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_last_hidden_state (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 像素解码器模型最后阶段的最后隐藏状态(最终特征图)。 - pixel_decoder_hidden_states (
tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 由torch.FloatTensor
组成的元组(一个用于嵌入的输出 + 一个用于每个阶段的输出),形状为(batch_size, num_channels, height, width)
。像素解码器模型在每个阶段输出的隐藏状态(也称为特征图)。 - transformer_decoder_last_hidden_state (
tuple(torch.FloatTensor)
) — 变压器解码器的最终输出(batch_size, sequence_length, hidden_size)
。 - transformer_decoder_hidden_states (
tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 由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)
。来自变压器解码器的自注意力和交叉注意力权重。
Mask2FormerUniversalSegmentationOutput
Mask2FormerForUniversalSegmentation 的前向方法,重写了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但之后应该调用Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
实例分割示例:
>>> from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation
>>> from PIL import Image
>>> import requests
>>> import torch
>>> # Load Mask2Former trained on COCO instance segmentation dataset
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/mask2former-swin-small-coco-instance")
>>> model = Mask2FormerForUniversalSegmentation.from_pretrained(
... "facebook/mask2former-swin-small-coco-instance"
... )
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> # Model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits
>>> # Perform post-processing to get instance segmentation map
>>> pred_instance_map = image_processor.post_process_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
类 transformers.Mask2FormerImageProcessor
< source >( do_resize: bool = True size: typing.Dict[str, int] = None size_divisor: int = 32 resample: Resampling =
参数
- 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
, optional, 默认为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
, optional, defaults toTrue
) — 是否使用均值和标准差对输入进行归一化。 - image_mean (
int
, 可选, 默认为[0.485, 0.456, 0.406]
) — 每个通道的均值序列,用于图像归一化。默认为ImageNet均值。 - image_std (
int
, 可选, 默认为[0.229, 0.224, 0.225]
) — 每个通道的标准差序列,用于归一化图像时使用。默认为ImageNet的标准差。 - ignore_index (
int
, optional) — 在分割图中分配给背景像素的标签。如果提供了,分割图中用0(背景)表示的像素将被替换为ignore_index
。 - do_reduce_labels (
bool
, 可选, 默认为False
) — 是否将分割图的所有标签值减1。通常用于数据集中0用于背景,而背景本身不包含在数据集的所有类别中(例如ADE20k)。 背景标签将被ignore_index
替换。 - num_labels (
int
, optional) — 分割图中的标签数量。
构建一个Mask2Former图像处理器。该图像处理器可用于为模型准备图像和可选目标。
此图像处理器继承自BaseImageProcessor,其中包含了大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。
预处理
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), typing.List[ForwardRef('PIL.Image.Image')], typing.List[numpy.ndarray], typing.List[ForwardRef('torch.Tensor')]] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), typing.List[ForwardRef('PIL.Image.Image')], typing.List[numpy.ndarray], typing.List[ForwardRef('torch.Tensor')], NoneType] = None instance_id_to_semantic_id: typing.Optional[typing.Dict[int, int]] = None do_resize: typing.Optional[bool] = None size: typing.Optional[typing.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, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.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] =
encode_inputs
< source >( pixel_values_list: typing.List[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), typing.List[ForwardRef('PIL.Image.Image')], typing.List[numpy.ndarray], typing.List[ForwardRef('torch.Tensor')]]] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), typing.List[ForwardRef('PIL.Image.Image')], typing.List[numpy.ndarray], typing.List[ForwardRef('torch.Tensor')]] = None instance_id_to_semantic_id: typing.Union[typing.List[typing.Dict[int, int]], typing.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
, optional) — The corresponding semantic segmentation maps with the pixel-wise annotations.(
bool
, 可选, 默认为True
): 是否将图像填充到批次中最大的图像并创建像素掩码。如果保留默认设置,将返回一个像素掩码,该掩码是:
- 1 for pixels that are real (i.e. not masked),
- 0 for pixels that are padding (i.e. masked).
- instance_id_to_semantic_id (
List[Dict[int, int]]
或Dict[int, int]
, 可选) — 对象实例ID和类别ID之间的映射。如果传递了此参数,segmentation_maps
将被视为实例分割图,其中每个像素代表一个实例ID。可以作为单个字典提供全局/数据集级别的映射,也可以作为字典列表(每个图像一个)提供,以分别映射每个图像中的实例ID。 - return_tensors (
str
or TensorType, 可选) — 如果设置,将返回张量而不是NumPy数组。如果设置为'pt'
,返回PyTorchtorch.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[typing.List[typing.Tuple[int, int]]] = None ) → List[torch.Tensor]
参数
- 输出 (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[typing.List[typing.Tuple[int, int]]] = None return_coco_annotation: typing.Optional[bool] = False return_binary_maps: typing.Optional[bool] = False ) → List[Dict]
参数
- 输出 (Mask2FormerForUniversalSegmentation) — 模型的原始输出。
- threshold (
float
, optional, defaults to 0.5) — 用于保留预测实例掩码的概率分数阈值。 - mask_threshold (
float
, optional, defaults to 0.5) — 用于将预测的掩码转换为二进制值的阈值。 - overlap_mask_area_threshold (
float
, optional, 默认为 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
的段的预测分数。
- 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[typing.Set[int]] = None target_sizes: typing.Optional[typing.List[typing.Tuple[int, int]]] = None ) → List[Dict]
参数
- 输出 (
Mask2FormerForUniversalSegmentationOutput
) — 来自 Mask2FormerForUniversalSegmentation 的输出. - threshold (
float
, optional, defaults to 0.5) — 用于保留预测实例掩码的概率分数阈值。 - mask_threshold (
float
, optional, defaults to 0.5) — 将预测的掩码转换为二进制值时使用的阈值。 - overlap_mask_area_threshold (
float
, optional, defaults to 0.8) — 用于合并或丢弃每个二进制实例掩码内小断开部分的重叠掩码区域阈值。 - label_ids_to_fuse (
Set[int]
, 可选) — 此状态中的标签将把它们的所有实例融合在一起。例如,我们可以说 一张图片中只能有一个天空,但可以有几个人,所以天空的标签ID会在那个 集合中,但人的标签ID不会在其中。 - target_sizes (
List[Tuple]
, optional) — 长度为 (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
的段的预测分数。
- id — 一个表示
将Mask2FormerForUniversalSegmentationOutput
的输出转换为图像全景分割预测。仅支持PyTorch。