原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/focalnet
FocalNet 模型是由 Jianwei Yang、Chunyuan Li、Xiyang Dai、Lu Yuan、Jianfeng Gao 在焦点调制网络中提出的。FocalNets 完全用焦点调制机制取代了自注意力(在模型中使用,如 ViT 和 Swin),用于建模视觉中的令牌交互。作者声称,FocalNets 在图像分类、目标检测和分割任务上优于基于自注意力的模型,且具有类似的计算成本。
该论文的摘要如下:
我们提出了焦点调制网络(简称 FocalNets),其中自注意力(SA)完全被焦点调制机制取代,用于建模视觉中的令牌交互。焦点调制包括三个组件:(i)分层上下文化,使用一堆深度卷积层实现,以编码从短到长范围的视觉上下文,(ii)门控聚合,根据其内容选择性地收集每个查询令牌的上下文,以及(iii)逐元调制或仿射变换,将聚合的上下文注入查询中。大量实验证明,FocalNets 在图像分类、目标检测和分割任务上优于最先进的自注意力对应物(例如 Swin 和 Focal Transformers),并且具有类似的计算成本。具体而言,尺寸微小和基础尺寸的 FocalNets 在 ImageNet-1K 上分别实现了 82.3%和 83.9%的 top-1 准确率。在 224 分辨率上在 ImageNet-22K 上预训练后,当分别使用 224 和 384 分辨率进行微调时,它分别达到了 86.5%和 87.3%的 top-1 准确率。转移到下游任务时,FocalNets 表现出明显的优势。对于使用 Mask R-CNN 进行目标检测,基础训练的 FocalNet 优于 Swin 对应物 2.1 个点,并且已经超过了使用 3 倍计划训练的 Swin(49.0 对 48.5)。对于使用 UPerNet 进行语义分割,单尺度的 FocalNet 优于 Swin 2.4 个点,并且在多尺度上击败了 Swin(50.5 对 49.7)。使用大型 FocalNet 和 Mask2former,我们在 ADE20K 语义分割上实现了 58.5 的 mIoU,以及在 COCO Panoptic 分割上实现了 57.9 的 PQ。使用巨大的 FocalNet 和 DINO,我们在 COCO minival 和 test-dev 上分别实现了 64.3 和 64.4 的 mAP,建立了新的 SoTA,超越了像 Swinv2-G 和 BEIT-3 这样的更大的基于注意力的模型。
class transformers.FocalNetConfig
参数
int
,可选,默认为 224)— 每个图像的大小(分辨率)。
patch_size
(int
,可选,默认为 4)— 嵌入层中每个补丁的大小(分辨率)。
num_channels
(int
,可选,默认为 3)— 输入通道数。
embed_dim
(int
,可选,默认为 96)— 补丁嵌入的维度。
use_conv_embed
(bool
,可选,默认为False
)— 是否使用卷积嵌入。作者指出,使用卷积嵌入通常会提高性能,但默认情况下不使用。
hidden_sizes
(List[int]
,可选,默认为[192, 384, 768, 768]
)— 每个阶段的维度(隐藏大小)。
depths
(list(int)
,可选,默认为[2, 2, 6, 2]
)— 编码器中每个阶段的深度(层数)。
focal_levels
(list(int)
,可选,默认为[2, 2, 2, 2]
)— 编码器中各阶段的每层中的焦点级别数。
focal_windows
(list(int)
, 可选, 默认为[3, 3, 3, 3]
) — 编码器中各阶段的各层中的焦点窗口大小。
hidden_act
(str
或function
, 可选, 默认为"gelu"
) — 编码器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。
mlp_ratio
(float
, 可选, 默认为 4.0) — MLP 隐藏维度与嵌入维度的比率。
hidden_dropout_prob
(float
, 可选, 默认为 0.0) — 嵌入和编码器中所有全连接层的丢失概率。
drop_path_rate
(float
, 可选, 默认为 0.1) — 随机深度率。
use_layerscale
(bool
, 可选, 默认为False
) — 是否在编码器中使用层比例。
layerscale_value
(float
, 可选, 默认为 0.0001) — 层比例的初始值。
use_post_layernorm
(bool
, 可选, 默认为False
) — 是否在编码器中使用后层归一化。
use_post_layernorm_in_modulation
(bool
, 可选, 默认为False
) — 是否在调制层中使用后层归一化。
normalize_modulator
(bool
, 可选, 默认为False
) — 是否对调制器进行归一化。
initializer_range
(float
, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps
(float
, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon。
encoder_stride
(int
, 可选, 默认为 32) — 用于掩蔽图像建模中解码器头部增加空间分辨率的因子。
out_features
(List[str]
, 可选) — 如果用作骨干,要输出的特征列表。可以是任何一个"stem"
、"stage1"
、"stage2"
等(取决于模型有多少阶段)。如果未设置且设置了out_indices
,将默认为相应的阶段。如果未设置且out_indices
未设置,将默认为最后一个阶段。必须按照stage_names
属性中定义的顺序。
out_indices
(List[int]
, 可选) — 如果用作骨干,要输出的特征的索引列表。可以是 0、1、2 等(取决于模型有多少阶段)。如果未设置且设置了out_features
,将默认为相应的阶段。如果未设置且out_features
未设置,将默认为最后一个阶段。必须按照stage_names
属性中定义的顺序。
这是用于存储 FocalNetModel 配置的配置类。它用于根据指定的参数实例化一个 FocalNet 模型,定义模型架构。使用默认值实例化配置将产生类似于FocalNet架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
class transformers.FocalNetModel
参数
config
(FocalNetConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。裸的 FocalNet 模型输出原始隐藏状态,没有特定的头部。这个模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用 AutoImageProcessor 获取。查看AutoImageProcessor.__call__()
获取详细信息。
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。查看返回张量中的hidden_states
获取更多细节。
return_dict
(bool
, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
bool_masked_pos
(torch.BoolTensor
,形状为(batch_size, num_patches)
) — 布尔掩码位置。指示哪些补丁被掩盖(1)哪些没有(0)。
返回
transformers.models.focalnet.modeling_focalnet.FocalNetModelOutput
或tuple(torch.FloatTensor)
一个transformers.models.focalnet.modeling_focalnet.FocalNetModelOutput
或一个torch.FloatTensor
元组(如果传入return_dict=False
或者config.return_dict=False
时)包含根据配置(FocalNetConfig)和输入的不同元素。
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。
pooler_output
(torch.FloatTensor
,形状为(batch_size, hidden_size)
,可选,当传入add_pooling_layer=True
时返回) — 最后一层隐藏状态的平均池化。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传入output_hidden_states=True
或者config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入输出,一个用于每个阶段的输出)。
模型在每一层输出的隐藏状态以及初始嵌入输出。
reshaped_hidden_states
(tuple(torch.FloatTensor)
,可选,当传入output_hidden_states=True
或者config.output_hidden_states=True
时返回) — 形状为(batch_size, hidden_size, height, width)
的torch.FloatTensor
元组(一个用于嵌入输出,一个用于每个阶段的输出)。
模型在每一层输出的隐藏状态以及初始嵌入输出重塑以包含空间维度。
FocalNetModel 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用Module
实例而不是这个,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.FocalNetForMaskedImageModeling
参数
config
(FocalNetConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。FocalNet 模型,顶部带有解码器,用于对遮蔽图像进行建模。
这遵循与SimMIM中相同的实现。
请注意,我们在我们的示例目录中提供了一个脚本,用于在自定义数据上预训练此模型。
这个模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
pixel_values
(torch.FloatTensor
of shape (batch_size, num_channels, height, width)
) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅AutoImageProcessor.__call__()
。
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。
bool_masked_pos
(torch.BoolTensor
of shape (batch_size, num_patches)
) — 布尔掩码位置。指示哪些补丁被掩盖(1)哪些没有(0)。
返回值
transformers.models.focalnet.modeling_focalnet.FocalNetMaskedImageModelingOutput
或tuple(torch.FloatTensor)
一个transformers.models.focalnet.modeling_focalnet.FocalNetMaskedImageModelingOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时)包含各种元素,具体取决于配置(FocalNetConfig)和输入。
loss
(torch.FloatTensor
of shape (1,)
, optional, returned when bool_masked_pos
is provided) — 遮蔽图像建模(MLM)损失。
reconstruction
(torch.FloatTensor
of shape (batch_size, num_channels, height, width)
) — 重建的像素值。
hidden_states
(tuple(torch.FloatTensor)
, optional, returned when output_hidden_states=True
is passed or when config.output_hidden_states=True
) — Tuple of torch.FloatTensor
(one for the output of the embeddings + one for the output of each stage) of shape (batch_size, sequence_length, hidden_size)
.
模型在每一层的输出处的隐藏状态以及初始嵌入输出。
reshaped_hidden_states
(tuple(torch.FloatTensor)
, optional, returned when output_hidden_states=True
is passed or when config.output_hidden_states=True
) — Tuple of torch.FloatTensor
(one for the output of the embeddings + one for the output of each stage) of shape (batch_size, hidden_size, height, width)
。
模型在每一层的输出处的隐藏状态以及重塑以包含空间维度的初始嵌入输出。
FocalNetForMaskedImageModeling 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.FocalNetForImageClassification
参数
config
(FocalNetConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。在顶部带有图像分类头部的 FocalNet 模型(在池化输出之上的线性层),例如用于 ImageNet。
此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
pixel_values
(torch.FloatTensor
,形状为 (batch_size, num_channels, height, width)
) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 AutoImageProcessor.__call__()
。
output_hidden_states
(bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
。
return_dict
(bool
,可选) — 是否返回 ModelOutput 而不是普通元组。
labels
(torch.LongTensor
,形状为 (batch_size,)
,可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1]
范围内。如果 config.num_labels == 1
,则计算回归损失(均方损失),如果 config.num_labels > 1
,则计算分类损失(交叉熵)。
返回
transformers.models.focalnet.modeling_focalnet.FocalNetImageClassifierOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.focalnet.modeling_focalnet.FocalNetImageClassifierOutput
或一个 torch.FloatTensor
元组(如果传递 return_dict=False
或当 config.return_dict=False
时)包含各种元素,取决于配置(FocalNetConfig)和输入。
loss
(torch.FloatTensor
,形状为 (1,)
,可选,当提供 labels
时返回) — 分类(或回归,如果 config.num_labels==1
)损失。
logits
(torch.FloatTensor
,形状为 (batch_size, config.num_labels)
) — 分类(或回归,如果 config.num_labels==1
)分数(SoftMax 之前)。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递 output_hidden_states=True
或当 config.output_hidden_states=True
时返回) — 形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个阶段的输出)。
模型在每个层的输出以及初始嵌入输出的隐藏状态。
reshaped_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递 output_hidden_states=True
或当 config.output_hidden_states=True
时返回) — 形状为 (batch_size, hidden_size, height, width)
的 torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个阶段的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出,重塑以包括空间维度。
FocalNetForImageClassification 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行前处理和后处理步骤,而后者则默默地忽略它们。
示例:
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/glpn
这是一个最近推出的模型,因此 API 尚未经过广泛测试。未来可能会有一些错误或轻微的破坏性更改需要修复。如果您发现异常,请提交 Github Issue。
GLPN 模型由 Doyeon Kim, Woonghyun Ga, Pyungwhan Ahn, Donggyu Joo, Sehwan Chun, Junmo Kim 在 Global-Local Path Networks for Monocular Depth Estimation with Vertical CutDepth 中提出。GLPN 将 SegFormer 的分层混合变压器与轻量级解码器结合,用于单眼深度估计。所提出的解码器显示出比先前提出的解码器更好的性能,且计算复杂度明显较低。
论文摘要如下:
从单个图像进行深度估计是一个重要的任务,可以应用于计算机视觉的各个领域,并随着卷积神经网络的发展而迅速增长。在本文中,我们提出了一种新颖的结构和训练策略,用于单眼深度估计,以进一步提高网络的预测准确性。我们部署了一个分层变压器编码器来捕获和传达全局上下文,并设计了一个轻量级但功能强大的解码器,以生成估计的深度图,同时考虑局部连接性。通过使用我们提出的选择性特征融合模块在多尺度局部特征和全局解码流之间构建连接路径,网络可以整合两种表示并恢复细节。此外,所提出的解码器显示出比先前提出的解码器更好的性能,且计算复杂度明显较低。此外,我们通过利用深度估计中的一个重要观察结果来改进深度特定的增强方法,以增强模型。我们的网络在具有挑战性的深度数据集 NYU Depth V2 上实现了最先进的性能。已进行了大量实验来验证和展示所提出方法的有效性。最后,我们的模型显示出比其他比较模型更好的泛化能力和鲁棒性。
方法概述。摘自 原始论文。
一系列官方 Hugging Face 和社区(由 🌎 表示)资源,可帮助您开始使用 GLPN。
class transformers.GLPNConfig
参数
num_channels
(int
, 可选, 默认为 3) — 输入通道数。
num_encoder_blocks
(int
, 可选, 默认为 4) — 编码器块的数量(即 Mix Transformer 编码器中的阶段数)。
depths
(List[int]
, 可选, 默认为 [2, 2, 2, 2]
) — 每个编码器块中的层数。
sr_ratios
(List[int]
, 可选, 默认为 [8, 4, 2, 1]
) — 每个编码器块中的序列缩减比率。
hidden_sizes
(List[int]
, 可选, 默认为 [32, 64, 160, 256]
) — 每个编码器块的维度。
patch_sizes
(List[int]
, 可选, 默认为 [7, 3, 3, 3]
) — 每个编码器块之前的补丁大小。
strides
(List[int]
, 可选, 默认为 [4, 2, 2, 2]
) — 每个编码器块之前的步幅。
num_attention_heads
(List[int]
, 可选, 默认为 [1, 2, 5, 8]
) — 每个 Transformer 编码器块中每个注意力层的注意力头数。
mlp_ratios
(List[int]
, 可选, 默认为 [4, 4, 4, 4]
) — 编码器块中 Mix FFN 隐藏层大小与输入层大小的比率。
hidden_act
(str
或 function
, 可选, 默认为 "gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu"
, "relu"
, "selu"
和 "gelu_new"
。
hidden_dropout_prob
(float
, 可选, 默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。
attention_probs_dropout_prob
(float
, 可选, 默认为 0.0) — 注意力概率的丢失比率。
initializer_range
(float
, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
drop_path_rate
(float
, 可选, 默认为 0.1) — 用于随机深度的丢失概率,用于 Transformer 编码器块中。
layer_norm_eps
(float
, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon。
decoder_hidden_size
(int
, 可选, 默认为 64) — 解码器的维度。
max_depth
(int
, 可选, 默认为 10) — 解码器的最大深度。
head_in_index
(int
, 可选, 默认为 -1) — 用于在头部中使用的特征的索引。
这是用于存储 GLPNModel 配置的配置类。它用于根据指定的参数实例化一个 GLPN 模型,定义模型架构。使用默认值实例化配置将产生类似于 GLPN vinvino02/glpn-kitti 架构的配置。
配置对象继承自 PretrainedConfig 并可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。
示例:
class transformers.GLPNFeatureExtractor
__call__
预处理一张图像或一批图像。
class transformers.GLPNImageProcessor
参数
do_resize
(bool
, 可选, 默认为 True
) — 是否调整图像的(高度,宽度)尺寸,将它们向下舍入到最接近 size_divisor
的倍数。可以被 preprocess
中的 do_resize
覆盖。
size_divisor
(int
, 可选, 默认为 32) — 当 do_resize
为 True
时,图像将被调整大小,使其高度和宽度向下舍入到最接近 size_divisor
的倍数。可以被 preprocess
中的 size_divisor
覆盖。
resample
(PIL.Image
重采样滤波器, 可选, 默认为 Resampling.BILINEAR
) — 如果调整图像大小,则要使用的重采样滤波器。可以被 preprocess
中的 resample
覆盖。
do_rescale
(bool
, 可选, 默认为 True
) — 是否应用缩放因子(使像素值在 0 和 1 之间浮动)。可以被 preprocess
中的 do_rescale
覆盖。
构建一个 GLPN 图像处理器。
preprocess
参数
images
(PIL.Image.Image
或 TensorType
或 List[np.ndarray]
或 List[TensorType]
)— 要预处理的图像。期望单个或批量图像,像素值范围从 0 到 255。如果传入像素值在 0 到 1 之间的图像,请设置 do_normalize=False
。
do_resize
(bool
,可选,默认为 self.do_resize
)— 是否调整输入大小,使得(高度,宽度)维度是 size_divisor
的倍数。
size_divisor
(int
,可选,默认为 self.size_divisor
)— 当 do_resize
为 True
时,图像被调整大小,使其高度和宽度向下舍入到最接近的 size_divisor
的倍数。
resample
(PIL.Image
重采样滤波器,可选,默认为 self.resample
)— 如果调整图像大小,则使用的 PIL.Image
重采样滤波器,例如 PILImageResampling.BILINEAR
。仅在 do_resize
设置为 True
时有效。
do_rescale
(bool
,可选,默认为 self.do_rescale
)— 是否应用缩放因子(使像素值在 0 到 1 之间)。
return_tensors
(str
或 TensorType
,可选)— 要返回的张量类型。可以是以下之一:
None
: 返回一个 np.ndarray
列表。
TensorType.TENSORFLOW
或 'tf'
: 返回类型为 tf.Tensor
的批处理。
TensorType.PYTORCH
或 'pt'
: 返回类型为 torch.Tensor
的批处理。
TensorType.NUMPY
或 'np'
: 返回类型为 np.ndarray
的批处理。
TensorType.JAX
或 'jax'
: 返回类型为 jax.numpy.ndarray
的批处理。
data_format
(ChannelDimension
或 str
,可选,默认为 ChannelDimension.FIRST
)— 输出图像的通道维度格式。可以是以下之一:
ChannelDimension.FIRST
: 图像以(通道数,高度,宽度)格式。
ChannelDimension.LAST
: 图像以(高度,宽度,通道数)格式。
input_data_format
(ChannelDimension
或 str
,可选)— 输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:
"channels_first"
或 ChannelDimension.FIRST
: 图像以(通道数,高度,宽度)格式。
"channels_last"
或 ChannelDimension.LAST
: 图像以(高度,宽度,通道数)格式。
"none"
或 ChannelDimension.NONE
: 图像以(高度,宽度)格式。
预处理给定的图像。
class transformers.GLPNModel
参数
config
(GLPNConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。裸的 GLPN 编码器(Mix-Transformer)输出原始隐藏状态,没有特定的顶部头。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
pixel_values
(形状为 (batch_size, num_channels, height, width)
的 torch.FloatTensor
)— 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 GLPNImageProcessor.call
()。
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.BaseModelOutput 或tuple(torch.FloatTensor)
transformers.modeling_outputs.BaseModelOutput 或torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
时)包含根据配置(GLPNConfig)和输入的不同元素。
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
)— 模型最后一层的隐藏状态序列。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型具有嵌入层,则为嵌入输出的一个+每个层的输出一个)。
模型在每个层的输出处的隐藏状态加上可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
GLPNModel 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.GLPNForDepthEstimation
参数
config
(GLPNConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。GLPN 模型变换器,顶部带有轻量级深度估计头,例如适用于 KITTI、NYUv2。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
前进
参数
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)- 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 GLPNImageProcessor.call
()。
output_attentions
(可选,布尔值)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
。
output_hidden_states
(可选,布尔值)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。
return_dict
(可选,布尔值)- 是否返回 ModelOutput 而不是普通元组。
labels
(形状为(batch_size, height, width)
的torch.FloatTensor
,可选)- 用于计算损失的地面真实深度估计图。
返回
transformers.modeling_outputs.DepthEstimatorOutput 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.DepthEstimatorOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时),包括根据配置(GLPNConfig)和输入的不同元素。
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)- 分类(如果 config.num_labels==1 则为回归)损失。
predicted_depth
(形状为(batch_size, height, width)
的torch.FloatTensor
)- 每个像素的预测深度。
hidden_states
(可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回)- 形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。
模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
attentions
(可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, patch_size, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
GLPNForDepthEstimation 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/imagegpt
ImageGPT 模型是由 Mark Chen、Alec Radford、Rewon Child、Jeffrey Wu、Heewoo Jun、David Luan、Ilya Sutskever 在像素生成预训练中提出的。ImageGPT(iGPT)是一个类似于 GPT-2 的模型,训练用于预测下一个像素值,从而实现无条件和有条件的图像生成。
论文摘要如下:
受到自然语言无监督表示学习进展的启发,我们研究类似的模型是否可以学习对图像有用的表示。我们训练一个序列 Transformer,自回归地预测像素,而不考虑 2D 输入结构的知识。尽管在没有标签的低分辨率 ImageNet 上训练,我们发现一个 GPT-2 规模的模型通过线性探测、微调和低数据分类来衡量,学习到了强大的图像表示。在 CIFAR-10 上,我们通过线性探测实现了 96.3%的准确率,超过了监督的 Wide ResNet,并且通过完全微调实现了 99.0%的准确率,与顶级监督预训练模型相匹敌。当用 VQVAE 编码替换像素时,我们在 ImageNet 上也与自监督基准竞争,通过线性探测我们的特征实现了 69.0%的 top-1 准确率。
方法概述。摘自原始论文。
该模型由nielsr贡献,基于此问题。原始代码可以在这里找到。
output_hidden_states=True
,然后在任何您喜欢的层上对隐藏状态进行平均池化,可以轻松获取特征。
模型变体 | 深度 | 隐藏大小 | 解码器隐藏大小 | 参数(M) | ImageNet-1k Top 1 |
---|---|---|---|---|---|
MiT-b0 | [2, 2, 2, 2] | [32, 64, 160, 256] | 256 | 3.7 | 70.5 |
MiT-b1 | [2, 2, 2, 2] | [64, 128, 320, 512] | 256 | 14.0 | 78.7 |
MiT-b2 | [3, 4, 6, 3] | [64, 128, 320, 512] | 768 | 25.4 | 81.6 |
MiT-b3 | [3, 4, 18, 3] | [64, 128, 320, 512] | 768 | 45.2 | 83.1 |
MiT-b4 | [3, 8, 27, 3] | [64, 128, 320, 512] | 768 | 62.6 | 83.6 |
MiT-b5 | [3, 6, 40, 3] | [64, 128, 320, 512] | 768 | 82.0 | 83.8 |
一个官方的 Hugging Face 和社区(由🌎表示)资源列表,帮助您开始使用 ImageGPT。
图像分类
如果您有兴趣提交资源以包含在这里,请随时打开一个 Pull Request,我们将进行审核!资源应该展示一些新东西,而不是重复现有资源。
class transformers.ImageGPTConfig
参数
vocab_size
(int
,可选,默认为 512) — GPT-2 模型的词汇大小。定义了在调用 ImageGPTModel 或TFImageGPTModel
时可以表示的不同令牌数量。
n_positions
(int
,可选,默认为 32*32) — 此模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512 或 1024 或 2048)。
n_embd
(int
,可选,默认为 512) — 嵌入和隐藏状态的维度。
n_layer
(int
,可选,默认为 24) — Transformer 编码器中的隐藏层数。
n_head
(int
,可选,默认为 8) — Transformer 编码器中每个注意力层的注意力头数。
n_inner
(int
,可选,默认为 None) — 内部前馈层的维度。None
将将其设置为 n_embd 的 4 倍。
activation_function
(str
,可选,默认为"quick_gelu"
) — 激活函数(可以是 src/transformers/activations.py 中定义的激活函数之一)。默认为"quick_gelu"
。
resid_pdrop
(float
,可选,默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的丢失概率。
embd_pdrop
(int
,可选,默认为 0.1) — 嵌入的丢失比率。
attn_pdrop
(float
,可选,默认为 0.1) — 注意力的丢失比率。
layer_norm_epsilon
(float
,可选,默认为 1e-5) — 在层归一化层中使用的 epsilon。
initializer_range
(float
,可选,默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
scale_attn_weights
(bool
,可选,默认为True
) — 通过除以 sqrt(hidden_size)来缩放注意力权重。
use_cache
(bool
, 可选, 默认为True
) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。
scale_attn_by_inverse_layer_idx
(bool
, 可选, 默认为False
) — 是否额外按1 / layer_idx + 1
缩放注意力权重。
reorder_and_upcast_attn
(bool
, 可选, 默认为False
) — 是否在计算注意力(点积)之前缩放键(K),并在使用混合精度训练时将注意力点积/softmax 向上转换为 float()。
这是配置类,用于存储 ImageGPTModel 或TFImageGPTModel
的配置。根据指定的参数实例化一个 GPT-2 模型,定义模型架构。使用默认值实例化配置将产生类似于 ImageGPT openai/imagegpt-small架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
class transformers.ImageGPTFeatureExtractor
__call__
预处理一张图像或一批图像。
class transformers.ImageGPTImageProcessor
参数
clusters
(np.ndarray
或List[List[int]]
, 可选) — 在颜色量化时要使用的颜色簇,形状为(n_clusters, 3)
。可以被preprocess
中的clusters
覆盖。
do_resize
(bool
, 可选, 默认为True
) — 是否将图像的尺寸调整为(size["height"], size["width"])
。可以被preprocess
中的do_resize
覆盖。
size
(Dict[str, int]
可选, 默认为{"height" -- 256, "width": 256}
): 调整大小后的图像尺寸。可以被preprocess
中的size
覆盖。
resample
(PILImageResampling
, 可选, 默认为Resampling.BILINEAR
) — 如果调整图像大小,要使用的重采样滤波器。可以被preprocess
中的resample
覆盖。
do_normalize
(bool
, 可选, 默认为True
) — 是否将图像像素值归一化为[-1, 1]之间。可以被preprocess
中的do_normalize
覆盖。
do_color_quantize
(bool
, 可选, 默认为True
) — 是否对图像进行颜色量化。可以被preprocess
中的do_color_quantize
覆盖。
构建一个 ImageGPT 图像处理器。此图像处理器可用于将图像调整为较小分辨率(如 32x32 或 64x64),对其进行归一化,最后进行颜色量化,以获得“像素值”(颜色簇)序列。
preprocess
参数
images
(ImageInput
) — 要预处理的图像。期望像素值从 0 到 255 的单个图像或图像批次。如果传入像素值在 0 到 1 之间的图像,请设置do_normalize=False
。
do_resize
(bool
, 可选, 默认为self.do_resize
) — 是否调整图像大小。
size
(Dict[str, int]
, 可选, 默认为self.size
) — 调整大小后的图像尺寸。
resample
(int
,可选,默认为 self.resample
) — 如果调整图像大小,则要使用的重采样滤波器。可以是枚举 PILImageResampling
中的一个,仅在 do_resize
设置为 True
时有效。
do_normalize
(bool
,可选,默认为 self.do_normalize
) — 是否对图像进行归一化
do_color_quantize
(bool
,可选,默认为 self.do_color_quantize
) — 是否对图像进行颜色量化。
clusters
(np.ndarray
或 List[List[int]]
,可选,默认为 self.clusters
) — 用于对图像进行量化的聚类,形状为 (n_clusters, 3)
。仅在 do_color_quantize
设置为 True
时有效。
return_tensors
(str
或 TensorType
,可选) — 返回的张量类型。可以是以下之一:
np.ndarray
列表。
TensorType.TENSORFLOW
或 'tf'
: 返回类型为 tf.Tensor
的批次。
TensorType.PYTORCH
或 'pt'
: 返回类型为 torch.Tensor
的批次。
TensorType.NUMPY
或 'np'
: 返回类型为 np.ndarray
的批次。
TensorType.JAX
或 'jax'
: 返回类型为 jax.numpy.ndarray
的批次。
data_format
(ChannelDimension
或 str
,可选,默认为 ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:
ChannelDimension.FIRST
: 图像格式为 (通道数, 高度, 宽度)。
ChannelDimension.LAST
: 图像格式为 (高度, 宽度, 通道数)。仅在 do_color_quantize
设置为 False
时有效。
input_data_format
(ChannelDimension
或 str
,可选) — 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:
"channels_first"
或 ChannelDimension.FIRST
: 图像格式为 (通道数, 高度, 宽度)。
"channels_last"
或 ChannelDimension.LAST
: 图像格式为 (高度, 宽度, 通道数)。
"none"
或 ChannelDimension.NONE
: 图像格式为 (高度, 宽度)。
预处理图像或图像批次。
class transformers.ImageGPTModel
参数
config
(ImageGPTConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。裸的 ImageGPT 模型变压器,输出没有特定头部的原始隐藏状态。
该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
该模型还是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。
forward
参数
input_ids
(形状为 (batch_size, sequence_length)
的 torch.LongTensor
) — 如果 past_key_values
为 None
,则 input_ids_length
= sequence_length
,否则为 past_key_values[0][0].shape[-2]
(输入过去关键值状态的序列长度)。词汇表中输入序列标记的索引。
如果使用了 past_key_values
,则只应将未计算其过去的 input_ids
作为 input_ids
传递。
可以使用 AutoImageProcessor 获取索引。有关详细信息,请参见 ImageGPTImageProcessor.call
()。
past_key_values
(长度为config.n_layers
的Tuple[Tuple[torch.Tensor]]
)- 包含由模型计算的预先计算的隐藏状态(注意力块中的键和值),可以用于加速顺序解码。将过去给定给该模型的input_ids
不应作为input_ids
传递,因为它们已经被计算过。
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:
masked
的标记,
masked
的标记。
什么是 attention masks?
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 段标记索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:
什么是 token type IDs?
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。
什么是 position IDs?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:
masked
,
masked
。
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。
如果使用past_key_values
,则可以选择仅输入最后的inputs_embeds
(请参见past_key_values
)。
use_cache
(bool
,可选)- 如果设置为True
,则返回past_key_values
键值状态,并可用于加速解码(请参见past_key_values
)。
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回的张量下的attentions
。
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回的张量下的hidden_states
。
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。
labels
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 用于语言建模的标签。请注意,模型内部的标签已经被移位,即您可以设置labels = input_ids
。索引在[-100, 0, ..., config.vocab_size]
中选择。所有设置为-100
的标签都被忽略(被masked
),损失仅计算标签在[0, ..., config.vocab_size]
中的情况。
返回
transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(ImageGPTConfig)和输入的各种元素。
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
) — 模型最后一层的输出的隐藏状态序列。
如果使用past_key_values
,则只输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。
past_key_values
(tuple(tuple(torch.FloatTensor))
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的tuple(torch.FloatTensor)
元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,如果config.is_encoder_decoder=True
还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。
包含预先计算的隐藏状态(自注意力块中的键和值,以及在交叉注意力块中可选地使用config.is_encoder_decoder=True
)可用于加速顺序解码(查看past_key_values
输入)。
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出,如果模型有嵌入层,+ 一个用于每个层的输出)。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
和config.add_cross_attention=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
ImageGPTModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.ImageGPTForCausalImageModeling
参数
config
(ImageGPTConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。ImageGPT 模型变压器,顶部带有语言建模头(线性层,其权重与输入嵌入层绑定)。
此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存,调整输入嵌入大小,修剪头等)。
此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 如果past_key_values
为None
,则input_ids_length
= sequence_length
,否则为past_key_values[0][0].shape[-2]
(输入过去键值状态的序列长度)。词汇中输入序列标记的索引。
如果使用past_key_values
,则只应将尚未计算其过去的input_ids
作为input_ids
传递。
可以使用 AutoImageProcessor 获取索引。有关详细信息,请参阅 ImageGPTImageProcessor.call
()。
past_key_values
(长度为config.n_layers
的Tuple[Tuple[torch.Tensor]]
)— 包含由模型计算的预计算隐藏状态(注意力块中的键和值)(请参阅下面的past_key_values
输出)。可用于加速顺序解码。已将其过去给予此模型的input_ids
不应作为input_ids
传递,因为它们已经计算过。
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
中:
什么是注意力掩码?
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]
中:
什么是令牌类型 ID?
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。
什么是位置 ID?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]
中:
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望更多地控制如何将input_ids
索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。
如果使用past_key_values
,则可以选择仅输入最后的inputs_embeds
(请参阅past_key_values
)。
use_cache
(bool
,可选)— 如果设置为True
,则返回past_key_values
键值状态,并可用于加速解码(请参阅past_key_values
)。
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的attentions
。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的hidden_states
。
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
labels
(torch.LongTensor
的形状为(batch_size, sequence_length)
,optional) — 语言建模的标签。请注意,标签在模型内部被移位,即您可以设置labels = input_ids
,索引在[-100, 0, ..., config.vocab_size]
中选择。所有设置为-100
的标签都被忽略(掩码),损失仅计算在[0, ..., config.vocab_size]
中的标签。
返回
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor
元组
一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
,则根据配置(ImageGPTConfig)和输入包含各种元素。
loss
(torch.FloatTensor
of shape (1,)
, optional, 当提供labels
时返回) — 语言建模损失(用于下一个标记预测)。
logits
(torch.FloatTensor
的形状为(batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — torch.FloatTensor
元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每个层的输出)的形状为(batch_size, sequence_length, hidden_size)
。
模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — torch.FloatTensor
元组(每层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)
。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — torch.FloatTensor
元组(每层一个)的形状为(batch_size, num_heads, sequence_length, sequence_length)
。
在注意力 softmax 之后的交叉注意力权重,用于计算交叉注意力头中的加权平均值。
past_key_values
(tuple(tuple(torch.FloatTensor))
, optional, 当传递use_cache=True
或config.use_cache=True
时返回) — 长度为config.n_layers
的torch.FloatTensor
元组,每个元组包含自注意力和交叉注意力层的缓存键、值状态,如果模型用于编码器-解码器设置,则相关。仅在config.is_decoder = True
时相关。
包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码(参见past_key_values
输入)。
ImageGPTForCausalImageModeling 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.ImageGPTForImageClassification
参数
config
(ImageGPTConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。ImageGPT 模型变压器顶部带有图像分类头(线性层)。ImageGPTForImageClassification 对隐藏状态进行平均池化以进行分类。
该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
该模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 如果past_key_values
为None
,则input_ids_length
= sequence_length
,否则为past_key_values[0][0].shape[-2]
(输入过去键值状态的序列长度)。词汇表中输入序列标记的索引。
如果使用past_key_values
,则只应将未计算其过去的input_ids
作为input_ids
传递。
可以使用 AutoImageProcessor 获取索引。有关详细信息,请参阅 ImageGPTImageProcessor.call
()。
past_key_values
(长度为config.n_layers
的Tuple[Tuple[torch.Tensor]]
)— 包含由模型计算的预计算隐藏状态(注意力块中的键和值)(请参见下面的past_key_values
输出)。可用于加速顺序解码。将过去给定给该模型的input_ids
不应作为input_ids
传递,因为它们已经计算过。
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:
masked
的标记,
masked
的标记。
什么是注意力掩码?
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引在[0, 1]
中选择:
什么是标记类型 ID?
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。
什么是位置 ID?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]
中选择:
masked
,
masked
。
inputs_embeds
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选)— 可选地,可以直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制权来将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。
如果使用了past_key_values
,则可能只需输入最后的inputs_embeds
(参见past_key_values
)。
use_cache
(bool
,可选)— 如果设置为True
,则返回past_key_values
键值状态,可用于加速解码(参见past_key_values
)。
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
,可选)— 是否返回一个 ModelOutput 而不是一个普通元组。
labels
(torch.LongTensor
,形状为(batch_size,)
,可选)— 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
范围内。如果config.num_labels == 1
,则计算回归损失(均方损失),如果config.num_labels > 1
,则计算分类损失(交叉熵)。
返回
transformers.modeling_outputs.SequenceClassifierOutputWithPast
或tuple(torch.FloatTensor)
一个transformers.modeling_outputs.SequenceClassifierOutputWithPast
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(ImageGPTConfig)和输入的各种元素。
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回)— 分类(如果 config.num_labels==1 则为回归)损失。
logits
(torch.FloatTensor
,形状为(batch_size, config.num_labels)
)— 分类(如果 config.num_labels==1 则为回归)得分(SoftMax 之前)。
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量。
包含预先计算的隐藏状态(自注意力块中的键和值),可用于加速顺序解码。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出加上每层的输出)。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
ImageGPTForImageClassification 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此之后调用,因为前者负责运行前处理和后处理步骤,而后者则会默默地忽略它们。
示例:
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/levit
LeViT 模型是由 Ben Graham,Alaaeldin El-Nouby,Hugo Touvron,Pierre Stock,Armand Joulin,Hervé Jégou,Matthijs Douze 在LeViT: Introducing Convolutions to Vision Transformers中提出的。LeViT 通过一些架构上的差异来提高视觉 Transformer(ViT)的性能和效率,例如在 Transformer 中使用分辨率递减的激活图以及引入注意偏置以整合位置信息。
论文摘要如下:
我们设计了一系列图像分类架构,优化了在高速环境中准确性和效率之间的权衡。我们的工作利用了最近在基于注意力的架构中的发现,这些架构在高度并行处理硬件上具有竞争力。我们重新审视了卷积神经网络的广泛文献中的原则,将它们应用于 Transformer,特别是使用分辨率递减的激活图。我们还引入了注意偏置,一种将位置信息整合到视觉 Transformer 中的新方法。因此,我们提出了 LeVIT:一个用于快速推理图像分类的混合神经网络。我们考虑在不同硬件平台上的不同效率措施,以最好地反映各种应用场景。我们的广泛实验证明了我们的技术选择,并表明它们适用于大多数架构。总体而言,LeViT 在速度/准确性权衡方面明显优于现有的卷积网络和视觉 Transformer。例如,在 80%的 ImageNet top-1 准确率下,LeViT 比 EfficientNet 在 CPU 上快 5 倍。
LeViT 架构。摘自原始论文。
一个官方 Hugging Face 和社区(由 🌎 表示)资源列表,帮助您开始使用 LeViT。
图像分类
如果您有兴趣提交资源以包含在此处,请随时打开一个 Pull Request,我们将对其进行审查!资源应该展示一些新东西,而不是重复现有资源。
class transformers.LevitConfig
参数
image_size
(int
, optional, defaults to 224) — 输入图像的大小。
num_channels
(int
, optional, defaults to 3) — 输入图像中的通道数。
kernel_size
(int
, optional, defaults to 3) — 补丁嵌入的初始卷积层的内核大小。
stride
(int
, optional, defaults to 2) — 补丁嵌入的初始卷积层的步幅大小。
padding
(int
, optional, defaults to 1) — 补丁嵌入的初始卷积层的填充大小。
patch_size
(int
, optional, defaults to 16) — 嵌入的补丁大小。
hidden_sizes
(List[int]
, optional, defaults to [128, 256, 384]
) — 每个编码器块的维度。
num_attention_heads
(List[int]
, 可选, 默认为 [4, 8, 12]
) — Transformer 编码器每个块中每个注意力层的注意力头数。
depths
(List[int]
, 可选, 默认为 [4, 4, 4]
) — 每个编码器块中的层数。
key_dim
(List[int]
, 可选, 默认为 [16, 16, 16]
) — 每个编码器块中键的大小。
drop_path_rate
(int
, 可选, 默认为 0) — 用于随机深度的丢弃概率,用于 Transformer 编码器块中的块。
mlp_ratios
(List[int]
, 可选, 默认为 [2, 2, 2]
) — 编码器块中 Mix FFNs 的隐藏层大小与输入层大小的比率。
attention_ratios
(List[int]
, 可选, 默认为 [2, 2, 2]
) — 注意力层的输出维度与输入维度的比率。
initializer_range
(float
, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
这是一个配置类,用于存储 LevitModel 的配置。根据指定的参数实例化一个 LeViT 模型,定义模型架构。使用默认值实例化配置将产生类似于 LeViT facebook/levit-128S架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
class transformers.LevitFeatureExtractor
__call__
预处理图像或一批图像。
class transformers.LevitImageProcessor
参数
do_resize
(bool
, 可选, 默认为 True
) — 是否将输入的最短边调整为 int(256/224 *size
)。可以被preprocess
方法中的do_resize
参数覆盖。
size
(Dict[str, int]
, 可选, 默认为 {"shortest_edge" -- 224}
): 调整大小后的输出图像大小。如果 size 是一个带有“width”和“height”键的字典,则图像将被调整为(size["height"], size["width"])
。如果 size 是一个带有“shortest_edge”键的字典,则最短边值c
将被重新缩放为int(c * (256/224))
。图像的较小边将匹配到这个值,即如果高度>宽度,则图像将被重新缩放为(size["shortest_egde"] * height / width, size["shortest_egde"])
。可以被preprocess
方法中的size
参数覆盖。
resample
(PILImageResampling
, 可选, 默认为 Resampling.BICUBIC
) — 如果调整图像大小,则要使用的重采样滤镜。可以被preprocess
方法中的resample
参数覆盖。
do_center_crop
(bool
, 可选, 默认为 True
) — 是否对输入进行中心裁剪为(crop_size["height"], crop_size["width"])
。可以被preprocess
方法中的do_center_crop
参数覆盖。
crop_size
(Dict
, 可选, 默认为 {"height" -- 224, "width": 224}
): center_crop
后的期望图像大小。可以被preprocess
方法中的crop_size
参数覆盖。
do_rescale
(bool
,可选,默认为True
)— 控制是否通过指定的比例rescale_factor
重新缩放图像。可以被preprocess
方法中的do_rescale
参数覆盖。
rescale_factor
(int
或float
,可选,默认为1/255
)— 如果重新缩放图像,则使用的比例因子。可以被preprocess
方法中的rescale_factor
参数覆盖。
do_normalize
(bool
,可选,默认为True
)— 控制是否对图像进行归一化。可以被preprocess
方法中的do_normalize
参数覆盖。
image_mean
(List[int]
,可选,默认为[0.485, 0.456, 0.406]
)— 如果要归一化图像,则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess
方法中的image_mean
参数覆盖。
image_std
(List[int]
,可选,默认为[0.229, 0.224, 0.225]
)— 如果要归一化图像,则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess
方法中的image_std
参数覆盖。
构建一个 LeViT 图像处理器。
preprocess
参数
images
(ImageInput
)— 要预处理的图像或图像批处理。期望单个或批处理的图像,像素值范围从 0 到 255。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。
do_resize
(bool
,可选,默认为self.do_resize
)— 是否调整图像大小。
size
(Dict[str, int]
,可选,默认为self.size
)— 调整大小后的输出图像大小。如果大小是一个带有“宽度”和“高度”键的字典,则图像将被调整为(高度,宽度)。如果大小是一个带有“最短边”键的字典,则最短边值c
将被重新缩放为 int(c
(256/224))。图像的较小边将与此值匹配,即,如果高度>宽度,则图像将被重新缩放为(大小高度/宽度,大小)。
resample
(PILImageResampling
,可选,默认为PILImageResampling.BICUBIC
)— 调整图像大小时要使用的重采样滤波器。
do_center_crop
(bool
,可选,默认为self.do_center_crop
)— 是否对图像进行中心裁剪。
crop_size
(Dict[str, int]
,可选,默认为self.crop_size
)— 中心裁剪后的输出图像大小。将图像裁剪为(crop_size[“height”],crop_size[“width”])。
do_rescale
(bool
,可选,默认为self.do_rescale
)— 是否通过指定的比例rescale_factor
重新缩放图像像素值-通常为 0 到 1 之间的值。
rescale_factor
(float
,可选,默认为self.rescale_factor
)— 用于重新缩放图像像素值的因子。
do_normalize
(bool
,可选,默认为self.do_normalize
)— 是否通过image_mean
和image_std
对图像像素值进行归一化。
image_mean
(float
或List[float]
,可选,默认为self.image_mean
)— 用于归一化图像像素值的均值。
image_std
(float
或List[float]
,可选,默认为self.image_std
)— 用于归一化图像像素值的标准差。
return_tensors
(str
或TensorType
,可选)— 要返回的张量类型。可以是以下之一:
np.ndarray
列表。
TensorType.TENSORFLOW
或'tf'
:返回类型为tf.Tensor
的批处理。
TensorType.PYTORCH
或'pt'
:返回类型为torch.Tensor
的批处理。
TensorType.NUMPY
或'np'
:返回类型为np.ndarray
的批处理。
TensorType.JAX
或'jax'
:返回类型为jax.numpy.ndarray
的批处理。
data_format
(str
或ChannelDimension
,可选,默认为ChannelDimension.FIRST
)— 输出图像的通道维度格式。如果未设置,则使用输入图像的通道维度格式。可以是以下之一:
"channels_first"
或ChannelDimension.FIRST
:图像以(num_channels, height, width)格式。
"channels_last"
或ChannelDimension.LAST
:图像以(height, width, num_channels)格式。
input_data_format
(ChannelDimension
或str
,可选)— 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:
"channels_first"
或ChannelDimension.FIRST
:图像以(num_channels, height, width)格式。
"channels_last"
或ChannelDimension.LAST
:图像以(height, width, num_channels)格式。
"none"
或ChannelDimension.NONE
:图像以(height, width)格式。
对图像或图像批次进行预处理,以用作 LeViT 模型的输入。
class transformers.LevitModel
参数
config
(LevitConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。裸的 Levit 模型输出原始特征,没有任何特定的头部。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。
forward
参数
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 LevitImageProcessor.call
()。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention
或tuple(torch.FloatTensor)
一个transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时)包含各种元素,具体取决于配置(LevitConfig)和输入。
last_hidden_state
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 模型最后一层的隐藏状态序列。
pooler_output
(形状为(batch_size, hidden_size)
的torch.FloatTensor
)— 在空间维度上进行池化操作后的最后一层隐藏状态。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回)— 形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
元组(如果模型具有嵌入层,则为嵌入的输出和每一层的输出)。
模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
LevitModel 前向方法,覆盖__call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在之后调用Module
实例,而不是在这里调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.LevitForImageClassification
参数
config
(LevitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。Levit 模型,顶部带有图像分类头(在池化特征的顶部有一个线性层),例如用于 ImageNet。
这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。
forward
参数
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 LevitImageProcessor.call
()。
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请查看返回张量下的hidden_states
。
return_dict
(bool
,可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
labels
(形状为(batch_size,)
的torch.LongTensor
,可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
范围内。如果config.num_labels == 1
,则计算回归损失(均方损失),如果config.num_labels > 1
,则计算分类损失(交叉熵)。
返回
transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
时)包含各种元素,这取决于配置(LevitConfig)和输入。
loss
(形状为(1,)
的torch.FloatTensor
,可选,在提供labels
时返回) — 分类(如果config.num_labels==1
则为回归)损失。
logits
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
) — 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
元组。模型在每个阶段输出的隐藏状态(也称为特征图)。
LevitForImageClassification 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在之后调用Module
实例,而不是调用此函数,因为前者会处理运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.LevitForImageClassificationWithTeacher
参数
config
(LevitConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。LeViT 模型变压器,顶部带有图像分类头(最终隐藏状态顶部的线性层和蒸馏令牌最终隐藏状态顶部的线性层),例如用于 ImageNet。… 警告:: 此模型仅支持推断。尚不支持使用蒸馏(即使用教师)进行微调。
此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 LevitImageProcessor.call
()。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请查看返回张量下的hidden_states
。
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.levit.modeling_levit.LevitForImageClassificationWithTeacherOutput
或tuple(torch.FloatTensor)
一个transformers.models.levit.modeling_levit.LevitForImageClassificationWithTeacherOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含各种元素,取决于配置(LevitConfig)和输入。
logits
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
)— 预测分数,作为cls_logits
和distillation_logits
的平均值。
cls_logits
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
)— 分类头的预测分数(即类令牌最终隐藏状态顶部的线性层)。
distillation_logits
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
)— 蒸馏头的预测分数(即蒸馏令牌最终隐藏状态顶部的线性层)。
hidden_states
(tuple(torch.FloatTensor)
, 可选的,当传递 output_hidden_states=True
或当 config.output_hidden_states=True
时返回) — 形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层的输出以及初始嵌入输出的隐藏状态。
LevitForImageClassificationWithTeacher 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的方法需要在这个函数内定义,但应该在此之后调用 Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/mask2former
Mask2Former 模型是由 Bowen Cheng、Ishan Misra、Alexander G. Schwing、Alexander Kirillov、Rohit Girdhar 在Masked-attention Mask Transformer for Universal Image Segmentation中提出的。Mask2Former 是一个统一的全景、实例和语义分割框架,相比于 MaskFormer 具有显著的性能和效率改进。
来自论文的摘要如下:
图像分割将具有不同语义的像素分组,例如类别或实例成员资格。每种语义选择定义了一个任务。虽然每个任务的语义不同,但当前的研究重点是为每个任务设计专门的架构。我们提出了 Masked-attention Mask Transformer(Mask2Former),这是一种新的架构,能够处理任何图像分割任务(全景、实例或语义)。其关键组件包括掩码注意力,通过限制在预测掩码区域内的交叉注意力来提取局部特征。除了将研究工作量至少减少三倍外,它在四个流行数据集上的表现明显优于最佳专门架构。值得注意的是,Mask2Former 在全景分割(COCO 上的 57.8 PQ)、实例分割(COCO 上的 50.1 AP)和语义分割(ADE20K 上的 57.7 mIoU)方面取得了新的最先进水平。
Mask2Former 架构。取自原始论文。
这个模型由Shivalika Singh和Alara Dirik贡献。原始代码可以在这里找到。
label_ids_to_fuse
参数,以将目标对象(例如天空)的实例合并在一起。
一系列官方 Hugging Face 和社区(由🌎表示)资源,可帮助您开始使用 Mask2Former。
如果您有兴趣提交资源以包含在这里,请随时打开一个 Pull Request,我们将进行审核。资源应该理想地展示一些新东西,而不是重复现有资源。
class transformers.Mask2FormerConfig
参数
backbone_config
(PretrainedConfig
or dict
, optional, defaults to SwinConfig()
) — 主干模型的配置。如果未设置,将使用与swin-base-patch4-window12-384
对应的配置。
feature_size
(int
, optional, defaults to 256) — 结果特征图的特征(通道)。
mask_feature_size
(int
, optional, defaults to 256) — 掩码的特征大小,此值还将用于指定特征金字塔网络特征的大小。
hidden_dim
(int
, optional, defaults to 256) — 编码器层的维度。
encoder_feedforward_dim
(int
, optional, defaults to 1024) — 用作像素解码器一部分的可变形 detr 编码器的前馈网络维度。
encoder_layers
(int
, optional, defaults to 6) — 用作像素解码器一部分的可变形 detr 编码器中的层数。
decoder_layers
(int
, optional, defaults to 10) — 变压器解码器中的层数。
num_attention_heads
(int
, optional, defaults to 8) — 每个注意力层的注意力头数。
dropout
(float
, optional, defaults to 0.1) — 嵌入层、编码器中所有全连接层的丢失概率。
dim_feedforward
(int
, optional, defaults to 2048) — 变压器解码器中前馈网络的特征维度。
pre_norm
(bool
, optional, defaults to False
) — 是否在变压器解码器中使用预 LayerNorm。
enforce_input_projection
(bool
, optional, defaults to False
) — 是否在 Transformer 解码器中添加一个输入投影 1x1 卷积,即使输入通道和隐藏维度相同。
common_stride
(int
, optional, defaults to 4) — 用于确定作为像素解码器一部分使用的 FPN 级别数的参数。
ignore_value
(int
, optional, defaults to 255) — 训练过程中要忽略的类别 ID。
num_queries
(int
, optional, defaults to 100) — 解码器的查询次数。
no_object_weight
(int
, optional, defaults to 0.1) — 用于空(无对象)类的权重。
class_weight
(int
, optional, defaults to 2.0) — 交叉熵损失的权重。
mask_weight
(int
, optional, defaults to 5.0) — 掩码损失的权重。
dice_weight
(int
, optional, defaults to 5.0) — dice 损失的权重。
train_num_points
(str
or function
, optional, defaults to 12544) — 在损失计算过程中用于采样的点数。
oversample_ratio
(float
, optional, defaults to 3.0) — 用于计算采样点数的过采样参数。
importance_sample_ratio
(float
, optional, defaults to 0.75) — 通过重要性采样抽样的点比例。
init_std
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
init_xavier_std
(float
, optional, defaults to 1.0) — 用于 HM 注意力图模块中 Xavier 初始化增益的缩放因子。
use_auxiliary_loss
(boolean``, *optional*, defaults to
True) -- 如果
True,
Mask2FormerForUniversalSegmentationOutput`将包含使用每个解码器阶段的 logits 计算的辅助损失。
feature_strides
(List[int]
, optional, defaults to [4, 8, 16, 32]
) — 与主干网络生成的特征对应的特征步幅。
output_auxiliary_logits
(bool
, optional) — 模型是否输出其auxiliary_logits
。
这是一个配置类,用于存储 Mask2FormerModel 的配置。根据指定的参数实例化一个 Mask2Former 模型,定义模型架构。使用默认值实例化配置将产生类似于 Mask2Former facebook/mask2former-swin-small-coco-instance架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
目前,Mask2Former 仅支持 Swin Transformer 作为骨干网络。
示例:
from_backbone_config
参数
backbone_config
(PretrainedConfig) — 骨干配置。返回
Mask2FormerConfig
一个配置对象的实例
从预训练的骨干模型配置实例化一个 Mask2FormerConfig(或派生类)。
class transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput
参数
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
,optional) — 编码器模型(骨干)最后阶段的最后隐藏状态(最终特征图)。当传递output_hidden_states=True
时返回。
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional) — 编码器模型在每个阶段输出的隐藏状态(也称为特征图)的元组,形状为(batch_size, num_channels, height, width)
。当传递output_hidden_states=True
时返回。
pixel_decoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
,optional) — 像素解码器模型最后阶段的最后隐藏状态(最终特征图)。
pixel_decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 像素解码器模型在每个阶段输出的隐藏状态(也称为特征图)的元组,形状为(batch_size, num_channels, height, width)
。当传递output_hidden_states=True
时返回。
transformer_decoder_last_hidden_state
(tuple(torch.FloatTensor)
) — 变压器解码器的最终输出(batch_size, sequence_length, hidden_size)
。
transformer_decoder_hidden_states
(tuple(torch.FloatTensor)
, optional) — 变压器解码器在每个阶段输出的隐藏状态(也称为特征图)的元组,形状为(batch_size, sequence_length, hidden_size)
。当传递output_hidden_states=True
时返回。
transformer_decoder_intermediate_states
(tuple(torch.FloatTensor)
,形状为(num_queries, 1, hidden_size)
) — 中间解码器激活,即每个解码器层的输出,每个都经过了 layernorm。
masks_queries_logits
(tuple(torch.FloatTensor)
,形状为(batch_size, num_queries, height, width)
) — transformer 解码器中每层的掩码预测。
attentions
(tuple(tuple(torch.FloatTensor))
,可选,当传递output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的元组的元组。transformer 解码器的自注意力权重。
用于 Mask2FormerModel 的输出类。该类返回计算 logits 所需的所有隐藏状态。
class transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput
参数
loss
(torch.Tensor
,可选) — 计算得到的损失,在存在标签时返回。
class_queries_logits
(torch.FloatTensor
) — 一个形状为(batch_size, num_queries, num_labels + 1)
的张量,表示每个查询的提议类别。请注意,+ 1
是因为我们包含了空类别。
masks_queries_logits
(torch.FloatTensor
) — 一个形状为(batch_size, num_queries, height, width)
的张量,表示每个查询的提议掩码。
auxiliary_logits
(List[Dict(str, torch.FloatTensor)]
,可选) — transformer 解码器每层的类别和掩码预测的列表。
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 编码器模型(骨干)最后阶段的最后隐藏状态(最终特征图)。
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, num_channels, height, width)
的元组的torch.FloatTensor
(一个用于嵌入的输出 + 一个用于每个阶段的输出)。编码器模型在每个阶段输出的隐藏状态(也称为特征图)。
pixel_decoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素解码器模型最后阶段的最后隐藏状态(最终特征图)。
pixel_decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, num_channels, height, width)
的元组的torch.FloatTensor
(一个用于嵌入的输出 + 一个用于每个阶段的输出)。像素解码器模型在每个阶段输出的隐藏状态(也称为特征图)。
transformer_decoder_last_hidden_state
(tuple(torch.FloatTensor)
) — transformer 解码器的最终输出(batch_size, sequence_length, hidden_size)
。
transformer_decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的元组的torch.FloatTensor
(一个用于嵌入的输出 + 一个用于每个阶段的输出)。transformer 解码器在每个阶段输出的隐藏状态(也称为特征图)。
attentions
(tuple(tuple(torch.FloatTensor))
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的元组的元组。来自 transformer 解码器的自注意力和交叉注意力权重。
Mask2FormerForUniversalSegmentationOutput
的输出类。
这个输出可以直接传递给 post_process_semantic_segmentation()或 post_process_instance_segmentation()或 post_process_panoptic_segmentation()来计算最终的分割地图。请参阅[`~Mask2FormerImageProcessor]以获取有关用法的详细信息。
class transformers.Mask2FormerModel
参数
config
(Mask2FormerConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。裸的 Mask2Former 模型输出原始隐藏状态,没有特定的头部。这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅AutoImageProcessor.preprocess
。
pixel_mask
(形状为(batch_size, height, width)
的torch.LongTensor
,可选)— 用于避免在填充像素值上执行注意力的掩码。掩码值选择在[0, 1]
中:
未掩码
),
掩码
)。
什么是注意力掩码?
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
output_attentions
(bool
,可选)— 是否返回 Detr 解码器注意力层的注意力张量。
return_dict
(bool
,可选)— 是否返回~Mask2FormerModelOutput
而不是普通元组。
返回
transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput 或tuple(torch.FloatTensor)
一个 transformers.models.mask2former.modeling_mask2former.Mask2FormerModelOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或当config.return_dict=False
时)包含根据配置(Mask2FormerConfig)和输入的各种元素。
encoder_last_hidden_state
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
,可选)— 编码器模型(骨干)最后阶段的最后隐藏状态(最终特征图)。当传递output_hidden_states=True
时返回。
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选)— 形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个阶段的输出)。编码器模型在每个阶段输出的隐藏状态(也称为特征图)。当传递output_hidden_states=True
时返回。
pixel_decoder_last_hidden_state
(形状为(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
元组(一个用于嵌入的输出 + 一个用于每个阶段的输出)。像素解码器模型在每个阶段输出的隐藏状态(也称为特征图)。当传递output_hidden_states=True
时返回。
transformer_decoder_last_hidden_state
(tuple(torch.FloatTensor)
)— 变压器解码器的最终输出(batch_size, sequence_length, hidden_size)
。
transformer_decoder_hidden_states
(tuple(torch.FloatTensor)
,可选)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个阶段的输出)。变压器解码器在每个阶段输出的隐藏状态(也称为特征图)。当传递output_hidden_states=True
时返回。
transformer_decoder_intermediate_states
(形状为(num_queries, 1, hidden_size)
的tuple(torch.FloatTensor)
) — 中间解码器激活,即每个解码器层的输出,每个都经过了一个 layernorm。
masks_queries_logits
(形状为(batch_size, num_queries, height, width)
的tuple(torch.FloatTensor)
) — 变压器解码器中每个层的掩码预测。
attentions
(tuple(tuple(torch.FloatTensor))
,可选,当传递output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tuple(torch.FloatTensor)
元组(每个层一个)。来自变压器解码器的自注意权重。
Mask2FormerModelOutput
Mask2FormerModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.Mask2FormerForUniversalSegmentation
参数
config
(Mask2FormerConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。Mask2Former 模型在顶部具有用于实例/语义/全景分割的头。这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
参数
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅AutoImageProcessor.preprocess
。
pixel_mask
(torch.LongTensor
,形状为(batch_size, height, width)
,optional) — 避免在填充像素值上执行注意力的掩码。选择的掩码值在[0, 1]
中:
not masked
),
masked
)。
什么是注意力掩码?
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
output_attentions
(bool
, optional) — 是否返回 Detr 解码器注意力层的注意力张量。
return_dict
(bool
, optional) — 是否返回~Mask2FormerModelOutput
而不是普通元组。
mask_labels
(List[torch.Tensor]
, optional) — 形状为(num_labels, height, width)
的掩码标签列表,用于馈送到模型。
class_labels
(List[torch.LongTensor]
, optional) — 形状为(num_labels, height, width)
的目标类别标签列表,用于馈送到模型。它们标识mask_labels
的标签,例如,如果class_labels[i][j]
的标签是mask_labels[i][j]
。
返回
transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput 或tuple(torch.FloatTensor)
一个 transformers.models.mask2former.modeling_mask2former.Mask2FormerForUniversalSegmentationOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含各种元素,这取决于配置(Mask2FormerConfig)和输入。
loss
(torch.Tensor
, optional) — 计算的损失,在存在标签时返回。
class_queries_logits
(torch.FloatTensor
) — 形状为(batch_size, num_queries, num_labels + 1)
的张量,表示每个查询的提议类别。请注意,+ 1
是因为我们包含了空类。
masks_queries_logits
(torch.FloatTensor
) — 形状为(batch_size, num_queries, height, width)
的张量,表示每个查询的提议掩码。
auxiliary_logits
(List[Dict(str, torch.FloatTensor)]
, optional) — 来自变压器解码器每一层的类别和掩码预测的列表。
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 编码器模型(骨干)最后一个阶段的最后隐藏状态(最终特征图)。
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_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素解码器模型最后一个阶段的最后隐藏状态(最终特征图)。
pixel_decoder_hidden_states
(tuple(torch.FloatTensor)
, 可选,当传递 output_hidden_states=True
或 config.output_hidden_states=True
时返回) — 形状为 (batch_size, num_channels, height, width)
的 torch.FloatTensor
元组。像素解码器模型在每个阶段输出的隐藏状态(也称为特征图)。
transformer_decoder_last_hidden_state
(tuple(torch.FloatTensor)
) — 变换器解码器的最终输出 (batch_size, sequence_length, hidden_size)
。
transformer_decoder_hidden_states
(tuple(torch.FloatTensor)
, 可选,当传递 output_hidden_states=True
或 config.output_hidden_states=True
时返回) — 形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
元组。变换器解码器在每个阶段输出的隐藏状态(也称为特征图)。
attentions
(tuple(tuple(torch.FloatTensor))
, 可选,当传递 output_attentions=True
或 config.output_attentions=True
时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)
的 tuple(torch.FloatTensor)
元组。变换器解码器的自注意力和交叉注意力权重。
Mask2FormerUniversalSegmentationOutput
Mask2FormerForUniversalSegmentation 的前向方法,覆盖 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
实例分割示例:
语义分割示例:
全景分割示例:
class transformers.Mask2FormerImageProcessor
参数
do_resize
(bool
, 可选,默认为 True
) — 是否将输入调整大小到特定的 size
。
size
(int
, 可选,默认为 800) — 调整输入大小为给定大小。仅在 do_resize
设置为 True
时有效。如果 size 是一个类似 (width, height)
的序列,输出大小将匹配到这个大小。如果 size 是一个整数,图像的较小边将匹配到这个数字。即,如果 height > width
,那么图像将被重新缩放为 (size * height / width, size)
。
size_divisor
(int
, 可选,默认为 32) — 一些主干网络需要可被某个数字整除的图像。如果未传递,则默认为 Swin Transformer 中使用的值。
resample
(int
, 可选,默认为 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
。
reduce_labels
(bool
,可选,默认为False
)— 是否将所有分割图的标签值减 1。通常用于数据集,其中 0 用于背景,并且背景本身不包含在数据集的所有类别中(例如 ADE20k)。背景标签将被替换为ignore_index
。
构建一个 Mask2Former 图像处理器。该图像处理器可用于为模型准备图像和可选目标。
此图像处理器继承自BaseImageProcessor
,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
预处理
编码输入
参数
pixel_values_list
(List[ImageInput]
)— 要填充的图像(像素值)列表。每个图像应该是形状为(channels, height, width)
的张量。
segmentation_maps
(ImageInput
,可选)— 具有像素级注释的相应语义分割图。
(bool
,可选,默认为True
):是否将图像填充到批次中最大的图像,并创建像素掩码。
如果保留默认设置,将返回以下像素掩码:
未掩码
),
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'
,则返回 PyTorch torch.Tensor
对象。
input_data_format
(ChannelDimension
或str
,可选)— 输入图像的通道维度格式。如果未提供,将被推断。
返回
BatchFeature
一个 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
。
Mask2Former 使用掩码分类范式处理语义分割,因此输入分割图将被转换为二进制掩码列表及其相应的标签。让我们看一个例子,假设segmentation_maps = [[2,6,7,9]]
,输出将包含mask_labels = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]
(四个二进制掩码)和class_labels = [2,6,7,9]
,每个掩码的标签。
后处理语义分割
参数
outputs
(Mask2FormerForUniversalSegmentation) — 模型的原始输出。
target_sizes
(List[Tuple[int, int]]
, 可选) — 长度为(batch_size)的列表,其中每个列表项(Tuple[int, int]]
)对应于每个预测的请求最终大小(高度,宽度)。如果设置为 None,则不会调整预测大小。
返回值
List[torch.Tensor]
一个长度为batch_size
的列表,其中每个项是形状为(高度,宽度)的语义分割地图,对应于 target_sizes 条目(如果指定了target_sizes
)。每个torch.Tensor
的每个条目对应于一个语义类别 id。
将 Mask2FormerForUniversalSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。
post_process_instance_segmentation
参数
outputs
(Mask2FormerForUniversalSegmentation) — 模型的原始输出。
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
,则将分割地图作为二进制分割地图的连接张量返回(每个检测到的实例一个)。
返回值
List[Dict]
一个字典列表,每个图像一个字典,每个字典包含两个键:
segmentation
— 形状为(高度,宽度)
的张量,其中每个像素表示一个segment_id
或List[List]
的运行长度编码(RLE)的分割地图,如果 return_coco_annotation 设置为True
,则设置为None
,如果没有找到高于threshold
的掩码。
segments_info
— 包含每个段的额外信息的字典。
id
— 代表segment_id
的整数。
label_id
— 代表与segment_id
对应的标签/语义类别 id 的整数。
score
— 具有segment_id
的段的预测分数。
将Mask2FormerForUniversalSegmentationOutput
的输出转换为实例分割预测。仅支持 PyTorch。
post_process_panoptic_segmentation
参数
outputs
(Mask2FormerForUniversalSegmentationOutput
) — 来自 Mask2FormerForUniversalSegmentation 的输出。
threshold
(float
, 可选, 默认为 0.5) — 保留预测实例掩码的概率分数阈值。
mask_threshold
(float
, 可选, 默认为 0.5) — 在将预测的掩码转换为二进制值时使用的阈值。
overlap_mask_area_threshold
(float
, optional, defaults to 0.8) — 重叠掩模面积阈值,用于合并或丢弃每个二进制实例掩模中的小不连续部分。
label_ids_to_fuse
(Set[int]
, optional) — 此状态中的标签将所有实例合并在一起。例如,我们可以说一张图像中只能有一个天空,但可以有几个人,因此天空的标签 ID 将在该集合中,但人的标签 ID 不在其中。
target_sizes
(List[Tuple]
, optional) — 长度为 (batch_size) 的列表,其中每个列表项 (Tuple[int, int]]
) 对应于批处理中每个预测的请求的最终大小(高度,宽度)。如果留空,则预测将不会被调整大小。
返回值
List[Dict]
一个字典列表,每个图像一个字典,每个字典包含两个键:
segmentation
— 形状为 (height, width)
的张量,其中每个像素代表一个 segment_id
,如果未找到掩模则设置为 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
的段的预测分数。
将 Mask2FormerForUniversalSegmentationOutput
的输出转换为图像全景分割预测。仅支持 PyTorch。
— 长度为(batch_size)的列表,其中每个列表项(Tuple[int, int]]
)对应于每个预测的请求最终大小(高度,宽度)。如果设置为 None,则不会调整预测大小。
return_coco_annotation
(bool
, 可选, 默认为False
) — 如果设置为True
,则以 COCO 运行长度编码(RLE)格式返回分割地图。
return_binary_maps
(bool
, 可选, 默认为False
) — 如果设置为True
,则将分割地图作为二进制分割地图的连接张量返回(每个检测到的实例一个)。
返回值
List[Dict]
一个字典列表,每个图像一个字典,每个字典包含两个键:
segmentation
— 形状为(高度,宽度)
的张量,其中每个像素表示一个segment_id
或List[List]
的运行长度编码(RLE)的分割地图,如果 return_coco_annotation 设置为True
,则设置为None
,如果没有找到高于threshold
的掩码。
segments_info
— 包含每个段的额外信息的字典。
id
— 代表segment_id
的整数。
label_id
— 代表与segment_id
对应的标签/语义类别 id 的整数。
score
— 具有segment_id
的段的预测分数。
将Mask2FormerForUniversalSegmentationOutput
的输出转换为实例分割预测。仅支持 PyTorch。
post_process_panoptic_segmentation
参数
outputs
(Mask2FormerForUniversalSegmentationOutput
) — 来自 Mask2FormerForUniversalSegmentation 的输出。
threshold
(float
, 可选, 默认为 0.5) — 保留预测实例掩码的概率分数阈值。
mask_threshold
(float
, 可选, 默认为 0.5) — 在将预测的掩码转换为二进制值时使用的阈值。
overlap_mask_area_threshold
(float
, optional, defaults to 0.8) — 重叠掩模面积阈值,用于合并或丢弃每个二进制实例掩模中的小不连续部分。
label_ids_to_fuse
(Set[int]
, optional) — 此状态中的标签将所有实例合并在一起。例如,我们可以说一张图像中只能有一个天空,但可以有几个人,因此天空的标签 ID 将在该集合中,但人的标签 ID 不在其中。
target_sizes
(List[Tuple]
, optional) — 长度为 (batch_size) 的列表,其中每个列表项 (Tuple[int, int]]
) 对应于批处理中每个预测的请求的最终大小(高度,宽度)。如果留空,则预测将不会被调整大小。
返回值
List[Dict]
一个字典列表,每个图像一个字典,每个字典包含两个键:
segmentation
— 形状为 (height, width)
的张量,其中每个像素代表一个 segment_id
,如果未找到掩模则设置为 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
的段的预测分数。
将 Mask2FormerForUniversalSegmentationOutput
的输出转换为图像全景分割预测。仅支持 PyTorch。