1. ViT究竟是什么?为什么说它颠覆了计算机视觉?
如果你这两年关注过AI,尤其是图像领域,那一定听说过Vision Transformer,简称ViT。我第一次看到这个模型时,感觉非常“反直觉”。长久以来,处理图像任务,比如图像分类、目标检测,那都是卷积神经网络(CNN)的天下。CNN通过一个个卷积核在图像上滑动,来提取局部特征,这非常符合我们对图像“局部相关”的直观认知。
而Transformer呢?它最初是为自然语言处理(NLP)设计的,处理的是像句子这样的一维序列。它的核心是自注意力机制,能让序列中的每个词(token)都去关注整个序列中所有其他的词,从而捕捉长距离的依赖关系。简单说,CNN是“局部视野”,Transformer是“全局视野”。
那么,一个为文本设计的“全局视野”模型,怎么用到图像上呢?ViT的作者们想了一个非常大胆又直接的办法:把图像当成一个由“视觉词汇”组成的句子。具体怎么操作?就是把一张完整的图片,像切豆腐块一样,切成一个个固定大小的小方块,我们称之为图像块。然后,把这些图像块展平,通过一个线性变换(一个全连接层)映射成一个固定维度的向量。这个过程,就叫做Patch Embedding。现在,一张图片就变成了一个“句子”,每个图像块向量就是一个“词向量”。
这个想法听起来简单,但效果却出奇的好。当训练数据量足够大时(比如在超大规模的ImageNet-21K或JFT-300M数据集上预训练),ViT的性能可以全面超越当时最先进的CNN模型。它证明了,在计算机视觉任务中,全局的上下文建模能力可能比我们过去依赖的局部归纳偏置(比如平移不变性)更为重要。这无疑是对传统CNN范式的一次巨大冲击,也开启了视觉大模型的新时代。
所以,ViT的核心思想可以概括为:抛弃卷积,将图像视为序列,用纯Transformer架构来处理视觉信息。接下来,我们就一步步拆解,看看这个“图像句子”到底是怎么被Transformer“阅读”和“理解”的。
2. 庖丁解牛:ViT的核心组件与实现细节
理解了ViT的宏观思想,我们深入到代码层面,看看每一个核心组件是如何实现的。我会以一个经典的PyTorch实现为例,结合代码和图示,让你彻底搞懂。
2.1 图像分块与嵌入:从像素到“视觉词汇”
这是ViT的第一步,也是最关键的一步。我们得把一张规整的图片,变成Transformer能吃的“序列大餐”。
假设我们有一张256x256像素的RGB图片。我们设定每个图像块的大小为32x32。那么,整张图就会被切成 (256/32) * (256/32) = 8 * 8 = 64 个图像块。每个图像块是 32 * 32 * 3 = 3072 个像素值(3是RGB通道)。
在代码里,这个过程通常用一个高效的张量重排操作(比如 einops.rearrange)和一个线性层来完成:
import torch
import torch.nn as nn
from einops import rearrange
class PatchEmbedding(nn.Module):
def __init__(self, img_size=256, patch_size=32, in_channels=3, embed_dim=1024):
super().__init__()
self.img_size = img_size
self.patch_size = patch_size
self.num_patches = (img_size // patch_size) ** 2
# 关键操作:将图像重排并投影
self.projection = nn.Sequential(
# 将 (b, c, h, w) 重排为 (b, num_patches, patch_dim)
# 其中 patch_dim = patch_size * patch_size * in_channels
nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size),
)
def forward(self, x):
# x 形状: [batch_size, channels, height, width]
x = self.projection(x) # 输出形状: [batch_size, embed_dim, num_patches_h, num_patches_w]
x = x.flatten(2) # 展平后两维: [batch_size, embed_dim, num_patches]
x = x.transpose(1, 2) # 调整维度: [batch_size, num_patches, embed_dim]
return x
这里我用了 nn.Conv2d 来实现,它的 kernel_size 和 stride 都等于 patch_size,效果等同于先切块再做线性投影,但计算上更高效。最终,我们得到了一个形状为 [batch_size, 64, 1024] 的张量。这64个1024维的向量,就是我们图像的“句子”。
2.2 可学习的[CLS]标记与位置编码
在NLP的BERT模型中,我们会在句子开头加一个特殊的 [CLS] 标记,这个标记的最终输出向量被用来做分类任务。ViT借鉴了这个天才的设计。
为什么需要[CLS]标记? 我们的图像序列有64个向量,每个向量代表图像的一个局部区域。最终分类时,我们需要一个能“代表”整张图片的全局特征。让模型自己去学习一个特殊的向量([CLS] token),让它在整个Transformer层的信息交互中,聚合所有图像块的信息,最终这个向量的状态就成为了整张图像的“抽象表示”。
位置编码又是什么? Transformer本身是置换不变的,也就是说,它不关心输入序列的顺序。打乱这64个图像块的顺序,理论上Transformer的输出(不考虑[CLS])也会被打乱,但内容不变。这显然不符合图像的空间结构信息。因此,我们必须显式地告诉模型每个图像块在原始图像中的位置。ViT采用了一种可学习的位置编码,就是为序列中的每一个位置(包括[CLS])分配一个与嵌入向量同维度的向量,然后直接加到对应的嵌入向量上。
class ViT(nn.Module):
def __init__(self, num_patches=64, embed_dim=1024):
super().__init__()
# 可学习的[CLS]标记,形状为 [1, 1, embed_dim]
self.cls_token = nn.Parameter(torch.randn(1, 1, embed_dim))
# 可学习的位置编码,形状为 [1, num_patches + 1, embed_dim]
# 加1是因为要包含[CLS]标记的位置
self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, embed_dim))
self.dropout = nn.Dropout(p=0.1)
def forward(self, x):
# x 形状: [batch_size, num_patches, embed_dim]
b, n, _ = x.shape
# 扩展[CLS]标记到batch中所有样本
cls_tokens = self.cls_token.expand(b, -1, -1) # 形状: [batch_size, 1, embed_dim]
# 将[CLS]标记拼接到图像块序列的开头
x = torch.cat((cls_tokens, x), dim=1) # 形状: [batch_size, n+1, embed_dim]
# 加上位置编码
x += self.pos_embedding[:, :(n + 1)]
x = self.dropout(x)
return x
经过这一步,我们的输入序列就从 [batch_size, 64, 1024] 变成了 [batch_size, 65, 1024]。多出来的那个“词”,就是肩负着分类使命的 [CLS] 标记。
2.3 Transformer编码器:信息融合的核心引擎
准备好输入序列后,就轮到Transformer编码器大显身手了。ViT使用的编码器结构和原始Transformer几乎一模一样,由多个相同的层堆叠而成,每一层都包含两个核心子层:多头自注意力层和前馈神经网络层,并且每个子层前后都应用了残差连接和层归一化。
多头自注意力:让每个“图像块”看看别的“块”在干嘛 这是Transformer的灵魂。对于序列中的每一个向量(比如第10个图像块),自注意力机制允许它“关注”序列中所有其他向量(包括它自己),并根据相关性加权聚合这些向量的信息。而“多头”则是把注意力过程复制多份,每份使用不同的线性变换矩阵(即不同的“视角”),最后把结果拼接起来。这样可以让模型同时关注来自不同表示子空间的信息。
class MultiHeadAttention(nn.Module):
def __init__(self, embed_dim=1024, num_heads=16):
super().__init__()
self.embed_dim = embed_dim
self.num_heads = num_heads
self.head_dim = embed_dim // num_heads
assert self.head_dim * num_heads == embed_dim, "embed_dim必须能被num_heads整除"
# 将Q, K, V的投影合并到一个线性层中,提升效率
self.qkv = nn.Linear(embed_dim, embed_dim * 3)
self.proj = nn.Linear(embed_dim, embed_dim)
self.scale = self.head_dim ** -0.5 # 缩放因子,防止点积过大导致softmax梯度消失
def forward(self, x):
B, N, C = x.shape
# 生成Q, K, V
qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
q, k, v = qkv[0], qkv[1], qkv[2] # 每个形状: [B, num_heads, N, head_dim]
# 计算注意力分数: Q * K^T / sqrt(d_k)
attn = (q @ k.transpose(-2, -1)) * self.scale
attn = attn.softmax(dim=-1) # 在最后一个维度(序列维度)做softmax
# 加权求和: Attention * V
x = (attn @ v).transpose(1, 2).reshape(B, N, C)
# 最后的投影层
x = self.proj(x)
return x
前馈神经网络与残差连接 注意力层之后是一个简单的两层MLP,通常中间有一个扩展因子(比如4倍),并配合GELU激活函数。它的作用是对每个位置的特征进行非线性变换和增强。
class FeedForward(nn.Module):
def __init__(self, embed_dim=1024, mlp_dim=2048, dropout=0.1):
super().__init__()
self.net = nn.Sequential(
nn.Linear(embed_dim, mlp_dim),
nn.GELU(),
nn.Dropout(dropout),
nn.Linear(mlp_dim, embed_dim),
nn.Dropout(dropout)
)
def forward(self, x):
return self.net(x)
最关键的是残差连接和层归一化。它们被包裹在注意力层和前馈层外面,构成了一个 Pre-Norm 的结构(即先做层归一化,再进入子层)。这是稳定深层Transformer训练的关键技巧。
class TransformerEncoderLayer(nn.Module):
def __init__(self, embed_dim, num_heads, mlp_dim, dropout=0.1):
super().__init__()
self.norm1 = nn.LayerNorm(embed_dim)
self.attn = MultiHeadAttention(embed_dim, num_heads)
self.norm2 = nn.LayerNorm(embed_dim)
self.ff = FeedForward(embed_dim, mlp_dim, dropout)
def forward(self, x):
# 注意力子层 + 残差
x = x + self.attn(self.norm1(x))
# 前馈子层 + 残差
x = x + self.ff(self.norm2(x))
return x
多个这样的编码器层堆叠起来(比如12层、24层),就构成了ViT的主干。信息在这些层中反复交互、融合,最终,序列第一个位置(即 [CLS] 标记)的向量,已经包含了来自全局上下文的丰富信息。
2.4 分类头:从特征到预测
经过L层Transformer编码器的处理,我们取输出序列的第一个向量,也就是 [CLS] 标记对应的向量。这个 [batch_size, 1, embed_dim] 的向量,就是模型对整张图片的“理解”。
分类头通常非常简单,就是一个层归一化加上一个线性分类器。
class ClassificationHead(nn.Module):
def __init__(self, embed_dim, num_classes):
super().__init__()
self.norm = nn.LayerNorm(embed_dim)
self.linear = nn.Linear(embed_dim, num_classes)
def forward(self, x):
# x 是Transformer编码器的输出,形状: [batch_size, seq_len, embed_dim]
# 我们只取[CLS]标记对应的特征
cls_token = x[:, 0] # 形状: [batch_size, embed_dim]
x = self.norm(cls_token)
x = self.linear(x)
return x
至此,一张图片从像素输入,到最终的类别预测,就完成了ViT的完整前向传播过程。
3. 动手实践:用PyTorch搭建一个可运行的ViT
理论讲得再多,不如亲手跑一遍代码来得实在。下面,我将带你一步步搭建一个简化版的ViT,并在一个小的数据集(比如CIFAR-10)上试试效果。这会让你对数据流和维度变化有最直观的感受。
3.1 环境准备与数据加载
首先,确保你的环境安装了PyTorch和Torchvision。我们使用CIFAR-10数据集,因为它图片小(32x32),训练快,适合演示。
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
# 定义数据预处理和增强
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
# 加载数据集
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=2)
3.2 组装我们的ViT模型
我们将前面章节定义的各个模块组合起来。注意,CIFAR-10图片是32x32,为了演示,我们设置图像块大小为4x4,这样会得到 (32/4)*(32/4)=64 个图像块,和之前256x256图片切32x32块得到的数量一样,但每个块的信息量少了很多。
class SimpleViT(nn.Module):
def __init__(self, img_size=32, patch_size=4, in_channels=3, num_classes=10,
embed_dim=256, depth=6, num_heads=8, mlp_ratio=4., dropout=0.1):
super().__init__()
self.num_patches = (img_size // patch_size) ** 2
patch_dim = in_channels * patch_size * patch_size
# 1. Patch Embedding
self.patch_embed = nn.Sequential(
nn.Conv2d(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size),
nn.Flatten(2), # 保持batch和embed_dim维度,展平空间维度
nn.LayerNorm(embed_dim), # 可选,有些实现会在这里加LN
)
# 2. [CLS] Token 和 Position Embedding
self.cls_token = nn.Parameter(torch.randn(1, 1, embed_dim))
self.pos_embed = nn.Parameter(torch.randn(1, self.num_patches + 1, embed_dim))
self.pos_dropout = nn.Dropout(dropout)
# 3. Transformer Encoder Layers
self.encoder_layers = nn.ModuleList([
TransformerEncoderLayer(embed_dim, num_heads, int(embed_dim * mlp_ratio), dropout)
for _ in range(depth)
])
self.norm = nn.LayerNorm(embed_dim)
# 4. Classification Head
self.head = nn.Linear(embed_dim, num_classes)
# 初始化权重
self._init_weights()
def _init_weights(self):
# 简单初始化,实际生产环境会用更复杂的初始化如 trunc_normal_
nn.init.normal_(self.cls_token, std=0.02)
nn.init.normal_(self.pos_embed, std=0.02)
for layer in self.encoder_layers:
nn.init.xavier_uniform_(layer.attn.qkv.weight)
nn.init.xavier_uniform_(layer.attn.proj.weight)
nn.init.xavier_uniform_(layer.ff.net[0].weight)
nn.init.xavier_uniform_(layer.ff.net[3].weight)
def forward(self, x):
B = x.shape[0]
# Patch Embedding
x = self.patch_embed(x) # 输出: [B, embed_dim, num_patches]
x = x.transpose(1, 2) # 转为: [B, num_patches, embed_dim]
# 添加[CLS] Token
cls_tokens = self.cls_token.expand(B, -1, -1)
x = torch.cat((cls_tokens, x), dim=1)
# 添加位置编码
x = x + self.pos_embed
x = self.pos_dropout(x)
# 通过Transformer编码器
for layer in self.encoder_layers:
x = layer(x)
# 取[CLS] Token的特征并归一化
x = self.norm(x[:, 0])
# 分类头
logits = self.head(x)
return logits
3.3 训练与评估循环
模型搭好了,接下来就是标准的训练流程。由于ViT在小数据集上容易过拟合,我们设置一个适中的学习率,并加上权重衰减。
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SimpleViT(img_size=32, patch_size=4, embed_dim=256, depth=6, num_heads=8).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.05)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=20)
def train_one_epoch(epoch):
model.train()
running_loss = 0.0
correct = 0
total = 0
for batch_idx, (inputs, targets) in enumerate(train_loader):
inputs, targets = inputs.to(device), targets.to(device)
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
running_loss += loss.item()
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
train_acc = 100. * correct / total
print(f'Epoch: {epoch}, Loss: {running_loss/(batch_idx+1):.3f}, Train Acc: {train_acc:.2f}%')
return train_acc
def evaluate():
model.eval()
correct = 0
total = 0
with torch.no_grad():
for inputs, targets in test_loader:
inputs, targets = inputs.to(device), targets.to(device)
outputs = model(inputs)
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
test_acc = 100. * correct / total
print(f'Test Acc: {test_acc:.2f}%')
return test_acc
# 简单训练几个Epoch看看
for epoch in range(20):
train_acc = train_one_epoch(epoch)
if epoch % 5 == 0:
test_acc = evaluate()
scheduler.step()
运行这段代码,你就能亲眼看到ViT是如何在图像分类任务上工作的。虽然在小规模CIFAR-10上,这个简单ViT的性能可能不如精心设计的CNN,但整个流程清晰地展示了其工作原理。你可以尝试调整 patch_size、embed_dim、depth 等超参数,观察它们对模型性能和速度的影响,这是理解模型最有效的方式。
4. ViT的变体、优化与实战经验
原始的ViT模型虽然强大,但也存在一些明显的痛点,比如计算量大(序列长度是图像块数量的平方级关系)、需要海量数据预训练、对超参数(如图像块大小)敏感等。因此,社区涌现出了许多优秀的变体和优化技巧。
4.1 主流变体模型简介
-
DeiT:用蒸馏弥补数据不足 这是我最喜欢的一个变体。ViT需要JFT-300M这样级别的私有数据集才能训好,这让很多人望而却步。DeiT的核心思想是知识蒸馏。它不再依赖海量无标签数据,而是用一个在ImageNet上训练好的大型CNN(如RegNet)作为“教师模型”,来指导一个ViT“学生模型”在ImageNet上训练。学生模型不仅学习真实的标签,还学习教师模型的“软标签”(输出概率分布),从而获得更强的泛化能力。DeiT证明了,通过适当的训练策略,ViT完全可以在ImageNet级别的公开数据集上取得SOTA效果。
-
Swin Transformer:引入局部性与层次化设计 Swin Transformer可以看作是CNN思想与Transformer的优雅结合。它提出了两个关键创新:
- 滑动窗口注意力:将自注意力计算限制在一个个不重叠的局部窗口内,大大降低了计算复杂度(从序列长度的平方降到窗口大小的平方)。窗口之间通过“移动窗口”的机制进行信息交互。
- 层次化特征图:像CNN一样,通过Patch Merging操作,随着网络加深,逐渐合并相邻的图像块,形成类似金字塔的多尺度特征表示。这使得Swin Transformer非常适合作为密集预测任务(如目标检测、语义分割)的通用骨干网络,并在这些任务上取得了统治性的成绩。
-
PVT与PVTv2:金字塔视觉Transformer 这是另一个为下游密集任务设计的变体。它同样构建了特征金字塔,但采用了空间缩减注意力来降低计算成本。在Key和Value的计算前,先对特征图进行下采样,减少了参与注意力计算的序列长度,从而在保持全局感受野的同时提升了效率。
4.2 关键优化技巧与调参心得
在实际项目中应用ViT及其变体,我踩过不少坑,也总结了一些经验。
1. 学习率与优化器
ViT对优化策略非常敏感。AdamW 优化器几乎是标配,因为它能很好地处理权重衰减。学习率方面,余弦退火或带热重启的余弦退火是常见选择。初始学习率不宜过大,对于ImageNet规模的训练,1e-3 到 5e-4 是个不错的起点。别忘了使用梯度裁剪,防止训练初期的不稳定。
2. 数据增强与正则化 强大的数据增强是ViT系列模型成功的关键。RandAugment、MixUp、CutMix 这些“重型”增强手段能显著提升模型鲁棒性,防止过拟合。在训练DeiT时,作者甚至用到了随机擦除和重复增强。此外,DropPath(也叫随机深度)对于训练深层Transformer至关重要,它随机在训练时“跳过”一些网络层,起到了模型集成的正则化效果。
3. 位置编码的选择 原始ViT使用可学习的位置编码。但实践中,我发现对于分辨率固定的任务(比如ImageNet的224x224),可学习的和固定的正弦余弦编码效果相差不大。但是,如果你的任务需要处理可变分辨率的图像(比如测试时输入尺寸与训练时不同),那么可学习的位置编码就会有问题,因为训练好的位置编码长度是固定的。这时,可以考虑使用相对位置编码或二维正弦编码,它们能更好地泛化到不同分辨率。
4. 图像块大小的影响
patch_size 是一个非常重要的超参数。较小的patch(如14x14或16x16)能保留更多细节信息,但会显著增加序列长度,导致计算量和内存消耗剧增。较大的patch(如32x32)计算效率高,但可能会丢失细粒度特征。通常需要在速度和精度之间做权衡。对于ImageNet分类,16x16是主流选择。
提示:在资源有限的情况下,如果你想快速实验ViT,可以从较小的模型配置开始,比如
embed_dim=384,depth=12,num_heads=6,并配合较强的数据增强。使用混合精度训练能有效节省显存并加速。
4.3 从分类到下游任务:如何利用预训练ViT
如今,我们很少从头开始训练一个ViT。更常见的做法是,在大型数据集(如ImageNet-21K)上预训练一个ViT模型,然后将其作为特征提取器,迁移到你的特定下游任务上,比如目标检测、语义分割、图像描述生成等。
微调策略:
- 整体微调:这是最直接的方法。加载预训练权重,替换掉最后的分类头,用你任务的数据集和损失函数对整个模型进行微调。适用于数据量相对充足的下游任务。
- 部分微调:只微调Transformer编码器的最后几层,或者只微调新添加的任务特定层(如检测头、分割头),而冻结大部分骨干网络的参数。这在数据量较少时非常有效,能防止过拟合。
- 线性探测:这是一种极端的迁移方式,完全冻结预训练好的ViT骨干,只训练一个简单的线性分类器(或回归器)。这可以用来评估预训练模型提取的特征质量。
以目标检测为例,你可以将Swin Transformer或PVT作为Faster R-CNN或Mask R-CNN的骨干网络,其输出的多尺度特征图可以直接送入区域提议网络和检测头。在语义分割中,ViT的序列输出可以通过一个解码器(如U-Net式的结构)上采样,恢复为像素级的预测图。
ViT及其变体已经成为了视觉基础模型的基石。理解它的核心算法和实现细节,不仅能让你用好这些现成的强大模型,更能为你设计新的视觉架构提供坚实的理论基础和灵感来源。
554



被折叠的 条评论
为什么被折叠?



