混合视觉 Transformer (ViT Hybrid)

此模型仅处于维护模式，我们不接受任何更改其代码的新 PR。如果您在运行此模型时遇到任何问题，请重新安装支持此模型的最后一个版本：v4.40.2。您可以通过运行以下命令来执行此操作：pip install -U transformers==4.40.2。

概述

混合视觉 Transformer (ViT) 模型在 An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale 中提出，作者是 Alexey Dosovitskiy、Lucas Beyer、Alexander Kolesnikov、Dirk Weissenborn、Xiaohua Zhai、Thomas Unterthiner、Mostafa Dehghani、Matthias Minderer、Georg Heigold、Sylvain Gelly、Jakob Uszkoreit、Neil Houlsby。这是第一篇成功在 ImageNet 上训练 Transformer 编码器的论文，与熟悉的卷积架构相比，获得了非常好的结果。ViT hybrid 是普通 Vision Transformer的一个轻微变体，它利用卷积骨干网络（特别是 BiT），其特征被用作 Transformer 的初始“tokens”。

论文的摘要如下：

虽然 Transformer 架构已成为自然语言处理任务的事实标准，但其在计算机视觉中的应用仍然有限。在视觉领域，注意力要么与卷积网络结合应用，要么用于替换卷积网络的某些组件，同时保持其整体结构不变。我们表明，对 CNN 的这种依赖不是必要的，直接应用于图像块序列的纯 Transformer 可以在图像分类任务中表现良好。当在大量数据上进行预训练并转移到多个中小型图像识别基准（ImageNet、CIFAR-100、VTAB 等）时，Vision Transformer (ViT) 与最先进的卷积网络相比获得了出色的结果，同时训练所需的计算资源也大大减少。

此模型由 nielsr 贡献。原始代码（用 JAX 编写）可以在这里找到。

使用缩放点积注意力 (SDPA)

PyTorch 包括一个原生的缩放点积注意力 (SDPA) 运算符，作为 torch.nn.functional 的一部分。此函数包含多个实现，可以根据输入和正在使用的硬件应用。有关更多信息，请参阅官方文档或GPU 推理页面。

当实现可用时，torch>=2.1.1 默认使用 SDPA，但您也可以在 from_pretrained() 中设置 attn_implementation="sdpa" 以显式请求使用 SDPA。

from transformers import ViTHybridForImageClassification
model = ViTHybridForImageClassification.from_pretrained("google/vit-hybrid-base-bit-384", attn_implementation="sdpa", torch_dtype=torch.float16)
...

为了获得最佳加速，我们建议以半精度（例如 torch.float16 或 torch.bfloat16）加载模型。

在本地基准测试（A100-40GB，PyTorch 2.3.0，OS Ubuntu 22.04）中使用 float32 和 google/vit-hybrid-base-bit-384 模型，我们在推理期间看到了以下加速。

批次大小	平均推理时间 (ms)，eager 模式	平均推理时间 (ms)，sdpa 模型	加速，Sdpa / Eager (x)
1	29	18	1.61
2	26	18	1.44
4	25	18	1.39
8	34	24	1.42

资源

官方 Hugging Face 和社区（🌎 表示）资源列表，可帮助您开始使用 ViT Hybrid。

图像分类

ViTHybridForImageClassification 由此示例脚本和笔记本支持。
另请参阅：图像分类任务指南

如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审核！理想情况下，资源应展示一些新的内容，而不是重复现有资源。

ViTHybridConfig

class transformers.ViTHybridConfig

< source >

( backbone_config = None backbone = None use_pretrained_backbone = False use_timm_backbone = False backbone_kwargs = None 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 = 1 num_channels = 3 backbone_featmap_shape = [1, 1024, 24, 24] qkv_bias = True **kwargs )

参数

backbone_config (Union[Dict[str, Any], PretrainedConfig], 可选) — 骨干网络的配置，可以是字典形式，也可以是骨干网络的配置对象。
backbone (str, 可选) — 当 backbone_config 为 None 时，要使用的骨干网络的名称。如果 use_pretrained_backbone 为 True，这将从 timm 或 transformers 库加载相应的预训练权重。如果 use_pretrained_backbone 为 False，这将加载骨干网络的配置并使用它来初始化具有随机权重的骨干网络。
use_pretrained_backbone (bool, 可选, 默认为 False) — 是否对骨干网络使用预训练权重。
use_timm_backbone (bool, 可选, 默认为 False) — 是否从 timm 库加载 backbone。如果为 False，则从 transformers 库加载 backbone。
backbone_kwargs (dict, 可选) — 从检查点加载时要传递给 AutoBackbone 的关键字参数，例如 {'out_indices': (0, 1, 2, 3)}。如果设置了 backbone_config，则不能指定此参数。
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) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
image_size (int, 可选, 默认为 224) — 每张图片的大小（分辨率）。
patch_size (int, 可选, 默认为 1) — 每个 patch 的大小（分辨率）。
num_channels (int, 可选, 默认为 3) — 输入通道数。
backbone_featmap_shape (List[int], 可选, 默认为 [1, 1024, 24, 24]) — 仅用于 hybrid 嵌入类型。backbone 的特征图的形状。
qkv_bias (bool, 可选, 默认为 True) — 是否向 queries, keys 和 values 添加偏置。

这是用于存储 ViTHybridModel 配置的配置类。它用于根据指定的参数实例化 ViT Hybrid 模型，定义模型架构。使用默认值实例化配置将产生与 ViT Hybrid google/vit-hybrid-base-bit-384 架构类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。

示例

>>> from transformers import ViTHybridConfig, ViTHybridModel

>>> # Initializing a ViT Hybrid vit-hybrid-base-bit-384 style configuration
>>> configuration = ViTHybridConfig()

>>> # Initializing a model (with random weights) from the vit-hybrid-base-bit-384 style configuration
>>> model = ViTHybridModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

ViTHybridImageProcessor

class transformers.ViTHybridImageProcessor

< source >

( do_resize: bool = True size: typing.Dict[str, int] = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: typing.Dict[str, int] = None do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = 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], 可选, 默认为 IMAGENET_STANDARD_MEAN) — 如果标准化图像，要使用的均值。这是一个浮点数或浮点数列表，其长度是图像中通道的数量。可以被 preprocess 方法中的 image_mean 参数重写。
image_std (float 或 List[float], 可选, 默认为 IMAGENET_STANDARD_STD) — 如果标准化图像，要使用的标准差。这是一个浮点数或浮点数列表，其长度是图像中通道的数量。可以被 preprocess 方法中的 image_std 参数重写。可以被 preprocess 方法中的 image_std 参数重写。
do_convert_rgb (bool, 可选, 默认为 True) — 是否将图像转换为 RGB 格式。

构造 ViT Hybrid 图像处理器。

preprocess

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: bool = None size: typing.Dict[str, int] = 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: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_convert_rgb: bool = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: typing.Optional[transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None **kwargs )

参数

images (ImageInput) — 要预处理的图像。期望是像素值范围从 0 到 255 的单张或批量图像。如果传入的图像像素值在 0 到 1 之间，请设置 do_rescale=False。
do_resize (bool, optional, defaults to self.do_resize) — 是否调整图像大小。
size (Dict[str, int], optional, defaults to self.size) — 调整大小后图像的尺寸。图像的最短边将调整为 size[“shortest_edge”]，最长边将调整为保持输入宽高比。
resample (int, optional, defaults to self.resample) — 如果调整图像大小，则使用的重采样过滤器。这可以是枚举 PILImageResampling 之一。仅当 do_resize 设置为 True 时才有效。
do_center_crop (bool, optional, defaults to self.do_center_crop) — 是否对图像进行中心裁剪。
crop_size (Dict[str, int], optional, defaults to self.crop_size) — 中心裁剪的尺寸。仅当 do_center_crop 设置为 True 时才有效。
do_rescale (bool, optional, defaults to self.do_rescale) — 是否对图像重新缩放。
rescale_factor (float, optional, defaults to self.rescale_factor) — 如果 do_rescale 设置为 True，则通过此重新缩放因子来重新缩放图像。
do_normalize (bool, optional, defaults to self.do_normalize) — 是否对图像进行归一化。
image_mean (float 或 List[float], optional, defaults to self.image_mean) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时才有效。
image_std (float 或 List[float], optional, defaults to self.image_std) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时才有效。
do_convert_rgb (bool, optional, defaults to self.do_convert_rgb) — 是否将图像转换为 RGB 格式。
return_tensors (str 或 TensorType, optional) — 返回的张量类型。可以是以下之一：
- Unset: 返回 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 to ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
- ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
- ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
- Unset: 默认为输入图像的通道维度格式。
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)。

预处理单张图像或批量图像。

ViTHybridModel

class transformers.ViTHybridModel

< source >

( config: ViTHybridConfig add_pooling_layer: bool = True use_mask_token: bool = False )

参数

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

裸 ViT Hybrid 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的 head。此模型是 PyTorch torch.nn.Module 子类。可以将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。

forward

< source >

( pixel_values: typing.Optional[torch.Tensor] = None bool_masked_pos: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

pixel_values (形状为 (batch_size, num_channels, height, width) 的 torch.FloatTensor) — 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 ViTHybridImageProcessor.call()。
head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.FloatTensor, optional) — 用于置空自注意力模块中选定 head 的掩码。掩码值在 [0, 1] 中选择：
- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
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)，optional) — 布尔掩码位置。指示哪些patch被掩码 (1) 以及哪些没有被掩码 (0)。

返回值

transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (ViTHybridConfig) 和输入。

last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 序列的第一个token（分类token）的最后一层隐藏状态，在通过用于辅助预训练任务的层进行进一步处理之后。例如，对于 BERT 系列模型，这返回通过线性层和 tanh 激活函数处理后的分类token。线性层权重是通过预训练期间的下一句预测（分类）目标训练的。
hidden_states (tuple(torch.FloatTensor)，optional，当传递了 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型具有嵌入层，则为嵌入层的输出 + 每层的输出各一个），形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor)，optional，当传递了 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

ViTHybridModel 的 forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但应该在此之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例

>>> from transformers import AutoImageProcessor, ViTHybridModel
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-hybrid-base-bit-384")
>>> model = ViTHybridModel.from_pretrained("google/vit-hybrid-base-bit-384")

>>> 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, 197, 768]

ViTHybridForImageClassification

class transformers.ViTHybridForImageClassification

< source >

( config: ViTHybridConfig )

参数

config (ViTHybridConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。

ViT Hybrid 模型转换器，顶部带有一个图像分类头（[CLS] token 的最终隐藏状态之上的线性层），例如用于 ImageNet。

此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< source >

( pixel_values: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获得。参见 ViTHybridImageProcessor.call() 了解详情。
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (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 而不是一个普通的元组。
labels (torch.LongTensor，形状为 (batch_size,)，optional) — 用于计算图像分类/回归损失的标签。索引应在 [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 时)，包含各种元素，具体取决于配置 (ViTHybridConfig) 和输入。

loss (torch.FloatTensor，形状为 (1,)，optional，当提供了 labels 时返回) — 分类（或回归，如果 config.num_labels==1）损失。
logits (torch.FloatTensor，形状为 (batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）得分（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor)，optional，当传递了 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型具有嵌入层，则为嵌入层的输出 + 每个阶段的输出各一个），形状为 (batch_size, sequence_length, hidden_size)。模型在每个阶段输出处的隐藏状态（也称为特征图）。
attentions (tuple(torch.FloatTensor)，optional，当传递了 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, patch_size, sequence_length)。

注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

ViTHybridForImageClassification 的 forward 方法，覆盖了 __call__ 特殊方法。

示例

>>> from transformers import AutoImageProcessor, ViTHybridForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-hybrid-base-bit-384")
>>> model = ViTHybridForImageClassification.from_pretrained("google/vit-hybrid-base-bit-384")

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

< > 在 GitHub 上更新