Transformers--4-37-中文文档-三十三-
Transformers 4.37 中文文档(三十三)
Big Transfer (BiT)
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/bit
概述
BiT 模型是由 Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Joan Puigcerver, Jessica Yung, Sylvain Gelly, Neil Houlsby 在 Big Transfer (BiT): General Visual Representation Learning 中提出的。BiT 是一个简单的方法,用于扩大类似于 ResNet(具体来说是 ResNetv2)的架构的预训练。该方法在迁移学习方面取得了显著的改进。
该论文的摘要如下:
预训练表示的迁移提高了样本效率,并简化了训练视觉深度神经网络时的超参数调整。我们重新审视了在大型监督数据集上进行预训练并在目标任务上微调模型的范例。我们扩大了预训练规模,并提出了一个我们称之为 Big Transfer (BiT) 的简单方法。通过组合几个精心选择的组件,并使用简单的启发式方法进行迁移,我们在超过 20 个数据集上取得了强大的性能。BiT 在各种数据范例中表现良好 — 从每类 1 个示例到总共 1M 个示例。BiT 在 ILSVRC-2012 上达到了 87.5% 的 top-1 准确率,在 CIFAR-10 上达到了 99.4%,在 19 个任务的 Visual Task Adaptation Benchmark (VTAB) 上达到了 76.3%。在小数据集上,BiT 在每类 10 个示例的情况下,ILSVRC-2012 达到了 76.8%,在 CIFAR-10 上达到了 97.0%。我们对导致高迁移性能的主要组件进行了详细分析。
使用提示
- BiT 模型在架构上等同于 ResNetv2,除了:1)所有批量归一化层都被 group normalization 取代,2)卷积层使用 weight standardization。作者表明,这两者的结合对于使用大批量大小进行训练是有用的,并且对迁移学习有显著影响。
资源
一系列官方 Hugging Face 和社区(由 🌎 表示)资源,可帮助您开始使用 BiT。
图像分类
如果您有兴趣提交资源以包含在此处,请随时打开 Pull Request,我们将进行审查!资源应该理想地展示一些新内容,而不是重复现有资源。
BitConfig
class transformers.BitConfig
( num_channels = 3 embedding_size = 64 hidden_sizes = [256, 512, 1024, 2048] depths = [3, 4, 6, 3] layer_type = 'preactivation' hidden_act = 'relu' global_padding = None num_groups = 32 drop_path_rate = 0.0 embedding_dynamic_padding = False output_stride = 32 width_factor = 1 out_features = None out_indices = None **kwargs )
参数
-
num_channels
(int
, optional, defaults to 3) — 输入通道数。 -
embedding_size
(int
, optional, defaults to 64) — 嵌入层的维度(隐藏大小)。 -
hidden_sizes
(List[int]
, optional, defaults to[256, 512, 1024, 2048]
) — 每个阶段的维度(隐藏大小)。 -
depths
(List[int]
, optional, defaults to[3, 4, 6, 3]
) — 每个阶段的深度(层数)。 -
layer_type
(str
, optional, defaults to"preactivation"
) — 要使用的层,可以是"preactivation"
或"bottleneck"
。 -
hidden_act
(str
, optional, defaults to"relu"
) — 每个块中的非线性激活函数。如果是字符串,支持"gelu"
,"relu"
,"selu"
和"gelu_new"
。 -
global_padding
(str
, 可选) — 用于卷积层的填充策略。可以是"valid"
、"same"
或None
。 -
num_groups
(int
, 可选, 默认为 32) — 用于BitGroupNormActivation
层的组数。 -
drop_path_rate
(float
, 可选, 默认为 0.0) — 随机深度的丢弃路径率。 -
embedding_dynamic_padding
(bool
, 可选, 默认为False
) — 是否使用动态填充来进行嵌入层。 -
output_stride
(int
, 可选, 默认为 32) — 模型的输出步幅。 -
width_factor
(int
, 可选, 默认为 1) — 模型的宽度因子。 -
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
属性中定义的顺序。
这是一个配置类,用于存储 BitModel 的配置。根据指定的参数实例化一个 BiT 模型,定义模型架构。使用默认值实例化配置将产生类似于 BiT google/bit-50 架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import BitConfig, BitModel
>>> # Initializing a BiT bit-50 style configuration
>>> configuration = BitConfig()
>>> # Initializing a model (with random weights) from the bit-50 style configuration
>>> model = BitModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
BitImageProcessor
class transformers.BitImageProcessor
( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_convert_rgb: bool = True **kwargs )
参数
-
do_resize
(bool
, 可选, 默认为True
) — 是否将图像的(高度,宽度)维度调整为指定的size
。可以被preprocess
方法中的do_resize
覆盖。 -
size
(Dict[str, int]
可选, 默认为{"shortest_edge" -- 224}
): 调整大小后的图像大小。图像的最短边被调整为 size[“shortest_edge”],最长边被调整以保持输入的纵横比。可以被preprocess
方法中的size
覆盖。 -
resample
(PILImageResampling
, 可选, 默认为PILImageResampling.BICUBIC
) — 如果调整图像大小,则使用的重采样滤波器。可以被preprocess
方法中的resample
覆盖。 -
do_center_crop
(bool
, 可选, 默认为True
) — 是否将图像居中裁剪到指定的crop_size
。可以被preprocess
方法中的do_center_crop
覆盖。 -
crop_size
(Dict[str, int]
可选, 默认为 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 — 是否对图像进行归一化。可以被preprocess
方法中的do_normalize
覆盖。 -
image_mean
(float
或List[float]
, optional, defaults toOPENAI_CLIP_MEAN
) — 如果归一化图像,则使用的均值。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以被preprocess
方法中的image_mean
参数覆盖。 -
image_std
(float
或List[float]
, optional, defaults toOPENAI_CLIP_MEAN
) — 如果归一化图像,则使用的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以被preprocess
方法中的image_std
参数覆盖。可以被preprocess
方法中的image_std
参数覆盖。 -
do_convert_rgb
(bool
, optional, defaults toTrue
) — 是否将图像转换为 RGB。
构造一个 BiT 图像处理器。
preprocess
( images: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_center_crop: bool = None crop_size: int = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None do_convert_rgb: bool = None return_tensors: Union = None data_format: Optional = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
参数
-
images
(ImageInput
) — 要预处理的图像。期望单个或批量图像,像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。 -
do_resize
(bool
, optional, defaults toself.do_resize
) — 是否调整图像大小。 -
size
(Dict[str, int]
, optional, defaults toself.size
) — 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”],最长边被调整以保持输入的长宽比。 -
resample
(int
, optional, defaults toself.resample
) — 如果调整图像大小,则使用的重采样滤波器。这可以是枚举PILImageResampling
之一。仅在do_resize
设置为True
时有效。 -
do_center_crop
(bool
, optional, defaults toself.do_center_crop
) — 是否对图像进行中心裁剪。 -
crop_size
(Dict[str, int]
, optional, defaults toself.crop_size
) — 中心裁剪的尺寸。仅在do_center_crop
设置为True
时有效。 -
do_rescale
(bool
, optional, defaults toself.do_rescale
) — 是否重新缩放图像。 -
rescale_factor
(float
, optional, defaults toself.rescale_factor
) — 如果do_rescale
设置为True
,则重新缩放图像的重新缩放因子。 -
do_normalize
(bool
, optional, defaults toself.do_normalize
) — 是否对图像进行归一化。 -
image_mean
(float
或List[float]
, optional, defaults toself.image_mean
) — 用于归一化的图像均值。仅在do_normalize
设置为True
时有效。 -
image_std
(float
或List[float]
, optional, defaults toself.image_std
) — 用于归一化的图像标准差。仅在do_normalize
设置为True
时有效。 -
do_convert_rgb
(bool
, optional, defaults toself.do_convert_rgb
) — 是否将图像转换为 RGB。 -
return_tensors
(str
或TensorType
, optional) — 要返回的张量类型。可以是以下之一:-
未设置:返回一个
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
, optional, defaults toChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
:图像以 (num_channels, height, width) 格式。 -
"channels_last"
或ChannelDimension.LAST
:图像以 (height, width, num_channels) 格式。 -
未设置:使用输入图像的通道维度格式。
-
-
input_data_format
(ChannelDimension
或str
, optional) — 输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
:图像以 (num_channels, height, width) 格式。 -
"channels_last"
或ChannelDimension.LAST
:图像以 (height, width, num_channels) 格式。 -
"none"
或ChannelDimension.NONE
:图像以(高度,宽度)格式。
-
预处理图像或图像批次。
BitModel
class transformers.BitModel
( config )
参数
config
(BitConfig) — 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸 BiT 模型输出原始特征,没有特定的头部。这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( pixel_values: Tensor output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 BitImageProcessor.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
时)包含各种元素,具体取决于配置(BitConfig)和输入。
-
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 模型最后一层的隐藏状态序列。 -
pooler_output
(torch.FloatTensor
,形状为(batch_size, hidden_size)
) — 在空间维度上进行池化操作后的最后一层隐藏状态。 -
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
元组。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
BitModel 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, BitModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("google/bit-50")
>>> model = BitModel.from_pretrained("google/bit-50")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 2048, 7, 7]
BitForImageClassification
class transformers.BitForImageClassification
( config )
参数
config
(BitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
BiT 模型,顶部带有图像分类头部(在池化特征之上的线性层),例如用于 ImageNet。
此模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( pixel_values: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.ImageClassifierOutputWithNoAttention or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 BitImageProcessor.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
,则计算分类损失(交叉熵)。
返回
transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或一个torch.FloatTensor
元组(如果传递return_dict=False
或者config.return_dict=False
时)包含各种元素,取决于配置(BitConfig)和输入。
-
损失
(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, num_channels, height, width)
的torch.FloatTensor
元组。模型在每个阶段输出的隐藏状态(也称为特征图)。
BitForImageClassification 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, BitForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("google/bit-50")
>>> model = BitForImageClassification.from_pretrained("google/bit-50")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tiger cat
条件 DETR
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/conditional_detr
概述
条件 DETR 模型是由孟德普、陈晓康、范泽佳、曾刚、李厚强、袁宇辉、孙磊、王京东在用于快速训练收敛的条件 DETR中提出的。条件 DETR 提出了一种用于快速 DETR 训练的条件交叉注意力机制。条件 DETR 的收敛速度比 DETR 快 6.7 倍至 10 倍。
论文摘要如下:
最近开发的 DETR 方法将 Transformer 编码器和解码器架构应用于目标检测,并取得了令人满意的性能。在本文中,我们处理了关键问题,即训练收敛速度慢,并提出了一种用于快速 DETR 训练的条件交叉注意力机制。我们的方法受到了 DETR 中的交叉注意力高度依赖内容嵌入以定位四个极点并预测框的启发,这增加了对高质量内容嵌入的需求,从而增加了训练难度。我们的方法,称为条件 DETR,从解码器嵌入中学习一个条件空间查询,用于解码器多头交叉注意力。好处在于通过条件空间查询,每个交叉注意力头都能关注包含不同区域的带,例如一个对象极点或对象框内的区域。这缩小了用于定位不同区域进行对象分类和框回归的空间范围,从而减轻了对内容嵌入的依赖并简化了训练。实证结果表明,对于骨干网络 R50 和 R101,条件 DETR 的收敛速度提高了 6.7 倍,对于更强大的骨干网络 DC5-R50 和 DC5-R101,提高了 10 倍。代码可在github.com/Atten4Vis/ConditionalDETR
找到。
条件 DETR 相对于原始 DETR 显示出更快的收敛速度。摘自原始论文。
资源
- 目标检测任务指南
ConditionalDetrConfig
class transformers.ConditionalDetrConfig
( use_timm_backbone = True backbone_config = None num_channels = 3 num_queries = 300 encoder_layers = 6 encoder_ffn_dim = 2048 encoder_attention_heads = 8 decoder_layers = 6 decoder_ffn_dim = 2048 decoder_attention_heads = 8 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 init_xavier_std = 1.0 auxiliary_loss = False position_embedding_type = 'sine' backbone = 'resnet50' use_pretrained_backbone = True dilation = False class_cost = 2 bbox_cost = 5 giou_cost = 2 mask_loss_coefficient = 1 dice_loss_coefficient = 1 cls_loss_coefficient = 2 bbox_loss_coefficient = 5 giou_loss_coefficient = 2 focal_alpha = 0.25 **kwargs )
参数
-
use_timm_backbone
(bool
, 可选, 默认为True
) — 是否使用timm
库作为骨干。如果设置为False
,将使用AutoBackbone
API。 -
backbone_config
(PretrainedConfig
或dict
, 可选) — 骨干模型的配置。仅在use_timm_backbone
设置为False
时使用,此时默认为ResNetConfig()
。 -
num_channels
(int
, 可选, 默认为 3) — 输入通道的数量。 -
num_queries
(int
, 可选, 默认为 100) — 对象查询的数量,即检测槽位。这是 ConditionalDetrModel 在单个图像中可以检测到的对象的最大数量。对于 COCO 数据集,我们建议使用 100 个查询。 -
d_model
(int
, 可选, 默认为 256) — 层的维度。 -
encoder_layers
(int
, 可选, 默认为 6) — 编码器层数。 -
decoder_layers
(int
, 可选, 默认为 6) — 解码器层数。 -
encoder_attention_heads
(int
, 可选, 默认为 8) — Transformer 编码器中每个注意力层的注意力头数。 -
decoder_attention_heads
(int
, 可选, 默认为 8) — Transformer 解码器中每个注意力层的注意力头数。 -
decoder_ffn_dim
(int
, optional, defaults to 2048) — 解码器中“中间”(通常称为前馈)层的维度。 -
encoder_ffn_dim
(int
, optional, defaults to 2048) — 解码器中“中间”(通常称为前馈)层的维度。 -
activation_function
(str
orfunction
, optional, defaults to"relu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。 -
dropout
(float
, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。 -
attention_dropout
(float
, optional, defaults to 0.0) — 注意力概率的丢弃比率。 -
activation_dropout
(float
, optional, defaults to 0.0) — 全连接层内激活的丢弃比率。 -
init_std
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
init_xavier_std
(float
, optional, defaults to 1) — 用于 HM Attention map 模块中 Xavier 初始化增益的缩放因子。 -
encoder_layerdrop
(float
, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息,请参阅 LayerDrop 论文)。 -
decoder_layerdrop
(float
, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息,请参阅 LayerDrop 论文)。 -
auxiliary_loss
(bool
, optional, defaults toFalse
) — 是否使用辅助解码损失(每个解码器层的损失)。 -
position_embedding_type
(str
, optional, defaults to"sine"
) — 在图像特征之上使用的位置嵌入的类型。其中之一是"sine"
或"learned"
。 -
backbone
(str
, optional, defaults to"resnet50"
) — 在use_timm_backbone
=True
时要使用的卷积主干的名称。支持 timm 包中的任何卷积主干。有关所有可用模型的列表,请参见此页面。 -
use_pretrained_backbone
(bool
, optional, defaults toTrue
) — 是否对主干使用预训练权重。仅在use_timm_backbone
=True
时支持。 -
dilation
(bool
, optional, defaults toFalse
) — 是否在最后的卷积块(DC5)中用膨胀替换步幅。仅在use_timm_backbone
=True
时支持。 -
class_cost
(float
, optional, defaults to 1) — 匈牙利匹配成本中分类错误的相对权重。 -
bbox_cost
(float
, optional, defaults to 5) — 匈牙利匹配成本中边界框坐标的 L1 误差的相对权重。 -
giou_cost
(float
, optional, defaults to 2) — 匈牙利匹配成本中边界框的广义 IoU 损失的相对权重。 -
mask_loss_coefficient
(float
, optional, defaults to 1) — 全景分割损失中 Focal 损失的相对权重。 -
dice_loss_coefficient
(float
, optional, defaults to 1) — 全景分割损失中 DICE/F-1 损失的相对权重。 -
bbox_loss_coefficient
(float
, optional, defaults to 5) — 目标检测损失中 L1 边界框损失的相对权重。 -
giou_loss_coefficient
(float
, optional, defaults to 2) — 目标检测损失中广义 IoU 损失的相对权重。 -
eos_coefficient
(float
, optional, defaults to 0.1) — 目标检测损失中“无物体”类别的相对分类权重。 -
focal_alpha
(float
, optional, defaults to 0.25) — 焦点损失中的 Alpha 参数。
这是用于存储 ConditionalDetrModel 配置的配置类。根据指定的参数实例化一个 Conditional DETR 模型,定义模型架构。使用默认值实例化配置将产生类似于 Conditional DETR microsoft/conditional-detr-resnet-50架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import ConditionalDetrConfig, ConditionalDetrModel
>>> # Initializing a Conditional DETR microsoft/conditional-detr-resnet-50 style configuration
>>> configuration = ConditionalDetrConfig()
>>> # Initializing a model (with random weights) from the microsoft/conditional-detr-resnet-50 style configuration
>>> model = ConditionalDetrModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
ConditionalDetrImageProcessor
class transformers.ConditionalDetrImageProcessor
( format: Union = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )
参数
-
format
(str
, optional, 默认为"coco_detection"
) — 注释的数据格式。其中之一为"coco_detection"
或“coco_panoptic”。 -
do_resize
(bool
, optional, 默认为True
) — 控制是否将图像的(高度,宽度)尺寸调整为指定的size
。可以被preprocess
方法中的do_resize
参数覆盖。 -
size
(Dict[str, int]
optional, 默认为{"shortest_edge" -- 800, "longest_edge": 1333}
): 调整大小后的图像(高度,宽度)尺寸。可以被preprocess
方法中的size
参数覆盖。 -
resample
(PILImageResampling
, optional, 默认为PILImageResampling.BILINEAR
) — 如果调整图像大小,则使用的重采样滤波器。 -
do_rescale
(bool
, optional, 默认为True
) — 控制是否按指定比例rescale_factor
重新调整图像。可以被preprocess
方法中的do_rescale
参数覆盖。 -
rescale_factor
(int
或float
, optional, 默认为1/255
) — 如果重新调整图像,则使用的比例因子。可以被preprocess
方法中的rescale_factor
参数覆盖。do_normalize
— 控制是否对图像进行归一化。可以被preprocess
方法中的do_normalize
参数覆盖。 -
image_mean
(float
或List[float]
, optional, 默认为IMAGENET_DEFAULT_MEAN
) — 在归一化图像时使用的均值。可以是单个值或值列表,每个通道一个值。可以被preprocess
方法中的image_mean
参数覆盖。 -
image_std
(float
或List[float]
, optional, 默认为IMAGENET_DEFAULT_STD
) — 在归一化图像时使用的标准差值。可以是单个值或值列表,每个通道一个值。可以被preprocess
方法中的image_std
参数覆盖。 -
do_pad
(bool
, optional, defaults toTrue
) — 控制是否将图像填充到批处理中最大的图像并创建像素掩码。可以被preprocess
方法中的do_pad
参数覆盖。
构建一个 Conditional Detr 图像处理器。
preprocess
( images: Union annotations: Union = None return_segmentation_masks: bool = None masks_path: Union = None do_resize: Optional = None size: Optional = None resample = None do_rescale: Optional = None rescale_factor: Union = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None format: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
参数
-
images
(ImageInput
) — 要预处理的图像或图像批次。期望单个图像或带有像素值范围从 0 到 255 的图像批次。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。 -
annotations
(AnnotationType
或List[AnnotationType]
, optional) — 与图像或图像批次关联的注释列表。如果注释用于目标检测,则注释应为具有以下键的字典:-
“image_id” (
int
): 图像 id。 -
“annotations” (
List[Dict]
): 图像的注释列表。每个注释应为一个字典。一个图像可能没有注释,此时列表应为空。如果注释用于分割,注释应为一个具有以下键的字典: -
“image_id” (
int
): 图像 id。 -
“segments_info” (
List[Dict]
): 图像的分段列表。每个分段应为一个字典。一个图像可能没有分段,此时列表应为空。 -
“file_name” (
str
): 图像的文件名。
-
-
return_segmentation_masks
(bool
, 可选, 默认为 self.return_segmentation_masks) — 是否返回分割掩模。 -
masks_path
(str
或pathlib.Path
, 可选) — 包含分割掩模的目录路径。 -
do_resize
(bool
, 可选, 默认为 self.do_resize) — 是否调整图像大小。 -
size
(Dict[str, int]
, 可选, 默认为 self.size) — 调整大小后的图像尺寸。 -
resample
(PILImageResampling
, 可选, 默认为 self.resample) — 调整图像大小时使用的重采样滤波器。 -
do_rescale
(bool
, 可选, 默认为 self.do_rescale) — 是否重新缩放图像。 -
rescale_factor
(float
, 可选, 默认为 self.rescale_factor) — 重新缩放图像时使用的缩放因子。 -
do_normalize
(bool
, 可选, 默认为 self.do_normalize) — 是否规范化图像。 -
image_mean
(float
或List[float]
, 可选, 默认为 self.image_mean) — 在规范化图像时使用的均值。 -
image_std
(float
或List[float]
, 可选, 默认为 self.image_std) — 在规范化图像时使用的标准差。 -
do_pad
(bool
, 可选, 默认为 self.do_pad) — 是否填充图像。 -
format
(str
或AnnotationFormat
, 可选, 默认为 self.format) — 注释的格式。 -
return_tensors
(str
或TensorType
, 可选, 默认为 self.return_tensors) — 要返回的张量类型。如果为None
,将返回图像列表。 -
data_format
(ChannelDimension
或str
, 可选, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
: 图像以 (通道数, 高度, 宽度) 格式。 -
"channels_last"
或ChannelDimension.LAST
: 图像以 (高度, 宽度, 通道数) 格式。 -
未设置: 使用输入图像的通道维度格式。
-
-
input_data_format
(ChannelDimension
或str
, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
: 图像以 (通道数, 高度, 宽度) 格式。 -
"channels_last"
或ChannelDimension.LAST
: 图像以 (高度, 宽度, 通道数) 格式。 -
"none"
或ChannelDimension.NONE
: 图像以 (高度, 宽度) 格式。
-
对图像或图像批次进行预处理,以便模型可以使用。
post_process_object_detection
( outputs threshold: float = 0.5 target_sizes: Union = None top_k: int = 100 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrObjectDetectionOutput
) — 模型的原始输出。 -
threshold
(float
, 可选) — 保留对象检测预测的分数阈值。 -
target_sizes
(torch.Tensor
或List[Tuple[int, int]]
, 可选) — 形状为(batch_size, 2)
的张量或包含每个图像目标大小 (高度, 宽度) 的元组列表 (Tuple[int, int]
)。如果保留为 None,则预测将不会被调整大小。 -
top_k
(int
, 可选, 默认为 100) — 在通过阈值过滤之前仅保留前 k 个边界框。
返回
List[Dict]
一个字典列表,每个字典包含模型预测的批次中图像的分数、标签和框。
将 ConditionalDetrForObjectDetection 的原始输出转换为最终边界框,格式为(top_left_x,top_left_y,bottom_right_x,bottom_right_y)。仅支持 PyTorch。
post_process_instance_segmentation
( outputs 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 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(ConditionalDetrForSegmentation)- 模型的原始输出。 -
threshold
(float
,可选,默认为 0.5)- 保留预测的实例掩模的概率分数阈值。 -
mask_threshold
(float
,可选,默认为 0.5)- 在将预测的掩模转换为二进制值时使用的阈值。 -
overlap_mask_area_threshold
(float
,可选,默认为 0.8)- 用于合并或丢弃每个二进制实例掩模中的小不连通部分的重叠掩模区域阈值。 -
target_sizes
(List[Tuple]
,可选)- 长度为(batch_size)的列表,其中每个列表项(Tuple[int, int]]
)对应于每个预测的请求最终大小(高度,宽度)。如果未设置,预测将不会被调整大小。 -
return_coco_annotation
(bool
,可选)- 默认为False
。如果设置为True
,则以 COCO 运行长度编码(RLE)格式返回分割地图。
返回
List[Dict]
一个字典列表,每个图像一个,每个字典包含两个键:
-
segmentation
- 形状为(高度,宽度)的张量,其中每个像素表示segment_id
或List[List]
的运行长度编码(RLE)的分割地图,如果 return_coco_annotation 设置为True
。如果未找到任何掩模,则设置为None
。 -
segments_info
- 包含每个段的附加信息的字典。-
id
- 表示segment_id
的整数。 -
label_id
- 表示与segment_id
对应的标签/语义类别 id 的整数。 -
score
- 具有segment_id
的段的预测分数。
-
将 ConditionalDetrForSegmentation 的输出转换为实例分割预测。仅支持 PyTorch。
post_process_semantic_segmentation
( outputs target_sizes: List = None ) → export const metadata = 'undefined';List[torch.Tensor]
参数
-
outputs
(ConditionalDetrForSegmentation)- 模型的原始输出。 -
target_sizes
(List[Tuple[int, int]]
,可选)- 包含批处理中每个图像的目标大小(高度,宽度)的元组(Tuple[int, int]
)列表。如果未设置,预测将不会被调整大小。
返回
List[torch.Tensor]
长度为batch_size
的列表,其中每个项目是形状为(高度,宽度)的语义分割地图,对应于目标大小条目(如果指定了target_sizes
)。每个torch.Tensor
的每个条目对应于语义类别 id。
将 ConditionalDetrForSegmentation 的输出转换为语义分割地图。仅支持 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 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(ConditionalDetrForSegmentation)- 来自 ConditionalDetrForSegmentation 的输出。 -
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]]
)对应于批处理中每个预测的请求的最终大小(高度,宽度)。如果未设置,预测将不会被调整大小。
返回
List[Dict]
一个字典列表,每个图像一个字典,每个字典包含两个键:
-
segmentation
— 形状为(高度,宽度)
的张量,其中每个像素代表一个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
的段的预测分数。
-
将 ConditionalDetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。
ConditionalDetrFeatureExtractor
class transformers.ConditionalDetrFeatureExtractor
( *args **kwargs )
__call__
( images **kwargs )
预处理一张图像或一批图像。
post_process_object_detection
( outputs threshold: float = 0.5 target_sizes: Union = None top_k: int = 100 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrObjectDetectionOutput
) — 模型的原始输出。 -
threshold
(float
, 可选) — 保留对象检测预测的分数阈值。 -
target_sizes
(torch.Tensor
或List[Tuple[int, int]]
, 可选) — 形状为(batch_size, 2)
的张量或包含每个图像的目标大小(高度,宽度)的元组列表(Tuple[int, int]
)。如果为 None,预测将不会被调整大小。 -
top_k
(int
, 可选, 默认为 100) — 在通过阈值筛选之前仅保留前 k 个边界框。
返回
List[Dict]
一个字典列表,每个字典包含模型预测的批处理中每个图像的分数、标签和框。
将 ConditionalDetrForObjectDetection 的原始输出转换为最终的边界框,格式为(top_left_x, top_left_y, bottom_right_x, bottom_right_y)。仅支持 PyTorch。
post_process_instance_segmentation
( outputs 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 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(ConditionalDetrForSegmentation) — 模型的原始输出。 -
threshold
(float
,可选,默认为 0.5)- 保留预测实例掩码的概率分数阈值。 -
mask_threshold
(float
,可选,默认为 0.5)- 在将预测的掩码转换为二进制值时使用的阈值。 -
overlap_mask_area_threshold
(float
,可选,默认为 0.8)- 用于合并或丢弃每个二进制实例掩码中的小不连续部分的重叠掩码区域阈值。 -
target_sizes
(List[Tuple]
,可选)- 长度为(batch_size)的列表,其中每个列表项(Tuple[int, int]]
)对应于每个预测的请求最终大小(高度,宽度)。如果未设置,预测将不会被调整大小。 -
return_coco_annotation
(bool
,可选)- 默认为False
。如果设置为True
,则以 COCO 运行长度编码(RLE)格式返回分割地图。
返回
List[Dict]
一个字典列表,每个图像一个字典,每个字典包含两个键:
-
segmentation
- 形状为(高度,宽度)的张量,其中每个像素表示segment_id
或分割地图的List[List]
运行长度编码(RLE),如果 return_coco_annotation 设置为True
。如果未找到高于threshold
的掩码,则设置为None
。 -
segments_info
- 包含每个段的其他信息的字典。-
id
- 表示segment_id
的整数。 -
label_id
- 表示与segment_id
对应的标签/语义类别 id 的整数。 -
score
- 具有segment_id
的段的预测分数。
-
将 ConditionalDetrForSegmentation 的输出转换为实例分割预测。仅支持 PyTorch。
post_process_semantic_segmentation
( outputs target_sizes: List = None ) → export const metadata = 'undefined';List[torch.Tensor]
参数
-
outputs
(ConditionalDetrForSegmentation)- 模型的原始输出。 -
target_sizes
(List[Tuple[int, int]]
,可选)- 包含批处理中每个图像的目标大小(高度,宽度)的元组列表(Tuple[int, int]
)。如果未设置,预测将不会被调整大小。
返回
List[torch.Tensor]
一个长度为batch_size
的列表,其中每个项目都是一个形状为(高度,宽度)的语义分割地图,对应于target_sizes
条目(如果指定了target_sizes
)。每个torch.Tensor
的每个条目对应一个语义类别 id。
将 ConditionalDetrForSegmentation 的输出转换为语义分割地图。仅支持 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 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(ConditionalDetrForSegmentation)- 来自 ConditionalDetrForSegmentation 的输出。 -
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]
)对应于批处理中每个预测的请求的最终大小(高度,宽度)。如果未设置,预测将不会被调整大小。
返回
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
的段的预测分数。
-
将 ConditionalDetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。
ConditionalDetrModel
class transformers.ConditionalDetrModel
( config: ConditionalDetrConfig )
参数
config
(ConditionalDetrConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸的 Conditional DETR 模型(由骨干和编码器-解码器 Transformer 组成),输出原始隐藏状态,没有特定的头部。
此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrModelOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 ConditionalDetrImageProcessor.
call
()。 -
pixel_mask
(形状为(batch_size, height, width)
的torch.LongTensor
,可选)— 避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]
中:-
对于真实的像素(即“未遮罩”),
-
对于填充的像素(即“遮罩”),值为 0。
什么是注意力掩码?
-
-
decoder_attention_mask
(形状为(batch_size, num_queries)
的torch.FloatTensor
,可选)— 默认情况下不使用。可用于遮罩对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
, optional) — 元组包括(last_hidden_state
, optional:hidden_states
, optional:attentions
)last_hidden_state
形状为(batch_size, sequence_length, hidden_size)
,是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以选择直接传递图像的扁平化表示,而不是传递骨干网络和投影层的输出的扁平化特征图。 -
decoder_inputs_embeds
(torch.FloatTensor
of shape(batch_size, num_queries, hidden_size)
, optional) — 可选地,您可以选择直接传递一个嵌入表示,而不是用零张量初始化查询。 -
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrModelOutput
或tuple(torch.FloatTensor)
一个transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrModelOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含各种元素,取决于配置(ConditionalDetrConfig)和输入。
-
last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
) — 模型解码器最后一层的隐藏状态序列。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — 解码器隐藏状态的元组,形状为(batch_size, sequence_length, hidden_size)
,包括每一层的输出和初始嵌入输出。 -
decoder_attentions
(tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — 解码器的注意力权重元组,形状为(batch_size, num_heads, sequence_length, sequence_length)
,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — 解码器交叉注意力层的注意力权重元组,形状为(batch_size, num_heads, sequence_length, sequence_length)
,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — 编码器隐藏状态的元组,形状为(batch_size, sequence_length, hidden_size)
,包括每一层的输出和初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
intermediate_hidden_states
(torch.FloatTensor
,形状为(config.decoder_layers, batch_size, sequence_length, hidden_size)
,可选,当config.auxiliary_loss=True
时返回)— 中间解码器激活,即每个解码器层的输出,每个都经过了 layernorm。
ConditionalDetrModel 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, AutoModel
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> model = AutoModel.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]
ConditionalDetrForObjectDetection
class transformers.ConditionalDetrForObjectDetection
( config: ConditionalDetrConfig )
参数
config
(ConditionalDetrConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
CONDITIONAL_DETR 模型(由骨干和编码器-解码器 Transformer 组成),在顶部具有用于诸如 COCO 检测等任务的目标检测头。
此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrObjectDetectionOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 ConditionalDetrImageProcessor.
call
()。 -
pixel_mask
(torch.LongTensor
,形状为(batch_size, height, width)
,可选) — 用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]
:-
1 表示真实像素(即
未被掩码
), -
0 表示填充像素。
什么是注意力掩码?
-
-
decoder_attention_mask
(torch.FloatTensor
,形状为(batch_size, num_queries)
,可选) — 默认情况下不使用。可用于屏蔽对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选) — 元组包括(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
形状为(batch_size, sequence_length, hidden_size)
,可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 可选地,您可以选择直接传递图像的扁平化表示,而不是传递扁平化特征图(骨干网络输出+投影层的输出)。 -
decoder_inputs_embeds
(torch.FloatTensor
,形状为(batch_size, num_queries, hidden_size)
,可选) — 可选地,您可以选择直接传递一个嵌入表示,而不是用零张量初始化查询。 -
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选) — 是否返回一个 ModelOutput 而不是一个普通元组。 -
labels
(List[Dict]
,长度为(batch_size,)
,可选) — 用于计算二部匹配损失的标签。字典列表,每个字典至少包含以下 2 个键:‘class_labels’和‘boxes’(分别是批次中图像的类别标签和边界框)。类别标签本身应该是长度为‘图像中边界框数量’的torch.LongTensor
,而边界框是形状为‘图像中边界框数量,4’的torch.FloatTensor
。
返回
transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrObjectDetectionOutput
或tuple(torch.FloatTensor)
一个transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrObjectDetectionOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含各种元素,这取决于配置(ConditionalDetrConfig)和输入。
-
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 总损失,作为类别预测的负对数似然(交叉熵)和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 -
loss_dict
(Dict
,可选) — 包含各个损失的字典。用于记录。 -
logits
(torch.FloatTensor
,形状为(batch_size, num_queries, num_classes + 1)
) — 所有查询的分类 logits(包括无对象)。 -
pred_boxes
(torch.FloatTensor
,形状为(batch_size, num_queries, 4)
) — 所有查询的归一化框坐标,表示为(中心 _x,中心 _y,宽度,高度)。这些值在[0, 1]范围内归一化,相对于批次中每个单独图像的大小(忽略可能的填充)。您可以使用 post_process_object_detection()来检索未归一化的边界框。 -
auxiliary_outputs
(list[Dict]
,可选) — 可选,仅在激活辅助损失(即config.auxiliary_loss
设置为True
)并提供标签时返回。这是一个包含每个解码器层的上述两个键(logits
和pred_boxes
)的字典列表。 -
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 模型解码器最后一层的隐藏状态序列。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。解码器在每个层的输出以及初始嵌入输出的隐藏状态。 -
decoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)的注意力权重。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)的注意力权重。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。编码器在每个层的输出以及初始嵌入输出的隐藏状态。 -
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)的注意力权重。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
ConditionalDetrForObjectDetection 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, AutoModelForObjectDetection
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> model = AutoModelForObjectDetection.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[
... 0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
... box = [round(i, 2) for i in box.tolist()]
... print(
... f"Detected {model.config.id2label[label.item()]} with confidence "
... f"{round(score.item(), 3)} at location {box}"
... )
Detected remote with confidence 0.833 at location [38.31, 72.1, 177.63, 118.45]
Detected cat with confidence 0.831 at location [9.2, 51.38, 321.13, 469.0]
Detected cat with confidence 0.804 at location [340.3, 16.85, 642.93, 370.95]
Detected remote with confidence 0.683 at location [334.48, 73.49, 366.37, 190.01]
Detected couch with confidence 0.535 at location [0.52, 1.19, 640.35, 475.1]
ConditionalDetrForSegmentation
class transformers.ConditionalDetrForSegmentation
( config: ConditionalDetrConfig )
参数
config
(ConditionalDetrConfig)- 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
CONDITIONAL_DETR 模型(由骨干和编码器-解码器 Transformer 组成),顶部带有分割头,用于诸如 COCO 全景等任务。
这个模型继承自 PreTrainedModel。查看超类文档以了解库实现的所有模型的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以了解所有与一般用法和行为相关的事项。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrSegmentationOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 ConditionalDetrImageProcessor.
call
()。 -
pixel_mask
(形状为(batch_size, height, width)
的torch.LongTensor
,可选)— 用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]
之间:-
1 表示真实的像素(即
未被掩码
), -
0 表示填充像素(即
已被掩码
)。
什么是注意力掩码?
-
-
decoder_attention_mask
(形状为(batch_size, num_queries)
的torch.FloatTensor
,可选)— 默认情况下不使用。可用于掩盖对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选)— 元组包含(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选)是编码器最后一层的输出的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递一个图像的扁平化表示,而不是传递骨干网络和投影层的输出。 -
decoder_inputs_embeds
(形状为(batch_size, num_queries, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递一个嵌入表示,而不是用零张量初始化查询。 -
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。 -
labels
(长度为(batch_size,)
的List[Dict]
,可选)— 用于计算二分匹配损失、DICE/F-1 损失和 Focal 损失的标签。字典列表,每个字典至少包含以下 3 个键:‘class_labels’、‘boxes’和‘masks’(分别是批次中图像的类标签、边界框和分割掩码)。类标签本身应该是长度为(图像中边界框的数量,)
的torch.LongTensor
,边界框是形状为(图像中边界框的数量, 4)
的torch.FloatTensor
,掩码是形状为(图像中边界框的数量, height, width)
的torch.FloatTensor
。
返回
transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrSegmentationOutput
或 tuple(torch.FloatTensor)
一个transformers.models.conditional_detr.modeling_conditional_detr.ConditionalDetrSegmentationOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含各种元素,取决于配置(ConditionalDetrConfig)和输入。
-
loss
(torch.FloatTensor
,形状为(1,)
,optional,当提供labels
时返回) — 总损失,作为类别预测的负对数似然(交叉熵)和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 -
loss_dict
(Dict
,optional) — 包含各个损失的字典。用于记录。 -
logits
(torch.FloatTensor
,形状为(batch_size, num_queries, num_classes + 1)
) — 所有查询的分类 logits(包括无对象)。 -
pred_boxes
(torch.FloatTensor
,形状为(batch_size, num_queries, 4)
) — 所有查询的归一化框坐标,表示为(中心 _x,中心 _y,宽度,高度)。这些值在[0, 1]范围内归一化,相对于批处理中每个单独图像的大小(忽略可能的填充)。您可以使用 post_process_object_detection()来检索未归一化的边界框。 -
pred_masks
(torch.FloatTensor
,形状为(batch_size, num_queries, height/4, width/4)
) — 所有查询的分割掩模 logits。另请参阅 post_process_semantic_segmentation()或 post_process_instance_segmentation()post_process_panoptic_segmentation()分别评估语义、实例和全景分割掩模。 -
auxiliary_outputs
(list[Dict]
,optional) — 可选,仅在激活辅助损失(即config.auxiliary_loss
设置为True
)并提供标签时返回。这是一个包含每个解码器层的上述两个键(logits
和pred_boxes
)的字典列表。 -
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,optional) — 模型解码器最后一层的隐藏状态序列。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,optional,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。解码器在每一层输出的隐藏状态加上初始嵌入输出。 -
decoder_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.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或者当config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。编码器在每一层输出的隐藏状态加上初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或者当config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
ConditionalDetrForSegmentation 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用 Module
实例,而不是这个函数,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> import io
>>> import requests
>>> from PIL import Image
>>> import torch
>>> import numpy
>>> from transformers import (
... AutoImageProcessor,
... ConditionalDetrConfig,
... ConditionalDetrForSegmentation,
... )
>>> from transformers.image_transforms import rgb_to_id
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50")
>>> # randomly initialize all weights of the model
>>> config = ConditionalDetrConfig()
>>> model = ConditionalDetrForSegmentation(config)
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])
>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]
ConvNeXT
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/convnext
概述
ConvNeXT 模型是由 Zhuang Liu、Hanzi Mao、Chao-Yuan Wu、Christoph Feichtenhofer、Trevor Darrell、Saining Xie 在2020 年的 ConvNet中提出的。ConvNeXT 是一种纯卷积模型(ConvNet),受到 Vision Transformers 设计的启发,声称胜过它们。
该论文的摘要如下:
视觉识别的“繁荣 20 年”始于 Vision Transformers(ViTs)的引入,它们迅速取代了 ConvNets 成为最先进的图像分类模型。另一方面,一个普通的 ViT 在应用于一般计算机视觉任务(如目标检测和语义分割)时会面临困难。正是分层 Transformer(例如 Swin Transformers)重新引入了几个 ConvNet 先验,使得 Transformers 在实践中成为通用视觉骨干,并在各种视觉任务上表现出色。然而,这种混合方法的有效性仍然主要归因于 Transformers 的固有优越性,而不是卷积的固有归纳偏差。在这项工作中,我们重新审视设计空间,并测试纯 ConvNet 可以实现的极限。我们逐渐将标准 ResNet“现代化”到一个视觉 Transformer 的设计,并发现了沿途对性能差异的贡献的几个关键组件。这次探索的结果是一系列被称为 ConvNeXt 的纯 ConvNet 模型。ConvNeXt 完全由标准 ConvNet 模块构建,以准确性和可扩展性方面与 Transformers 竞争,实现了 87.8%的 ImageNet top-1 准确性,并在 COCO 检测和 ADE20K 分割上胜过 Swin Transformers,同时保持了标准 ConvNets 的简单性和效率。
ConvNeXT 架构。摘自原始论文。
这个模型是由nielsr贡献的。模型的 TensorFlow 版本是由ariG23498、gante和sayakpaul(平等贡献)贡献的。原始代码可以在这里找到。
资源
一个官方 Hugging Face 和社区(由🌎表示)资源列表,帮助您开始使用 ConvNeXT。
图像分类
如果您有兴趣提交资源以包含在此处,请随时打开一个 Pull Request,我们将对其进行审查!资源应该理想地展示一些新东西,而不是重复现有资源。
ConvNextConfig
class transformers.ConvNextConfig
( num_channels = 3 patch_size = 4 num_stages = 4 hidden_sizes = None depths = None hidden_act = 'gelu' initializer_range = 0.02 layer_norm_eps = 1e-12 layer_scale_init_value = 1e-06 drop_path_rate = 0.0 image_size = 224 out_features = None out_indices = None **kwargs )
参数
-
num_channels
(int
, optional, defaults to 3) — 输入通道数。 -
patch_size
(int
, optional, defaults to 4) — 在补丁嵌入层中使用的补丁大小。 -
num_stages
(int
, optional, defaults to 4) — 模型中的阶段数。 -
hidden_sizes
(List[int]
, optional, defaults to [96, 192, 384, 768]) — 每个阶段的维度(隐藏大小)。 -
depths
(List[int]
, 可选, 默认为[3, 3, 9, 3]) — 每个阶段的深度(块数)。 -
hidden_act
(str
或function
, 可选, 默认为"gelu"
) — 每个块中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 -
initializer_range
(float
, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
layer_norm_eps
(float
, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon。 -
layer_scale_init_value
(float
, 可选, 默认为 1e-6) — 层比例的初始值。 -
drop_path_rate
(float
, 可选, 默认为 0.0) — 随机深度的丢弃率。 -
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
属性中定义的顺序。
这是用于存储 ConvNextModel 配置的配置类。根据指定的参数实例化 ConvNeXT 模型,定义模型架构。使用默认值实例化配置将产生类似于 ConvNeXT facebook/convnext-tiny-224架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import ConvNextConfig, ConvNextModel
>>> # Initializing a ConvNext convnext-tiny-224 style configuration
>>> configuration = ConvNextConfig()
>>> # Initializing a model (with random weights) from the convnext-tiny-224 style configuration
>>> model = ConvNextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
ConvNextFeatureExtractor
class transformers.ConvNextFeatureExtractor
( *args **kwargs )
ConvNextImageProcessor
class transformers.ConvNextImageProcessor
( do_resize: bool = True size: Dict = None crop_pct: float = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )
参数
-
do_resize
(bool
, 可选, 默认为True
) — 控制是否将图像的(高度、宽度)维度调整为指定的size
。可以被preprocess
方法中的do_resize
覆盖。 -
size
(Dict[str, int]
可选, 默认为{"shortest_edge" -- 384}
): 在应用resize
后输出图像的分辨率。如果size["shortest_edge"]
>= 384,则将图像调整为(size["shortest_edge"], size["shortest_edge"])
。否则,图像的较小边将匹配到int(size["shortest_edge"]/crop_pct)
,然后将图像裁剪为(size["shortest_edge"], size["shortest_edge"])
。仅在do_resize
设置为True
时有效。可以被preprocess
方法中的size
覆盖。 -
crop_pct
(float
可选, 默认为 224 / 256) — 要裁剪的图像百分比。仅在do_resize
为True
且大小<384 时有效。可以被preprocess
方法中的crop_pct
覆盖。 -
resample
(PILImageResampling
, 可选, 默认为Resampling.BILINEAR
) — 如果调整图像大小,要使用的重采样滤波器。可以被preprocess
方法中的resample
覆盖。 -
do_rescale
(bool
, optional, 默认为True
) — 是否按指定比例rescale_factor
重新缩放图像。可以被preprocess
方法中的do_rescale
覆盖。 -
rescale_factor
(int
或float
, optional, 默认为1/255
) — 如果重新缩放图像,则使用的比例因子。可以被preprocess
方法中的rescale_factor
覆盖。 -
do_normalize
(bool
, optional, 默认为True
) — 是否对图像进行归一化。可以被preprocess
方法中的do_normalize
参数覆盖。 -
image_mean
(float
或List[float]
, optional, 默认为IMAGENET_STANDARD_MEAN
) — 归一化图像时使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess
方法中的image_mean
参数覆盖。 -
image_std
(float
或List[float]
, optional, 默认为IMAGENET_STANDARD_STD
) — 用于归一化图像时使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess
方法中的image_std
参数覆盖。
构造一个 ConvNeXT 图像处理器。
preprocess
( images: Union do_resize: bool = None size: Dict = None crop_pct: float = None resample: Resampling = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
参数
-
images
(ImageInput
) — 要预处理的图像。期望单个或批量像素值范围为 0 到 255 的图像。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。 -
do_resize
(bool
, optional, 默认为self.do_resize
) — 是否调整图像大小。 -
size
(Dict[str, int]
, optional, 默认为self.size
) — 在应用resize
后输出图像的大小。如果size["shortest_edge"]
>= 384,则将图像调整为(size["shortest_edge"], size["shortest_edge"])
。否则,图像的较小边将匹配到int(size["shortest_edge"]/ crop_pct)
,然后将图像裁剪为(size["shortest_edge"], size["shortest_edge"])
。仅在do_resize
设置为True
时有效。 -
crop_pct
(float
, optional, 默认为self.crop_pct
) — 如果大小 < 384,则裁剪图像的百分比。 -
resample
(int
, optional, 默认为self.resample
) — 如果调整图像大小,则要使用的重采样滤波器。这可以是PILImageResampling
中的一个滤波器。仅在do_resize
设置为True
时有效。 -
do_rescale
(bool
, optional, 默认为self.do_rescale
) — 是否将图像值重新缩放在 [0 - 1] 之间。 -
rescale_factor
(float
, optional, 默认为self.rescale_factor
) — 如果do_rescale
设置为True
,则用于重新缩放图像的重新缩放因子。 -
do_normalize
(bool
, optional, 默认为self.do_normalize
) — 是否对图像进行归一化。 -
image_mean
(float
或List[float]
, optional, 默认为self.image_mean
) — 图像均值。 -
image_std
(float
或List[float]
, optional, 默认为self.image_std
) — 图像标准差。 -
return_tensors
(str
或TensorType
, optional) — 要返回的张量类型。可以是以下之一:-
未设置: 返回一个
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
, optional, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
: 图像以 (num_channels, height, width) 格式。 -
"channels_last"
或ChannelDimension.LAST
: 图像以 (height, width, num_channels) 格式。 -
未设置: 使用输入图像的通道维度格式。
-
-
input_data_format
(ChannelDimension
或str
, optional) — 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
:图像以(通道数,高度,宽度)格式。 -
"channels_last"
或ChannelDimension.LAST
:图像以(高度,宽度,通道数)格式。 -
"none"
或ChannelDimension.NONE
:图像以(高度,宽度)格式。
-
预处理图像或图像批处理。
PytorchHide Pytorch content
ConvNextModel
class transformers.ConvNextModel
( config )
参数
config
(ConvNextConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸的 ConvNext 模型输出原始特征,没有特定的头部。这个模型是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( pixel_values: FloatTensor = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 ConvNextImageProcessor.call
()。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention
或tuple(torch.FloatTensor)
一个transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含各种元素,取决于配置(ConvNextConfig)和输入。
-
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 模型最后一层的隐藏状态序列。 -
pooler_output
(torch.FloatTensor
,形状为(batch_size, hidden_size)
) — 空间维度上池化操作后的最后一层隐藏状态。 -
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的一个 + 每个层的输出一个)。模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
ConvNextModel 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, ConvNextModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224")
>>> model = ConvNextModel.from_pretrained("facebook/convnext-tiny-224")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 768, 7, 7]
ConvNextForImageClassification
class transformers.ConvNextForImageClassification
( config )
参数
config
(ConvNextConfig)— 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
ConvNext 模型,顶部带有图像分类头(池化特征之上的线性层),例如用于 ImageNet。
此模型是 PyTorch 的torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( pixel_values: FloatTensor = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.ImageClassifierOutputWithNoAttention or tuple(torch.FloatTensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 ConvNextImageProcessor.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
时)包含根据配置(ConvNextConfig)和输入的各种元素。
-
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
元组。模型在每个阶段的输出的隐藏状态(也称为特征图)。
ConvNextForImageClassification 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的步骤需要在此函数中定义,但应该在此之后调用Module
实例,而不是这个,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, ConvNextForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224")
>>> model = ConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat
TensorFlow 隐藏 TensorFlow 内容
TFConvNextModel
class transformers.TFConvNextModel
( config *inputs add_pooling_layer = True **kwargs )
参数
config
(ConvNextConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
裸的 ConvNext 模型输出原始特征,没有特定的头部。该模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
-
将所有输入作为关键字参数(类似于 PyTorch 模型),或
-
将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持,当使用model.fit()
等方法时,您应该可以“轻松使用” - 只需以model.fit()
支持的任何格式传递输入和标签!但是,如果您想在 Keras 方法之外使用第二种格式,比如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可以用来收集所有输入张量放在第一个位置参数中:
-
只有一个带有
pixel_values
的张量,没有其他内容:model(pixel_values)
-
一个长度可变的列表,其中包含一个或多个输入张量,按照文档字符串中给定的顺序:
model([pixel_values, attention_mask])
或model([pixel_values, attention_mask, token_type_ids])
-
一个字典,其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量:
model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心这些内容,因为您可以像对待任何其他 Python 函数一样传递输入!
call
( pixel_values: TFModelInputType | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)
参数
-
pixel_values
(np.ndarray
、tf.Tensor
、List[tf.Tensor]
、Dict[str, tf.Tensor]
或Dict[str, np.ndarray]
,每个示例的形状必须为(batch_size, num_channels, height, width)
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 ConvNextImageProcessor.call
()。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。这个参数只能在急切模式下使用,在图模式下,将使用配置中的值。 -
return_dict
(bool
,可选)— 是否返回一个 ModelOutput 而不是一个普通元组。这个参数可以在急切模式下使用,在图模式下,该值将始终设置为 True。
返回
transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个tf.Tensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时)包括根据配置(ConvNextConfig)和输入的各种元素。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
)— 模型最后一层的隐藏状态的序列。 -
pooler_output
(形状为(batch_size, hidden_size)
的tf.Tensor
)— 序列第一个标记(分类标记)的最后一层隐藏状态,进一步由线性层和 Tanh 激活函数处理。线性层权重是在预训练期间从下一个句子预测(分类)目标中训练的。这个输出通常不是输入语义内容的良好摘要,您通常最好对整个输入序列的隐藏状态进行平均或池化。
-
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出+一个用于每个层的输出)。模型在每一层输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFConvNextModel 前向方法,覆盖__call__
特殊方法。
虽然前向传递的方法需要在这个函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFConvNextModel
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224")
>>> model = TFConvNextModel.from_pretrained("facebook/convnext-tiny-224")
>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
TFConvNextForImageClassification
class transformers.TFConvNextForImageClassification
( config: ConvNextConfig *inputs **kwargs )
参数
config
(ConvNextConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
ConvNext 模型,顶部带有图像分类头(在池化特征之上的线性层),例如用于 ImageNet。
此模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
-
将所有输入作为关键字参数(类似于 PyTorch 模型),或
-
将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是,Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,在使用model.fit()
等方法时,应该“只需工作” - 只需传递model.fit()
支持的任何格式的输入和标签!但是,如果您想在 Keras 方法之外使用第二种格式,例如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可用于收集第一个位置参数中的所有输入张量:
-
只有一个包含
pixel_values
的张量,没有其他内容:model(pixel_values)
-
一个长度可变的列表,其中包含一个或多个按照文档字符串中给定的顺序的输入张量:
model([pixel_values, attention_mask])
或model([pixel_values, attention_mask, token_type_ids])
-
一个字典,其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量:
model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心这些内容,因为您可以像对待任何其他 Python 函数一样传递输入!
call
( pixel_values: TFModelInputType | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)
参数
-
pixel_values
(np.ndarray
,tf.Tensor
,List[tf.Tensor]
``Dict[str, tf.Tensor]或
Dict[str, np.ndarray],每个示例的形状必须为
(batch_size, num_channels, height, width))— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 ConvNextImageProcessor.
call`()。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。此参数仅在急切模式下使用,在图模式下将使用配置中的值。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用,在图模式下该值将始终设置为 True。 -
labels
(形状为(batch_size,)
的tf.Tensor
或np.ndarray
,可选)— 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
范围内。如果config.num_labels == 1
,则计算回归损失(均方损失),如果config.num_labels > 1
,则计算分类损失(交叉熵)。
返回
transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个 tf.Tensor
元组(如果传递 return_dict=False
或 config.return_dict=False
)包含各种元素,取决于配置(ConvNextConfig)和输入。
-
loss
(tf.Tensor
,形状为(batch_size, )
,可选,当提供labels
时返回) — 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(tf.Tensor
,形状为(batch_size, config.num_labels)
) — 分类(如果config.num_labels==1
则为回归)分数(SoftMax 之前)。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层的输出的隐藏状态加上初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
TFConvNextForImageClassification 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用 Module
实例,而不是这个函数,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFConvNextForImageClassification
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224")
>>> model = TFConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224")
>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = tf.math.argmax(logits, axis=-1)[0]
>>> print("Predicted class:", model.config.id2label[int(predicted_class_idx)])
ConvNeXt V2
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/convnextv2
概述
ConvNeXt V2 模型是由 Sanghyun Woo, Shoubhik Debnath, Ronghang Hu, Xinlei Chen, Zhuang Liu, In So Kweon, Saining Xie 在ConvNeXt V2: Co-designing and Scaling ConvNets with Masked Autoencoders中提出的。ConvNeXt V2 是一个纯卷积模型(ConvNet),受到 Vision Transformers 设计的启发,是 ConvNeXT 的后继者。
论文的摘要如下:
受到改进的架构和更好的表示学习框架的驱动,视觉识别领域在 2020 年代初迅速现代化和性能提升。例如,现代 ConvNets,如 ConvNeXt,已经在各种场景中展示出强大的性能。虽然这些模型最初是为带有 ImageNet 标签的监督学习而设计的,但它们也有可能从像遮罩自动编码器(MAE)这样的自监督学习技术中受益。然而,我们发现简单地将这两种方法结合起来会导致性能不佳。在本文中,我们提出了一个完全卷积的遮罩自动编码器框架和一个新的全局响应归一化(GRN)层,可以添加到 ConvNeXt 架构中以增强通道间特征竞争。这种自监督学习技术和架构改进的共同设计导致了一个名为 ConvNeXt V2 的新模型系列,显著提高了纯 ConvNets 在各种识别基准上的性能,包括 ImageNet 分类、COCO 检测和 ADE20K 分割。我们还提供了各种规模的预训练 ConvNeXt V2 模型,从一个高效的 3.7M 参数 Atto 模型,在 ImageNet 上达到 76.7% 的 top-1 准确率,到一个 650M 的 Huge 模型,仅使用公共训练数据就实现了最先进的 88.9% 准确率。
ConvNeXt V2 架构。摘自原始论文。
资源
一个官方的 Hugging Face 和社区(由 🌎 表示)资源列表,帮助您开始使用 ConvNeXt V2。
图像分类
如果您有兴趣提交资源以包含在这里,请随时打开一个 Pull Request,我们将进行审查!资源应该展示出一些新东西,而不是重复现有资源。
ConvNextV2Config
class transformers.ConvNextV2Config
( num_channels = 3 patch_size = 4 num_stages = 4 hidden_sizes = None depths = None hidden_act = 'gelu' initializer_range = 0.02 layer_norm_eps = 1e-12 drop_path_rate = 0.0 image_size = 224 out_features = None out_indices = None **kwargs )
参数
-
num_channels
(int
,可选,默认为 3) — 输入通道数。 -
patch_size
(int
,可选,默认为 4) — 在补丁嵌入层中使用的补丁大小。 -
num_stages
(int
,可选,默认为 4) — 模型中的阶段数。 -
hidden_sizes
(List[int]
,可选,默认为[96, 192, 384, 768]
) — 每个阶段的维度(隐藏大小)。 -
depths
(List[int]
,可选,默认为[3, 3, 9, 3]
) — 每个阶段的深度(块数)。 -
hidden_act
(str
或function
,可选,默认为"gelu"
) — 每个块中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 -
initializer_range
(float
, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
layer_norm_eps
(float
, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。 -
drop_path_rate
(float
, optional, 默认为 0.0) — 随机深度的丢弃率。 -
out_features
(List[str]
, optional) — 如果用作骨干,要输出的特征列表。可以是"stem"
、"stage1"
、"stage2"
等(取决于模型有多少阶段)。如果未设置且设置了out_indices
,将默认为相应的阶段。如果未设置且未设置out_indices
,将默认为最后一个阶段。必须按照stage_names
属性中定义的顺序。 -
out_indices
(List[int]
, optional) — 如果用作骨干,要输出的特征索引列表。可以是 0、1、2 等(取决于模型有多少阶段)。如果未设置且设置了out_features
,将默认为相应的阶段。如果未设置且未设置out_features
,将默认为最后一个阶段。必须按照stage_names
属性中定义的顺序。
这是用于存储 ConvNextV2Model 配置的配置类。它用于根据指定的参数实例化 ConvNeXTV2 模型,定义模型架构。使用默认值实例化配置将产生类似于 ConvNeXTV2 facebook/convnextv2-tiny-1k-224架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import ConvNeXTV2Config, ConvNextV2Model
>>> # Initializing a ConvNeXTV2 convnextv2-tiny-1k-224 style configuration
>>> configuration = ConvNeXTV2Config()
>>> # Initializing a model (with random weights) from the convnextv2-tiny-1k-224 style configuration
>>> model = ConvNextV2Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
ConvNextV2Model
class transformers.ConvNextV2Model
( config )
参数
config
(ConvNextV2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
裸的 ConvNextV2 模型输出原始特征,没有任何特定的头部。这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。
forward
( pixel_values: FloatTensor = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用 ConvNextImageProcessor 获取。有关详细信息,请参阅 ConvNextImageProcessor.call
()。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention
或 tuple(torch.FloatTensor)
一个transformers.modeling_outputs.BaseModelOutputWithPoolingAndNoAttention
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时)包括根据配置(ConvNextV2Config)和输入的各种元素。
-
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
元组(如果模型有嵌入层,则为嵌入的输出和每一层的输出)。模型在每一层输出处的隐藏状态加上可选的初始嵌入输出。
ConvNextV2Model 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, ConvNextV2Model
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> model = ConvNextV2Model.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 768, 7, 7]
ConvNextV2ForImageClassification
class transformers.ConvNextV2ForImageClassification
( config )
参数
config
(ConvNextV2Config)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
ConvNextV2 模型在顶部具有图像分类头部(在池化特征之上的线性层),例如用于 ImageNet。
此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( pixel_values: FloatTensor = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.ImageClassifierOutputWithNoAttention or tuple(torch.FloatTensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。像素值可以使用 ConvNextImageProcessor 获取。有关详细信息,请参阅 ConvNextImageProcessor.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
)包含各种元素,取决于配置(ConvNextV2Config)和输入。
-
loss
(torch.FloatTensor
of shape(1,)
, 可选,当提供labels
时返回) — 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(torch.FloatTensor
of shape(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, num_channels, height, width)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每个阶段的输出)。模型在每个阶段输出的隐藏状态(也称为特征图)。
ConvNextV2ForImageClassification 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, ConvNextV2ForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> model = ConvNextV2ForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat
TFConvNextV2Model
class transformers.TFConvNextV2Model
( config: ConvNextV2Config *inputs **kwargs )
参数
config
(ConvNextV2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸的 ConvNextV2 模型输出原始特征,没有特定的头部。此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以了解与一般使用和行为相关的所有事项。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
-
将所有输入作为关键字参数(类似于 PyTorch 模型),或
-
将所有输入作为列表、元组或字典在第一个位置参数中。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用model.fit()
等方法时,应该可以“正常工作” - 只需传递您支持的任何格式的输入和标签给model.fit()
!但是,如果您想在 Keras 方法之外使用第二种格式,比如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可以用来收集所有输入张量在第一个位置参数中:
-
只有
pixel_values
的单个张量,没有其他内容:model(pixel_values)
-
一个长度可变的列表,其中包含一个或多个输入张量,按照文档字符串中给定的顺序:
model([pixel_values, attention_mask])
或model([pixel_values, attention_mask, token_type_ids])
-
一个包含与文档字符串中给定的输入名称相关联的一个或多个输入张量的字典:
model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您不需要担心这些问题,因为您可以像对待任何其他 Python 函数一样传递输入!
call
( pixel_values: TFModelInputType | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndNoAttention or tuple(tf.Tensor)
参数
-
pixel_values
(np.ndarray
,tf.Tensor
,List[tf.Tensor]
,Dict[str, tf.Tensor]
或Dict[str, np.ndarray]
,每个示例必须具有形状(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 ConvNextImageProcessor.call
()。 -
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。此参数仅在急切模式下使用,在图模式下将使用配置中的值。 -
return_dict
(bool
, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。这个参数可以在急切模式下使用,在图模式下,该值将始终设置为True
。
返回
transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndNoAttention
或tuple(tf.Tensor)
一个transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndNoAttention
或一个tf.Tensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时)包含各种元素,这取决于配置(ConvNextV2Config)和输入。
-
last_hidden_state
(形状为(batch_size, num_channels, height, width)
的tf.Tensor
) — 模型最后一层的隐藏状态序列。 -
pooler_output
(tf.Tensor
,形状为(batch_size, hidden_size)
) — 在空间维度上进行池化操作后的最后一层隐藏状态。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回) — 形状为(batch_size, num_channels, height, width)
的tf.Tensor
元组(如果模型有嵌入层,则为嵌入的输出+每一层的输出)。模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
TFConvNextV2Model 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFConvNextV2Model
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> model = TFConvNextV2Model.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> inputs = image_processor(image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 768, 7, 7]
TFConvNextV2ForImageClassification
class transformers.TFConvNextV2ForImageClassification
( config: ConvNextV2Config *inputs **kwargs )
参数
config
(ConvNextV2Config)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
ConvNextV2 模型,顶部带有图像分类头(在池化特征的顶部是一个线性层),例如用于 ImageNet。
此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型还是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
-
将所有输入作为关键字参数(类似于 PyTorch 模型),或
-
将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是,当将输入传递给模型和层时,Keras 方法更喜欢这种格式。由于这种支持,当使用model.fit()
等方法时,应该可以正常工作 - 只需以model.fit()
支持的任何格式传递输入和标签即可!但是,如果要在 Keras 方法之外使用第二种格式,例如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可用于在第一个位置参数中收集所有输入张量:
-
只有一个张量,其中仅包含
pixel_values
,没有其他内容:model(pixel_values)
-
一个长度不定的列表,其中包含一个或多个输入张量,按照文档字符串中给定的顺序:
model([pixel_values, attention_mask])
或model([pixel_values, attention_mask, token_type_ids])
-
一个字典,其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量:
model({"pixel_values": pixel_values, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像对待任何其他 Python 函数一样传递输入!
call
( pixel_values: TFModelInputType | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention or tuple(tf.Tensor)
参数
-
pixel_values
(np.ndarray
,tf.Tensor
,List[tf.Tensor]
,Dict[str, tf.Tensor]
或Dict[str, np.ndarray]
,每个示例的形状必须为(batch_size, num_channels, height, width)
)— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参见 ConvNextImageProcessor.call
()。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量中的hidden_states
。此参数仅在急切模式下可用,在图模式下将使用配置中的值。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用,在图模式下该值将始终设置为True
。 -
labels
(tf.Tensor
或np.ndarray
,形状为(batch_size,)
,可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
范围内。如果config.num_labels == 1
,则计算回归损失(均方损失),如果config.num_labels > 1
,则计算分类损失(交叉熵)。
返回
transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention
或 tuple(tf.Tensor)
一个transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention
或一个tf.Tensor
元组(如果传递了return_dict=False
或config.return_dict=False
)包含各种元素,取决于配置(ConvNextV2Config)和输入。
-
loss
(tf.Tensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(tf.Tensor
,形状为(batch_size, config.num_labels)
) — 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, num_channels, height, width)
的tf.Tensor
元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每个阶段的输出)。模型在每个阶段输出的隐藏状态(也称为特征图)。
TFConvNextV2ForImageClassification 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFConvNextV2ForImageClassification
>>> import tensorflow as tf
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> model = TFConvNextV2ForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224")
>>> inputs = image_processor(image, return_tensors="tf")
>>> logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = int(tf.math.argmax(logits, axis=-1))
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat
卷积视觉 Transformer(CvT)
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/cvt
概述
CvT 模型由吴海平、肖斌、诺尔·科代拉、刘梦晨、戴希扬、袁璐和张磊在CvT: Introducing Convolutions to Vision Transformers中提出。卷积视觉 Transformer(CvT)通过将卷积引入 ViT 中,提高了视觉 Transformer(ViT)的性能和效率,以获得这两种设计的最佳效果。
论文摘要如下:
我们在本文中提出了一种名为卷积视觉 Transformer(CvT)的新架构,通过将卷积引入 ViT 中,提高了 ViT 的性能和效率,以获得这两种设计的最佳效果。这通过两个主要修改实现:包含新的卷积标记嵌入的 Transformer 层次结构,以及利用卷积投影的卷积 Transformer 块。这些改变将卷积神经网络(CNN)的理想特性引入 ViT 架构(即平移、缩放和失真不变性),同时保持 Transformer 的优点(即动态注意力、全局上下文和更好的泛化)。我们通过进行广泛实验验证了 CvT,显示这种方法在 ImageNet-1k 上实现了其他视觉 Transformer 和 ResNet 的最新性能,参数更少,FLOPs 更低。此外,当在更大的数据集(例如 ImageNet-22k)上进行预训练并微调到下游任务时,性能增益得以保持。在 ImageNet-22k 上预训练,我们的 CvT-W24 在 ImageNet-1k 验证集上获得了 87.7%的 top-1 准确率。最后,我们的结果表明,位置编码,现有视觉 Transformer 中的关键组件,可以在我们的模型中安全地移除,简化了更高分辨率视觉任务的设计。
使用提示
-
CvT 模型是常规的视觉 Transformer,但是经过卷积训练。当在 ImageNet-1K 和 CIFAR-100 上进行微调时,它们的性能优于原始模型(ViT)。
-
您可以查看关于推理以及在自定义数据上进行微调的演示笔记本这里(您只需将 ViTFeatureExtractor 替换为 AutoImageProcessor,将 ViTForImageClassification 替换为 CvtForImageClassification)。
-
可用的检查点要么(1)仅在ImageNet-22k(包含 1400 万图像和 22k 类别)上进行预训练,要么(2)在 ImageNet-22k 上进行微调,要么(3)在ImageNet-1k(也称为 ILSVRC 2012,包含 130 万图像和 1000 类别)上进行微调。
资源
一份官方 Hugging Face 和社区(由🌎表示)资源列表,帮助您开始使用 CvT。
图像分类
如果您有兴趣提交资源以包含在此处,请随时打开一个 Pull Request,我们将进行审查!资源应该展示一些新内容,而不是重复现有资源。
CvtConfig
class transformers.CvtConfig
( num_channels = 3 patch_sizes = [7, 3, 3] patch_stride = [4, 2, 2] patch_padding = [2, 1, 1] embed_dim = [64, 192, 384] num_heads = [1, 3, 6] depth = [1, 2, 10] mlp_ratio = [4.0, 4.0, 4.0] attention_drop_rate = [0.0, 0.0, 0.0] drop_rate = [0.0, 0.0, 0.0] drop_path_rate = [0.0, 0.0, 0.1] qkv_bias = [True, True, True] cls_token = [False, False, True] qkv_projection_method = ['dw_bn', 'dw_bn', 'dw_bn'] kernel_qkv = [3, 3, 3] padding_kv = [1, 1, 1] stride_kv = [2, 2, 2] padding_q = [1, 1, 1] stride_q = [1, 1, 1] initializer_range = 0.02 layer_norm_eps = 1e-12 **kwargs )
参数
-
num_channels
(int
, optional, defaults to 3) — 输入通道数 -
patch_sizes
(List[int]
, optional, defaults to[7, 3, 3]
) — 每个编码器块的补丁嵌入的内核大小 -
patch_stride
(List[int]
, optional, defaults to[4, 2, 2]
) — 每个编码器块的补丁嵌入的步幅大小 -
patch_padding
(List[int]
, optional, defaults to[2, 1, 1]
) — 每个编码器块的补丁嵌入的填充大小 -
embed_dim
(List[int]
, optional, defaults to[64, 192, 384]
) — 每个编码器块的维度 -
num_heads
(List[int]
, optional, defaults to[1, 3, 6]
) — 每个 Transformer 编码器块中每个注意力层的注意力头数。 -
depth
(List[int]
, optional, defaults to[1, 2, 10]
) — 每个编码器块中的层数 -
mlp_ratios
(List[float]
, optional, defaults to[4.0, 4.0, 4.0, 4.0]
) — 在编码器块中 Mix FFN 的隐藏层大小与输入层大小的比率 -
attention_drop_rate
(List[float]
, optional, defaults to[0.0, 0.0, 0.0]
) — 注意力概率的丢弃比率 -
drop_rate
(List[float]
, optional, defaults to[0.0, 0.0, 0.0]
) — 补丁嵌入概率的丢弃比率 -
drop_path_rate
(List[float]
, optional, defaults to[0.0, 0.0, 0.1]
) — 随机深度的丢弃概率,用于 Transformer 编码器块中 -
qkv_bias
(List[bool]
, optional, defaults to[True, True, True]
) — 查询、键和值的注意力中的偏置布尔值 -
cls_token
(List[bool]
, optional, defaults to[False, False, True]
) — 是否向每个最后 3 个阶段的输出添加分类令牌 -
qkv_projection_method
(List[string]
, optional, defaults to [“dw_bn”, “dw_bn”, “dw_bn”]`) — 查询、键和值的投影方法,默认为深度卷积和批量归一化。使用“avg”进行线性投影。 -
kernel_qkv
(List[int]
, optional, defaults to[3, 3, 3]
) — 注意力层中查询、键和值的内核大小 -
padding_kv
(List[int]
, optional, defaults to[1, 1, 1]
) — 注意力层中键和值的填充大小 -
stride_kv
(List[int]
, optional, defaults to[2, 2, 2]
) — 注意力层中键和值的步幅大小 -
padding_q
(List[int]
, optional, defaults to[1, 1, 1]
) — 注意力层中查询的填充大小 -
stride_q
(List[int]
, optional, defaults to[1, 1, 1]
) — 查询在注意力层中的步幅大小 -
initializer_range
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差 -
layer_norm_eps
(float
, optional, defaults to 1e-6) — 层归一化层使用的 epsilon
这是用于存储 CvtModel 配置的配置类。它用于根据指定的参数实例化 CvT 模型,定义模型架构。使用默认值实例化配置将产生类似于 CvT microsoft/cvt-13架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import CvtConfig, CvtModel
>>> # Initializing a Cvt msft/cvt style configuration
>>> configuration = CvtConfig()
>>> # Initializing a model (with random weights) from the msft/cvt style configuration
>>> model = CvtModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
PytorchHide Pytorch 内容
CvtModel
class transformers.CvtModel
( config add_pooling_layer = True )
参数
config
(CvtConfig)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸 Cvt 模型变压器输出原始隐藏状态,没有特定的头部。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。
forward
( pixel_values: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.cvt.modeling_cvt.BaseModelOutputWithCLSToken or tuple(torch.FloatTensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅CvtImageProcessor.__call__
。 -
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.cvt.modeling_cvt.BaseModelOutputWithCLSToken
或tuple(torch.FloatTensor)
一个transformers.models.cvt.modeling_cvt.BaseModelOutputWithCLSToken
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(CvtConfig)和输入的各种元素。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
)- 模型最后一层的隐藏状态序列。 -
cls_token_value
(形状为(batch_size, 1, 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
元组。模型在每一层的输出的隐藏状态 + 初始嵌入输出。
CvtModel 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此之后调用,因为前者会负责运行前处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, CvtModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = CvtModel.from_pretrained("microsoft/cvt-13")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 384, 14, 14]
CvtForImageClassification
class transformers.CvtForImageClassification
( config )
参数
config
(CvtConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
带有图像分类头部的 Cvt 模型变压器(在 [CLS] 标记的最终隐藏状态之上的线性层),例如用于 ImageNet。
此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
前进
( pixel_values: Optional = None labels: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.ImageClassifierOutputWithNoAttention or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅CvtImageProcessor.__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.modeling_outputs.ImageClassifierOutputWithNoAttention 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.ImageClassifierOutputWithNoAttention 或一个 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时)包含根据配置(CvtConfig)和输入的不同元素。
-
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, num_channels, height, width)
的torch.FloatTensor
元组。模型在每个阶段输出的隐藏状态(也称为特征图)。
CvtForImageClassification 前进方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, CvtForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = CvtForImageClassification.from_pretrained("microsoft/cvt-13")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat
TensorFlow 隐藏 TensorFlow 内容
TFCvtModel
类 transformers.TFCvtModel
( config: CvtConfig *inputs **kwargs )
参数
config
(CvtConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 Cvt 模型变压器输出原始隐藏状态,没有特定的顶部头。
此模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个 tf.keras.Model 子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。
TF 2.0 模型接受两种格式的输入:
-
将所有输入作为关键字参数(如 PyTorch 模型),或
-
将所有输入作为列表、元组或字典放在第一个位置参数中。
当使用 tf.keras.Model.fit
方法时,第二个选项很有用,该方法当前要求在模型调用函数的第一个参数中具有所有张量:model(inputs)
。
call
( pixel_values: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.models.cvt.modeling_tf_cvt.TFBaseModelOutputWithCLSToken or tuple(tf.Tensor)
参数
-
pixel_values
(np.ndarray
、tf.Tensor
、List[tf.Tensor]
、Dict[str, tf.Tensor]
或Dict[str, np.ndarray]
,每个示例的形状必须为(batch_size, num_channels, height, width)
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅CvtImageProcessor.__call__
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。此参数仅在急切模式下可用,在图模式下将使用配置中的值。 -
return_dict
(bool
,可选)— 是否返回一个 ModelOutput 而不是一个普通元组。此参数可以在急切模式下使用,在图模式下该值将始终设置为 True。 -
training
(bool
,可选,默认为False
)— 是否在训练模式下使用模型(某些模块如丢弃模块在训练和评估之间有不同的行为)。
返回
transformers.models.cvt.modeling_tf_cvt.TFBaseModelOutputWithCLSToken
或 tuple(tf.Tensor)
一个 transformers.models.cvt.modeling_tf_cvt.TFBaseModelOutputWithCLSToken
或一个 tf.Tensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时)包含根据配置(CvtConfig)和输入的各种元素。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
)— 模型最后一层的隐藏状态序列。 -
cls_token_value
(形状为(batch_size, 1, hidden_size)
的tf.Tensor
)— 模型最后一层的分类标记。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每一层的输出隐藏状态加上初始嵌入输出。
TFCvtModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此之后调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFCvtModel
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = TFCvtModel.from_pretrained("microsoft/cvt-13")
>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
TFCvtForImageClassification
class transformers.TFCvtForImageClassification
( config: CvtConfig *inputs **kwargs )
参数
config
(CvtConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
Cvt 模型变压器,顶部带有图像分类头(在[CLS]标记的最终隐藏状态之上的线性层),例如用于 ImageNet。
此模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型还是tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有事项。
TF 2.0 模型接受两种格式的输入:
-
将所有输入作为关键字参数(类似于 PyTorch 模型),或
-
将所有输入作为列表、元组或字典放在第一个位置参数中。
当使用tf.keras.Model.fit
方法时,第二个选项很有用,该方法当前要求在模型调用函数的第一个参数中具有所有张量:model(inputs)
。
call
( pixel_values: tf.Tensor | None = None labels: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention or tuple(tf.Tensor)
参数
-
pixel_values
(np.ndarray
、tf.Tensor
、List[tf.Tensor]
、Dict[str, tf.Tensor]
或Dict[str, np.ndarray]
,每个示例的形状必须为(batch_size, num_channels, height, width)
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参见CvtImageProcessor.__call__
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。此参数仅在急切模式下可用,在图模式下将使用配置中的值。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用,在图模式下该值将始终设置为 True。 -
training
(bool
,可选,默认为False
)— 是否在训练模式下使用模型(某些模块如 dropout 模块在训练和评估之间具有不同的行为)。 -
labels
(形状为(batch_size,)
的tf.Tensor
或np.ndarray
,可选)— 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
范围内。如果config.num_labels == 1
,则计算回归损失(均方损失),如果config.num_labels > 1
,则计算分类损失(交叉熵)。
返回
transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention
或tuple(tf.Tensor)
transformers.modeling_tf_outputs.TFImageClassifierOutputWithNoAttention
或者一个 tf.Tensor
元组(如果传入了 return_dict=False
或者 config.return_dict=False
)包含不同的元素,取决于配置(CvtConfig)和输入。
-
loss
(形状为(1,)
的tf.Tensor
,可选,当提供了labels
时返回)— 分类(如果config.num_labels==1
则为回归)损失。 -
logits
(形状为(batch_size, config.num_labels)
的tf.Tensor
)— 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传入output_hidden_states=True
或者config.output_hidden_states=True
时返回)— 形状为(batch_size, num_channels, height, width)
的tf.Tensor
元组。模型在每个阶段输出的隐藏状态(也称为特征图)。
TFCvtForImageClassification 的前向方法,重写了 __call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用 Module
实例,而不是这个函数,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFCvtForImageClassification
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("microsoft/cvt-13")
>>> model = TFCvtForImageClassification.from_pretrained("microsoft/cvt-13")
>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = tf.math.argmax(logits, axis=-1)[0]
>>> print("Predicted class:", model.config.id2label[int(predicted_class_idx)])
Deformable DETR
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/deformable_detr
概述
Deformable DETR 模型是由 Xizhou Zhu,Weijie Su,Lewei Lu,Bin Li,Xiaogang Wang,Jifeng Dai 在Deformable DETR: Deformable Transformers for End-to-End Object Detection中提出的。Deformable DETR 通过利用一个新的可变形注意力模块,该模块只关注参考周围一小组关键采样点,从而缓解了原始 DETR 的收敛速度慢和特征空间分辨率有限的问题。
论文摘要如下:
DETR 最近被提出,旨在消除目标检测中许多手工设计的组件的需求,同时表现良好。然而,由于 Transformer 注意力模块在处理图像特征图时的限制,它存在收敛速度慢和特征空间分辨率有限的问题。为了缓解这些问题,我们提出了 Deformable DETR,其注意力模块只关注参考周围一小组关键采样点。Deformable DETR 可以比 DETR 实现更好的性能(特别是对于小目标),并且训练时长减少了 10 倍。在 COCO 基准测试上的大量实验证明了我们方法的有效性。
Deformable DETR 架构。摘自原始论文。
使用提示
- 训练 Deformable DETR 等同于训练原始 DETR 模型。有关演示笔记本,请参见下面的资源部分。
资源
官方 Hugging Face 和社区(由🌎表示)资源列表,可帮助您开始使用 Deformable DETR。
目标检测
-
关于在自定义数据集上进行推理+微调的演示笔记本,可以在这里找到。
-
另请参阅:目标检测任务指南。
如果您有兴趣提交资源以包含在此处,请随时提出拉取请求,我们将对其进行审查!资源应该展示一些新内容,而不是重复现有资源。
DeformableDetrImageProcessor
class transformers.DeformableDetrImageProcessor
( format: Union = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )
参数
-
format
(str
,可选,默认为"coco_detection"
) — 注释的数据格式。其中之一是"coco_detection"
或“coco_panoptic”。 -
do_resize
(bool
,可选,默认为True
) — 控制是否将图像的(高度,宽度)尺寸调整为指定的size
。可以通过preprocess
方法中的do_resize
参数进行覆盖。 -
size
(Dict[str, int]
可选,默认为{"shortest_edge" -- 800, "longest_edge": 1333}
):调整大小后的图像(高度,宽度)尺寸。可以通过preprocess
方法中的size
参数进行覆盖。 -
resample
(PILImageResampling
,可选,默认为PILImageResampling.BILINEAR
) — 如果调整图像大小,则要使用的重采样滤波器。 -
do_rescale
(bool
,可选,默认为True
) — 控制是否按指定比例rescale_factor
对图像进行重新缩放。可以通过preprocess
方法中的do_rescale
参数进行覆盖。 -
rescale_factor
(int
或float
,可选,默认为1/255
)— 如果重新缩放图像,则使用的比例因子。可以被preprocess
方法中的rescale_factor
参数覆盖。do_normalize — 控制是否规范化图像。可以被preprocess
方法中的do_normalize
参数覆盖。 -
image_mean
(float
或List[float]
,可选,默认为IMAGENET_DEFAULT_MEAN
)— 在规范化图像时使用的均值。可以是单个值或值列表,每个通道一个值。可以被preprocess
方法中的image_mean
参数覆盖。 -
image_std
(float
或List[float]
,可选,默认为IMAGENET_DEFAULT_STD
)— 在规范化图像时使用的标准差值。可以是单个值或值列表,每个通道一个值。可以被preprocess
方法中的image_std
参数覆盖。 -
do_pad
(bool
,可选,默认为True
)— 控制是否将图像填充到批次中最大的图像并创建像素掩模。可以被preprocess
方法中的do_pad
参数覆盖。
构造一个可变形 DETR 图像处理器。
preprocess
( images: Union annotations: Union = None return_segmentation_masks: bool = None masks_path: Union = None do_resize: Optional = None size: Optional = None resample = None do_rescale: Optional = None rescale_factor: Union = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None format: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
参数
-
images
(ImageInput
)— 要预处理的图像或图像批次。期望单个图像或像素值范围从 0 到 255 的图像批次。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。 -
annotations
(AnnotationType
或List[AnnotationType]
,可选)— 与图像或图像批次关联的注释列表。如果注释用于目标检测,则注释应该是一个带有以下键的字典:-
“image_id”(
int
):图像 ID。 -
“annotations”(
List[Dict]
):图像的注释列表。每个注释应该是一个字典。一个图像可以没有注释,此时列表应为空。如果注释是用于分割的,注释应该是一个带有以下键的字典: -
“image_id”(
int
):图像 ID。 -
“segments_info”(
List[Dict]
):图像的分段列表。每个分段应该是一个字典。一个图像可以没有分段,此时列表应为空。 -
“file_name”(
str
):图像的文件名。
-
-
return_segmentation_masks
(bool
,可选,默认为 self.return_segmentation_masks)— 是否返回分割掩模。 -
masks_path
(str
或pathlib.Path
,可选)— 包含分割掩模的目录的路径。 -
do_resize
(bool
,可选,默认为 self.do_resize)— 是否调整图像大小。 -
size
(Dict[str, int]
,可选,默认为 self.size)— 调整大小后的图像尺寸。 -
resample
(PILImageResampling
,可选,默认为 self.resample)— 调整图像大小时要使用的重采样滤波器。 -
do_rescale
(bool
,可选,默认为 self.do_rescale)— 是否重新缩放图像。 -
rescale_factor
(float
,可选,默认为 self.rescale_factor)— 重新缩放图像时使用的比例因子。 -
do_normalize
(bool
,可选,默认为 self.do_normalize)— 是否规范化图像。 -
image_mean
(float
或List[float]
,可选,默认为 self.image_mean)— 在规范化图像时使用的均值。 -
image_std
(float
或List[float]
,可选,默认为 self.image_std)— 在规范化图像时使用的标准差。 -
do_pad
(bool
,可选,默认为 self.do_pad)— 是否填充图像。 -
format
(str
或AnnotationFormat
,可选,默认为 self.format)— 注释的格式。 -
return_tensors
(str
或TensorType
,可选,默认为 self.return_tensors)— 要返回的张量类型。如果为None
,将返回图像列表。 -
data_format
(ChannelDimension
或str
, 可选, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
:图像以 (通道数, 高度, 宽度) 格式。 -
"channels_last"
或ChannelDimension.LAST
:图像以 (高度, 宽度, 通道数) 格式。 -
未设置:使用输入图像的通道维度格式。
-
-
input_data_format
(ChannelDimension
或str
, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
:图像以 (通道数, 高度, 宽度) 格式。 -
"channels_last"
或ChannelDimension.LAST
:图像以 (高度, 宽度, 通道数) 格式。 -
"none"
或ChannelDimension.NONE
:图像以 (高度, 宽度) 格式。
-
预处理图像或图像批次,以便模型可以使用。
post_process_object_detection
( outputs threshold: float = 0.5 target_sizes: Union = None top_k: int = 100 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrObjectDetectionOutput
) — 模型的原始输出。 -
threshold
(float
, 可选) — 保留目标检测预测的分数阈值。 -
target_sizes
(torch.Tensor
或List[Tuple[int, int]]
, 可选) — 形状为(batch_size, 2)
的张量或包含批次中每个图像目标大小 (高度, 宽度) 的元组列表 (Tuple[int, int]
)。如果为 None,则预测不会被调整大小。 -
top_k
(int
, 可选, 默认为 100) — 在通过阈值过滤之前仅保留前 k 个边界框。
返回
List[Dict]
一个字典列表,每个字典包含模型预测的批次中每个图像的分数、标签和框。
将 DeformableDetrForObjectDetection 的原始输出转换为最终的边界框,格式为 (左上角 x 坐标, 左上角 y 坐标, 右下角 x 坐标, 右下角 y 坐标)。仅支持 PyTorch。
DeformableDetrFeatureExtractor
class transformers.DeformableDetrFeatureExtractor
( *args **kwargs )
__call__
( images **kwargs )
预处理图像或图像批次。
post_process_object_detection
( outputs threshold: float = 0.5 target_sizes: Union = None top_k: int = 100 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrObjectDetectionOutput
) — 模型的原始输出。 -
threshold
(float
, 可选) — 保留目标检测预测的分数阈值。 -
target_sizes
(torch.Tensor
或List[Tuple[int, int]]
, 可选) — 形状为(batch_size, 2)
的张量或包含批次中每个图像目标大小 (高度, 宽度) 的元组列表 (Tuple[int, int]
)。如果为 None,则预测不会被调整大小。 -
top_k
(int
, 可选, 默认为 100) — 在通过阈值过滤之前仅保留前 k 个边界框。
返回
List[Dict]
一个字典列表,每个字典包含模型预测的批次中每个图像的分数、标签和框。
将 DeformableDetrForObjectDetection 的原始输出转换为最终的边界框,格式为 (左上角 x 坐标, 左上角 y 坐标, 右下角 x 坐标, 右下角 y 坐标)。仅支持 PyTorch。
DeformableDetrConfig
class transformers.DeformableDetrConfig
( use_timm_backbone = True backbone_config = None num_channels = 3 num_queries = 300 max_position_embeddings = 1024 encoder_layers = 6 encoder_ffn_dim = 1024 encoder_attention_heads = 8 decoder_layers = 6 decoder_ffn_dim = 1024 decoder_attention_heads = 8 encoder_layerdrop = 0.0 is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 init_xavier_std = 1.0 return_intermediate = True auxiliary_loss = False position_embedding_type = 'sine' backbone = 'resnet50' use_pretrained_backbone = True dilation = False num_feature_levels = 4 encoder_n_points = 4 decoder_n_points = 4 two_stage = False two_stage_num_proposals = 300 with_box_refine = False class_cost = 1 bbox_cost = 5 giou_cost = 2 mask_loss_coefficient = 1 dice_loss_coefficient = 1 bbox_loss_coefficient = 5 giou_loss_coefficient = 2 eos_coefficient = 0.1 focal_alpha = 0.25 disable_custom_kernels = False **kwargs )
参数
-
use_timm_backbone
(bool
, optional, defaults toTrue
) — 是否使用timm
库作为骨干网络。如果设置为False
,将使用AutoBackbone
API。 -
backbone_config
(PretrainedConfig
ordict
, optional) — 骨干模型的配置。仅在use_timm_backbone
设置为False
时使用,此时默认为ResNetConfig()
。 -
num_channels
(int
, optional, defaults to 3) — 输入通道数。 -
num_queries
(int
, optional, defaults to 300) — 对象查询的数量,即检测槽位。这是 DeformableDetrModel 在单个图像中可以检测到的对象的最大数量。如果将two_stage
设置为True
,则使用two_stage_num_proposals
。 -
d_model
(int
, optional, defaults to 256) — 层的维度。 -
encoder_layers
(int
, optional, defaults to 6) — 编码器层数。 -
decoder_layers
(int
, optional, defaults to 6) — 解码器层数。 -
encoder_attention_heads
(int
, optional, defaults to 8) — Transformer 编码器中每个注意力层的注意力头数。 -
decoder_attention_heads
(int
, optional, defaults to 8) — Transformer 解码器中每个注意力层的注意力头数。 -
decoder_ffn_dim
(int
, optional, defaults to 1024) — 解码器中“中间”(通常称为前馈)层的维度。 -
encoder_ffn_dim
(int
, optional, defaults to 1024) — 解码器中“中间”(通常称为前馈)层的维度。 -
activation_function
(str
orfunction
, optional, defaults to"relu"
) — 编码器和池化层中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。 -
dropout
(float
, optional, defaults to 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢失概率。 -
attention_dropout
(float
, optional, defaults to 0.0) — 注意力概率的丢失比率。 -
activation_dropout
(float
, optional, defaults to 0.0) — 全连接层内激活的丢失比率。 -
init_std
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
init_xavier_std
(float
, optional, defaults to 1) — 用于 HM Attention map 模块中的 Xavier 初始化增益的缩放因子。 -
encoder_layerdrop
(float
, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息,请参阅 LayerDrop 论文)。 -
auxiliary_loss
(bool
, optional, defaults toFalse
) — 是否使用辅助解码损失(每个解码器层的损失)。 -
position_embedding_type
(str
, optional, defaults to"sine"
) — 在图像特征之上使用的位置嵌入类型。其中之一是"sine"
或"learned"
。 -
backbone
(str
, optional, defaults to"resnet50"
) — 在use_timm_backbone
=True
时要使用的卷积骨干的名称。支持来自 timm 包的任何卷积骨干。有关所有可用模型的列表,请参见此页面。 -
use_pretrained_backbone
(bool
, optional, defaults toTrue
) — 是否对骨干网络使用预训练权重。仅在use_timm_backbone
=True
时支持。 -
dilation
(bool
, optional, defaults toFalse
) — 是否在最后一个卷积块(DC5)中用膨胀替换步幅。仅在use_timm_backbone
=True
时支持。 -
class_cost
(float
, optional, defaults to 1) — 匈牙利匹配成本中分类错误的相对权重。 -
bbox_cost
(float
, optional, defaults to 5) — 匈牙利匹配成本中边界框坐标的 L1 误差的相对权重。 -
giou_cost
(float
, optional, defaults to 2) — 匈牙利匹配成本中边界框广义 IoU 损失的相对权重。 -
mask_loss_coefficient
(float
, optional, defaults to 1) — 全景分割损失中焦点损失的相对权重。 -
dice_loss_coefficient
(float
, optional, defaults to 1) — DICE/F-1 损失在全景分割损失中的相对权重。 -
bbox_loss_coefficient
(float
, optional, defaults to 5) — 目标检测损失中 L1 边界框损失的相对权重。 -
giou_loss_coefficient
(float
, optional, defaults to 2) — 目标检测损失中广义 IoU 损失的相对权重。 -
eos_coefficient
(float
, optional, defaults to 0.1) — 目标检测损失中“无对象”类的相对分类权重。 -
num_feature_levels
(int
, optional, defaults to 4) — 输入特征级别的数量。 -
encoder_n_points
(int
, optional, defaults to 4) — 编码器中每个注意力头的每个特征级别中采样的键的数量。 -
decoder_n_points
(int
, optional, defaults to 4) — 解码器中每个注意力头的每个特征级别中采样的键的数量。 -
two_stage
(bool
, optional, defaults toFalse
) — 是否应用两阶段可变形 DETR,其中区域提议也由 Deformable DETR 的变体生成,并进一步输入解码器进行迭代边界框细化。 -
two_stage_num_proposals
(int
, optional, defaults to 300) — 要生成的区域提议数量,如果two_stage
设置为True
。 -
with_box_refine
(bool
, optional, defaults toFalse
) — 是否应用迭代边界框细化,其中每个解码器层根据前一层的预测细化边界框。 -
focal_alpha
(float
, optional, defaults to 0.25) — 焦点损失中的 Alpha 参数。 -
disable_custom_kernels
(bool
, optional, defaults toFalse
) — 禁用自定义 CUDA 和 CPU 内核的使用。这个选项对 ONNX 导出是必要的,因为 PyTorch ONNX 导出不支持自定义内核。
这是用于存储 DeformableDetrModel 配置的配置类。根据指定的参数实例化 Deformable DETR 模型,定义模型架构。使用默认值实例化配置将产生类似于 Deformable DETR SenseTime/deformable-detr架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import DeformableDetrConfig, DeformableDetrModel
>>> # Initializing a Deformable DETR SenseTime/deformable-detr style configuration
>>> configuration = DeformableDetrConfig()
>>> # Initializing a model (with random weights) from the SenseTime/deformable-detr style configuration
>>> model = DeformableDetrModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
DeformableDetrModel
class transformers.DeformableDetrModel
( config: DeformableDetrConfig )
参数
config
(DeformableDetrConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸的 Deformable DETR 模型(由骨干和编码器-解码器 Transformer 组成),输出没有特定头部的原始隐藏状态。
此模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
此模型也是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrModelOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。默认情况下将忽略填充。像素值可以使用 AutoImageProcessor 获得。有关详细信息,请参见 DeformableDetrImageProcessor.
call
()。 -
pixel_mask
(torch.LongTensor
of shape(batch_size, height, width)
, optional) — 避免在填充像素值上执行注意力的蒙版。蒙版值选择在[0, 1]
范围内:-
对于真实像素为 1(即
not masked
), -
对于填充的像素为 0(即
masked
)。
什么是注意力蒙版?
-
-
decoder_attention_mask
(torch.FloatTensor
of shape(batch_size, num_queries)
, optional) — 默认情况下不使用。可用于屏蔽对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
, optional) — 元组包括(last_hidden_state
, optional:hidden_states
, optional:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,optional)是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以选择直接传递图像的扁平化表示,而不是传递扁平化特征图(骨干网络输出 + 投影层输出)。 -
decoder_inputs_embeds
(torch.FloatTensor
of shape(batch_size, num_queries, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示,而不是使用零张量初始化查询。 -
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrModelOutput
或 tuple(torch.FloatTensor)
一个transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrModelOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
,则包含根据配置(DeformableDetrConfig)和输入的各种元素。
-
init_reference_points
(torch.FloatTensor
of shape(batch_size, num_queries, 4)
) — 通过 Transformer 解码器发送的初始参考点。 -
last_hidden_state
(torch.FloatTensor
of shape(batch_size, num_queries, hidden_size)
) — 模型解码器最后一层的输出中的隐藏状态序列。 -
intermediate_hidden_states
(torch.FloatTensor
,形状为(batch_size, config.decoder_layers, num_queries, hidden_size)
) — 堆叠的中间隐藏状态(解码器每层的输出)。 -
intermediate_reference_points
(torch.FloatTensor
,形状为(batch_size, config.decoder_layers, num_queries, 4)
) — 堆叠的中间参考点(解码器每层的参考点)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 每个层的形状为(batch_size, num_queries, hidden_size)
的torch.FloatTensor
元组。解码器在每个层的输出加上初始嵌入输出的隐藏状态。 -
decoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 每个层的形状为(batch_size, num_heads, num_queries, num_queries)
的torch.FloatTensor
元组。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 每个层的形状为(batch_size, num_queries, num_heads, 4, 4)
的torch.FloatTensor
元组。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 每个层的形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。编码器在每个层的输出加上初始嵌入输出的隐藏状态。 -
encoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 每个层的形状为(batch_size, num_queries, num_heads, 4, 4)
的torch.FloatTensor
元组。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
enc_outputs_class
(torch.FloatTensor
,形状为(batch_size, sequence_length, config.num_labels)
,optional,当config.with_box_refine=True
和config.two_stage=True
时返回) — 预测的边界框分数,第一阶段选择前config.two_stage_num_proposals
个得分最高的边界框作为区域提议。边界框二元分类的输出(即前景和背景)。 -
enc_outputs_coord_logits
(torch.FloatTensor
,形状为(batch_size, sequence_length, 4)
,optional,当config.with_box_refine=True
和config.two_stage=True
时返回) — 第一阶段预测的边界框坐标的 logits。
DeformableDetrModel 的 forward 方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DeformableDetrModel
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("SenseTime/deformable-detr")
>>> model = DeformableDetrModel.from_pretrained("SenseTime/deformable-detr")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]
DeformableDetrForObjectDetection
class transformers.DeformableDetrForObjectDetection
( config: DeformableDetrConfig )
参数
config
(DeformableDetrConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
Deformable DETR 模型(由骨干和编码器-解码器 Transformer 组成),顶部带有目标检测头,用于诸如 COCO 检测的任务。
这个模型继承自 PreTrainedModel。查看超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrObjectDetectionOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。默认情况下将忽略填充。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 DeformableDetrImageProcessor.
call
()。 -
pixel_mask
(torch.LongTensor
,形状为(batch_size, height, width)
,可选) — 用于避免在填充像素值上执行注意力的掩码。选择的掩码值在[0, 1]
中。-
1 表示真实像素(即
未屏蔽
), -
0 表示填充像素(即
masked
)。
什么是注意力掩码?
-
-
decoder_attention_mask
(torch.FloatTensor
,形状为(batch_size, num_queries)
,可选) — 默认情况下不使用。可用于屏蔽对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选) — 元组包含(last_hidden_state
,可选:hidden_states
,可选:attentions
),last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 可选地,可以直接传递扁平化的特征图(骨干+投影层的输出),而不是传递图像的扁平化表示。 -
decoder_inputs_embeds
(torch.FloatTensor
,形状为(batch_size, num_queries, hidden_size)
,可选) — 可选地,可以直接传递嵌入表示,而不是使用零张量初始化查询。 -
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的attentions
。 -
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的hidden_states
。 -
return_dict
(bool
,可选) — 是否返回 ModelOutput 而不是普通元组。 -
labels
(List[Dict]
of len(batch_size,)
, optional) — 用于计算二部匹配损失的标签。字典列表,每个字典至少包含以下 2 个键:'class_labels'和'boxes'(分别是批处理中图像的类标签和边界框)。类标签本身应该是长度为(图像中边界框的数量,)
的torch.LongTensor
,而边界框应该是形状为(图像中边界框的数量, 4)
的torch.FloatTensor
。
返回
transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrObjectDetectionOutput
或 tuple(torch.FloatTensor)
一个transformers.models.deformable_detr.modeling_deformable_detr.DeformableDetrObjectDetectionOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(DeformableDetrConfig)和输入而异的各种元素。
-
loss
(torch.FloatTensor
of shape(1,)
, optional, 当提供labels
时返回) — 作为负对数似然(交叉熵)和边界框损失的线性组合的总损失。后者被定义为 L1 损失和广义比例不变 IoU 损失的线性组合。 -
loss_dict
(Dict
, optional) — 包含各个损失的字典。用于记录日志。 -
logits
(torch.FloatTensor
of shape(batch_size, num_queries, num_classes + 1)
) — 所有查询的分类 logits(包括无对象)。 -
pred_boxes
(torch.FloatTensor
of shape(batch_size, num_queries, 4)
) — 所有查询的规范化框坐标,表示为(中心 _x,中心 _y,宽度,高度)。这些值在[0, 1]范围内进行了规范化,相对于批处理中每个单独图像的大小(忽略可能的填充)。您可以使用~DeformableDetrProcessor.post_process_object_detection
来检索未规范化的边界框。 -
auxiliary_outputs
(list[Dict]
, optional) — 可选,仅在激活辅助损失(即config.auxiliary_loss
设置为True
)并提供标签时返回。这是一个包含每个解码器层的上述两个键(logits
和pred_boxes
)的字典列表。 -
last_hidden_state
(torch.FloatTensor
of shape(batch_size, num_queries, hidden_size)
, optional) — 模型解码器最后一层的隐藏状态序列。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 一个元组,包含形状为(batch_size, num_queries, hidden_size)
的torch.FloatTensor
(一个用于嵌入输出,一个用于每层输出)。解码器在每层输出的隐藏状态加上初始嵌入输出。 -
decoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 一个元组,包含形状为(batch_size, num_heads, num_queries, num_queries)
的torch.FloatTensor
(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 一个元组,包含形状为(batch_size, num_queries, num_heads, 4, 4)
的torch.FloatTensor
(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — Tuple oftorch.FloatTensor
(one for the output of the embeddings + one for the output of each layer) of shape(batch_size, sequence_length, hidden_size)
. Hidden-states of the encoder at the output of each layer plus the initial embedding outputs. -
encoder_attentions
(tuple(torch.FloatTensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — Tuple oftorch.FloatTensor
(one for each layer) of shape(batch_size, sequence_length, num_heads, 4, 4)
. Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the self-attention heads. -
intermediate_hidden_states
(torch.FloatTensor
of shape(batch_size, config.de
DeiT
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/deit
概述
DeiT 模型是由 Hugo Touvron、Matthieu Cord、Matthijs Douze、Francisco Massa、Alexandre Sablayrolles、Hervé Jégou 在通过注意力进行数据高效图像变换器训练和蒸馏中提出的。Vision Transformer(ViT)是由Dosovitskiy 等人,2020引入的,它表明可以使用 Transformer 编码器(类似 BERT)匹配甚至超越现有的卷积神经网络。然而,该论文中介绍的 ViT 模型需要在昂贵的基础设施上进行多周的训练,使用外部数据。DeiT(数据高效图像变换器)是更高效的用于图像分类的训练变换器,与原始 ViT 模型相比,需要更少的数据和更少的计算资源。
论文摘要如下:
最近,纯基于注意力的神经网络被证明可以解决图像理解任务,如图像分类。然而,这些视觉变换器是使用昂贵的基础设施对数亿张图像进行预训练的,从而限制了它们的采用。在这项工作中,我们通过仅在 Imagenet 上进行训练,制作了一款竞争力强的无卷积变换器。我们在不到 3 天的时间内在一台计算机上对它们进行训练。我们的参考视觉变换器(8600 万参数)在 ImageNet 上的单裁剪评估中实现了 83.1%的 top-1 准确率,没有使用外部数据。更重要的是,我们引入了一种特定于变换器的师生策略。它依赖于一个蒸馏标记,确保学生通过注意力从老师那里学习。我们展示了基于这种基于标记的蒸馏的兴趣,特别是在使用卷积网络作为老师时。这使我们能够报告与卷积网络在 Imagenet 上竞争的结果(我们的准确率高达 85.2%),以及在转移到其他任务时。我们分享我们的代码和模型。
该模型由nielsr贡献。该模型的 TensorFlow 版本由amyeroberts添加。
使用提示
-
与 ViT 相比,DeiT 模型使用所谓的蒸馏标记来有效地从老师那里学习(在 DeiT 论文中,老师是类似 ResNet 的模型)。通过自注意力层,蒸馏标记通过与类([CLS])和补丁标记的交互进行反向传播学习。
-
对蒸馏模型进行微调有两种方式,要么(1)采用传统方式,只在类标记的最终隐藏状态上放置一个预测头,不使用蒸馏信号,要么(2)在类标记和蒸馏标记的顶部都放置一个预测头。在这种情况下,[CLS]预测头使用预测头和地面真实标签之间的常规交叉熵进行训练,而蒸馏预测头使用硬蒸馏进行训练(蒸馏头的预测和教师预测的标签之间的交叉熵)。在推理时,将两个头之间的平均预测作为最终预测。(2)也被称为“蒸馏微调”,因为依赖于已经在下游数据集上进行微调的教师。在模型方面,(1)对应于 DeiTForImageClassification,(2)对应于 DeiTForImageClassificationWithTeacher。
-
请注意,作者们还尝试了对(2)进行软蒸馏(在这种情况下,蒸馏预测头使用 KL 散度进行训练,以匹配老师的 softmax 输出),但硬蒸馏效果最好。
-
所有发布的检查点仅在 ImageNet-1k 上进行了预训练和微调。没有使用外部数据。这与原始的 ViT 模型形成对比,原始的 ViT 模型使用了外部数据,如 JFT-300M 数据集/Imagenet-21k 进行预训练。
-
DeiT 的作者还发布了更高效训练的 ViT 模型,您可以直接插入 ViTModel 或 ViTForImageClassification。为了模拟在一个更大的数据集上训练(仅使用 ImageNet-1k 进行预训练),使用了数据增强、优化和正则化等技术。有 4 个变体可用(3 种不同大小):facebook/deit-tiny-patch16-224、facebook/deit-small-patch16-224、facebook/deit-base-patch16-224和facebook/deit-base-patch16-384。请注意,应该使用 DeiTImageProcessor 来为模型准备图像。
资源
一系列官方 Hugging Face 和社区(由🌎表示)资源,可帮助您开始使用 DeiT。
图像分类
此外:
- DeiTForMaskedImageModeling 由这个示例脚本支持。
如果您有兴趣提交资源以包含在此处,请随时打开一个 Pull Request,我们将对其进行审查!资源应该理想地展示一些新东西,而不是重复现有资源。
DeiTConfig
class transformers.DeiTConfig
( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 image_size = 224 patch_size = 16 num_channels = 3 qkv_bias = True encoder_stride = 16 **kwargs )
参数
-
hidden_size
(int
,可选,默认为 768)— 编码器层和池化层的维度。 -
num_hidden_layers
(int
,可选,默认为 12)— Transformer 编码器中的隐藏层数量。 -
num_attention_heads
(int
,可选,默认为 12)— Transformer 编码器中每个注意力层的注意力头数。 -
intermediate_size
(int
,可选,默认为 3072)— Transformer 编码器中“中间”(即前馈)层的维度。 -
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)— 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
layer_norm_eps
(float
,可选,默认为 1e-12)— 层归一化层使用的 epsilon。 -
image_size
(int
,可选,默认为 224)— 每个图像的大小(分辨率)。 -
patch_size
(int
,可选,默认为 16)— 每个补丁的大小(分辨率)。 -
num_channels
(int
,可选,默认为 3)— 输入通道的数量。 -
qkv_bias
(bool
,可选,默认为True
)— 是否为查询、键和值添加偏置。 -
encoder_stride
(int
, optional, 默认为 16) — 用于在解码器头部增加空间分辨率的因子,用于遮蔽图像建模。
这是一个配置类,用于存储 DeiTModel 的配置。它用于根据指定的参数实例化一个 DeiT 模型,定义模型架构。使用默认值实例化配置将产生类似于 DeiT facebook/deit-base-distilled-patch16-224 架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import DeiTConfig, DeiTModel
>>> # Initializing a DeiT deit-base-distilled-patch16-224 style configuration
>>> configuration = DeiTConfig()
>>> # Initializing a model (with random weights) from the deit-base-distilled-patch16-224 style configuration
>>> model = DeiTModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
DeiTFeatureExtractor
class transformers.DeiTFeatureExtractor
( *args **kwargs )
__call__
( images **kwargs )
预处理图像或一批图像。
DeiTImageProcessor
class transformers.DeiTImageProcessor
( do_resize: bool = True size: Dict = None resample: Resampling = 3 do_center_crop: bool = True crop_size: Dict = None rescale_factor: Union = 0.00392156862745098 do_rescale: bool = True do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )
参数
-
do_resize
(bool
, optional, 默认为True
) — 是否将图像的 (height, width) 尺寸调整为指定的size
。可以被preprocess
中的do_resize
覆盖。 -
size
(Dict[str, int]
optional, 默认为{"height" -- 256, "width": 256}
):resize
后的图像尺寸。可以被preprocess
中的size
覆盖。 -
resample
(PILImageResampling
过滤器, optional, 默认为Resampling.BICUBIC
) — 如果调整图像大小,要使用的重采样滤波器。可以被preprocess
中的resample
覆盖。 -
do_center_crop
(bool
, optional, 默认为True
) — 是否对图像进行中心裁剪。如果输入尺寸在任一边小于crop_size
,则图像将用 0 填充,然后进行中心裁剪。可以被preprocess
中的do_center_crop
覆盖。 -
crop_size
(Dict[str, int]
, optional, 默认为{"height" -- 224, "width": 224}
): 应用中心裁剪时的期望输出尺寸。可以被preprocess
中的crop_size
覆盖。 -
rescale_factor
(int
或float
, optional, 默认为1/255
) — 如果重新缩放图像,要使用的缩放因子。可以被preprocess
方法中的rescale_factor
参数覆盖。 -
do_rescale
(bool
, optional, 默认为True
) — 是否按指定比例rescale_factor
重新缩放图像。可以被preprocess
方法中的do_rescale
参数覆盖。 -
do_normalize
(bool
, optional, 默认为True
) — 是否对图像进行归一化。可以被preprocess
方法中的do_normalize
参数覆盖。 -
image_mean
(float
或List[float]
, optional, 默认为IMAGENET_STANDARD_MEAN
) — 如果对图像进行归一化,要使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess
方法中的image_mean
参数覆盖。 -
image_std
(float
或List[float]
, optional, 默认为IMAGENET_STANDARD_STD
) — 如果对图像进行归一化,要使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess
方法中的image_std
参数覆盖。
构建一个 DeiT 图像处理器。
preprocess
( images: Union do_resize: bool = None size: Dict = None resample = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
参数
-
images
(ImageInput
) — 要预处理的图像。期望单个图像或图像批次,像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。 -
do_resize
(bool
, optional, 默认为self.do_resize
) — 是否调整图像大小。 -
size
(Dict[str, int]
, optional, 默认为self.size
) —resize
后的图像大小。 -
resample
(PILImageResampling
, optional, 默认为self.resample
) — 如果调整图像大小,则使用的 PILImageResampling 过滤器。仅在do_resize
设置为True
时有效。 -
do_center_crop
(bool
, optional, 默认为self.do_center_crop
) — 是否对图像进行中心裁剪。 -
crop_size
(Dict[str, int]
, optional, 默认为self.crop_size
) — 居中裁剪后的图像大小。如果图像的一条边小于crop_size
,则将用零填充,然后裁剪。 -
do_rescale
(bool
, optional, 默认为self.do_rescale
) — 是否将图像值重新缩放到 [0 - 1] 之间。 -
rescale_factor
(float
, optional, 默认为self.rescale_factor
) — 如果do_rescale
设置为True
,则用于重新缩放图像的重新缩放因子。 -
do_normalize
(bool
, optional, 默认为self.do_normalize
) — 是否对图像进行归一化。 -
image_mean
(float
或List[float]
, optional, 默认为self.image_mean
) — 图像均值。 -
image_std
(float
或List[float]
, optional, 默认为self.image_std
) — 图像标准差。 -
return_tensors
(str
或TensorType
, optional) — 要返回的张量类型。可以是以下之一:-
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
, optional, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:-
ChannelDimension.FIRST
: 图像以 (num_channels, height, width) 格式。 -
ChannelDimension.LAST
: 图像以 (height, width, num_channels) 格式。
-
-
input_data_format
(ChannelDimension
或str
, optional) — 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
: 图像以 (num_channels, height, width) 格式。 -
"channels_last"
或ChannelDimension.LAST
: 图像以 (height, width, num_channels) 格式。 -
"none"
或ChannelDimension.NONE
: 图像以 (height, width) 格式。
-
预处理图像或图像批次。
PytorchHide Pytorch content
DeiTModel
class transformers.DeiTModel
( config: DeiTConfig add_pooling_layer: bool = True use_mask_token: bool = False )
参数
config
(DeiTConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 DeiT 模型变换器输出原始隐藏状态,没有特定的顶部头。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。
forward
( pixel_values: Optional = None bool_masked_pos: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 DeiTImageProcessor.call
()。 -
head_mask
(torch.FloatTensor
of shape(num_heads,)
or(num_layers, num_heads)
, optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]
:-
1 表示头部未被遮蔽,
-
0 表示头部被遮蔽。
-
-
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。 -
bool_masked_pos
(torch.BoolTensor
of shape(batch_size, num_patches)
, optional) — 布尔掩码位置。指示哪些补丁被遮蔽(1)哪些没有(0)。
返回
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时)包含根据配置(DeiTConfig)和输入不同元素。
-
last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。 -
pooler_output
(torch.FloatTensor
of shape(batch_size, hidden_size)
) — 序列第一个标记(分类标记)的最后一层隐藏状态,在通过用于辅助预训练任务的层进一步处理后。例如,对于 BERT 系列模型,这将返回经过线性层和双曲正切激活函数处理后的分类标记。线性层权重是从预训练期间的下一个句子预测(分类)目标中训练的。 -
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 后的注意力权重,用于计算自注意力头中的加权平均值。
DeiTModel 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者会处理运行前处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DeiTModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTModel.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 198, 768]
DeiTForMaskedImageModeling
class transformers.DeiTForMaskedImageModeling
( config: DeiTConfig )
参数
config
(DeiTConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
带有顶部解码器的 DeiT 模型,用于遮罩图像建模,如SimMIM中提出的。
请注意,我们在我们的示例目录中提供了一个脚本,用于在自定义数据上预训练此模型。
这个模型是一个 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( pixel_values: Optional = None bool_masked_pos: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedImageModelingOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 DeiTImageProcessor.call
()。 -
head_mask
(torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,optional) — 用于使自注意力模块中选择的头部失效的掩码。在[0, 1]
中选择的掩码值:-
1 表示头部是
not masked
, -
0 表示头部是
masked
。
-
-
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。 -
bool_masked_pos
(torch.BoolTensor
,形状为(batch_size, num_patches)
) — 布尔掩码位置。指示哪些补丁被掩盖(1)哪些没有(0)。
返回
transformers.modeling_outputs.MaskedImageModelingOutput
或tuple(torch.FloatTensor)
一个transformers.modeling_outputs.MaskedImageModelingOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
时)包含各种元素,具体取决于配置(DeiTConfig)和输入。
-
loss
(torch.FloatTensor
,形状为(1,)
,optional,当提供bool_masked_pos
时返回) — 重建损失。 -
reconstruction
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 重建/完成的图像。 -
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
时返回 -
when
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
时返回 -
config.output_attentions=True):
形状为(batch_size, num_heads, patch_size, sequence_length)
的torch.FloatTensor
元组(每层一个)。自注意力头中的注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
DeiTForMaskedImageModeling 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DeiTForMaskedImageModeling
>>> import torch
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForMaskedImageModeling.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool()
>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 224, 224]
DeiTForImageClassification
class transformers.DeiTForImageClassification
( config: DeiTConfig )
参数
config
(DeiTConfig)- 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
带有图像分类头部的 DeiT 模型变换器(在[CLS]标记的最终隐藏状态之上的线性层),例如用于 ImageNet。
此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( pixel_values: Optional = None head_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.ImageClassifierOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 DeiTImageProcessor.call
()。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]
范围内:-
1 表示头部未被
masked
, -
0 表示头部是
masked
。
-
-
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
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.ImageClassifierOutput 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.ImageClassifierOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(DeiTConfig)和输入不同元素。
-
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, sequence_length, hidden_size)
的torch.FloatTensor
元组。模型在每个阶段的输出的隐藏状态(也称为特征图)。 -
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, patch_size, sequence_length)
的torch.FloatTensor
元组。自注意力头中用于计算加权平均值的注意力权重在注意力 softmax 之后。
DeiTForImageClassification 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DeiTForImageClassification
>>> import torch
>>> from PIL import Image
>>> import requests
>>> torch.manual_seed(3)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> # note: we are loading a DeiTForImageClassificationWithTeacher from the hub here,
>>> # so the head will be randomly initialized, hence the predictions will be random
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForImageClassification.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: magpie
DeiTForImageClassificationWithTeacher
class transformers.DeiTForImageClassificationWithTeacher
( config: DeiTConfig )
参数
config
(DeiTConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
DeiT 模型变压器,顶部带有图像分类头(在[CLS]令牌的最终隐藏状态顶部有一个线性层,在蒸馏令牌的最终隐藏状态顶部有一个线性层),例如用于 ImageNet。
.. 警告::
这个模型仅支持推理。尚不支持使用蒸馏(即使用教师)进行微调。
这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( pixel_values: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deit.modeling_deit.DeiTForImageClassificationWithTeacherOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 DeiTImageProcessor.call
()。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部未被遮蔽,
-
0 表示头部是
masked
。
-
-
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.deit.modeling_deit.DeiTForImageClassificationWithTeacherOutput
或tuple(torch.FloatTensor)
一个transformers.models.deit.modeling_deit.DeiTForImageClassificationWithTeacherOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含各种元素,取决于配置(DeiTConfig)和输入。
-
logits
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
)- 预测分数,作为cls_logits
和蒸馏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
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。模型在每个层的输出和初始嵌入输出处的隐藏状态。 -
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
DeiTForImageClassificationWithTeacher 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DeiTForImageClassificationWithTeacher
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat
TensorFlow 隐藏 TensorFlow 内容
TFDeiTModel
class transformers.TFDeiTModel
( config: DeiTConfig add_pooling_layer: bool = True use_mask_token: bool = False **kwargs )
参数
config
(DeiTConfig)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
裸 DeiT 模型变压器输出原始隐藏状态,没有特定头部。此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规 TensorFlow 模块,并参考 TensorFlow 文档以获取有关一般用法和行为的所有相关信息。
call
( pixel_values: tf.Tensor | None = None bool_masked_pos: tf.Tensor | None = None head_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的tf.Tensor
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参见 DeiTImageProcessor.call
()。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的tf.Tensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]
中:-
1 表示头部
未被掩盖
, -
0 表示头部
被掩盖
。
-
-
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或tuple(tf.Tensor)
transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个tf.Tensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(DeiTConfig)和输入的各种元素。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
)— 模型最后一层的隐藏状态序列。 -
pooler_output
(形状为(batch_size, hidden_size)
的tf.Tensor
)— 序列第一个标记(分类标记)的最后一层隐藏状态,经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测(分类)目标中训练的。这个输出通常不是输入的语义内容的好摘要,通常最好对整个输入序列的隐藏状态进行平均或池化。
-
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(嵌入输出的一个+每层输出的一个)。模型在每一层输出的隐藏状态以及初始嵌入输出。
-
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFDeiTModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFDeiTModel
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTModel.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> inputs = image_processor(image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 198, 768]
TFDeiTForMaskedImageModeling
class transformers.TFDeiTForMaskedImageModeling
( config: DeiTConfig )
参数
config
(DeiTConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
DeiT 模型在顶部带有解码器,用于遮蔽图像建模,如 SimMIM 中提出的。此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规 TensorFlow 模块,并参考 TensorFlow 文档以获取有关一般用法和行为的所有相关信息。
call
( pixel_values: tf.Tensor | None = None bool_masked_pos: tf.Tensor | None = None head_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedImageModelingOutput or tuple(tf.Tensor)
参数
-
pixel_values
(tf.Tensor
of shape(batch_size, num_channels, height, width)
) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 DeiTImageProcessor.call
()。 -
head_mask
(tf.Tensor
of shape(num_heads,)
or(num_layers, num_heads)
, optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]
中选择:-
1 表示头部是
not masked
, -
0 表示头部是
masked
。
-
-
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。 -
bool_masked_pos
(tf.Tensor
of type bool and shape(batch_size, num_patches)
) — 布尔掩码位置。指示哪些补丁被遮蔽(1)哪些没有(0)。
返回
transformers.modeling_tf_outputs.TFMaskedImageModelingOutput
或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFMaskedImageModelingOutput
或一个 tf.Tensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时)包含根据配置(DeiTConfig)和输入的各种元素。
-
loss
(tf.Tensor
of shape(1,)
, optional, returned whenbool_masked_pos
is provided) — Reconstruction loss. -
reconstruction
(tf.Tensor
of shape(batch_size, num_channels, height, width)
) — 重建/完成的图像。 -
hidden_states
(tuple(tf.Tensor)
, optional, returned whenoutput_hidden_states=True
is passed or when -
config.output_hidden_states=True):
tf.Tensor
元组(如果模型具有嵌入层,则一个用于嵌入的输出 + 一个用于每个阶段的输出)的形状为(batch_size, sequence_length, hidden_size)
。模型在每个阶段输出的隐藏状态(也称为特征图)。 -
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或 -
config.output_attentions=True):
tf.Tensor
元组(每个层一个)的形状为(batch_size, num_heads, patch_size, sequence_length)
。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFDeiTForMaskedImageModeling 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFDeiTForMaskedImageModeling
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTForMaskedImageModeling.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> num_patches = (model.config.image_size // model.config.patch_size) ** 2
>>> pixel_values = image_processor(images=image, return_tensors="tf").pixel_values
>>> # create random boolean mask of shape (batch_size, num_patches)
>>> bool_masked_pos = tf.cast(tf.random.uniform((1, num_patches), minval=0, maxval=2, dtype=tf.int32), tf.bool)
>>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos)
>>> loss, reconstructed_pixel_values = outputs.loss, outputs.reconstruction
>>> list(reconstructed_pixel_values.shape)
[1, 3, 224, 224]
TFDeiTForImageClassification
class transformers.TFDeiTForImageClassification
( config: DeiTConfig )
参数
config
(DeiTConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。
DeiT 模型变压器,顶部带有图像分类头部(在 [CLS] 标记的最终隐藏状态之上的线性层),例如用于 ImageNet。
此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规 TensorFlow 模块,并参考 TensorFlow 文档以获取与一般用法和行为相关的所有事项。
call
( pixel_values: tf.Tensor | None = None head_mask: tf.Tensor | None = None labels: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFImageClassifierOutput or tuple(tf.Tensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的tf.Tensor
)— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 DeiTImageProcessor.call
()。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的tf.Tensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]
范围内:-
1 表示头部未被遮罩,
-
0 表示头部被遮罩。
-
-
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请查看返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请查看返回张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。 -
labels
(形状为(batch_size,)
的tf.Tensor
,可选)— 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
范围内。如果config.num_labels == 1
,则计算回归损失(均方损失),如果config.num_labels > 1
,则计算分类损失(交叉熵)。
返回
transformers.modeling_tf_outputs.TFImageClassifierOutput
或 tuple(tf.Tensor)
transformers.modeling_tf_outputs.TFImageClassifierOutput
或 tuple(tf.Tensor)
(如果传递了 return_dict=False
或当 config.return_dict=False
时)包含各种元素,取决于配置(DeiTConfig)和输入。
-
loss
(形状为(1,)
的tf.Tensor
,可选,当提供labels
时返回)— 分类(或如果config.num_labels==1
则为回归)损失。 -
logits
(形状为(batch_size, config.num_labels)
的tf.Tensor
)— 分类(或如果config.num_labels==1
则为回归)分数(SoftMax 之前)。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(如果模型具有嵌入层的输出,则为嵌入的输出+每个阶段的输出)。模型在每个阶段的输出的隐藏状态(也称为特征图)。 -
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, patch_size, sequence_length)
的tf.Tensor
元组(每层一个)。注意权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
TFDeiTForImageClassification 前向方法,覆盖__call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFDeiTForImageClassification
>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests
>>> tf.keras.utils.set_random_seed(3)
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> # note: we are loading a TFDeiTForImageClassificationWithTeacher from the hub here,
>>> # so the head will be randomly initialized, hence the predictions will be random
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTForImageClassification.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> inputs = image_processor(images=image, return_tensors="tf")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_class_idx = tf.math.argmax(logits, axis=-1)[0]
>>> print("Predicted class:", model.config.id2label[int(predicted_class_idx)])
Predicted class: little blue heron, Egretta caerulea
TFDeiTForImageClassificationWithTeacher
class transformers.TFDeiTForImageClassificationWithTeacher
( config: DeiTConfig )
参数
config
(DeiTConfig)- 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
DeiT 模型变压器,顶部带有图像分类头(在[CLS]令牌的最终隐藏状态顶部有一个线性层,在蒸馏令牌的最终隐藏状态顶部有一个线性层),例如用于 ImageNet。
.. 警告::
此模型仅支持推断。尚不支持使用蒸馏(即与教师一起)进行微调。
此模型是一个 TensorFlow tf.keras.layers.Layer。将其用作常规的 TensorFlow 模块,并参考 TensorFlow 文档以获取有关一般用法和行为的所有相关信息。
call
( pixel_values: tf.Tensor | None = None head_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.models.deit.modeling_tf_deit.TFDeiTForImageClassificationWithTeacherOutput or tuple(tf.Tensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的tf.Tensor
)- 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 DeiTImageProcessor.call
()。 -
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的tf.Tensor
,可选)- 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]
中:-
1 表示头部未被
masked
, -
0 表示头部被
masked
。
-
-
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.deit.modeling_tf_deit.TFDeiTForImageClassificationWithTeacherOutput
或tuple(tf.Tensor)
一个transformers.models.deit.modeling_tf_deit.TFDeiTForImageClassificationWithTeacherOutput
或一个tf.Tensor
元组(如果传递return_dict=False
或config.return_dict=False
时)包含根据配置(DeiTConfig)和输入的不同元素。
-
logits
(形状为(batch_size, config.num_labels)
的tf.Tensor
)- 预测分数,作为 cls_logits 和 distillation logits 的平均值。 -
cls_logits
(形状为(batch_size, config.num_labels)
的tf.Tensor
)- 分类头部的预测分数(即在类令牌的最终隐藏状态之上的线性层)。 -
distillation_logits
(形状为(batch_size, config.num_labels)
的tf.Tensor
)- 蒸馏头部的预测分数(即在蒸馏令牌的最终隐藏状态之上的线性层)。 -
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组。模型在每一层输出的隐藏状态加上初始嵌入输出。 -
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFDeiTForImageClassificationWithTeacher 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, TFDeiTForImageClassificationWithTeacher
>>> import tensorflow as tf
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> model = TFDeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224")
>>> inputs = image_processor(image, return_tensors="tf")
>>> logits = model(**inputs).logits
>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = int(tf.math.argmax(logits, axis=-1))
>>> print(model.config.id2label[predicted_label])
tabby, tabby cat
DETA
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/deta
概述
DETA 模型是由 Jeffrey Ouyang-Zhang、Jang Hyun Cho、Xingyi Zhou、Philipp Krähenbühl 在NMS Strikes Back中提出的。DETA(Detection Transformers with Assignment)通过将传统检测器中使用的一对一二部匹配损失替换为使用非极大值抑制(NMS)的一对多标签分配来改进 Deformable DETR,从而实现了高达 2.5 mAP 的显着增益。
论文摘要如下:
检测变换器(DETR)在训练期间通过一对一的二部匹配直接将查询转换为唯一对象,并实现端到端的目标检测。最近,这些模型在 COCO 上超越了传统的检测器,具有不可否认的优雅。然而,它们在多个设计方面与传统检测器不同,包括模型架构和训练计划,因此一对一匹配的有效性尚未完全理解。在这项工作中,我们在 DETR 中进行了一项严格的比较,与传统检测器中的一对多标签分配相比,传统检测器使用非极大值抑制(NMS)。令人惊讶的是,我们观察到在相同设置下,NMS 中的一对多分配始终优于标准的一对一匹配,获得了高达 2.5 mAP 的显着增益。我们的检测器使用传统的 IoU-based 标签分配训练 Deformable-DETR,在 ResNet50 骨干网络下在 12 个时期(1x 计划)内实现了 50.2 的 COCO mAP,优于此设置中的所有现有传统或基于变换器的检测器。在多个数据集、计划和架构上,我们始终表明二部匹配对于高性能检测变换器是不必要的。此外,我们将检测变换器的成功归因于其富有表现力的变换器架构。
DETA 概述。摘自原始论文。
资源
一个官方 Hugging Face 和社区(由🌎表示)资源列表,可帮助您开始使用 DETA。
-
DETA 的演示笔记本可以在这里找到。
-
另请参阅:目标检测任务指南
如果您有兴趣提交资源以包含在这里,请随时打开一个 Pull Request,我们将进行审查!资源应该理想地展示一些新东西,而不是复制现有资源。
DetaConfig
class transformers.DetaConfig
( backbone_config = None num_queries = 900 max_position_embeddings = 2048 encoder_layers = 6 encoder_ffn_dim = 2048 encoder_attention_heads = 8 decoder_layers = 6 decoder_ffn_dim = 1024 decoder_attention_heads = 8 encoder_layerdrop = 0.0 is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 init_xavier_std = 1.0 return_intermediate = True auxiliary_loss = False position_embedding_type = 'sine' num_feature_levels = 5 encoder_n_points = 4 decoder_n_points = 4 two_stage = True two_stage_num_proposals = 300 with_box_refine = True assign_first_stage = True assign_second_stage = True class_cost = 1 bbox_cost = 5 giou_cost = 2 mask_loss_coefficient = 1 dice_loss_coefficient = 1 bbox_loss_coefficient = 5 giou_loss_coefficient = 2 eos_coefficient = 0.1 focal_alpha = 0.25 **kwargs )
参数
-
backbone_config
(PretrainedConfig
或dict
,可选,默认为ResNetConfig()
)—骨干模型的配置。 -
num_queries
(int
,可选,默认为 900)—对象查询的数量,即检测槽位。这是 DetaModel 在单个图像中可以检测到的对象的最大数量。如果two_stage
设置为True
,则使用two_stage_num_proposals
。 -
d_model
(int
,可选,默认为 256)—层的维度。 -
encoder_layers
(int
,可选,默认为 6)—编码器层数。 -
decoder_layers
(int
,可选,默认为 6)—解码器层数。 -
encoder_attention_heads
(int
,可选,默认为 8)—变换器编码器中每个注意力层的注意力头数。 -
decoder_attention_heads
(int
, optional, defaults to 8) — Transformer 解码器中每个注意力层的注意力头数。 -
decoder_ffn_dim
(int
, optional, defaults to 2048) — 解码器中“中间”(通常称为前馈)层的维度。 -
encoder_ffn_dim
(int
, optional, defaults to 2048) — 解码器中“中间”(通常称为前馈)层的维度。 -
activation_function
(str
orfunction
, optional, defaults to"relu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,则支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。 -
dropout
(float
, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。 -
attention_dropout
(float
, optional, defaults to 0.0) — 注意力概率的 dropout 比率。 -
activation_dropout
(float
, optional, defaults to 0.0) — 全连接层内激活的 dropout 比率。 -
init_std
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 -
init_xavier_std
(float
, optional, defaults to 1) — 用于 HM Attention map 模块中 Xavier 初始化增益的缩放因子。 -
encoder_layerdrop
(float
, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。有关更多详细信息,请参阅LayerDrop paper。 -
auxiliary_loss
(bool
, optional, defaults toFalse
) — 是否使用辅助解码损失(每个解码器层的损失)。 -
position_embedding_type
(str
, optional, defaults to"sine"
) — 用于图像特征之上的位置嵌入的类型。可以是"sine"
或"learned"
之一。 -
class_cost
(float
, optional, defaults to 1) — 匈牙利匹配成本中分类错误的相对权重。 -
bbox_cost
(float
, optional, defaults to 5) — 匈牙利匹配成本中边界框坐标的 L1 误差的相对权重。 -
giou_cost
(float
, optional, defaults to 2) — 匈牙利匹配成本中边界框广义 IoU 损失的相对权重。 -
mask_loss_coefficient
(float
, optional, defaults to 1) — Focal loss 在全景分割损失中的相对权重。 -
dice_loss_coefficient
(float
, optional, defaults to 1) — 全景分割损失中 DICE/F-1 损失的相对权重。 -
bbox_loss_coefficient
(float
, optional, defaults to 5) — 目标检测损失中 L1 边界框损失的相对权重。 -
giou_loss_coefficient
(float
, optional, defaults to 2) — 目标检测损失中广义 IoU 损失的相对权重。 -
eos_coefficient
(float
, optional, defaults to 0.1) — 目标检测损失中“无对象”类的相对分类权重。 -
num_feature_levels
(int
, optional, defaults to 5) — 输入特征级别的数量。 -
encoder_n_points
(int
, optional, defaults to 4) — 编码器中每个注意力头的每个特征级别中采样的键的数量。 -
decoder_n_points
(int
, optional, defaults to 4) — 解码器中每个注意力头的每个特征级别中采样的键的数量。 -
two_stage
(bool
, optional, defaults toTrue
) — 是否应用两阶段可变形 DETR,其中区域提议也是由 DETA 的变体生成的,然后进一步馈入解码器进行迭代边界框细化。 -
two_stage_num_proposals
(int
, optional, defaults to 300) — 要生成的区域提议数量,如果two_stage
设置为True
。 -
with_box_refine
(bool
, optional, defaults toTrue
) — 是否应用迭代边界框细化,其中每个解码器层根据前一层的预测对边界框进行细化。 -
focal_alpha
(float
, optional, defaults to 0.25) — Focal loss 中的 Alpha 参数。 -
assign_first_stage
(bool
, optional, defaults toTrue
) — 如果重叠大于阈值 0.7,则将每个预测 i 分配给最高重叠的地面真实对象。 -
assign_second_stage
(bool
, optional, defaults toTrue
) — 是否在第二阶段紧随第一阶段分配程序进行第二次分配。
这是一个配置类,用于存储 DetaModel 的配置。它用于根据指定的参数实例化一个 DETA 模型,定义模型架构。使用默认值实例化配置将产生与 DETA SenseTime/deformable-detr 架构类似的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import DetaConfig, DetaModel
>>> # Initializing a DETA SenseTime/deformable-detr style configuration
>>> configuration = DetaConfig()
>>> # Initializing a model (with random weights) from the SenseTime/deformable-detr style configuration
>>> model = DetaModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
DetaImageProcessor
class transformers.DetaImageProcessor
( format: Union = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )
参数
-
format
(str
, optional, defaults to"coco_detection"
) — 注释的数据格式。其中之一为"coco_detection"
或“coco_panoptic”。 -
do_resize
(bool
, optional, defaults toTrue
) — 控制是否将图像的(高度,宽度)尺寸调整为指定的size
。可以被preprocess
方法中的do_resize
参数覆盖。 -
size
(Dict[str, int]
optional, defaults to{"shortest_edge" -- 800, "longest_edge": 1333}
): 调整大小后的图像(高度,宽度)尺寸。可以被preprocess
方法中的size
参数覆盖。 -
resample
(PILImageResampling
, optional, defaults toPILImageResampling.BILINEAR
) — 如果调整图像大小,则使用的重采样滤波器。 -
do_rescale
(bool
, optional, defaults toTrue
) — 控制是否按指定的比例rescale_factor
对图像进行重新缩放。可以被preprocess
方法中的do_rescale
参数覆盖。 -
rescale_factor
(int
orfloat
, optional, defaults to1/255
) — 如果重新缩放图像,则使用的比例因子。可以被preprocess
方法中的rescale_factor
参数覆盖。 do_normalize — 控制是否对图像进行归一化。可以被preprocess
方法中的do_normalize
参数覆盖。 -
image_mean
(float
orList[float]
, optional, defaults toIMAGENET_DEFAULT_MEAN
) — 在归一化图像时使用的均值。可以是单个值或每个通道的值列表。可以被preprocess
方法中的image_mean
参数覆盖。 -
image_std
(float
orList[float]
, optional, defaults toIMAGENET_DEFAULT_STD
) — 在归一化图像时使用的标准差值。可以是单个值或每个通道的值列表。可以被preprocess
方法中的image_std
参数覆盖。 -
do_pad
(bool
, optional, defaults toTrue
) — 控制是否将图像填充到批处理中最大的图像并创建像素掩码。可以被preprocess
方法中的do_pad
参数覆盖。
构建一个可变形 DETR 图像处理器。
preprocess
( images: Union annotations: Union = None return_segmentation_masks: bool = None masks_path: Union = None do_resize: Optional = None size: Optional = None resample = None do_rescale: Optional = None rescale_factor: Union = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None format: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
参数
-
images
(ImageInput
) — 要预处理的图像或图像批处理。期望单个图像或像素值范围从 0 到 255 的图像批处理。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。 -
annotations
(List[Dict]
或List[List[Dict]]
,可选)- 与图像或一批图像相关联的注释列表。如果注释用于目标检测,则注释应该是一个带有以下键的字典:-
“image_id”(
int
):图像 ID。 -
“annotations”(
List[Dict]
):图像的注释列表。每个注释应该是一个字典。一个图像可能没有注释,此时列表应为空。如果注释用于分割,注释应该是一个带有以下键的字典: -
“image_id”(
int
):图像 ID。 -
“segments_info”(
List[Dict]
):图像的段列表。每个段应该是一个字典。一个图像可能没有段,此时列表应为空。 -
“file_name”(
str
):图像的文件名。
-
-
return_segmentation_masks
(bool
,可选,默认为 self.return_segmentation_masks)- 是否返回分割掩模。 -
masks_path
(str
或pathlib.Path
,可选)- 包含分割掩模的目录路径。 -
do_resize
(bool
,可选,默认为 self.do_resize)- 是否调整图像大小。 -
size
(Dict[str, int]
,可选,默认为 self.size)- 调整大小后的图像大小。 -
resample
(PILImageResampling
,可选,默认为 self.resample)- 调整图像大小时使用的重采样滤波器。 -
do_rescale
(bool
,可选,默认为 self.do_rescale)- 是否重新缩放图像。 -
rescale_factor
(float
,可选,默认为 self.rescale_factor)- 重新缩放图像时使用的重新缩放因子。 -
do_normalize
(bool
,可选,默认为 self.do_normalize)- 是否对图像进行归一化。 -
image_mean
(float
或List[float]
,可选,默认为 self.image_mean)- 在归一化图像时使用的均值。 -
image_std
(float
或List[float]
,可选,默认为 self.image_std)- 在归一化图像时使用的标准差。 -
do_pad
(bool
,可选,默认为 self.do_pad)- 是否对图像进行填充。 -
format
(str
或AnnotationFormat
,可选,默认为 self.format)- 注释的格式。 -
return_tensors
(str
或TensorType
,可选,默认为 self.return_tensors)- 要返回的张量类型。如果为None
,将返回图像列表。 -
data_format
(ChannelDimension
或str
,可选,默认为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)格式。
-
对图像或一批图像进行预处理,以便模型可以使用。
post_process_object_detection
( outputs threshold: float = 0.5 target_sizes: Union = None nms_threshold: float = 0.7 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrObjectDetectionOutput
)- 模型的原始输出。 -
threshold
(float
,可选,默认为 0.5)- 保留目标检测预测的分数阈值。 -
target_sizes
(torch.Tensor
或List[Tuple[int, int]]
,可选)- 形状为(batch_size, 2)
的张量或包含每个图像批次中目标大小(高度,宽度)的元组列表(Tuple[int, int]
)。如果设置为 None,预测将不会被调整大小。 -
nms_threshold
(float
,可选,默认为 0.7)- NMS 阈值。
返回
List[Dict]
一个字典列表,每个字典包含模型预测的批次中图像的分数、标签和框。
将 DetaForObjectDetection 的输出转换为最终的边界框,格式为(top_left_x, top_left_y, bottom_right_x, bottom_right_y)。仅支持 PyTorch。
DetaModel
class transformers.DetaModel
( config: DetaConfig )
参数
config
(DetaConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
裸的 DETA 模型(由骨干和编码器-解码器 Transformer 组成),输出原始隐藏状态,没有特定的头部。
此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deta.modeling_deta.DetaModelOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。默认情况下将忽略填充。像素值可以使用 AutoImageProcessor 获得。有关详细信息,请参阅
AutoImageProcessor.__call__()
。 -
pixel_mask
(torch.LongTensor
,形状为(batch_size, height, width)
,可选) — 用于避免在填充像素值上执行注意力的掩码。掩码值选择在[0, 1]
范围内:-
对于真实像素(即
未屏蔽
)为 1, -
对于填充像素(即
屏蔽
)为 0。
什么是注意力掩码?
-
-
decoder_attention_mask
(torch.FloatTensor
,形状为(batch_size, num_queries)
,可选) — 默认情况下不使用。可用于屏蔽对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
, 可选) — 元组包含(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 可选地,您可以选择直接传递图像的扁平化表示,而不是传递扁平化特征图(骨干网络和投影层的输出)。 -
decoder_inputs_embeds
(torch.FloatTensor
,形状为(batch_size, num_queries, hidden_size)
,可选) — 可选地,您可以选择直接传递嵌入表示,而不是使用零张量初始化查询。 -
output_attentions
(bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请查看返回张量下的attentions
。 -
output_hidden_states
(bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请查看返回张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回一个 ModelOutput 而不是一个普通元组。
返回值
transformers.models.deta.modeling_deta.DetaModelOutput
或tuple(torch.FloatTensor)
一个transformers.models.deta.modeling_deta.DetaModelOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时)包括根据配置(DetaConfig)和输入的不同元素。
-
init_reference_points
(形状为(batch_size, num_queries, 4)
的torch.FloatTensor
)— 通过 Transformer 解码器发送的初始参考点。 -
last_hidden_state
(形状为(batch_size, num_queries, hidden_size)
的torch.FloatTensor
)— 模型解码器最后一层的隐藏状态序列。 -
intermediate_hidden_states
(形状为(batch_size, config.decoder_layers, num_queries, hidden_size)
的torch.FloatTensor
)— 堆叠的中间隐藏状态(解码器每层的输出)。 -
intermediate_reference_points
(形状为(batch_size, config.decoder_layers, num_queries, 4)
的torch.FloatTensor
)— 堆叠的中间参考点(解码器每层的参考点)。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回)— 形状为(batch_size, num_queries, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。解码器在每层输出的隐藏状态加上初始嵌入输出。 -
decoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, num_queries, num_queries)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)— 形状为(batch_size, num_queries, num_heads, 4, 4)
的torch.FloatTensor
元组(每层一个)。解码器交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。编码器在每层输出的隐藏状态加上初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)— 形状为(batch_size, num_queries, num_heads, 4, 4)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
enc_outputs_class
(形状为(batch_size, sequence_length, config.num_labels)
的torch.FloatTensor
,可选,当config.with_box_refine=True
和config.two_stage=True
时返回)— 预测的边界框分数,其中选择前config.two_stage_num_proposals
个得分最高的边界框作为第一阶段的区域提议。边界框二元分类的输出(即前景和背景)。 -
enc_outputs_coord_logits
(torch.FloatTensor
,形状为(batch_size, sequence_length, 4)
,可选,当config.with_box_refine=True
和config.two_stage=True
时返回)— 第一阶段中预测的边界框坐标的 logits。 -
output_proposals
(torch.FloatTensor
,形状为(batch_size, sequence_length, 4)
,可选,当config.two_stage=True
时返回)— 在 gen_encoder_output_proposals 中提议边界框坐标的 logits。
DetaModel 的前向方法覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DetaModel
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("jozhang97/deta-swin-large-o365")
>>> model = DetaModel.from_pretrained("jozhang97/deta-swin-large-o365", two_stage=False)
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 900, 256]
DetaForObjectDetection
class transformers.DetaForObjectDetection
( config: DetaConfig )
参数
config
(DetaConfig)— 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
DETA 模型(由骨干和编码器-解码器 Transformer 组成),顶部带有目标检测头,用于诸如 COCO 检测之类的任务。
这个模型继承自 PreTrainedModel。查看超类文档以了解库实现的所有模型的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是 PyTorch 的torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.deta.modeling_deta.DetaObjectDetectionOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
)— 像素值。默认情况下将忽略填充。像素值可以使用 AutoImageProcessor 获得。查看
AutoImageProcessor.__call__()
以获取详细信息。 -
pixel_mask
(torch.LongTensor
,形状为(batch_size, height, width)
,可选)— 用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]
之间:-
1 表示真实像素(即
未被掩码
), -
0 表示填充像素(即
已掩码
)。
什么是注意力掩码?
-
-
decoder_attention_mask
(torch.FloatTensor
,形状为(batch_size, num_queries)
,可选)— 默认情况下不使用。可用于屏蔽对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选)— 元组包含(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
形状为(batch_size, sequence_length, hidden_size)
,可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选)— 可选地,可以直接传递图像的扁平特征图(骨干+投影层的输出),而不是传递图像的扁平表示。 -
decoder_inputs_embeds
(torch.FloatTensor
of shape(batch_size, num_queries, hidden_size)
, optional) — 可选,可以选择直接传递嵌入表示,而不是用零张量初始化查询。 -
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。 -
labels
(List[Dict]
of len(batch_size,)
, optional) — 用于计算二分匹配损失的标签。字典列表,每个字典至少包含以下 2 个键:'class_labels'和'boxes'(分别是批处理中图像的类标签和边界框)。类标签本身应该是长度为(图像中边界框数量,)
的torch.LongTensor
,而边界框是形状为(图像中边界框数量, 4)
的torch.FloatTensor
。
返回
transformers.models.deta.modeling_deta.DetaObjectDetectionOutput
或tuple(torch.FloatTensor)
transformers.models.deta.modeling_deta.DetaObjectDetectionOutput
或torch.FloatTensor
的元组(如果传递了return_dict=False
或config.return_dict=False
时)包括各种元素,具体取决于配置(DetaConfig)和输入。
-
loss
(torch.FloatTensor
of shape(1,)
, optional, 当提供labels
时返回) — 总损失,作为负对数似然(交叉熵)和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 -
loss_dict
(Dict
, optional) — 包含各个损失的字典。用于记录。 -
logits
(torch.FloatTensor
of shape(batch_size, num_queries, num_classes + 1)
) — 所有查询的分类 logits(包括无对象)。 -
pred_boxes
(torch.FloatTensor
of shape(batch_size, num_queries, 4)
) — 所有查询的标准化框坐标,表示为(中心 _x,中心 _y,宽度,高度)。这些值在[0, 1]范围内标准化,相对于批处理中每个单独图像的大小(忽略可能的填充)。您可以使用~DetaProcessor.post_process_object_detection
来检索未标准化的边界框。 -
auxiliary_outputs
(list[Dict]
, optional) — 可选,仅在辅助损失被激活时返回(即config.auxiliary_loss
设置为True
)并提供标签时返回。这是一个包含每个解码器层的上述两个键(logits
和pred_boxes
)的字典列表。 -
last_hidden_state
(torch.FloatTensor
of shape(batch_size, num_queries, hidden_size)
, optional) — 模型解码器最后一层的隐藏状态序列的输出。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, num_queries, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。解码器在每层输出的隐藏状态加上初始嵌入输出。 -
decoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, num_queries, num_queries)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 元组的torch.FloatTensor
(每一层一个)的形状为(batch_size, num_queries, num_heads, 4, 4)
。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 元组的torch.FloatTensor
(一个用于嵌入的输出 + 一个用于每一层的输出)的形状为(batch_size, sequence_length, hidden_size)
。编码器在每一层输出的隐藏状态加上初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 元组的torch.FloatTensor
(每一层一个)的形状为(batch_size, sequence_length, num_heads, 4, 4)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
intermediate_hidden_states
(torch.FloatTensor
of shape(batch_size, config.decoder_layers, num_queries, hidden_size)
) — 堆叠的中间隐藏状态(解码器每一层的输出)。 -
intermediate_reference_points
(torch.FloatTensor
of shape(batch_size, config.decoder_layers, num_queries, 4)
) — 堆叠的中间参考点(解码器每一层的参考点)。 -
init_reference_points
(torch.FloatTensor
of shape(batch_size, num_queries, 4)
) — 通过 Transformer 解码器发送的初始参考点。 -
enc_outputs_class
(torch.FloatTensor
of shape(batch_size, sequence_length, config.num_labels)
,可选,当config.with_box_refine=True
和config.two_stage=True
时返回) — 预测的边界框分数,其中选择前config.two_stage_num_proposals
个得分最高的边界框作为第一阶段的区域提议。边界框二元分类的输出(即前景和背景)。 -
enc_outputs_coord_logits
(torch.FloatTensor
of shape(batch_size, sequence_length, 4)
,可选,当config.with_box_refine=True
和config.two_stage=True
时返回) — 第一阶段中预测的边界框坐标的 logits。 -
output_proposals
(torch.FloatTensor
of shape(batch_size, sequence_length, 4)
,可选,当config.two_stage=True
时返回) — 在 gen_encoder_output_proposals 中的提议边界框坐标的 logits。
DetaForObjectDetection 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在这个函数中定义,但应该在之后调用Module
实例,而不是这个函数,因为前者会处理运行前后的处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DetaForObjectDetection
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("jozhang97/deta-swin-large")
>>> model = DetaForObjectDetection.from_pretrained("jozhang97/deta-swin-large")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[
... 0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
... box = [round(i, 2) for i in box.tolist()]
... print(
... f"Detected {model.config.id2label[label.item()]} with confidence "
... f"{round(score.item(), 3)} at location {box}"
... )
Detected cat with confidence 0.683 at location [345.85, 23.68, 639.86, 372.83]
Detected cat with confidence 0.683 at location [8.8, 52.49, 316.93, 473.45]
Detected remote with confidence 0.568 at location [40.02, 73.75, 175.96, 117.33]
Detected remote with confidence 0.546 at location [333.68, 77.13, 370.12, 187.51]
DETR
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/detr
概述
DETR 模型是由 Nicolas Carion、Francisco Massa、Gabriel Synnaeve、Nicolas Usunier、Alexander Kirillov 和 Sergey Zagoruyko 在使用变压器进行端到端目标检测中提出的。DETR 由一个卷积主干后面跟着一个编码器-解码器变压器组成,可以进行端到端的目标检测训练。它极大地简化了像 Faster-R-CNN 和 Mask-R-CNN 这样的模型的复杂性,这些模型使用区域提议、非极大值抑制程序和锚点生成等技术。此外,DETR 还可以自然地扩展到执行全景分割,只需在解码器输出之上添加一个蒙版头。
论文摘要如下:
我们提出了一种将目标检测视为直接集合预测问题的新方法。我们的方法简化了检测流程,有效地消除了许多手工设计的组件,如非极大值抑制程序或明确编码我们对任务的先验知识的锚点生成。新框架 DEtection TRansformer 或 DETR 的主要组成部分是通过二部匹配强制唯一预测的基于集合的全局损失,以及一个变压器编码器-解码器架构。给定一组固定的学习目标查询,DETR 推理对象之间的关系和全局图像上下文,直接并行输出最终的预测集。这个新模型在概念上简单,不需要专门的库,不像许多其他现代检测器。DETR 在具有挑战性的 COCO 目标检测数据集上表现出与经过充分优化的 Faster RCNN 基线相当的准确性和运行时性能。此外,DETR 可以轻松推广为以统一方式产生全景分割。我们展示它明显优于竞争基线。
DETR 的工作原理
以下是解释 DetrForObjectDetection 工作原理的 TLDR:
首先,将图像通过预训练的卷积主干(在论文中,作者使用 ResNet-50/ResNet-101)。假设我们也添加了一个批处理维度。这意味着主干的输入是一个形状为(batch_size, 3, height, width)
的张量,假设图像有 3 个颜色通道(RGB)。CNN 主干输出一个新的低分辨率特征图,通常形状为(batch_size, 2048, height/32, width/32)
。然后,将其投影到 DETR 变压器的隐藏维度,该维度默认为256
,使用nn.Conv2D
层。现在,我们有一个形状为(batch_size, 256, height/32, width/32)
的张量。接下来,特征图被展平并转置,以获得形状为(batch_size, seq_len, d_model)
= (batch_size, width/32*height/32, 256)
的张量。因此,与 NLP 模型的一个区别是,序列长度实际上比通常更长,但d_model
较小(在 NLP 中通常为 768 或更高)。
接下来,这通过编码器发送,输出相同形状的encoder_hidden_states
(您可以将这些视为图像特征)。接下来,所谓的对象查询通过解码器发送。这是一个形状为(batch_size, num_queries, d_model)
的张量,其中num_queries
通常设置为 100,并用零初始化。这些输入嵌入是学习的位置编码,作者将其称为对象查询,类似于编码器,它们被添加到每个注意力层的输入中。每个对象查询将在图像中寻找特定对象。解码器通过多个自注意力和编码器-解码器注意力层更新这些嵌入,以输出相同形状的decoder_hidden_states
:(batch_size, num_queries, d_model)
。接下来,顶部添加了两个头用于对象检测:一个线性层用于将每个对象查询分类为对象或“无对象”之一,以及一个 MLP 用于预测每个查询的边界框。
该模型使用二部匹配损失进行训练:实际上我们比较每个 N = 100 个对象查询的预测类别+边界框与地面真实注释,填充到相同长度 N(因此如果图像仅包含 4 个对象,则 96 个注释将只有一个“无对象”作为类别和一个“无边界框”作为边界框)。使用匈牙利匹配算法找到每个 N 查询与每个 N 注释的最佳一对一映射。接下来,使用标准交叉熵(用于类别)和 L1 的线性组合以及广义 IoU 损失(用于边界框)来优化模型的参数。
DETR 可以自然扩展以执行全景分割(将语义分割和实例分割统一起来)。DetrForSegmentation 在 DetrForObjectDetection 的顶部添加了一个分割掩码头。掩码头可以同时训练,或者在两个步骤的过程中训练,首先训练一个 DetrForObjectDetection 模型来检测“事物”(实例)和“物品”(背景物品,如树木、道路、天空)周围的边界框,然后冻结所有权重,仅训练掩码头 25 个时代。实验上,这两种方法给出了类似的结果。请注意,为了使训练成为可能,预测框是必需的,因为匈牙利匹配是使用框之间的距离计算的。
使用提示
-
DETR 使用所谓的对象查询来检测图像中的对象。查询的数量确定了单个图像中可以检测到的对象的最大数量,默认设置为 100(请参阅 DetrConfig 的参数
num_queries
)。请注意,最好有一些余地(在 COCO 中,作者使用了 100,而 COCO 图像中的最大对象数量约为 70)。 -
DETR 的解码器并行更新查询嵌入。这与像 GPT-2 这样使用自回归解码而不是并行的语言模型不同。因此,不使用因果关注掩码。
-
在将隐藏状态投影到查询和键之前,DETR 在每个自注意力和交叉注意力层中添加位置嵌入。对于图像的位置嵌入,可以在固定正弦或学习的绝对位置嵌入之间进行选择。默认情况下,DetrConfig 的参数
position_embedding_type
设置为"sine"
。 -
在训练期间,DETR 的作者确实发现在解码器中使用辅助损失是有帮助的,特别是为了帮助模型输出每个类别的正确对象数量。如果将 DetrConfig 的参数
auxiliary_loss
设置为True
,则在每个解码器层之后添加预测前馈神经网络和匈牙利损失(FFN 共享参数)。 -
如果您想在跨多个节点的分布式环境中训练模型,则应该在modeling_detr.py中的DetrLoss类中更新num_boxes变量。在多个节点上训练时,应将其设置为所有节点上目标框的平均数量,可以在原始实现中看到这里。
-
DetrForObjectDetection 和 DetrForSegmentation 可以使用timm 库中可用的任何卷积骨干进行初始化。例如,可以通过将 DetrConfig 的
backbone
属性设置为"tf_mobilenetv3_small_075"
,然后使用该配置初始化模型来使用 MobileNet 骨干。 -
DETR 调整输入图像的大小,使最短边至少为一定数量的像素,而最长边至多为 1333 像素。在训练时,使用尺度增强,使最短边随机设置为至少 480 像素,最多 800 像素。在推断时,最短边设置为 800。可以使用 DetrImageProcessor 为模型准备图像(以及可选的以 COCO 格式的注释)。由于这种调整大小,批处理中的图像可能具有不同的大小。DETR 通过将图像填充到批处理中的最大大小,并创建一个像素掩码来指示哪些像素是真实的/哪些是填充来解决这个问题。另外,也可以定义一个自定义的
collate_fn
来批处理图像,使用~transformers.DetrImageProcessor.pad_and_create_pixel_mask
。 -
图像的大小将决定所使用的内存量,从而确定
batch_size
。建议每个 GPU 使用批量大小为 2。有关更多信息,请参阅此 Github 线程。
有三种实例化 DETR 模型的方法(取决于您的偏好):
选项 1:使用整个模型的预训练权重实例化 DETR
>>> from transformers import DetrForObjectDetection
>>> model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
选项 2:使用随机初始化的 Transformer 权重实例化 DETR,但使用骨干的预训练权重
>>> from transformers import DetrConfig, DetrForObjectDetection
>>> config = DetrConfig()
>>> model = DetrForObjectDetection(config)
选项 3:使用随机初始化的骨干+Transformer 实例化 DETR
>>> config = DetrConfig(use_pretrained_backbone=False)
>>> model = DetrForObjectDetection(config)
总之,请参考以下表格:
任务 | 目标检测 | 实例分割 | 全景分割 |
---|---|---|---|
描述 | 预测图像中物体周围的边界框和类标签 | 预测图像中物体(即实例)周围的掩模 | 预测图像中物体(即实例)以及“物质”(即背景物品如树木和道路)周围的掩模 |
模型 | DetrForObjectDetection | DetrForSegmentation | DetrForSegmentation |
示例数据集 | COCO 检测 | COCO 检测,COCO 全景 | COCO 全景 |
提供给 DetrImageProcessor 的注释格式 | {‘image_id’: int , ‘annotations’: List[Dict] },每个 Dict 是一个 COCO 对象注释 |
{‘image_id’: int , ‘annotations’: List[Dict] }(在 COCO 检测的情况下)或{‘file_name’: str , ‘image_id’: int , ‘segments_info’: List[Dict] }(在 COCO 全景的情况下) |
{‘file_name’: str , ‘image_id’: int , ‘segments_info’: List[Dict] }和 masks_path(包含 PNG 文件的掩模目录的路径) |
后处理(即将模型输出转换为 Pascal VOC 格式) | post_process() |
post_process_segmentation() |
post_process_segmentation() , post_process_panoptic() |
评估器 | CocoEvaluator with iou_types="bbox" |
CocoEvaluator with iou_types="bbox" or "segm" |
CocoEvaluator with iou_tupes="bbox" or "segm" , PanopticEvaluator |
简而言之,应该准备数据以 COO 检测或 COO 全景格式,然后使用 DetrImageProcessor 创建pixel_values
、pixel_mask
和可选的labels
,然后可以用于训练(或微调)模型。对于评估,应该首先使用 DetrImageProcessor 的其中一种后处理方法转换模型的输出。这些可以提供给CocoEvaluator
或PanopticEvaluator
,这些评估器允许您计算像平均精度(mAP)和全景质量(PQ)这样的指标。后者对象在原始存储库中实现。有关评估的更多信息,请参见示例笔记本。
资源
一个官方 Hugging Face 和社区(由🌎表示)资源列表,可帮助您开始使用 DETR。
目标检测
-
所有示例笔记本说明在自定义数据集上对 DetrForObjectDetection 和 DetrForSegmentation 进行微调的示例可以在此处找到。
-
参见:目标检测任务指南
如果您有兴趣提交资源以包含在此处,请随时打开一个 Pull Request,我们将进行审查!资源应该展示一些新东西,而不是重复现有资源。
DetrConfig
class transformers.DetrConfig
( use_timm_backbone = True backbone_config = None num_channels = 3 num_queries = 100 encoder_layers = 6 encoder_ffn_dim = 2048 encoder_attention_heads = 8 decoder_layers = 6 decoder_ffn_dim = 2048 decoder_attention_heads = 8 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 is_encoder_decoder = True activation_function = 'relu' d_model = 256 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 init_xavier_std = 1.0 auxiliary_loss = False position_embedding_type = 'sine' backbone = 'resnet50' use_pretrained_backbone = True dilation = False class_cost = 1 bbox_cost = 5 giou_cost = 2 mask_loss_coefficient = 1 dice_loss_coefficient = 1 bbox_loss_coefficient = 5 giou_loss_coefficient = 2 eos_coefficient = 0.1 **kwargs )
参数
-
use_timm_backbone
(bool
,可选,默认为True
)— 是否使用timm
库作为骨干。如果设置为False
,将使用AutoBackbone
API。 -
backbone_config
(PretrainedConfig
或dict
,可选)— 骨干模型的配置。仅在use_timm_backbone
设置为False
时使用,默认为ResNetConfig()
。 -
num_channels
(int
,可选,默认为 3)— 输入通道的数量。 -
num_queries
(int
,可选,默认为 100)— 对象查询的数量,即检测槽的数量。这是 DetrModel 在单个图像中可以检测的对象的最大数量。对于 COCO,我们建议使用 100 个查询。 -
d_model
(int
,可选,默认为 256)— 层的维度。 -
encoder_layers
(int
,可选,默认为 6)— 编码器层数。 -
decoder_layers
(int
,可选,默认为 6)— 解码器层数。 -
encoder_attention_heads
(int
,可选,默认为 8)— Transformer 编码器中每个注意力层的注意力头数。 -
decoder_attention_heads
(int
, optional, defaults to 8) — Transformer 解码器中每个注意力层的注意力头数。 -
decoder_ffn_dim
(int
, optional, defaults to 2048) — 解码器中“中间”(通常称为前馈)层的维度。 -
encoder_ffn_dim
(int
, optional, defaults to 2048) — 解码器中“中间”(通常称为前馈)层的维度。 -
activation_function
(str
orfunction
, optional, defaults to"relu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。 -
dropout
(float
, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。 -
attention_dropout
(float
, optional, defaults to 0.0) — 注意力概率的 dropout 比率。 -
activation_dropout
(float
, optional, defaults to 0.0) — 全连接层内激活的 dropout 比率。 -
init_std
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。 -
init_xavier_std
(float
, optional, defaults to 1) — 用于 HM Attention map 模块中 Xavier 初始化增益的缩放因子。 -
encoder_layerdrop
(float
, optional, defaults to 0.0) — 编码器的 LayerDrop 概率。更多细节请参阅LayerDrop paper。 -
decoder_layerdrop
(float
, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。更多细节请参阅LayerDrop paper。 -
auxiliary_loss
(bool
, optional, defaults toFalse
) — 是否使用辅助解码损失(每个解码器层的损失)。 -
position_embedding_type
(str
, optional, defaults to"sine"
) — 在图像特征之上使用的位置嵌入的类型。可以是"sine"
或"learned"
之一。 -
backbone
(str
, optional, defaults to"resnet50"
) — 在use_timm_backbone
=True
时要使用的卷积骨干网络的名称。支持 timm 包中的任何卷积骨干网络。有关所有可用模型的列表,请参阅此页面。 -
use_pretrained_backbone
(bool
, optional, defaults toTrue
) — 是否在骨干网络中使用预训练权重。仅在use_timm_backbone
=True
时支持。 -
dilation
(bool
, optional, defaults toFalse
) — 是否在最后的卷积块(DC5)中用扩张替换步幅。仅在use_timm_backbone
=True
时支持。 -
class_cost
(float
, optional, defaults to 1) — 匈牙利匹配成本中分类错误的相对权重。 -
bbox_cost
(float
, optional, defaults to 5) — 相对于匈牙利匹配成本中边界框坐标的 L1 误差的权重。 -
giou_cost
(float
, optional, defaults to 2) — 相对于匈牙利匹配成本中边界框广义 IoU 损失的权重。 -
mask_loss_coefficient
(float
, optional, defaults to 1) — 泛光分割损失中 Focal 损失的相对权重。 -
dice_loss_coefficient
(float
, optional, defaults to 1) — 泛光分割损失中 DICE/F-1 损失的相对权重。 -
bbox_loss_coefficient
(float
, optional, defaults to 5) — 目标检测损失中 L1 边界框损失的相对权重。 -
giou_loss_coefficient
(float
, optional, defaults to 2) — 目标检测损失中广义 IoU 损失的相对权重。 -
eos_coefficient
(float
, optional, defaults to 0.1) — 目标检测损失中“无对象”类别的相对分类权重。
这是一个配置类,用于存储 DetrModel 的配置。它用于根据指定的参数实例化一个 DETR 模型,定义模型架构。使用默认值实例化配置将产生类似于 DETR facebook/detr-resnet-50架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import DetrConfig, DetrModel
>>> # Initializing a DETR facebook/detr-resnet-50 style configuration
>>> configuration = DetrConfig()
>>> # Initializing a model (with random weights) from the facebook/detr-resnet-50 style configuration
>>> model = DetrModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
from_backbone_config
( backbone_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';DetrConfig
参数
backbone_config
(PretrainedConfig) — 骨干配置。
返回
DetrConfig
配置对象的实例
从预训练的骨干模型配置实例化一个 DetrConfig(或派生类)。
DetrImageProcessor
class transformers.DetrImageProcessor
( format: Union = <AnnotationFormat.COCO_DETECTION: 'coco_detection'> do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )
参数
-
format
(str
, optional, 默认为"coco_detection"
) — 注释的数据格式。可以是"coco_detection"
或“coco_panoptic”之一。 -
do_resize
(bool
, optional, 默认为True
) — 控制是否将图像的(height, width)
维度调整为指定的size
。可以被preprocess
方法中的do_resize
参数覆盖。 -
size
(Dict[str, int]
optional, 默认为{"shortest_edge" -- 800, "longest_edge": 1333}
): 调整大小后的图像的(height, width)
维度大小。可以被preprocess
方法中的size
参数覆盖。 -
resample
(PILImageResampling
, optional, 默认为PILImageResampling.BILINEAR
) — 如果调整图像大小,则要使用的重采样滤波器。 -
do_rescale
(bool
, optional, 默认为True
) — 控制是否按指定比例因子rescale_factor
重新缩放图像。可以被preprocess
方法中的do_rescale
参数覆盖。 -
rescale_factor
(int
或float
, optional, 默认为1/255
) — 如果重新调整图像,则要使用的比例因子。可以被preprocess
方法中的rescale_factor
参数覆盖。do_normalize — 控制是否对图像进行归一化。可以被preprocess
方法中的do_normalize
参数覆盖。 -
image_mean
(float
或List[float]
, optional, 默认为IMAGENET_DEFAULT_MEAN
) — 在归一化图像时使用的均值。可以是单个值或每个通道的值列表。可以被preprocess
方法中的image_mean
参数覆盖。 -
image_std
(float
或List[float]
, optional, 默认为IMAGENET_DEFAULT_STD
) — 在归一化图像时使用的标准差值。可以是单个值或每个通道的值列表。可以被preprocess
方法中的image_std
参数覆盖。 -
do_pad
(bool
, optional, 默认为True
) — 控制是否将图像填充到批处理中最大的图像并创建像素掩码。可以被preprocess
方法中的do_pad
参数覆盖。
构造一个 Detr 图像处理器。
preprocess
( images: Union annotations: Union = None return_segmentation_masks: bool = None masks_path: Union = None do_resize: Optional = None size: Optional = None resample = None do_rescale: Optional = None rescale_factor: Union = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None format: Union = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
参数
-
images
(ImageInput
) — 要预处理的图像或图像批次。期望单个或批量像素值范围从 0 到 255 的图像。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。 -
annotations
(AnnotationType
orList[AnnotationType]
, optional) — 与图像或图像批次相关联的注释列表。如果注释是用于对象检测的,则注释应该是一个带有以下键的字典:-
“image_id” (
int
): 图像 id。 -
“annotations” (
List[Dict]
): 图像的注释列表。每个注释应该是一个字典。一个图像可以没有注释,此时列表应为空。如果注释是用于分割的,注释应该是一个带有以下键的字典: -
“image_id” (
int
): 图像 id。 -
“segments_info” (
List[Dict]
): 图像的段列表。每个段应该是一个字典。一个图像可以没有段,此时列表应为空。 -
“file_name” (
str
): 图像的文件名。
-
-
return_segmentation_masks
(bool
, optional, 默认为 self.return_segmentation_masks) — 是否返回分割蒙版。 -
masks_path
(str
orpathlib.Path
, optional) — 包含分割蒙版的目录路径。 -
do_resize
(bool
, optional, 默认为 self.do_resize) — 是否调整图像大小。 -
size
(Dict[str, int]
, optional, 默认为 self.size) — 调整大小后的图像尺寸。 -
resample
(PILImageResampling
, optional, 默认为 self.resample) — 调整图像大小时使用的重采样滤波器。 -
do_rescale
(bool
, optional, 默认为 self.do_rescale) — 是否重新缩放图像。 -
rescale_factor
(float
, optional, 默认为 self.rescale_factor) — 调整图像时使用的缩放因子。 -
do_normalize
(bool
, optional, 默认为 self.do_normalize) — 是否规范化图像。 -
image_mean
(float
orList[float]
, optional, 默认为 self.image_mean) — 在规范化图像时使用的均值。 -
image_std
(float
orList[float]
, optional, 默认为 self.image_std) — 在规范化图像时使用的标准差。 -
do_pad
(bool
, optional, 默认为 self.do_pad) — 是否填充图像。 -
format
(str
orAnnotationFormat
, optional, 默认为 self.format) — 注释的格式。 -
return_tensors
(str
orTensorType
, optional, 默认为 self.return_tensors) — 要返回的张量类型。如果为None
,将返回图像列表。 -
data_format
(ChannelDimension
orstr
, optional, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
: 图像以(通道数,高度,宽度)格式。 -
"channels_last"
或ChannelDimension.LAST
: 图像以(高度,宽度,通道数)格式。 -
未设置:使用输入图像的通道维度格式。
-
-
input_data_format
(ChannelDimension
orstr
, optional) — 输入图像的通道维度格式。如果未设置,将从输入图像中推断通道维度格式。可以是以下之一:-
"channels_first"
或ChannelDimension.FIRST
: 图像以(通道数,高度,宽度)格式。 -
"channels_last"
或ChannelDimension.LAST
: 图像以(高度,宽度,通道数)格式。 -
"none"
或ChannelDimension.NONE
: 图像以(高度,宽度)格式。
-
预处理图像或图像批次,以便模型可以使用。
post_process_object_detection
( outputs threshold: float = 0.5 target_sizes: Union = None ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrObjectDetectionOutput
) — 模型的原始输出。 -
threshold
(float
, optional) — 保留对象检测预测的分数阈值。 -
target_sizes
(torch.Tensor
或列表[元组[int, int]]
, 可选) — 形状为(batch_size, 2)
的张量或包含每个图像的目标大小(高度,宽度)
的元组列表(元组[int, int]
)。如果未设置,预测将不会被调整大小。
返回
列表[字典]
一个字典列表,每个字典包含模型预测的批次中图像的分数、标签和框。
将 DetrForObjectDetection 的原始输出转换为最终的边界框,格式为(左上角 _x,左上角 _y,右下角 _x,右下角 _y)。仅支持 PyTorch。
后处理语义分割
( outputs target_sizes: List = None ) → export const metadata = 'undefined';List[torch.Tensor]
参数
-
outputs
(DetrForSegmentation) — 模型的原始输出。 -
target_sizes
(列表[元组[int, int]]
, 可选) — 一个元组列表(元组[int, int]
),包含批次中每个图像的目标大小(高度,宽度)。如果未设置,预测将不会被调整大小。
返回
列表[torch.Tensor]
一个长度为batch_size
的列表,其中每个项是一个形状为(高度,宽度)的语义分割地图,对应于目标大小条目(如果指定了target_sizes
)。每个torch.Tensor
的每个条目对应于一个语义类别 id。
将 DetrForSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。
后处理实例分割
( outputs 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 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrForSegmentation) — 模型的原始输出。 -
threshold
(float
, 可选, 默认为 0.5) — 保留预测实例掩模的概率分数阈值。 -
mask_threshold
(float
, 可选, 默认为 0.5) — 将预测的掩模转换为二进制值时使用的阈值。 -
overlap_mask_area_threshold
(float
, 可选, 默认为 0.8) — 合并或丢弃每个二进制实例掩模中的小不连续部分的重叠掩模区域阈值。 -
target_sizes
(列表[元组]
, 可选) — 长度为(batch_size)的列表,其中每个列表项(元组[int, int]]
)对应于每个预测的请求最终大小(高度,宽度)。如果未设置,预测将不会被调整大小。 -
return_coco_annotation
(bool
, 可选) — 默认为False
。如果设置为True
,则以 COCO 运行长度编码(RLE)格式返回分割地图。
返回
列表[字典]
一个字典列表,每个图像一个字典,每个字典包含两个键:
-
segmentation
— 形状为(高度,宽度)
的张量,其中每个像素代表segment_id
或列表[列表]
的运行长度编码(RLE)的分割地图,如果 return_coco_annotation 设置为True
。如果未找到高于threshold
的掩模,则设置为None
。 -
segments_info
— 包含每个段的附加信息的字典。-
id
— 代表segment_id
的整数。 -
label_id
— 代表与segment_id
对应的标签/语义类别 id 的整数。 -
score
— 具有segment_id
的段的预测分数。
-
将 DetrForSegmentation 的输出转换为实例分割预测。仅支持 PyTorch。
后处理全景分割
( 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 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrForSegmentation) — 来自 DetrForSegmentation 的输出。 -
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]]
)对应于批次中每个预测的请求最终大小(高度、宽度)。如果未设置,预测将不会被调整大小。
返回
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
的段的预测分数。
-
将 DetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。
DetrFeatureExtractor
class transformers.DetrFeatureExtractor
( *args **kwargs )
__call__
( images **kwargs )
预处理一张图像或一批图像。
post_process_object_detection
( outputs threshold: float = 0.5 target_sizes: Union = None ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrObjectDetectionOutput
) — 模型的原始输出。 -
threshold
(float
, 可选) — 保留对象检测预测的分数阈值。 -
target_sizes
(torch.Tensor
或List[Tuple[int, int]]
, 可选) — 形状为(batch_size, 2)
的张量或包含批次中每个图像的目标大小(height, width)
的元组列表(Tuple[int, int]
)。如果未设置,预测将不会被调整大小。
返回
List[Dict]
一个字典列表,每个字典包含模型预测的批次中每个图像的分数、标签和框。
将 DetrForObjectDetection 的原始输出转换为(top_left_x, top_left_y, bottom_right_x, bottom_right_y)格式的最终边界框。仅支持 PyTorch。
post_process_semantic_segmentation
( outputs target_sizes: List = None ) → export const metadata = 'undefined';List[torch.Tensor]
参数
-
outputs
(DetrForSegmentation) — 模型的原始输出。 -
target_sizes
(List[Tuple[int, int]]
,可选) - 一个元组列表(Tuple[int, int]
),包含批处理中每个图像的目标大小(高度,宽度)。如果未设置,预测将不会被调整大小。
返回
List[torch.Tensor]
一个长度为batch_size
的列表,其中每个项目都是一个形状为(高度,宽度)的语义分割地图,对应于target_sizes
条目(如果指定了target_sizes
)。每个torch.Tensor
的条目对应于一个语义类别 id。
将 DetrForSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。
post_process_instance_segmentation
( outputs 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 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrForSegmentation) - 模型的原始输出。 -
threshold
(float
,可选,默认为 0.5) - 保留预测实例掩码的概率分数阈值。 -
mask_threshold
(float
,可选,默认为 0.5) - 在将预测的掩码转换为二进制值时使用的阈值。 -
overlap_mask_area_threshold
(float
,可选,默认为 0.8) - 合并或丢弃每个二进制实例掩码中的小断开部分的重叠掩码区域阈值。 -
target_sizes
(List[Tuple]
,可选) - 长度为(batch_size)的列表,其中每个列表项(Tuple[int, int]
)对应于每个预测的请求最终大小(高度,宽度)。如果未设置,预测将不会被调整大小。 -
return_coco_annotation
(bool
,可选) - 默认为False
。如果设置为True
,则以 COCO 运行长度编码(RLE)格式返回分割地图。
返回
List[Dict]
一个字典列表,每个图像一个字典,每个字典包含两个键:
-
segmentation
- 一个形状为(高度,宽度)的张量,其中每个像素表示segment_id
或分割地图的List[List]
运行长度编码(RLE),如果return_coco_annotation
设置为True
。如果未找到高于threshold
的掩码,则设置为None
。 -
segments_info
- 包含每个段的附加信息的字典。-
id
- 表示segment_id
的整数。 -
label_id
- 表示与segment_id
对应的标签/语义类别 id 的整数。 -
score
- 具有segment_id
的段的预测分数。
-
将 DetrForSegmentation 的输出转换为实例分割预测。仅支持 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 ) → export const metadata = 'undefined';List[Dict]
参数
-
outputs
(DetrForSegmentation) - 来自 DetrForSegmentation 的输出。 -
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]
, 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
的段的预测分数。
-
将 DetrForSegmentation 的输出转换为图像全景分割预测。仅支持 PyTorch。
DETR 特定输出
class transformers.models.detr.modeling_detr.DetrModelOutput
( last_hidden_state: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None intermediate_hidden_states: Optional = None )
参数
-
last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
) — 模型解码器最后一层的隐藏状态序列。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 元组,每层一个torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
。每层解码器的隐藏状态加上初始嵌入输出。 -
decoder_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 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 元组,每层一个torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
。每层编码器的隐藏状态加上初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 元组,每层一个torch.FloatTensor
,形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
intermediate_hidden_states
(torch.FloatTensor
,形状为(config.decoder_layers, batch_size, sequence_length, hidden_size)
,可选,当config.auxiliary_loss=True
时返回)— 中间解码器激活,即每个解码器层的输出,每个输出都经过了 layernorm。
DETR 编码器-解码器模型输出的基类。该类在 Seq2SeqModelOutput 中添加了一个属性,即一个可选的中间解码器激活堆栈,即每个解码器层的输出,每个输出都经过了 layernorm。在使用辅助解码损失训练模型时,这是有用的。
class transformers.models.detr.modeling_detr.DetrObjectDetectionOutput
( loss: Optional = None loss_dict: Optional = None logits: FloatTensor = None pred_boxes: FloatTensor = None auxiliary_outputs: Optional = None last_hidden_state: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)— 总损失,作为类预测的负对数似然(交叉熵)和边界框损失的线性组合。后者定义为 L1 损失和广义比例不变 IoU 损失的线性组合。 -
loss_dict
(Dict
,可选)— 包含各个损失的字典。用于记录日志。 -
logits
(形状为(batch_size, num_queries, num_classes + 1)
的torch.FloatTensor
)— 所有查询的分类 logits(包括无对象)。 -
pred_boxes
(形状为(batch_size, num_queries, 4)
的torch.FloatTensor
)— 所有查询的归一化框坐标,表示为(中心 _x,中心 _y,宽度,高度)。这些值在[0, 1]范围内归一化,相对于批处理中每个单独图像的大小(忽略可能的填充)。您可以使用 post_process_object_detection()来检索未归一化的边界框。 -
auxiliary_outputs
(list[Dict]
,可选)— 仅在激活辅助损失(即config.auxiliary_loss
设置为True
)并提供标签时返回。它是一个包含两个上述键(logits
和pred_boxes
)的字典列表,每个字典对应一个解码器层。 -
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选)— 模型解码器最后一层的隐藏状态序列。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。每个层的解码器的隐藏状态加上初始嵌入输出。 -
decoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选)— 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。编码器在每一层的隐藏状态加上初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
DetrForObjectDetection 的输出类型。
class transformers.models.detr.modeling_detr.DetrSegmentationOutput
( loss: Optional = None loss_dict: Optional = None logits: FloatTensor = None pred_boxes: FloatTensor = None pred_masks: FloatTensor = None auxiliary_outputs: Optional = None last_hidden_state: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None )
参数
-
loss
(torch.FloatTensor
of shape(1,)
, optional, 当提供labels
时返回) — 作为负对数似然(交叉熵)和边界框损失的线性组合的总损失。后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 -
loss_dict
(Dict
, optional) — 包含各个损失的字典。用于记录日志。 -
logits
(torch.FloatTensor
of shape(batch_size, num_queries, num_classes + 1)
) — 所有查询的分类 logits(包括无对象)。 -
pred_boxes
(torch.FloatTensor
of shape(batch_size, num_queries, 4)
) — 所有查询的归一化框坐标,表示为(中心 _x,中心 _y,宽度,高度)。这些值在[0, 1]范围内归一化,相对于批处理中每个单独图像的大小(忽略可能的填充)。您可以使用 post_process_object_detection()来检索未归一化的边界框。 -
pred_masks
(torch.FloatTensor
of shape(batch_size, num_queries, height/4, width/4)
) — 所有查询的分割掩模 logits。另请参阅 post_process_semantic_segmentation()或 post_process_instance_segmentation()post_process_panoptic_segmentation()分别评估语义、实例和全景分割掩模。 -
auxiliary_outputs
(list[Dict]
, optional) — 可选,仅在激活辅助损失(即config.auxiliary_loss
设置为True
)并提供标签时返回。它是一个包含每个解码器层的上述两个键(logits
和pred_boxes
)的字典列表。 -
last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型解码器最后一层的隐藏状态序列。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。解码器在每一层的隐藏状态加上初始嵌入输出。 -
decoder_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。编码器在每层输出的隐藏状态加上初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
DetrForSegmentation 的输出类型。
DetrModel
class transformers.DetrModel
( config: DetrConfig )
参数
config
(DetrConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
裸的 DETR 模型(由骨干和编码器-解码器 Transformer 组成),输出原始隐藏状态,没有特定的头部。
这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.detr.modeling_detr.DetrModelOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 DetrImageProcessor.
call
()。 -
pixel_mask
(形状为(batch_size, height, width)
的torch.LongTensor
,可选)— 用于避免在填充像素值上执行注意力的遮罩。遮罩值选择在[0, 1]
中:-
对于真实的像素(即
未被遮罩
), -
对于填充像素(即
被遮罩
)为 0。
什么是注意力遮罩?
-
-
decoder_attention_mask
(形状为(batch_size, num_queries)
的torch.FloatTensor
,可选)— 默认情况下不使用。可用于屏蔽对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选)— 元组包括(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选)是编码器最后一层的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递一个图像的扁平表示,而不是传递扁平特征图(骨干网络输出+投影层的输出)。 -
decoder_inputs_embeds
(形状为(batch_size, num_queries, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递一个嵌入表示,而不是用零张量初始化查询。 -
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.detr.modeling_detr.DetrModelOutput 或tuple(torch.FloatTensor)
一个 transformers.models.detr.modeling_detr.DetrModelOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或当config.return_dict=False
时)包括根据配置(DetrConfig)和输入的不同元素。
-
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
)— 模型解码器最后一层的隐藏状态序列的输出。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回)— 元组包括(每个层的嵌入输出+每个层的输出的torch.FloatTensor
)形状为(batch_size, sequence_length, hidden_size)
。解码器在每一层的输出隐藏状态加上初始嵌入输出。 -
decoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)— 元组包括(每层一个)形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)—模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)—编码器的隐藏状态元组,形状为(batch_size, sequence_length, hidden_size)
(每层一个)。每层的编码器隐藏状态加上初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)—编码器的注意力权重元组,形状为(batch_size, num_heads, sequence_length, sequence_length)
(每层一个)。用于计算自注意力头中的加权平均值的编码器的注意力 softmax 后的注意力权重。 -
intermediate_hidden_states
(形状为(config.decoder_layers, batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选,当config.auxiliary_loss=True
时返回)—中间解码器激活,即每个解码器层的输出,每个都经过一个 layernorm。
DetrModel 的前向方法覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行前处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DetrModel
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
>>> model = DetrModel.from_pretrained("facebook/detr-resnet-50")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 100, 256]
DetrForObjectDetection
class transformers.DetrForObjectDetection
( config: DetrConfig )
参数
config
(DetrConfig)—模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
DETR 模型(由骨干和编码器-解码器 Transformer 组成),顶部带有目标检测头,用于诸如 COCO 检测之类的任务。
这个模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.detr.modeling_detr.DetrObjectDetectionOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)—像素值。默认情况下,如果提供填充,则将忽略填充。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 DetrImageProcessor.
call
()。 -
pixel_mask
(形状为(batch_size, height, width)
的torch.LongTensor
,可选)—用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]
之间:-
1 表示真实像素(即
未屏蔽
), -
0 表示填充像素(即
屏蔽
)。
什么是注意力掩码?
-
-
decoder_attention_mask
(torch.FloatTensor
of shape(batch_size, num_queries)
, optional) — 默认情况下不使用。可用于屏蔽对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
, optional) — 元组由(last_hidden_state
, optional:hidden_states
, optional:attentions
)组成,last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,optional)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 可选地,您可以选择直接传递图像的扁平化特征图(骨干网络+投影层的输出),而不是传递扁平化表示。 -
decoder_inputs_embeds
(torch.FloatTensor
of shape(batch_size, num_queries, hidden_size)
, optional) — 可选地,您可以选择直接传递嵌入表示,而不是用零张量初始化查询。 -
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的attentions
。 -
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的hidden_states
。 -
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。 -
labels
(List[Dict]
of len(batch_size,)
, optional) — 用于计算二部匹配损失的标签。字典列表,每个字典至少包含以下 2 个键:'class_labels'和'boxes'(分别是批处理中图像的类别标签和边界框)。类别标签本身应该是长度为(图像中边界框数量,)
的torch.LongTensor
,而边界框应该是形状为(图像中边界框数量, 4)
的torch.FloatTensor
。
返回
transformers.models.detr.modeling_detr.DetrObjectDetectionOutput 或 tuple(torch.FloatTensor)
transformers.models.detr.modeling_detr.DetrObjectDetectionOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含各种元素,这取决于配置(DetrConfig)和输入。
-
loss
(torch.FloatTensor
of shape(1,)
, optional, returned whenlabels
are provided)) — 作为类别预测的负对数似然(交叉熵)和边界框损失的线性组合的总损失。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 -
loss_dict
(Dict
, optional) — 包含各个损失的字典。用于记录日志。 -
logits
(torch.FloatTensor
of shape(batch_size, num_queries, num_classes + 1)
) — 所有查询的分类 logits(包括无对象)。 -
pred_boxes
(torch.FloatTensor
of shape(batch_size, num_queries, 4)
) — 所有查询的归一化框坐标,表示为(中心 _x,中心 _y,宽度,高度)。这些值在[0, 1]范围内归一化,相对于批处理中每个单独图像的大小(忽略可能的填充)。您可以使用 post_process_object_detection()来检索未归一化的边界框。 -
auxiliary_outputs
(list[Dict]
, optional) — 可选,仅在激活辅助损失(即config.auxiliary_loss
设置为True
)并提供标签时返回。它是一个包含每个解码器层的上述两个键(logits
和pred_boxes
)的字典列表。 -
last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型解码器最后一层的隐藏状态序列。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 解码器的隐藏状态元组,每层一个,形状为(batch_size, sequence_length, hidden_size)
。每层解码器的隐藏状态加上初始嵌入输出。 -
decoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 解码器的注意力权重元组,每层一个,形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
cross_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 解码器的交叉注意力层的注意力权重元组,每层一个,形状为(batch_size, num_heads, sequence_length, sequence_length)
。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 编码器的隐藏状态元组,每层一个,形状为(batch_size, sequence_length, hidden_size)
。每层编码器的隐藏状态加上初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 编码器的注意力权重元组,每层一个,形状为(batch_size, num_heads, sequence_length, sequence_length)
。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
DetrForObjectDetection 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在这个函数内定义,但应该在此之后调用Module
实例,而不是在此之后调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DetrForObjectDetection
>>> import torch
>>> from PIL import Image
>>> import requests
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
>>> model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[
... 0
... ]
>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
... box = [round(i, 2) for i in box.tolist()]
... print(
... f"Detected {model.config.id2label[label.item()]} with confidence "
... f"{round(score.item(), 3)} at location {box}"
... )
Detected remote with confidence 0.998 at location [40.16, 70.81, 175.55, 117.98]
Detected remote with confidence 0.996 at location [333.24, 72.55, 368.33, 187.66]
Detected couch with confidence 0.995 at location [-0.02, 1.15, 639.73, 473.76]
Detected cat with confidence 0.999 at location [13.24, 52.05, 314.02, 470.93]
Detected cat with confidence 0.999 at location [345.4, 23.85, 640.37, 368.72]
DetrForSegmentation
class transformers.DetrForSegmentation
( config: DetrConfig )
参数
config
(DetrConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
DETR 模型(由骨干和编码器-解码器 Transformer 组成),顶部带有分割头,用于诸如 COCO 全景等任务。
此模型继承自 PreTrainedModel。查看超类文档以获取库实现的通用方法(例如下载或保存,调整输入嵌入大小,修剪头等)。
此模型还是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( pixel_values: FloatTensor pixel_mask: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.detr.modeling_detr.DetrSegmentationOutput or tuple(torch.FloatTensor)
参数
-
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 DetrImageProcessor.
call
()。 -
pixel_mask
(形状为(batch_size, height, width)
的torch.LongTensor
,可选)— 用于避免在填充像素值上执行注意力的掩码。选择的掩码值在[0, 1]
中:-
对于真实的像素(即
未被遮罩
), -
对于填充像素(即
遮罩
)的像素为 0。
什么是注意力遮罩?
-
-
decoder_attention_mask
(形状为(batch_size, num_queries)
的torch.FloatTensor
,可选)— 默认情况下不使用。可用于屏蔽对象查询。 -
encoder_outputs
(tuple(tuple(torch.FloatTensor)
,可选)— 元组包括(last_hidden_state
,可选:hidden_states
,可选:attentions
)last_hidden_state
的形状为(batch_size, sequence_length, hidden_size)
,可选是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 -
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递图像的扁平特征图(骨干+投影层的输出)而不是传递它。 -
decoder_inputs_embeds
(形状为(batch_size, num_queries, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递嵌入表示来初始化查询,而不是使用零张量。 -
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 -
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 -
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。 -
labels
(长度为(batch_size,)
的List[Dict]
,可选)— 用于计算二部匹配损失、DICE/F-1 损失和 Focal 损失的标签。字典列表,每个字典至少包含以下 3 个键:‘class_labels’、‘boxes’和‘masks’(分别是批次中图像的类标签、边界框和分割掩码)。类标签本身应该是长度为(图像中边界框的数量,)
的torch.LongTensor
,边界框是形状为(图像中边界框的数量, 4)
的torch.FloatTensor
,掩码是形状为(图像中边界框的数量, height, width)
的torch.FloatTensor
。
返回
transformers.models.detr.modeling_detr.DetrSegmentationOutput 或tuple(torch.FloatTensor)
一个 transformers.models.detr.modeling_detr.DetrSegmentationOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含各种元素,取决于配置(DetrConfig)和输入。
-
loss
(torch.FloatTensor
,形状为(1,)
,optional,当提供labels
时返回) — 总损失,作为负对数似然(交叉熵)和边界框损失的线性组合。后者被定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 -
loss_dict
(Dict
,optional) — 包含各个损失的字典。用于记录。 -
logits
(torch.FloatTensor
,形状为(batch_size, num_queries, num_classes + 1)
) — 所有查询的分类 logits(包括无对象)。 -
pred_boxes
(torch.FloatTensor
,形状为(batch_size, num_queries, 4)
) — 所有查询的归一化框坐标,表示为(中心 _x,中心 _y,宽度,高度)。这些值在[0, 1]范围内归一化,相对于批处理中每个单独图像的大小(忽略可能的填充)。您可以使用 post_process_object_detection()来检索未归一化的边界框。 -
pred_masks
(torch.FloatTensor
,形状为(batch_size, num_queries, height/4, width/4)
) — 所有查询的分割掩模 logits。另请参阅 post_process_semantic_segmentation()或 post_process_instance_segmentation()post_process_panoptic_segmentation()分别评估语义、实例和全景分割掩模。 -
auxiliary_outputs
(list[Dict]
, optional) — 当辅助损失被激活时(即config.auxiliary_loss
设置为True
)并且提供了标签时才返回。这是一个包含每个解码器层的两个上述键(logits
和pred_boxes
)的字典列表。 -
last_hidden_state
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,optional) — 模型解码器最后一层的隐藏状态序列。 -
decoder_hidden_states
(tuple(torch.FloatTensor)
,optional,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。解码器在每个层的输出的隐藏状态加上初始嵌入输出。 -
decoder_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.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。 -
encoder_last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组。编码器每一层的隐藏状态加上初始嵌入输出。 -
encoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。编码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
DetrForSegmentation 的前向方法重写了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> import io
>>> import requests
>>> from PIL import Image
>>> import torch
>>> import numpy
>>> from transformers import AutoImageProcessor, DetrForSegmentation
>>> from transformers.image_transforms import rgb_to_id
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])
>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 如何使用 Uni-app 实现视频聊天(源码,支持安卓、iOS)
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)