🏆 ยอดนิยม: sand/article/details/ - ประเด็นร้อน

从NLP到CV：手把手教你用PyTorch实现Vision Transformer图像分类（附完整代码）

当Transformer在自然语言处理领域大放异彩时，谁曾想到它会在计算机视觉领域掀起一场革命？2020年，一篇名为《An Image is Worth 16x16 Words》的论文彻底打破了卷积神经网络（CNN）在视觉任务中的垄断地位。本文将带你深入理解Vision Transformer（ViT）的核心原理，并通过PyTorch实战演示如何在CIFAR-10数据集上实现图像分类任务。

1. Vision Transformer核心原理解析

1.1 图像分块嵌入：将像素转化为"视觉单词"

传统Transformer处理的是词序列，而ViT的创新之处在于将图像视为"视觉单词"的集合。具体实现分为三个关键步骤：

图像分块：将输入图像划分为固定大小的非重叠patch。例如，224×224的图像以16×16的patch划分，会得到196个patch（224/16 × 224/16）。
线性投影：每个patch被展平为向量后，通过可训练的线性层映射到模型维度（如768维）。这类似于NLP中的词嵌入过程。
位置编码：由于Transformer本身不具备空间感知能力，需要添加可学习的位置编码来保留patch的空间位置信息。

class PatchEmbedding(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
        super().__init__()
        self.img_size = img_size
        self.patch_size = patch_size
        self.n_patches = (img_size // patch_size) ** 2
        
        self.proj = nn.Conv2d(
            in_chans, embed_dim, 
            kernel_size=patch_size, 
            stride=patch_size
        )
    
    def forward(self, x):
        x = self.proj(x)  # (B, E, H/P, W/P)
        x = x.flatten(2)  # (B, E, N)
        x = x.transpose(1, 2)  # (B, N, E)
        return x

1.2 Transformer编码器架构

ViT仅使用Transformer的编码器部分，由交替的多头自注意力（MSA）和多层感知机（MLP）块组成：

组件	功能描述	关键参数
LayerNorm	前置归一化提升训练稳定性	eps=1e-6
MSA	捕捉patch间全局关系	heads=12
MLP	特征变换与非线性映射	ratio=4
DropPath	正则化防止过拟合	rate=0.1

class TransformerBlock(nn.Module):
    def __init__(self, dim, num_heads, mlp_ratio=4., drop_path=0.):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.attn = MultiHeadAttention(dim, num_heads)
        self.norm2 = nn.LayerNorm(dim)
        self.mlp = MLP(dim, int(dim*mlp_ratio))
        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
    
    def forward(self, x):
        x = x + self.drop_path(self.attn(self.norm1(x)))
        x = x + self.drop_path(self.mlp(self.norm2(x)))
        return x

1.3 分类头设计

ViT引入了一个特殊的[class] token，其最终状态作为整个图像的表示：

初始化为可学习的嵌入向量
与patch tokens一起输入Transformer
经过所有层后，使用第一个位置的特征进行分类

class VisionTransformer(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
        self.pos_embed = nn.Parameter(torch.zeros(1, n_patches+1, embed_dim))
        
        self.blocks = nn.Sequential(*[
            TransformerBlock(embed_dim, num_heads) 
            for _ in range(depth)
        ])
        
        self.head = nn.Linear(embed_dim, num_classes)
    
    def forward(self, x):
        B = x.shape[0]
        x = self.patch_embed(x)
        
        cls_tokens = self.cls_token.expand(B, -1, -1)
        x = torch.cat((cls_tokens, x), dim=1)
        x = x + self.pos_embed
        
        x = self.blocks(x)
        cls_token_final = x[:, 0]
        return self.head(cls_token_final)

2. CIFAR-10实战：从数据准备到模型训练

2.1 数据集处理与增强

CIFAR-10图像尺寸为32×32，远小于原始ViT设计的224×224输入。我们需要调整patch大小和模型结构：

from torchvision import transforms

train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(15),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

train_set = CIFAR10(root='./data', train=True, download=True, transform=train_transform)
test_set = CIFAR10(root='./data', train=False, download=True, transform=test_transform)

2.2 模型配置调整

针对小尺寸图像的修改策略：

Patch大小：从16×16改为4×4（32/4=8，得到64个patch）
位置编码：使用2D可学习位置编码替代原版1D编码
深度缩减：12层减少到6层以降低计算量

config = {
    'img_size': 32,
    'patch_size': 4,
    'embed_dim': 192,
    'depth': 6,
    'num_heads': 3,
    'mlp_ratio': 4,
    'num_classes': 10
}

2.3 训练技巧与超参数设置

优化策略组合：

AdamW优化器（weight decay=0.05）
余弦学习率衰减（初始lr=3e-4）
标签平滑（smoothing=0.1）
梯度裁剪（max_norm=1.0）

def train_epoch(model, loader, optimizer, criterion, device):
    model.train()
    total_loss, total_acc = 0, 0
    
    for x, y in loader:
        x, y = x.to(device), y.to(device)
        
        optimizer.zero_grad()
        logits = model(x)
        loss = criterion(logits, y)
        
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
        
        acc = (logits.argmax(dim=1) == y).float().mean()
        total_loss += loss.item() * x.size(0)
        total_acc += acc.item() * x.size(0)
    
    return total_loss / len(loader.dataset), total_acc / len(loader.dataset)

3. 关键问题解决方案与调优

3.1 小数据集训练技巧

原始ViT需要大规模数据预训练，我们在CIFAR-10上采用以下策略：

知识蒸馏：使用预训练的CNN作为教师模型
混合架构：在patch嵌入前加入轻量级CNN
数据增强：CutMix、MixUp等增强策略

class HybridViT(nn.Module):
    def __init__(self):
        super().__init__()
        self.cnn = nn.Sequential(
            nn.Conv2d(3, 64, 3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.patch_embed = PatchEmbedding(16, 8, 64, 192)
        
    def forward(self, x):
        x = self.cnn(x)  # (B, 64, 16, 16)
        x = self.patch_embed(x)
        # ... rest of ViT

3.2 注意力可视化分析

理解模型关注哪些图像区域：

def visualize_attention(model, img):
    model.eval()
    with torch.no_grad():
        feat = model.patch_embed(img.unsqueeze(0))
        cls_token = model.cls_token.expand(1, -1, -1)
        x = torch.cat([cls_token, feat], dim=1) + model.pos_embed
        
        attns = []
        for blk in model.blocks:
            x = blk.norm1(x)
            _, attn = blk.attn(x, return_attention=True)
            attns.append(attn)
            
        # Average attention across all heads and layers
        attn_map = torch.mean(torch.stack(attns), dim=0)[:, 0, 1:]  # [head, patch]
        
    return attn_map.reshape(-1, 8, 8)  # Assuming 8x8 patches

4. 完整代码实现与性能对比

4.1 模型完整架构

class ViTForCIFAR10(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.patch_embed = PatchEmbedding(
            img_size=config['img_size'],
            patch_size=config['patch_size'],
            in_chans=3,
            embed_dim=config['embed_dim']
        )
        
        self.cls_token = nn.Parameter(torch.zeros(1, 1, config['embed_dim']))
        self.pos_embed = nn.Parameter(torch.zeros(1, self.patch_embed.n_patches+1, config['embed_dim']))
        
        self.blocks = nn.Sequential(*[
            TransformerBlock(
                dim=config['embed_dim'],
                num_heads=config['num_heads'],
                mlp_ratio=config['mlp_ratio'],
                drop_path=0.1 * (i / (config['depth']-1))  # Linear drop path
            ) for i in range(config['depth'])
        ])
        
        self.norm = nn.LayerNorm(config['embed_dim'])
        self.head = nn.Linear(config['embed_dim'], config['num_classes'])
        
        nn.init.trunc_normal_(self.pos_embed, std=0.02)
        nn.init.trunc_normal_(self.cls_token, std=0.02)
    
    def forward(self, x):
        B = x.shape[0]
        x = self.patch_embed(x)
        
        cls_tokens = self.cls_token.expand(B, -1, -1)
        x = torch.cat((cls_tokens, x), dim=1)
        x = x + self.pos_embed
        
        x = self.blocks(x)
        x = self.norm(x)
        return self.head(x[:, 0])