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的架构。取自原始论文。
![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/maskformer_architecture.png)
使用提示
- MaskFormer的Transformer解码器与DETR的解码器相同。在训练过程中,DETR的作者确实发现使用辅助损失在解码器中是有帮助的,特别是帮助模型输出每个类别的正确数量的对象。如果你将MaskFormerConfig的参数
use_auxiliary_loss
设置为True
,那么在每个解码器层之后会添加预测前馈神经网络和匈牙利损失(FFNs共享参数)。 - 如果你想在多个节点的分布式环境中训练模型,那么应该更新
modeling_maskformer.py
文件中MaskFormerLoss
类中的get_num_masks
函数。在多个节点上训练时,这应该设置为所有节点上目标掩码的平均数量,如原始实现中所示这里。 - 可以使用MaskFormerImageProcessor来为模型准备图像以及模型的可选目标。
- 要获得最终的分割结果,根据任务的不同,你可以调用post_process_semantic_segmentation()或post_process_panoptic_segmentation()。这两个任务都可以使用MaskFormerForInstanceSegmentation的输出解决,全景分割接受一个可选的
label_ids_to_fuse
参数,用于将目标对象(例如天空)的实例融合在一起。
资源
- 所有展示推理以及使用MaskFormer对自定义数据进行微调的笔记本都可以在这里找到。
- 用于微调
MaskFormer
的脚本,可以使用 Trainer 或 Accelerate,可以在 这里 找到。
MaskFormer 特定输出
类 transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput
< source >( 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[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 hidden_states: typing.Optional[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)
) — 编码器模型(骨干)最后阶段的最后隐藏状态(最终特征图)。 - pixel_decoder_last_hidden_state (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素解码器模型最后阶段的最后隐藏状态(最终特征图)。 - transformer_decoder_last_hidden_state (
torch.FloatTensor
of shape(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
元组 - 注意力 (
tuple(torch.FloatTensor)
, 可选, 当output_attentions=True
传递或当config.output_attentions=True
时返回) —torch.FloatTensor
的元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。来自 Detr 解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
用于MaskFormerModel输出的类。该类返回计算logits所需的所有隐藏状态。
类 transformers.models.maskformer.modeling_maskformer.MaskFormerForInstanceSegmentationOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_logits: 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[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 hidden_states: typing.Optional[typing.Tuple[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)
的张量,表示每个查询的提议掩码。 - encoder_last_hidden_state (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 编码器模型(骨干)最后阶段的最后隐藏状态(最终特征图)。 - pixel_decoder_last_hidden_state (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素解码器模型最后阶段的最后隐藏状态(最终特征图)。 - transformer_decoder_last_hidden_state (
torch.FloatTensor
of shape(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
元组. - 注意力 (
tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) —torch.FloatTensor
的元组(每层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。来自 Detr 解码器的注意力权重,经过注意力 softmax 后,用于计算自注意力头中的加权平均值。
用于MaskFormerForInstanceSegmentation输出的类。
此输出可以直接传递给 post_process_semantic_segmentation() 或 post_process_instance_segmentation() 或 post_process_panoptic_segmentation(),具体取决于任务。请参阅 [`~MaskFormerImageProcessor] 了解使用详情。
MaskFormerConfig
类 transformers.MaskFormerConfig
< source >( 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[typing.Dict] = None decoder_config: typing.Optional[typing.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[typing.Dict] = None **kwargs )
参数
- mask_feature_size (
int
, optional, defaults to 256) — 掩码的特征大小,此值也将用于指定特征金字塔网络特征的大小。 - no_object_weight (
float
, optional, 默认为 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
, optional,False
) — 是否使用预训练的权重作为骨干网络。 - use_timm_backbone (
bool
, optional,False
) — 是否从timm库加载backbone
。如果为False
,则从transformers库加载backbone。 - backbone_kwargs (
dict
, 可选) — 从检查点加载时传递给AutoBackbone的关键字参数 例如{'out_indices': (0, 1, 2, 3)}
。如果设置了backbone_config
,则不能指定此参数。 - decoder_config (
Dict
, 可选) — 传递给变压器解码器模型的配置,如果未设置,将使用detr-resnet-50
的基本配置。 - init_std (
float
, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - init_xavier_std (
float
, optional, defaults to 1) — 用于HM注意力图模块中Xavier初始化增益的缩放因子。 - dice_weight (
float
, optional, defaults to 1.0) — dice损失的权重。 - cross_entropy_weight (
float
, optional, defaults to 1.0) — 交叉熵损失的权重。 - mask_weight (
float
, optional, defaults to 20.0) — 掩码损失的权重。 - output_auxiliary_logits (
bool
, optional) — 模型是否应该输出其auxiliary_logits
.
引发
ValueError
ValueError
— 如果选择的主干模型类型不在["swin"]
中或选择的解码器模型类型不在["detr"]
中,则会引发此错误
这是用于存储MaskFormerModel配置的配置类。它用于根据指定的参数实例化一个MaskFormer模型,定义模型架构。使用默认值实例化配置将产生与在ADE20k-150上训练的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
< source >( backbone_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → MaskFormerConfig
参数
- backbone_config (PretrainedConfig) — 骨干配置.
- decoder_config (PretrainedConfig) — 要使用的变压器解码器配置。
配置对象的一个实例
从预训练的主干模型配置和DETR模型配置实例化一个MaskFormerConfig(或派生类)。
MaskFormerImageProcessor
类 transformers.MaskFormerImageProcessor
< 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
, optional, 默认为 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
, 可选) — 在分割图中分配给背景像素的标签。如果提供,分割图中用0(背景)表示的像素将被替换为ignore_index
. - do_reduce_labels (
bool
, 可选, 默认为False
) — 是否将分割图的所有标签值减1。通常用于数据集中0用于背景,而背景本身不包含在数据集的所有类别中(例如 ADE20k)。 背景标签将被替换为ignore_index
. - num_labels (
int
, optional) — 分割图中的标签数量。
构建一个MaskFormer图像处理器。该图像处理器可用于为模型准备图像和可选目标。
此图像处理器继承自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
或 TensorType, 可选) — 如果设置,将返回张量而不是NumPy数组。如果设置为'pt'
,则返回PyTorchtorch.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
< source >( outputs target_sizes: typing.Optional[typing.List[typing.Tuple[int, int]]] = None ) → List[torch.Tensor]
参数
- 输出 (MaskFormerForInstanceSegmentation) — 模型的原始输出。
- 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。
将MaskFormerForInstanceSegmentation的输出转换为语义分割图。仅支持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]
参数
- 输出 (MaskFormerForInstanceSegmentation) — 模型的原始输出。
- 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) — 用于合并或丢弃每个二进制实例掩码中小的不连接部分的重叠掩码区域阈值。 - target_sizes (
List[Tuple]
, optional) — 长度为 (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 — 一个表示
将MaskFormerForInstanceSegmentationOutput
的输出转换为实例分割预测。仅支持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]
参数
- 输出 (
MaskFormerForInstanceSegmentationOutput
) — 来自 MaskFormerForInstanceSegmentation 的输出. - 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]
, 可选) — 长度为 (batch_size) 的列表,其中每个列表项 (Tuple[int, int]]
) 对应于批次中每个预测的请求 最终大小(高度,宽度)。如果留空,预测将不会 调整大小。
返回
List[Dict]
一个字典列表,每个图像一个字典,每个字典包含两个键:
- segmentation — 一个形状为
(height, width)
的张量,其中每个像素代表一个segment_id
,如果在threshold
以上没有找到掩码,则设置为None
。如果指定了target_sizes
,则分割将调整为相应的target_sizes
条目。 - segments_info — 一个包含每个段附加信息的字典。
- id — 一个表示
segment_id
的整数。 - label_id — 一个表示与
segment_id
对应的标签/语义类 ID 的整数。 - was_fused — 一个布尔值,如果
label_id
在label_ids_to_fuse
中,则为True
,否则为False
。相同类/标签的多个实例被融合并分配一个segment_id
。 - score — 具有
segment_id
的段的预测分数。
- id — 一个表示
将MaskFormerForInstanceSegmentationOutput
的输出转换为图像全景分割预测。仅支持PyTorch。
MaskFormerFeatureExtractor
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, optional) — 如果设置,将返回张量而不是NumPy数组。如果设置为'pt'
,则返回PyTorchtorch.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
< source >( outputs target_sizes: typing.Optional[typing.List[typing.Tuple[int, int]]] = None ) → List[torch.Tensor]
参数
- 输出 (MaskFormerForInstanceSegmentation) — 模型的原始输出。
- target_sizes (
List[Tuple[int, int]]
, optional) — 长度为 (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
< 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]
参数
- 输出 (MaskFormerForInstanceSegmentation) — 模型的原始输出。
- 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]
, optional) — 长度为 (batch_size) 的列表,其中每个列表项 (Tuple[int, int]]
) 对应于每个预测的请求最终大小(高度,宽度)。如果留空,预测将不会调整大小。 - return_coco_annotation (
bool
, 可选, 默认为False
) — 如果设置为True
,分割图将以 COCO 运行长度编码 (RLE) 格式返回。 - return_binary_maps (
bool
, 可选, 默认为False
) — 如果设置为True
,分割图将作为二进制分割图的连接张量返回 (每个检测到的实例一个)。
返回
List[Dict]
一个字典列表,每个图像一个,每个字典包含两个键:
- segmentation — 一个形状为
(height, width)
的张量,其中每个像素代表一个segment_id
,或者如果 return_coco_annotation 设置为True
,则为分割图的List[List]
运行长度编码(RLE),或者如果 return_binary_maps 设置为True
,则为形状为(num_instances, height, width)
的张量。如果在threshold
以上没有找到掩码,则设置为None
。 - segments_info — 一个包含每个段附加信息的字典。
- id — 一个表示
segment_id
的整数。 - label_id — 一个表示与
segment_id
对应的标签/语义类 ID 的整数。 - score — 具有
segment_id
的段的预测分数。
- id — 一个表示
将MaskFormerForInstanceSegmentationOutput
的输出转换为实例分割预测。仅支持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]
参数
- 输出 (
MaskFormerForInstanceSegmentationOutput
) — 来自 MaskFormerForInstanceSegmentation 的输出. - threshold (
float
, optional, defaults to 0.5) — 用于保留预测实例掩码的概率分数阈值。 - mask_threshold (
float
, optional, defaults to 0.5) — 将预测的掩码转换为二进制值时使用的阈值。 - overlap_mask_area_threshold (
float
, optional, 默认为 0.8) — 用于合并或丢弃每个二进制实例掩码中小的不连接部分的重叠掩码区域阈值。 - label_ids_to_fuse (
Set[int]
, 可选) — 此状态中的标签将使其所有实例融合在一起。例如,我们可以说 一张图片中只能有一个天空,但可以有几个人,所以天空的标签ID会在该集合中, 但人的标签ID不会在其中。 - target_sizes (
List[Tuple]
, optional) — 长度为 (batch_size) 的列表,其中每个列表项 (Tuple[int, int]]
) 对应于批次中每个预测的请求 最终大小(高度,宽度)。如果留空,预测将不会 调整大小。
返回
List[Dict]
一个字典列表,每个图像一个字典,每个字典包含两个键:
- segmentation — 一个形状为
(height, width)
的张量,其中每个像素代表一个segment_id
,如果在threshold
以上没有找到掩码,则设置为None
。如果指定了target_sizes
,则分割将调整为相应的target_sizes
条目。 - segments_info — 一个包含每个段附加信息的字典。
- id — 一个表示
segment_id
的整数。 - label_id — 一个表示与
segment_id
对应的标签/语义类 ID 的整数。 - was_fused — 一个布尔值,如果
label_id
在label_ids_to_fuse
中,则为True
,否则为False
。相同类/标签的多个实例被融合并分配一个segment_id
。 - score — 具有
segment_id
的段的预测分数。
- id — 一个表示
将MaskFormerForInstanceSegmentationOutput
的输出转换为图像全景分割预测。仅支持PyTorch。
MaskFormerModel
类 transformers.MaskFormerModel
< source >( config: MaskFormerConfig )
参数
- config (MaskFormerConfig) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
裸的MaskFormer模型输出原始隐藏状态,没有任何特定的头部。 该模型是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.maskformer.modeling_maskformer.MaskFormerModelOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用AutoImageProcessor获取。详情请参见 MaskFormerImageProcessor.call(). - 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
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - output_attentions (
bool
, optional) — 是否返回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
时返回) — 由torch.FloatTensor
组成的元组,包含encoder_hidden_states
,pixel_decoder_hidden_states
和decoder_hidden_states
- 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
前进
< 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_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.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用AutoImageProcessor获取。详情请参见 MaskFormerImageProcessor.call(). - 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
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - output_attentions (
bool
, optional) — 是否返回Detr解码器注意力层的注意力张量。 - return_dict (
bool
, optional) — 是否返回一个~MaskFormerModelOutput
而不是一个普通的元组。 - mask_labels (
List[torch.Tensor]
, optional) — 形状为(num_labels, height, width)
的掩码标签列表,用于输入模型 - class_labels (
List[torch.LongTensor]
, optional) — 要输入模型的形状为(num_labels, height, width)
的目标类别标签列表。它们标识了mask_labels
的标签,例如mask_labels[i][j]
的标签如果class_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
时返回) — 由torch.FloatTensor
组成的元组(一个用于嵌入的输出 + 一个用于每个阶段的输出),形状为(batch_size, sequence_length, hidden_size)
。变压器解码器在每个阶段输出的隐藏状态。 - hidden_states
tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 由torch.FloatTensor
组成的元组,包含encoder_hidden_states
,pixel_decoder_hidden_states
和decoder_hidden_states
。 - attentions (
tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或当config.output_attentions=True
时返回) — 由torch.FloatTensor
组成的元组(每个层一个),形状为(batch_size, num_heads, sequence_length, sequence_length)
。Detr解码器在注意力softmax后的注意力权重,用于计算 自注意力头中的加权平均值。
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.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]