OneFormer
概述
OneFormer 模型由 Jitesh Jain、Jiachen Li、MangTik Chiu、Ali Hassani、Nikita Orlov、Humphrey Shi 在 OneFormer: One Transformer to Rule Universal Image Segmentation 中提出。 OneFormer 是一个通用的图像分割框架，可以在单个全景数据集上进行训练，以执行语义分割、实例分割和全景分割任务。 OneFormer 使用任务令牌来调节模型关注的任务，使架构在训练时具有任务引导性，在推理时具有任务动态性。
该论文的摘要如下：
通用图像分割并非新概念。过去几十年中，统一图像分割的尝试包括场景解析、全景分割，以及最近出现的新型全景架构。然而，这些全景架构并没有真正统一图像分割，因为它们需要在语义分割、实例分割或全景分割上分别进行训练，才能获得最佳性能。理想情况下，一个真正通用的框架应该只需训练一次，并在所有三个图像分割任务中都达到 SOTA 性能。为此，我们提出了 OneFormer，这是一个通用的图像分割框架，它通过多任务一次性训练设计来统一分割。我们首先提出了一种任务条件联合训练策略，该策略支持在单个多任务训练过程中，对每个领域（语义分割、实例分割和全景分割）的真值进行训练。其次，我们引入了一个任务令牌来调节我们的模型，使其专注于手头的任务，使我们的模型具有任务动态性，以支持多任务训练和推理。第三，我们建议在训练期间使用查询-文本对比损失，以建立更好的任务间和类间区分。值得注意的是，我们单个 OneFormer 模型在 ADE20k、CityScapes 和 COCO 的所有三个分割任务上，都优于专门的 Mask2Former 模型，尽管后者在每个任务上都进行了单独训练，资源是前者的三倍。借助新的 ConvNeXt 和 DiNAT 主干网络，我们观察到性能得到了更大的提升。我们相信 OneFormer 是朝着使图像分割更通用和更易访问迈出的重要一步。
下图说明了 OneFormer 的架构。取自原始论文。
此模型由 Jitesh Jain 贡献。 原始代码可以在这里找到。
使用提示
- OneFormer 在推理期间需要两个输入：图像和任务令牌。
- 在训练期间，OneFormer 仅使用全景注释。
- 如果要在跨多个节点的分布式环境中训练模型，则应更新
modeling_oneformer.py的OneFormerLoss类中的get_num_masks函数。在多个节点上训练时，应将其设置为所有节点的目标掩码的平均数量，这可以在原始实现 这里 中看到。 - 可以使用 OneFormerProcessor 为模型准备输入图像和任务输入，以及为模型准备可选目标。OneFormerProcessor 将 OneFormerImageProcessor 和 CLIPTokenizer 包装到单个实例中，以同时准备图像和编码任务输入。
- 要获得最终分割结果，可以根据任务调用 post_process_semantic_segmentation() 或 post_process_instance_segmentation() 或 post_process_panoptic_segmentation()。所有三个任务都可以使用 OneFormerForUniversalSegmentation 输出解决，全景分割接受可选的
label_ids_to_fuse参数，将目标对象（例如天空）的实例融合在一起。
资源
以下是官方 Hugging Face 和社区（🌎 表示）资源列表，可帮助您开始使用 OneFormer。
- 有关推理 + 在自定义数据上进行微调的演示 notebook 可以在此处找到。
如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审核。 理想情况下，该资源应展示一些新的内容，而不是重复现有资源。
class transformers.models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput
< source >( loss: Optional = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_predictions: List = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None transformer_decoder_object_queries: FloatTensor = None transformer_decoder_contrastive_queries: Optional = None transformer_decoder_mask_predictions: FloatTensor = None transformer_decoder_class_predictions: FloatTensor = None transformer_decoder_auxiliary_predictions: Optional = None text_queries: Optional = None task_token: FloatTensor = None attentions: Optional = None )
Parameters
- loss (
torch.Tensor, optional) — The computed loss, returned when labels are present. - class_queries_logits (
torch.FloatTensor) — A tensor of shape(batch_size, num_queries, num_labels + 1)representing the proposed classes for each query. Note the+ 1is needed because we incorporate the null class. - masks_queries_logits (
torch.FloatTensor) — 形状为(batch_size, num_queries, height, width)的张量，表示每个查询的提议掩码。 - auxiliary_predictions (Dict 的列表，键值对为
str, torch.FloatTensor，可选) — 来自 Transformer 解码器每一层的类别和掩码预测列表。 - encoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（嵌入输出一个，每个阶段输出一个）。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。 - pixel_decoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（嵌入输出一个，每个阶段输出一个）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。 - transformer_decoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（嵌入输出一个，每个阶段输出一个）。Transformer 解码器在每个阶段输出的隐藏状态（也称为特征图）。 - transformer_decoder_object_queries (形状为
(batch_size, num_queries, hidden_dim)的torch.FloatTensor) — 来自 Transformer 解码器最后一层的输出对象查询。 - transformer_decoder_contrastive_queries (形状为
(batch_size, num_queries, hidden_dim)的torch.FloatTensor) — 来自 Transformer 解码器的对比查询。 - transformer_decoder_mask_predictions (形状为
(batch_size, num_queries, height, width)的torch.FloatTensor) — 来自 Transformer 解码器最后一层的掩码预测。 - transformer_decoder_class_predictions (形状为
(batch_size, num_queries, num_classes+1)的torch.FloatTensor) — 来自 Transformer 解码器最后一层的类别预测。 - transformer_decoder_auxiliary_predictions (Dict 的列表，键值对为
str, torch.FloatTensor，可选) — 来自 Transformer 解码器每一层的类别和掩码预测列表。 - text_queries (
torch.FloatTensor, 可选，形状为(batch_size, num_queries, hidden_dim)) — 从输入文本列表派生的文本查询，用于在训练期间计算对比损失。 - task_token (形状为
(batch_size, hidden_dim)的torch.FloatTensor) — 用于调节查询的 1D 任务令牌。 - attentions (
tuple(tuple(torch.FloatTensor)), 可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tuple(torch.FloatTensor)元组（每层一个）。来自 Transformer 解码器的自注意力和交叉注意力权重。
OneFormerForUniversalSegmentationOutput 输出的类。
此输出可以直接传递给 post_process_semantic_segmentation() 或 post_process_instance_segmentation() 或 post_process_panoptic_segmentation()，具体取决于任务。有关使用详情，请参阅 [`~OneFormerImageProcessor]。
OneFormerConfig
class transformers.OneFormerConfig
< source >( backbone_config: Optional = None backbone: Optional = None use_pretrained_backbone: bool = False use_timm_backbone: bool = False backbone_kwargs: Optional = None ignore_value: int = 255 num_queries: int = 150 no_object_weight: int = 0.1 class_weight: float = 2.0 mask_weight: float = 5.0 dice_weight: float = 5.0 contrastive_weight: float = 0.5 contrastive_temperature: float = 0.07 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 layer_norm_eps: float = 1e-05 is_training: bool = False use_auxiliary_loss: bool = True output_auxiliary_logits: bool = True strides: Optional = [4, 8, 16, 32] task_seq_len: int = 77 text_encoder_width: int = 256 text_encoder_context_length: int = 77 text_encoder_num_layers: int = 6 text_encoder_vocab_size: int = 49408 text_encoder_proj_layers: int = 2 text_encoder_n_ctx: int = 16 conv_dim: int = 256 mask_dim: int = 256 hidden_dim: int = 256 encoder_feedforward_dim: int = 1024 norm: str = 'GN' encoder_layers: int = 6 decoder_layers: int = 10 use_task_norm: bool = True num_attention_heads: int = 8 dropout: float = 0.1 dim_feedforward: int = 2048 pre_norm: bool = False enforce_input_proj: bool = False query_dec_layers: int = 2 common_stride: int = 4 **kwargs )
Parameters
- backbone_config (
PretrainedConfig, 可选，默认为SwinConfig) — 主干模型的配置。 - backbone (
str, 可选) — 当backbone_config为None时，要使用的主干名称。如果use_pretrained_backbone为True，这将从 timm 或 transformers 库加载相应的预训练权重。如果use_pretrained_backbone为False，这将加载主干的配置，并使用该配置使用随机权重初始化主干。 - use_pretrained_backbone (
bool, 可选，默认为False) — 是否对主干使用预训练权重。 - use_timm_backbone (
bool, 可选，默认为False) — 是否从 timm 库加载backbone。如果为False，则从 transformers 库加载主干。 - backbone_kwargs (
dict, 可选) — 从检查点加载时要传递给 AutoBackbone 的关键字参数，例如{'out_indices': (0, 1, 2, 3)}。如果设置了backbone_config，则无法指定。 - ignore_value (
int, 可选，默认为 255) — 计算损失时，GT 标签中要忽略的值。 - num_queries (
int, 可选，默认为 150) — 对象查询的数量。 - no_object_weight (
float, 可选，默认为 0.1) — 无对象类别预测的权重。 - class_weight (
float, 可选, 默认为 2.0) — 分类交叉熵损失的权重。 - mask_weight (
float, 可选, 默认为 5.0) — 二进制交叉熵损失的权重。 - dice_weight (
float, 可选, 默认为 5.0) — Dice 损失的权重。 - contrastive_weight (
float, 可选, 默认为 0.5) — 对比损失的权重。 - contrastive_temperature (
float, 可选, 默认为 0.07) — 用于缩放对比 logits 的初始值。 - 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) — Xavier 均匀初始化的标准差。 - layer_norm_eps (
float, 可选, 默认为 1e-05) — 层归一化的 epsilon 值。 - is_training (
bool, 可选, 默认为False) — 是否在训练或推理模式下运行。 - use_auxiliary_loss (
bool, 可选, 默认为True) — 是否使用来自 Transformer 解码器的中间预测计算损失。 - output_auxiliary_logits (
bool, 可选, 默认为True) — 是否返回来自 Transformer 解码器的中间预测。 - strides (
list, 可选, 默认为[4, 8, 16, 32]) — 包含编码器中特征图的步长的列表。 - task_seq_len (
int, 可选, 默认为 77) — 用于标记文本列表输入的序列长度。 - text_encoder_width (
int, 可选, 默认为 256) — 文本编码器的隐藏层大小。 - text_encoder_context_length (
int, 可选, 默认为 77) — 文本编码器的输入序列长度。 - text_encoder_num_layers (
int, 可选, 默认为 6) — 文本编码器中 Transformer 的层数。 - text_encoder_vocab_size (
int, 可选, 默认为 49408) — 分词器的词汇表大小。 - text_encoder_proj_layers (
int, 可选, 默认为 2) — 用于投影文本查询的 MLP 中的层数。 - text_encoder_n_ctx (
int, 可选, 默认为 16) — 可学习的文本上下文查询的数量。 - conv_dim (
int, 可选, 默认为 256) — 用于映射来自骨干网络的输出的特征图维度。 - mask_dim (
int, 可选, 默认为 256) — 像素解码器中特征图的维度。 - hidden_dim (
int, 可选, 默认为 256) — Transformer 解码器中隐藏状态的维度。 - encoder_feedforward_dim (
int, 可选, 默认为 1024) — 像素解码器中 FFN 层的维度。 - norm (
str, 可选, 默认为"GN") — 归一化类型。 - encoder_layers (
int, 可选, 默认为 6) — 像素解码器中的层数。 - decoder_layers (
int, 可选, 默认为 10) — Transformer 解码器中的层数。 - use_task_norm (
bool, 可选, 默认为True) — 是否对任务 token 进行归一化。 - num_attention_heads (
int, 可选, 默认为 8) — 像素解码器和 Transformer 解码器中 Transformer 层中注意力头的数量。 - dropout (
float, 可选, 默认为 0.1) — 像素解码器和 Transformer 解码器的 dropout 概率。 - dim_feedforward (
int, 可选, 默认为 2048) — Transformer 解码器中 FFN 层的维度。 - pre_norm (
bool, optional, defaults toFalse) — 是否在 Transformer 解码器中的注意力层之前对隐藏状态进行归一化。 - enforce_input_proj (
bool, optional, defaults toFalse) — 是否在 Transformer 解码器中投影隐藏状态。 - query_dec_layers (
int, optional, defaults to 2) — 查询 Transformer 中的层数。 - common_stride (
int, optional, defaults to 4) — 像素解码器中特征的常用步幅。
这是用于存储 OneFormerModel 配置的配置类。它用于根据指定的参数实例化 OneFormer 模型，定义模型架构。使用默认值实例化配置将产生与 OneFormer shi-labs/oneformer_ade20k_swin_tiny 架构类似的配置，该架构在 ADE20k-150 上训练。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import OneFormerConfig, OneFormerModel
>>> # Initializing a OneFormer shi-labs/oneformer_ade20k_swin_tiny configuration
>>> configuration = OneFormerConfig()
>>> # Initializing a model (with random weights) from the shi-labs/oneformer_ade20k_swin_tiny style configuration
>>> model = OneFormerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configOneFormerImageProcessor
class transformers.OneFormerImageProcessor
< source >( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: bool = False repo_path: Optional = 'shi-labs/oneformer_demo' class_info_file: str = None num_text: Optional = None num_labels: Optional = None **kwargs )
Parameters
- do_resize (
bool, optional, defaults toTrue) — 是否将输入调整为特定的size大小。 - size (
int, optional, defaults to 800) — 将输入调整为给定大小。仅当do_resize设置为True时才有效。如果 size 是像(width, height)这样的序列，则输出大小将与此匹配。如果 size 是一个整数，则图像的较小边缘将与此数字匹配。即，如果height > width，则图像将被缩放到(size * height / width, size)。 - resample (
int, optional, defaults toResampling.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, optional, defaults toTrue) — 是否将输入重新缩放到某个scale比例。 - rescale_factor (
float, optional, defaults to1/ 255) — 通过给定因子重新缩放输入。仅当do_rescale设置为True时才有效。 - do_normalize (
bool, optional, defaults toTrue) — 是否使用均值和标准差对输入进行归一化。 - image_mean (
int, optional, defaults to[0.485, 0.456, 0.406]) — 用于归一化图像的每个通道的均值序列。默认为 ImageNet 均值。 - image_std (
int, optional, defaults to[0.229, 0.224, 0.225]) — 用于归一化图像的每个通道的标准差序列。默认为 ImageNet 标准差。 - ignore_index (
int, optional) — 分割图中要分配给背景像素的标签。如果提供，则用ignore_index替换用 0（背景）表示的分割图像素。 - do_reduce_labels (
bool, optional, defaults toFalse) — 是否将分割图的所有标签值减 1。通常用于数据集，其中 0 用于背景，而背景本身不包含在数据集的所有类别中（例如 ADE20k）。背景标签将被ignore_index替换。 - repo_path (
str, optional, defaults to"shi-labs/oneformer_demo") — 包含数据集类别信息的 JSON 文件的 Hub 仓库路径或本地目录。如果未设置，将在当前工作目录中查找class_info_file。 - class_info_file (
str, optional) — 包含数据集类别信息的 JSON 文件。有关示例，请参阅shi-labs/oneformer_demo/cityscapes_panoptic.json。 - num_text (
int, optional) — 文本输入列表中的文本条目数。 - num_labels (
int, optional) — 分割图中的标签数量。
构建 OneFormer 图像处理器。图像处理器可用于准备图像、任务输入以及模型的可选文本输入和目标。
此图像处理器继承自 BaseImageProcessor，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
preprocess
< source >( images: Union task_inputs: Optional = None segmentation_maps: Union = None instance_id_to_semantic_id: Optional = None do_resize: Optional = None size: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: Optional = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None )
encode_inputs
< source >( pixel_values_list: List task_inputs: List segmentation_maps: Union = None instance_id_to_semantic_id: Union = None ignore_index: Optional = None do_reduce_labels: bool = False return_tensors: Union = None input_data_format: Union = None ) → BatchFeature
Parameters
- pixel_values_list (
List[ImageInput]) — 要填充的图像（像素值）列表。每个图像都应是形状为(channels, height, width)的张量。 - task_inputs (
List[str]) — 任务值列表。 - segmentation_maps (
ImageInput, optional) — 对应的语义分割图，带有像素级标注。(
bool, optional, defaults toTrue): 是否将图像填充到批次中最大的图像，并创建像素掩码。如果保留默认值，将返回一个像素掩码，其中：
- 1 表示真实像素（即未掩码），
- 0 表示填充像素（即已掩码）。
- instance_id_to_semantic_id (
List[Dict[int, int]]或Dict[int, int], 可选) — 对象实例 ID 和类别 ID 之间的映射。如果传入，则segmentation_maps被视为实例分割图，其中每个像素代表一个实例 ID。可以作为单个字典（包含全局/数据集级别的映射）或字典列表（每个图像一个）提供，以分别映射每个图像中的实例 ID。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensors 而不是 NumPy 数组。如果设置为'pt'，则返回 PyTorchtorch.Tensor对象。 - input_data_format (
str或ChannelDimension, 可选) — 输入图像的通道维度格式。如果未提供，将从输入图像中推断。
一个 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]的标签。 - text_inputs — 可选的文本字符串条目列表，用于馈送到模型（当提供
annotations时）。它们标识图像中存在的二元掩码。
将图像填充到批次中最大的图像大小，并创建相应的 pixel_mask。
OneFormer 使用掩码分类范式处理语义分割，因此输入分割图将转换为二元掩码列表及其各自的标签。让我们看一个例子，假设 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: Optional = None ) → List[torch.Tensor]
Parameters
- outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。
- target_sizes (
List[Tuple[int, int]], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于每个预测请求的最终大小（高度，宽度）。如果保留为 None，则预测不会调整大小。
返回
List[torch.Tensor]
长度为 batch_size 的列表，其中每个项目是形状为 (height, width) 的语义分割图，对应于 target_sizes 条目（如果指定了 target_sizes）。每个 torch.Tensor 的每个条目都对应于一个语义类别 ID。
将 MaskFormerForInstanceSegmentation 的输出转换为语义分割图。仅支持 PyTorch。
post_process_instance_segmentation (后处理实例分割)
< source (源码) >( outputs task_type: str = 'instance' is_demo: bool = True threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False ) → List[Dict]
Parameters
- outputs (
OneFormerForUniversalSegmentationOutput) — 来自OneFormerForUniversalSegmentationOutput的输出。 - task_type (
str, 可选, 默认为 “instance”) — 后处理取决于任务令牌输入。如果task_type为 “panoptic”，我们需要忽略 stuff 预测。 - is_demo (
bool, 可选, 默认为True) — 模型是否处于演示模式。如果为 true，则使用阈值来预测最终掩码。 - 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) — 是否以 COCO 格式返回预测。
返回
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 — 表示
将 OneFormerForUniversalSegmentationOutput 的输出转换为图像实例分割预测。仅支持 PyTorch。
post_process_panoptic_segmentation (后处理全景分割)
< source (源码) >( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → List[Dict]
Parameters
- outputs (
MaskFormerForInstanceSegmentationOutput) — 来自 MaskFormerForInstanceSegmentation 的输出。 - threshold (
float, 可选, 默认为 0.5) — 用于保留预测实例掩码的概率分数阈值。 - mask_threshold (
float, 可选, 默认为 0.5) — 将预测掩码转换为二元值时使用的阈值。 - overlap_mask_area_threshold (
float, 可选, 默认为 0.8) — 重叠掩码区域阈值，用于合并或丢弃每个二元实例掩码内的小的断开连接的部分。 - label_ids_to_fuse (
Set[int], 可选) — 此状态下的标签将使其所有实例融合在一起。例如，我们可以说一张图像中只能有一个天空，但可以有多个人，因此天空的标签 ID 将在该集合中，但人的标签 ID 不会。 - target_sizes (
List[Tuple], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于批次中每个预测的请求最终尺寸（高度，宽度）。如果保留为 None，则不会调整预测大小。
返回
List[Dict]
字典列表，每个图像一个字典，每个字典包含两个键
- segmentation — 形状为
(height, width)的张量，其中每个像素表示一个segment_id，如果未找到高于threshold的掩码，则设置为None。如果指定了target_sizes，则分割将调整为相应的target_sizes条目。 - segments_info — 包含每个分割段的附加信息的字典。
- id — 表示
segment_id的整数。 - label_id — 表示与
segment_id对应的标签/语义类别 ID 的整数。 - was_fused — 一个布尔值，如果
label_id在label_ids_to_fuse中，则为True，否则为False。同一类别/标签的多个实例被融合并分配了单个segment_id。 - score — 分割段
segment_id的预测分数。
- id — 表示
将 MaskFormerForInstanceSegmentationOutput 的输出转换为图像全景分割预测。仅支持 PyTorch。
OneFormerProcessor
class transformers.OneFormerProcessor
< source >( image_processor = None tokenizer = None max_seq_length: int = 77 task_seq_length: int = 77 **kwargs )
Parameters
- image_processor (OneFormerImageProcessor) — 图像处理器是必需的输入。
- tokenizer ([
CLIPTokenizer,CLIPTokenizerFast]) — 分词器是必需的输入。 - max_seq_len (
int, 可选，默认为 77) — 输入文本列表的序列长度。 - task_seq_len (
int, 可选，默认为 77) — 输入任务令牌的序列长度。
构建一个 OneFormer 处理器，它将 OneFormerImageProcessor 和 CLIPTokenizer/CLIPTokenizerFast 封装到一个单一的处理器中，该处理器同时继承了图像处理器和分词器的功能。
此方法将其所有参数转发到 OneFormerImageProcessor.encode_inputs()，然后对 task_inputs 进行分词。 有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 OneFormerImageProcessor.post_process_instance_segmentation()。 有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 OneFormerImageProcessor.post_process_panoptic_segmentation()。 有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 OneFormerImageProcessor.post_process_semantic_segmentation()。 有关更多信息，请参阅此方法的文档字符串。
OneFormerModel
class transformers.OneFormerModel
< source >( config: OneFormerConfig )
Parameters
- config (OneFormerConfig) — 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
裸 OneFormer 模型输出原始隐藏状态，顶部没有任何特定的头部。 此模型是 PyTorch nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( pixel_values: Tensor task_inputs: Tensor text_inputs: Optional = None pixel_mask: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → transformers.models.oneformer.modeling_oneformer.OneFormerModelOutput 或 tuple(torch.FloatTensor)
Parameters
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。 像素值可以使用 OneFormerProcessor 获得。 有关详细信息，请参见OneFormerProcessor.__call__()。 - task_inputs (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 任务输入。 任务输入可以使用 AutoImageProcessor 获得。 有关详细信息，请参见OneFormerProcessor.__call__()。 - pixel_mask (
torch.LongTensor，形状为(batch_size, height, width)，可选) — 避免对填充像素值执行注意力的掩码。 在[0, 1]中选择的掩码值：- 1 表示真实像素（即未被掩盖），
- 0 表示填充像素（即被掩盖）。
- output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 - output_attentions (
bool，可选) — 是否返回 Detr 解码器注意力层的注意力张量。 - return_dict (
bool，可选) — 是否返回~OneFormerModelOutput而不是普通元组。
返回
transformers.models.oneformer.modeling_oneformer.OneFormerModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.oneformer.modeling_oneformer.OneFormerModelOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含取决于配置 (OneFormerConfig) 和输入的各种元素。
- 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 解码器在每个阶段输出的隐藏状态（也称为特征图）。 - transformer_decoder_object_queries (
torch.FloatTensor，形状为(batch_size, num_queries, hidden_dim)) 来自 transformer 解码器最后一层的输出对象查询。 - transformer_decoder_contrastive_queries (
torch.FloatTensor，形状为(batch_size, num_queries, hidden_dim)) 来自 transformer 解码器的对比查询。 - transformer_decoder_mask_predictions (
torch.FloatTensor，形状为(batch_size, num_queries, height, width)) 来自 transformer 解码器最后一层的掩码预测。 - transformer_decoder_class_predictions (
torch.FloatTensor，形状为(batch_size, num_queries, num_classes+1)) — 来自 transformer 解码器最后一层的类预测。 - transformer_decoder_auxiliary_predictions (
str, torch.FloatTensor字典的元组, 可选) — 来自 transformer 解码器每一层的类别和掩码预测的元组。 - text_queries (
torch.FloatTensor, 可选，形状为(batch_size, num_queries, hidden_dim)) 从输入文本列表衍生的文本查询，用于在训练期间计算对比损失。 - task_token (
torch.FloatTensor, 形状为(batch_size, hidden_dim)) 用于调节查询的 1D 任务令牌。 - attentions (
tuple(tuple(torch.FloatTensor)), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —tuple(torch.FloatTensor)的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。来自 transformer 解码器的自注意力权重和交叉注意力权重。
OneFormerModelOutput
OneFormerModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是直接调用此函数，因为前者会处理预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import OneFormerProcessor, OneFormerModel
>>> # download texting image
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> # load processor for preprocessing the inputs
>>> processor = OneFormerProcessor.from_pretrained("shi-labs/oneformer_ade20k_swin_tiny")
>>> model = OneFormerModel.from_pretrained("shi-labs/oneformer_ade20k_swin_tiny")
>>> inputs = processor(image, ["semantic"], return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> mask_predictions = outputs.transformer_decoder_mask_predictions
>>> class_predictions = outputs.transformer_decoder_class_predictions
>>> f"👉 Mask Predictions Shape: {list(mask_predictions.shape)}, Class Predictions Shape: {list(class_predictions.shape)}"
'👉 Mask Predictions Shape: [1, 150, 128, 171], Class Predictions Shape: [1, 150, 151]'OneFormerForUniversalSegmentation
类 transformers.OneFormerForUniversalSegmentation
< source >( config: OneFormerConfig )
Parameters
- config (OneFormerConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
用于实例、语义和全景图像分割的 OneFormer 模型。此模型是 PyTorch nn.Module 子类。可以像常规 PyTorch Module 一样使用它，并参考 PyTorch 文档以了解所有与常规用法和行为相关的事项。
forward
< source >( pixel_values: Tensor task_inputs: Tensor text_inputs: Optional = None mask_labels: Optional = None class_labels: Optional = None pixel_mask: Optional = None output_auxiliary_logits: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → transformers.models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput 或 tuple(torch.FloatTensor)
Parameters
- pixel_values (
torch.FloatTensor, 形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 OneFormerProcessor 获得。有关详细信息，请参阅OneFormerProcessor.__call__()。 - task_inputs (
torch.FloatTensor, 形状为(batch_size, sequence_length)) — 任务输入。任务输入可以使用 AutoImageProcessor 获得。有关详细信息，请参阅OneFormerProcessor.__call__()。 - pixel_mask (
torch.LongTensor, 形状为(batch_size, height, width), 可选) — 用于避免对填充像素值执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示真实像素（即未被掩码），
- 0 表示填充像素（即已被掩码）。
- output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - output_attentions (
bool, 可选) — 是否返回 Detr 解码器注意力层的注意力张量。 - return_dict (
bool, 可选) — 是否返回~OneFormerModelOutput而不是普通元组。 - text_inputs (
List[torch.Tensor], 可选) — 形状为(num_queries, sequence_length)的张量，将馈送到模型 - mask_labels (
List[torch.Tensor], 可选) — 形状为(num_labels, height, width)的掩码标签列表，将馈送到模型 - class_labels (
List[torch.LongTensor], 可选) — 形状为(num_labels, height, width)的目标类别标签列表，将馈送到模型。它们标识mask_labels的标签，例如，如果class_labels[i][j]，则为mask_labels[i][j]的标签。
返回
transformers.models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput 或 tuple(torch.FloatTensor)
transformers.models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput 或 torch.FloatTensor 的元组 (如果传递 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (OneFormerConfig) 和输入。
- 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_predictions (
str, 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 解码器在每个阶段输出的隐藏状态（也称为特征图）。 - transformer_decoder_object_queries (
torch.FloatTensor，形状为(batch_size, num_queries, hidden_dim)) 来自 transformer 解码器最后一层的输出对象查询。 - transformer_decoder_contrastive_queries (
torch.FloatTensor，形状为(batch_size, num_queries, hidden_dim)) 来自 transformer 解码器的对比查询。 - transformer_decoder_mask_predictions (
torch.FloatTensor，形状为(batch_size, num_queries, height, width)) 来自 transformer 解码器最后一层的掩码预测。 - transformer_decoder_class_predictions (
torch.FloatTensor，形状为(batch_size, num_queries, num_classes+1)) — 来自 transformer 解码器最后一层的类预测。 - transformer_decoder_auxiliary_predictions (
str, torch.FloatTensor字典的列表, 可选) — 来自 transformer 解码器每一层的类别和掩码预测的列表。 - text_queries (
torch.FloatTensor, 可选，形状为(batch_size, num_queries, hidden_dim)) 从输入文本列表衍生的文本查询，用于在训练期间计算对比损失。 - task_token (
torch.FloatTensor, 形状为(batch_size, hidden_dim)) 用于调节查询的 1D 任务令牌。 - attentions (
tuple(tuple(torch.FloatTensor)), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —tuple(torch.FloatTensor)的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。来自 transformer 解码器的自注意力权重和交叉注意力权重。
OneFormerUniversalSegmentationOutput
OneFormerForUniversalSegmentation 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是直接调用此函数，因为前者会处理预处理和后处理步骤，而后者会静默地忽略它们。
示例
通用分割示例
>>> from transformers import OneFormerProcessor, OneFormerForUniversalSegmentation
>>> from PIL import Image
>>> import requests
>>> import torch
>>> # load OneFormer fine-tuned on ADE20k for universal segmentation
>>> processor = OneFormerProcessor.from_pretrained("shi-labs/oneformer_ade20k_swin_tiny")
>>> model = OneFormerForUniversalSegmentation.from_pretrained("shi-labs/oneformer_ade20k_swin_tiny")
>>> 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)
>>> # Semantic Segmentation
>>> inputs = processor(image, ["semantic"], 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
>>> # you can pass them to processor for semantic postprocessing
>>> predicted_semantic_map = processor.post_process_semantic_segmentation(
... outputs, target_sizes=[image.size[::-1]]
... )[0]
>>> f"👉 Semantic Predictions Shape: {list(predicted_semantic_map.shape)}"
'👉 Semantic Predictions Shape: [512, 683]'
>>> # Instance Segmentation
>>> inputs = processor(image, ["instance"], 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
>>> # you can pass them to processor for instance postprocessing
>>> predicted_instance_map = processor.post_process_instance_segmentation(
... outputs, target_sizes=[image.size[::-1]]
... )[0]["segmentation"]
>>> f"👉 Instance Predictions Shape: {list(predicted_instance_map.shape)}"
'👉 Instance Predictions Shape: [512, 683]'
>>> # Panoptic Segmentation
>>> inputs = processor(image, ["panoptic"], 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
>>> # you can pass them to processor for panoptic postprocessing
>>> predicted_panoptic_map = processor.post_process_panoptic_segmentation(
... outputs, target_sizes=[image.size[::-1]]
... )[0]["segmentation"]
>>> f"👉 Panoptic Predictions Shape: {list(predicted_panoptic_map.shape)}"
'👉 Panoptic Predictions Shape: [512, 683]'