Transformers 文档
MaskFormer
并获得增强的文档体验
开始使用
MaskFormer
这是一个最近引入的模型，因此 API 尚未经过广泛测试。未来可能会有一些错误或轻微的破坏性更改来修复它。如果您发现任何异常，请提交 Github Issue。
概述
MaskFormer 模型在 Per-Pixel Classification is Not All You Need for Semantic Segmentation (作者：Bowen Cheng、Alexander G. Schwing、Alexander Kirillov) 中提出。MaskFormer 通过掩码分类范式来解决语义分割问题，而不是执行经典的像素级分类。
以下是论文的摘要
现代方法通常将语义分割表述为像素级分类任务，而实例级分割则通过另一种掩码分类来处理。我们的关键见解是：掩码分类足够通用，可以使用完全相同的模型、损失和训练程序，以统一的方式解决语义和实例级分割任务。基于这一观察，我们提出了 MaskFormer，这是一个简单的掩码分类模型，它预测一组二元掩码，每个掩码都与单个全局类别标签预测相关联。总的来说，所提出的基于掩码分类的方法简化了语义和全景分割任务的有效方法格局，并显示出出色的实证结果。特别是，我们观察到，当类别数量很大时，MaskFormer 的性能优于像素级分类基线。我们基于掩码分类的方法优于当前最先进的语义分割 (ADE20K 上为 55.6 mIoU) 和全景分割 (COCO 上为 52.7 PQ) 模型。
下图说明了 MaskFormer 的架构。取自原始论文。
此模型由 francesco 贡献。原始代码可以在 这里找到。
使用技巧
- MaskFormer 的 Transformer 解码器与 DETR 的解码器相同。在训练期间，DETR 的作者发现使用解码器中的辅助损失很有帮助，尤其是在帮助模型输出每个类别的正确对象数量方面。如果您将 MaskFormerConfig 的参数
use_auxiliary_loss设置为True，那么预测前馈神经网络和 Hungarian 损失将在每个解码器层之后添加（FFN 共享参数）。 - 如果您想在跨多个节点的分布式环境中训练模型，则应更新
modeling_maskformer.py的MaskFormerLoss类中的get_num_masks函数。在多个节点上训练时，应将其设置为所有节点的目标掩码的平均数量，这可以在原始实现 此处 中看到。 - 可以使用 MaskFormerImageProcessor 为模型准备图像以及模型的可选目标。
- 为了获得最终的分割结果，根据任务的不同，您可以调用 post_process_semantic_segmentation() 或 post_process_panoptic_segmentation()。这两个任务都可以使用 MaskFormerForInstanceSegmentation 输出解决，全景分割接受一个可选的
label_ids_to_fuse参数，用于融合目标对象（例如天空）的实例。
资源
- 所有说明 MaskFormer 推理以及在自定义数据上进行微调的 notebook 都可以在这里找到。
- 使用 Trainer 或 Accelerate 微调
MaskFormer的脚本可以在这里找到。
MaskFormer 特定输出
class transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput
< 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，形状为(batch_size, num_channels, height, width)) — 编码器模型（骨干网络）最后一级的最后隐藏状态（最终特征图）。 - pixel_decoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素解码器模型 (FPN) 最后一级的最后隐藏状态（最终特征图）。 - transformer_decoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — transformer 解码器模型最后一级的最后隐藏状态（最终特征图）。 - encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（每个阶段的输出一个，加上嵌入层的输出一个），形状为(batch_size, num_channels, height, width)。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。 - pixel_decoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（每个阶段的输出一个，加上嵌入层的输出一个），形状为(batch_size, num_channels, height, width)。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。 - transformer_decoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（每个阶段的输出一个，加上嵌入层的输出一个），形状为(batch_size, sequence_length, hidden_size)。transformer 解码器在每个阶段输出的隐藏状态（也称为特征图）。 - hidden_states
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 包含encoder_hidden_states、pixel_decoder_hidden_states和decoder_hidden_states的torch.FloatTensor元组 - attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。 来自 Detr 解码器在 attention softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
用于 MaskFormerModel 输出的类。 此类返回计算 logits 所需的所有隐藏状态。
class 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, 可选) — 当存在标签时返回的计算损失。 - class_queries_logits (
torch.FloatTensor) — 形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的提议类别。 请注意，由于我们加入了 null 类，因此需要+ 1。 - masks_queries_logits (
torch.FloatTensor) — 形状为(batch_size, num_queries, height, width)的张量，表示每个查询的提议 mask。 - encoder_last_hidden_state (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 编码器模型（backbone）最后一阶段的最后隐藏状态（最终特征图）。 - 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时返回) —torch.FloatTensor的元组（embedding 输出一个，每个阶段的输出一个），形状为(batch_size, num_channels, height, width)。 编码器模型在每个阶段输出处的隐藏状态（也称为特征图）。 - pixel_decoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（embedding 输出一个，每个阶段的输出一个），形状为(batch_size, num_channels, height, width)。 像素解码器模型在每个阶段输出处的隐藏状态（也称为特征图）。 - transformer_decoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（embedding 输出一个，每个阶段的输出一个），形状为(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元组。 - attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。 来自 Detr 解码器在 attention softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
用于 MaskFormerForInstanceSegmentation 输出的类。
此输出可以直接传递给 post_process_semantic_segmentation() 或 post_process_instance_segmentation() 或 post_process_panoptic_segmentation()，具体取决于任务。 有关使用详情，请参阅 [`~MaskFormerImageProcessor]。
MaskFormerConfig
class 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, 可选, 默认为 256) — mask 的特征大小，此值也将用于指定特征金字塔网络 (Feature Pyramid Network) 的特征大小。 - no_object_weight (
float, 可选, 默认为 0.1) — 应用于 null（无对象）类的权重。 - use_auxiliary_loss(
bool, 可选, 默认为False) — 如果为True，则MaskFormerForInstanceSegmentationOutput将包含使用来自每个解码器阶段的 logits 计算的辅助损失。 - backbone_config (
Dict, 可选) — 传递给 backbone 的配置，如果未设置，将使用对应于swin-base-patch4-window12-384的配置。 - backbone (
str, 可选) — 当backbone_config为None时要使用的 backbone 名称。 如果use_pretrained_backbone为True，这将从 timm 或 transformers 库加载相应的预训练权重。 如果use_pretrained_backbone为False，这将加载 backbone 的配置并使用它来初始化具有随机权重的 backbone。 - use_pretrained_backbone (
bool, 可选,False) — 是否对 backbone 使用预训练权重。 - use_timm_backbone (
bool, 可选,False) — 是否从 timm 库加载backbone。 如果为False，则从 transformers 库加载 backbone。 - backbone_kwargs (
dict, 可选) — 从检查点加载时要传递给 AutoBackbone 的关键字参数，例如{'out_indices': (0, 1, 2, 3)}。 如果设置了backbone_config，则无法指定。 - decoder_config (
Dict, 可选) — 传递给 transformer 解码器模型的配置，如果未设置，则将使用detr-resnet-50的基本配置。 - init_std (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - init_xavier_std (
float, 可选, 默认为 1) — 用于 HM Attention 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。
Raises
ValueError
ValueError— 如果选择的 backbone 模型类型不在["swin"]中，或者选择的 decoder 模型类型不在["detr"]中，则会引发此错误。
这是用于存储 MaskFormerModel 配置的配置类。它用于根据指定的参数实例化 MaskFormer 模型，定义模型架构。使用默认值实例化配置将产生类似于在 ADE20k-150 上训练的 MaskFormer facebook/maskformer-swin-base-ade 架构的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
目前，MaskFormer 仅支持 Swin Transformer 作为 backbone。
Examples
>>> 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
< source >( backbone_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → MaskFormerConfig
参数
- backbone_config (PretrainedConfig) — Backbone 配置。
- decoder_config (PretrainedConfig) — 要使用的 transformer 解码器配置。
Returns
配置对象的实例
从预训练的 backbone 模型配置和 DETR 模型配置实例化 MaskFormerConfig（或派生类）。
MaskFormerImageProcessor
class transformers.MaskFormerImageProcessor
< source >( do_resize: bool = True size: typing.Dict[str, int] = None size_divisor: int = 32 resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float]] = None image_std: typing.Union[float, typing.List[float]] = None ignore_index: typing.Optional[int] = None do_reduce_labels: bool = False num_labels: typing.Optional[int] = None **kwargs )
参数
- do_resize (
bool, 可选, 默认为True) — 是否将输入调整为特定size。 - size (
int, 可选, 默认为 800) — 将输入调整为给定大小。仅当do_resize设置为True时才有效。如果 size 是像(width, height)这样的序列，则输出大小将与此匹配。如果 size 是一个整数，则图像的较小边缘将与此数字匹配。即，如果height > width，则图像将被缩放到(size * height / width, size)。 - size_divisor (
int, 可选, 默认为 32) — 一些 backbone 需要图像可被某个数字整除。如果未传递，则默认为 Swin Transformer 中使用的值。 - resample (
int, 可选, 默认为Resampling.BILINEAR) — 可选的重采样过滤器。可以是PIL.Image.Resampling.NEAREST、PIL.Image.Resampling.BOX、PIL.Image.Resampling.BILINEAR、PIL.Image.Resampling.HAMMING、PIL.Image.Resampling.BICUBIC或PIL.Image.Resampling.LANCZOS之一。仅当do_resize设置为True时才有效。 - do_rescale (
bool, 可选, 默认为True) — 是否将输入重新缩放到特定scale。 - rescale_factor (
float, 可选, 默认为1/ 255) — 按给定的因子重新缩放输入。仅当do_rescale设置为True时才有效。 - do_normalize (
bool, 可选, 默认为True) — 是否使用均值和标准差对输入进行归一化。 - image_mean (
int, 可选, 默认为[0.485, 0.456, 0.406]) — 每个通道的均值序列，用于归一化图像。默认为 ImageNet 均值。 - image_std (
int, 可选, 默认为[0.229, 0.224, 0.225]) — 每个通道的标准差序列，用于归一化图像。默认为 ImageNet 标准差。 - ignore_index (
int, 可选) — 要分配给分割图中背景像素的标签。如果提供，则分割图中用 0（背景）表示的像素将替换为ignore_index。 - do_reduce_labels (
bool, 可选, 默认为False) — 是否将分割图的所有标签值减 1。通常用于数据集，其中 0 用于背景，而背景本身不包含在数据集的所有类别中（例如 ADE20k）。背景标签将被ignore_index替换。 - num_labels (
int, 可选) — 分割图中的标签数量。
构建 MaskFormer 图像处理器。图像处理器可用于为模型准备图像和可选目标。
此图像处理器继承自 BaseImageProcessor，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
preprocess
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None instance_id_to_semantic_id: typing.Optional[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] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )
encode_inputs
< source >( pixel_values_list: typing.List[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] = 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, 可选) — 相应的语义分割图，带有像素级注释。(
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对象。
Returns
具有以下字段的 BatchFeature
- pixel_values — 要馈送到模型的像素值。
- pixel_mask — 要馈送到模型的像素掩码（当
=True或pixel_mask在self.model_input_names中时）。 - mask_labels — 形状为
(labels, height, width)的可选掩码标签列表，用于馈送到模型（当提供annotations时）。 - class_labels — 形状为
(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
< source >( outputs target_sizes: typing.Optional[typing.List[typing.Tuple[int, int]]] = None ) → List[torch.Tensor]
参数
- outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。
- target_sizes (
List[Tuple[int, int]], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于每个预测请求的最终大小（高度，宽度）。如果保留为 None，则预测不会调整大小。
Returns
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]
参数
- 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，则分割图将作为二进制分割图的串联张量（每个检测到的实例一个）返回。
Returns
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]
参数
- 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]]) 对应于批次中每个预测的请求最终大小（高度，宽度）。如果留空，则不会调整预测大小。
Returns
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'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]] segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] = 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, 可选) — 相应的语义分割图，带有像素级注释。(
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对象。
Returns
具有以下字段的 BatchFeature
- pixel_values — 要馈送到模型的像素值。
- pixel_mask — 要馈送到模型的像素掩码（当
=True或pixel_mask在self.model_input_names中时）。 - mask_labels — 形状为
(labels, height, width)的可选掩码标签列表，用于馈送到模型（当提供annotations时）。 - class_labels — 形状为
(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
< source >( outputs target_sizes: typing.Optional[typing.List[typing.Tuple[int, int]]] = None ) → List[torch.Tensor]
参数
- outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。
- target_sizes (
List[Tuple[int, int]], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于每个预测的请求最终大小（高度，宽度）。如果留空，则不会调整预测大小。
Returns
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]
参数
- 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]]) 对应于每个预测的请求最终大小（高度，宽度）。如果留空，则不会调整预测大小。 - return_coco_annotation (
bool, 可选, 默认为False) — 如果设置为True，则以 COCO 游程编码 (RLE) 格式返回分割图。 - return_binary_maps (
bool, 可选, 默认为False) — 如果设置为True，则分割图将作为二值分割图的串联张量（每个检测到的实例一个）返回。
Returns
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]
参数
- 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，则预测将不会调整大小。
Returns
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
class transformers.MaskFormerModel
< source >( config: MaskFormerConfig )
参数
- config (MaskFormerConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 MaskFormer 模型输出原始隐藏状态，顶部没有任何特定的 head。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( pixel_values: Tensor pixel_mask: typing.Optional[torch.Tensor] = None output_hidden_states: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.maskformer.modeling_maskformer.MaskFormerModelOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 MaskFormerImageProcessor.call()。 - pixel_mask (形状为
(batch_size, height, width)的torch.LongTensor, 可选) — 避免对填充像素值执行注意力的掩码。在[0, 1]中选择的掩码值：- 1 代表真实像素（即，未掩码），
- 0 代表填充像素（即，已掩码）。
- output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - output_attentions (
bool, 可选) — 是否返回 Detr 解码器注意力层的注意力张量。 - return_dict (
bool, 可选) — 是否返回~MaskFormerModelOutput而不是普通元组。
Returns
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 (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 编码器模型（backbone）最后阶段的最后隐藏状态（最终特征图）。 - 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时返回) —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元组 - attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。来自 Detr 解码器的注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
MaskFormerModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
Examples
>>> 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
forward
< 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 (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 MaskFormerImageProcessor.call()。 - pixel_mask (形状为
(batch_size, height, width)的torch.LongTensor, 可选) — 避免对填充像素值执行注意力机制的掩码。掩码值在[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], optional) — 形状为(num_labels, height, width)的目标类别标签列表，用于馈送到模型。 它们标识mask_labels的标签，例如，如果class_labels[i][j]，则为mask_labels[i][j]的标签。
Returns
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, 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 (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 编码器模型（backbone）最后阶段的最后隐藏状态（最终特征图）。 - 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时返回) —torch.FloatTensor的元组（每个嵌入输出一个，每个阶段输出一个），形状为(batch_size, num_channels, height, width)。编码器模型在每个阶段输出端的隐藏状态（也称为特征图）。 - pixel_decoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组（每个嵌入输出一个，每个阶段输出一个），形状为(batch_size, num_channels, height, width)。像素解码器模型在每个阶段输出端的隐藏状态（也称为特征图）。 - transformer_decoder_hidden_states (
tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（embeddings 输出一个，每个阶段的输出一个），形状为(batch_size, sequence_length, hidden_size)。 变压器解码器在每个阶段输出端的隐藏状态。 - hidden_states
tuple(torch.FloatTensor), optional, 当传递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 之后，用于计算自注意力头中的加权平均值。
MaskFormerForInstanceSegmentation 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
Examples
语义分割示例
>>> 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]