Transformers

( 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 )

参数

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时返回) — 形状为 (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_decoder_object_queries (torch.FloatTensor of shape (batch_size, num_queries, hidden_dim)) — 从变压器解码器的最后一层输出的对象查询。
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 (Dict的元组 str, torch.FloatTensor，可选) — 从每个Transformer解码器层的类别预测和掩码预测的元组。
text_queries (torch.FloatTensor，可选，形状为 (batch_size, num_queries, hidden_dim)）— 训练期间用于计算对比损失的输入文本列表导出的文本查询。
task_token (torch.FloatTensor，形状为 (batch_size, hidden_dim)）— 用于查询条件的1D任务token。
attentions (tuple(tuple(torch.FloatTensor)), 可选的，当传递 output_attentions=True 或者时 config.output_attentions=True 返回) — 一个 tuple(tuple(torch.FloatTensor)) 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。来自 Transformer 解码器的自注意力和交叉注意力权重。

为 OneFormerModel 的输出定义类。此类返回所有需要计算 logit 的隐藏状态。

类 transformers.models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput

( loss: 可选 = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_predictions: 列表 = None encoder_hidden_states: 可选 = None pixel_decoder_hidden_states: 可选 = None transformer_decoder_hidden_states: 可选 = None transformer_decoder_object_queries: FloatTensor = None transformer_decoder_contrastive_queries: 可选 = None transformer_decoder_mask_predictions: FloatTensor = None transformer_decoder_class_predictions: FloatTensor = None transformer_decoder_auxiliary_predictions: 可选 = None text_queries: 可选 = None task_token: FloatTensor = None attentions: 可选 = None )

参数

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 （解码器每层的类别和掩码预测的字典列表，可选）
encoder_hidden_states (tuple(torch.FloatTensor), optional, 返回当 output_hidden_states=True 被传递或者当 config.output_hidden_states=True 时) — 一个形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor 的元组（一个用于嵌入输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段的输出中的隐藏状态（也称为特征图）。
pixel_decoder_hidden_states (tuple(torch.FloatTensor), optional, 返回当 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 (torch.FloatTensor of shape (batch_size, num_queries, hidden_dim)) — 来自transformer解码器最后一层的物体查询输出。
transformer_decoder_contrastive_queries (torch.FloatTensor of shape (batch_size, num_queries, hidden_dim)) — transformer解码器的对比查询。
transformer_decoder_mask_predictions （当量torch.FloatTensor，形状为(batch_size, num_queries, height, width)）— 来自变压器解码器最末层的掩码预测。
transformer_decoder_class_predictions （当量torch.FloatTensor，形状为(batch_size, num_queries, num_classes+1)）— 来自变压器解码器最末层的分类预测。
transformer_decoder_auxiliary_predictions （当量List of Dict of str, torch.FloatTensor，可选）— 变压器解码器的每一层的类和掩码预测列表。
text_queries (torch.FloatTensor, 可选, 形状为 (batch_size, num_queries, hidden_dim)) — 从输入文本列表中导出的文本查询，用于计算训练期间的对比损失。
task_token (torch.FloatTensor of shape (batch_size, hidden_dim)) — 一维任务标记，用于条件化查询。
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

类 transformers.OneFormerConfig

( 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 )

参数

backbone_config (PretrainedConfig, 可选, 默认为 SwinConfig) — 背骨模型的配置。
backbone (str, 可选) — 当 backbone_config 为 None 时使用的背骨名称。如果 use_pretrained_backbone 是 True，此选项将从 timm 或 transformers 库加载相应的预训练权重。如果 use_pretrained_backbone 是 False，则加载背骨的配置，并使用该配置以随机权重初始化背骨。
use_pretrained_backbone （布尔值，可选，默认为 False）—— 是否使用预训练的骨干网络权重。
use_timm_backbone （布尔值，可选，默认为 False）—— 是否从 timm 库加载 backbone。如果为 False，则从 transformers 库中加载骨干网络。
backbone_kwargs （字典，可选）—— 传递给 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）— 分类 CE 损失的权重。
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, optional, defaults to 77) — 文本列表输入的分词序列长度。
text_encoder_width (int, optional, defaults to 256) — 文本编码器隐藏层大小。
text_encoder_context_length (int, optional, defaults to 77) — 文本编码器输入序列长度。
text_encoder_num_layers (int, optional, defaults to 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) — 变换器解码器中隐藏状态的维度。
encoder_feedforward_dim (int, 可选，默认为1024) — 像素解码器中FFN层的维度。
norm (str, 可选，默认为"GN") — 归一化类型。
encoder_layers (int, 可选, 默认值为6) — 像素解码器中的层数数。
decoder_layers (int, 可选, 默认值为10) — 变换解码器中的层数数。
use_task_norm (bool, 可选, 默认值为true) — 是否对任务令牌进行归一化。
num_attention_heads (int, 可选, 默认值为8) — 像素和变换解码器中变换层中的注意力头数。
позитивный элемент (float, по умолчанию 0.1) — Вероятность выброса для декодеров пикселей и трансформаций.
позитивный элемент (int, по умолчанию 2048) — Мридина для слоя FFN в трансформационном декодере.
позитивный элемент (bool, по умолчанию False) — Нормализация скрытых состояний перед слоем внимания в трансформационном декодере.
positive element (bool, {DEFAULT} False) Whether to project hidden states in transformer decoder.
query_dec_layers (int, optional, defaults to 2) —— 查询转换器中的层数。
common_stride (int, optional, defaults to 4) —— 用于像素解码器中特征的公共步幅。

这是存储OneFormerModel配置的配置类。它根据指定的参数实例化OneFormer模型，定义模型架构。使用默认值实例化配置将产生类似于在ADE20k-150上训练的shi-labs/oneformer_ade20k_swin_tiny架构的OneFormer配置。

配置对象继承自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.config

OneFormerImageProcessor

类 transformers.OneFormerImageProcessor

( 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 )

参数

do_resize (bool, optional, defaults to True) — 是否调整输入到特定的size。
size (int, optional, defaults to 800) — 调整输入到给定的尺寸。仅在do_resize设置为True时生效。如果尺寸是一个序列如(width, height)，输出尺寸将与这个匹配。如果尺寸是一个整数，图像较小的边将匹配这个数字。即，如果height > width，则图像将调整到(size * height / width, size)。
resample (int, optional, defaults to 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) — 是否使用均值和标准差将输入normalize（正则化）。
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替换。
repo_path (str, 可选, 默认为 "shi-labs/oneformer_demo") — 包含数据集类信息的JSON文件的hub仓库路径或本地目录。如果未设置，将在当前工作目录中查找class_info_file。
class_info_file (str, 可选) — 包含数据集类信息的JSON文件。请参考shi-labs/oneformer_demo/cityscapes_panoptic.json。
num_text (int, 可选) — 文本输入列表中文本条目的数量。
num_labels (int, 可选) — 分割图中标签的数量。

构建一个 OneFormer 图像处理器。该图像处理器可用于准备图像、任务输入以及在模型中使用可选的文本输入和目标。

此图像处理器继承自 BaseImageProcessor，它包含大多数主要方法。用户应参考这个超类以获取关于这些方法的更多信息。

preprocess

( images: 模式 task_inputs: 可选 = None segmentation_maps: 模式 = None instance_id_to_semantic_id: 可选 = None do_resize: 可选 = None size: 可选 = None resample: 重采样 = None do_rescale: 可选 = None rescale_factor: 可选 = None do_normalize: 可选 = None image_mean: 模式 = None image_std: 模式 = None ignore_index: 可选 = None do_reduce_labels: 可选 = None return_tensors: 模式 = None data_format: 模式 = <ChannelDimension.FIRST: 'channels_first'> input_data_format: 模式 = None )

编码输入

( pixel_values_list: 列表 task_inputs: 列表 segmentation_maps: 合并 = None instance_id_to_semantic_id: 合并 = None ignore_index: 可选 = None do_reduce_labels: 布尔 = False return_tensors: 合并 = None input_data_format: 合并 = None ) → BatchFeature

参数

pixel_values_list (List[ImageInput]) — 需要填充的图像（像素值）列表。每个图像都应该是一个形状为 (通道, 高度, 宽度) 的张量。
task_inputs (List[str]) — 任务值列表。
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'，则返回 PyTorch torch.Tensor 对象。
input_data_format (str 或 ChannelDimension, 可选) — 输入图像的通道维度格式。如果未提供，则将从输入图像中推断。

BatchFeature

A 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

( outputs target_sizes: Optional = None ) → List[torch.Tensor]

参数

outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。
target_sizes (List[Tuple[int, int]], 可选) — （batch_size）长度的列表，其中每个列表项（Tuple[int, int]]）对应于每个预测请求的最终大小（高度，宽度）。如果留为None，则预测将不进行缩放。

List[torch.Tensor]

长度为 batch_size 的列表，其中每个项是一个与目标大小的条目（如果指定了target_sizes）相对应的形状为（高度，宽度）的语义分割图。每个torch.Tensor的每个条目都对应于一个语义类别ID。

将MaskFormerForInstanceSegmentation的输出转换为语义分割图。仅支持PyTorch。

post_process_instance_segmentation

( 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]

参数

outputs (OneFormerForUniversalSegmentationOutput) — OneFormerForUniversalSegmentationOutput 的输出。
task_type (str, 可选, 默认为“instance”) — 后处理依赖于输入的任务标记。如果 task_type 为“panoptic”，则需要忽略内容预测。
is_demo (bool, 可选，默认为 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 的段的预测分数。

将 OneFormerForUniversalSegmentationOutput 的输出转换为图像实例分割预测。仅支持 PyTorch。

post_process_panoptic_segmentation

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → List[Dict]

参数

outputs (MaskFormerForInstanceSegmentationOutput) — 来自 MaskFormerForInstanceSegmentation 的输出。
阈值 (浮点数, 可选, 默认为 0.5) — 保留预测实例掩码的概率分数阈值。
掩码阈值 (浮点数, 可选, 默认为 0.5) — 将预测掩码转换为二进制值时使用的阈值。
重叠掩码区域阈值 (浮点数, 可选, 默认为 0.8) — 合并或丢弃每个二进制实例掩码内的小的、不相连接部分的重叠掩码面积阈值。
label_ids_to_fuse （Set[int]，可选）——该状态中的标签将具有所有其实例都融合在一起。例如，我们可以认为图像中只能有一个天空，但可以有几个人，因此天空的标签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 的段的预测分数。

将MaskFormerForInstanceSegmentationOutput的输出转换为图像全景分割预测。仅支持PyTorch。

OneFormerProcessor

类 transformers.OneFormerProcessor

( image_processor = None tokenizer = None max_seq_length: int = 77 task_seq_length: int = 77 **kwargs )

参数

image_processor (OneFormerImageProcessor) — 图片处理器是必需的输入。
tokenizer ([CLIPTokenizer, CLIPTokenizerFast]) — 分词器是必需的输入。
max_seq_len (int, optional, defaults to 77)) — 输入文本列表的序列长度。
task_seq_len (int, optional, defaults to 77) — 输入任务标记的序列长度。

创建一个OneFormer处理器，它将OneFormerImageProcessor和CLIPTokenizer/CLIPTokenizerFast合并成一个处理器，继承图像处理器和标记化器的功能。

编码输入

( images = None task_inputs = None segmentation_maps = None **kwargs )

此方法将所有参数转发到OneFormerImageProcessor.encode_inputs()，然后再对task_inputs进行分词。有关更多信息，请参阅该方法的文档字符串。

post_process_instance_segmentation

( *args **kwargs )

此方法将所有参数转发到OneFormerImageProcessor.post_process_instance_segmentation()。有关更多信息，请参阅该方法的文档字符串。

post_process_panoptic_segmentation

( *args **kwargs )

此方法将所有参数转发到OneFormerImageProcessor.post_process_panoptic_segmentation()。有关更多信息，请参阅该方法的文档字符串。

post_process_semantic_segmentation

( *args **kwargs )

此方法将所有其参数传递给 OneFormerImageProcessor.post_process_semantic_segmentation()。有关更多信息，请参阅该方法的文档字符串。

OneFormerModel

类 transformers.OneFormerModel

( config: OneFormerConfig )

参数

config (OneFormerConfig) — 模型配置类，包含所有模型参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

输出原始隐藏状态的朴素 OneFormer 模型，没有顶部的任何特定头部。该模型是 PyTorch 的 nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档以获取所有与一般使用和行为相关的内容。

forward

( 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 or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 OneFormerProcessor 获取。有关详细信息，请参阅 OneFormerProcessor.__call__()。
task_inputs (torch.FloatTensor with shape (batch_size, sequence_length)) — 任务输入。任务输入可以通过 AutoImageProcessor 获取。有关详细信息，请参阅 OneFormerProcessor.__call__()。
pixel_mask (torch.LongTensor with shape (batch_size, height, width), optional) — 用于防止在填充像素值上执行注意力的掩码。掩码值选择在 [0, 1] 之间：
- 1 为真实像素（即 未掩码），
- 0 为填充像素（即掩码）。
什么是注意力掩码？
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 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 或者一个包含各种元素（取决于配置（OneFormerConfig）和输入）的torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False）。

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 (torch.FloatTensor of shape (batch_size, num_queries, hidden_dim)) 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 (包含str, torch.FloatTensor的Dict的元组，可选)—— 包含来自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时返回）—— 每个解码器层的一个tuple(torch.FloatTensor)的元组（每个层一个）的元组，形状为(batch_size, num_heads, sequence_length, sequence_length)。从transformer解码器中获取的自注意力和交叉注意力权重。

OneFormerModelOutput

OneFormerModel的前向方法覆盖了特殊方法__call__。

尽管需要在此函数内定义前向传播的配方，但应该调用该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

class transformers.OneFormerForUniversalSegmentation

( config: OneFormerConfig )

参数

配置 (OneFormerConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。请参阅from_pretrained()方法来加载模型权重。-->

OneFormer 模型，用于实例、语义和全景图像分割。该模型是 PyTorch nn.Module 的子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档了解有关通用使用和行为的所有相关内容。

forward