第12章 视觉Transformer¶

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

class PatchEmbedding(nn.Module):  # 继承nn.Module定义网络层
    """将图像分割为patches并投影到嵌入空间

    用Conv2d实现，等价于：切patch → 展平 → 线性投影
    但Conv2d利用了GPU并行计算，效率更高
    """
    def __init__(self, img_size=224, patch_size=16, in_channels=3, embed_dim=768):
        super().__init__()  # super()调用父类方法
        self.img_size = img_size
        self.patch_size = patch_size
        self.n_patches = (img_size // patch_size) ** 2  # 196 for 224/16

        # Conv2d with kernel_size=stride=patch_size 等价于切patch+线性投影
        self.proj = nn.Conv2d(
            in_channels, embed_dim,
            kernel_size=patch_size, stride=patch_size
        )

    def forward(self, x):
        # x: (B, C, H, W) e.g. (B, 3, 224, 224)
        x = self.proj(x)        # (B, embed_dim, H/P, W/P) e.g. (B, 768, 14, 14)
        x = x.flatten(2)        # (B, embed_dim, N) e.g. (B, 768, 196)
        x = x.transpose(1, 2)   # (B, N, embed_dim) e.g. (B, 196, 768)
        return x

# 可学习的1D位置编码
# +1是因为还有一个CLS token
pos_embed = nn.Parameter(torch.zeros(1, n_patches + 1, embed_dim))
nn.init.trunc_normal_(pos_embed, std=0.02)

# 方案1: CLS Token（ViT原始）
cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
output = transformer_output[:, 0]  # 取CLS位置

# 方案2: Global Average Pooling（很多变体采用）
output = transformer_output[:, 1:].mean(dim=1)  # 对所有patch取平均

class MultiHeadSelfAttention(nn.Module):
    """多头自注意力机制

    实现要点:
    1. QKV投影用一个线性层高效计算
    2. 缩放因子 sqrt(d_k) 防止softmax梯度消失
    3. 支持attention dropout
    """
    def __init__(self, embed_dim=768, num_heads=12, attn_drop=0., proj_drop=0.):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = embed_dim // num_heads
        self.scale = self.head_dim ** -0.5  # 1/sqrt(d_k)

        # 一个线性层同时计算Q, K, V（效率更高）
        self.qkv = nn.Linear(embed_dim, embed_dim * 3)
        self.attn_drop = nn.Dropout(attn_drop)
        self.proj = nn.Linear(embed_dim, embed_dim)
        self.proj_drop = nn.Dropout(proj_drop)

    def forward(self, x):
        B, N, C = x.shape

        # QKV投影并reshape为多头格式
        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim)  # 重塑张量形状
        # permute将QKV维度提到最前面，unbind(0)沿第0维拆分为3个张量，避免3次独立线性层节省计算
        qkv = qkv.permute(2, 0, 3, 1, 4)  # (3, B, heads, N, head_dim)
        q, k, v = qkv.unbind(0)  # 各 (B, heads, N, head_dim)

        # Scaled Dot-Product Attention
        attn = (q @ k.transpose(-2, -1)) * self.scale  # (B, heads, N, N)
        attn = attn.softmax(dim=-1)
        attn = self.attn_drop(attn)

        # 加权求和并重组
        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
        x = self.proj(x)
        x = self.proj_drop(x)
        return x

class MLP(nn.Module):
    """前馈神经网络（FFN）"""
    def __init__(self, embed_dim=768, mlp_ratio=4.0, drop=0.):
        super().__init__()
        hidden_dim = int(embed_dim * mlp_ratio)
        self.fc1 = nn.Linear(embed_dim, hidden_dim)
        self.act = nn.GELU()
        self.fc2 = nn.Linear(hidden_dim, embed_dim)
        self.drop = nn.Dropout(drop)

    def forward(self, x):
        x = self.fc1(x)
        x = self.act(x)
        x = self.drop(x)
        x = self.fc2(x)
        x = self.drop(x)
        return x

class TransformerBlock(nn.Module):
    """Pre-Norm Transformer Block"""
    def __init__(self, embed_dim=768, num_heads=12, mlp_ratio=4.0,
                 drop=0., attn_drop=0.):
        super().__init__()
        self.norm1 = nn.LayerNorm(embed_dim)
        self.attn = MultiHeadSelfAttention(embed_dim, num_heads, attn_drop, drop)
        self.norm2 = nn.LayerNorm(embed_dim)
        self.mlp = MLP(embed_dim, mlp_ratio, drop)

    def forward(self, x):
        x = x + self.attn(self.norm1(x))   # 残差连接
        x = x + self.mlp(self.norm2(x))    # 残差连接
        return x

class VisionTransformer(nn.Module):
    """完整的Vision Transformer实现

    ViT-Base:  embed_dim=768,  depth=12, num_heads=12  (86M params)
    ViT-Large: embed_dim=1024, depth=24, num_heads=16  (307M params)
    ViT-Huge:  embed_dim=1280, depth=32, num_heads=16  (632M params)
    """
    def __init__(self, img_size=224, patch_size=16, in_channels=3, num_classes=1000,
                 embed_dim=768, depth=12, num_heads=12, mlp_ratio=4.0,
                 drop_rate=0., attn_drop_rate=0.):
        super().__init__()
        self.num_classes = num_classes
        self.embed_dim = embed_dim

        # 1. Patch Embedding
        self.patch_embed = PatchEmbedding(img_size, patch_size, in_channels, embed_dim)
        num_patches = self.patch_embed.n_patches

        # 2. CLS Token
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))

        # 3. Position Embedding (可学习的1D)
        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim))
        self.pos_drop = nn.Dropout(drop_rate)

        # 4. Transformer Encoder
        self.blocks = nn.Sequential(*[
            TransformerBlock(embed_dim, num_heads, mlp_ratio, drop_rate, attn_drop_rate)
            for _ in range(depth)
        ])

        # 5. Classification Head
        self.norm = nn.LayerNorm(embed_dim)
        self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity()

        # 参数初始化
        self._init_weights()

    def _init_weights(self):
        nn.init.trunc_normal_(self.pos_embed, std=0.02)
        nn.init.trunc_normal_(self.cls_token, std=0.02)
        self.apply(self._init_module_weights)

    def _init_module_weights(self, m):
        if isinstance(m, nn.Linear):  # isinstance检查类型
            nn.init.trunc_normal_(m.weight, std=0.02)
            if m.bias is not None:
                nn.init.zeros_(m.bias)
        elif isinstance(m, nn.LayerNorm):
            nn.init.ones_(m.weight)
            nn.init.zeros_(m.bias)

    def forward(self, x):
        B = x.shape[0]

        # Step 1: Patch Embedding → (B, N, D)
        x = self.patch_embed(x)

        # Step 2: Prepend CLS Token → (B, N+1, D)
        cls_tokens = self.cls_token.expand(B, -1, -1)
        x = torch.cat([cls_tokens, x], dim=1)  # torch.cat沿已有维度拼接张量

        # Step 3: Add Position Embedding
        x = x + self.pos_embed
        x = self.pos_drop(x)

        # Step 4: Transformer Encoder
        x = self.blocks(x)

        # Step 5: Classification
        x = self.norm(x)
        cls_output = x[:, 0]  # 取CLS token输出
        logits = self.head(cls_output)
        return logits

# ViT模型变体配置
def vit_base_patch16_224(**kwargs):  # *args接收任意位置参数，**kwargs接收任意关键字参数
    return VisionTransformer(
        patch_size=16, embed_dim=768, depth=12, num_heads=12, **kwargs)

def vit_large_patch16_224(**kwargs):
    return VisionTransformer(
        patch_size=16, embed_dim=1024, depth=24, num_heads=16, **kwargs)

def vit_huge_patch14_224(**kwargs):
    return VisionTransformer(
        patch_size=14, embed_dim=1280, depth=32, num_heads=16, **kwargs)

class WindowAttention(nn.Module):
    """Swin Transformer的窗口注意力（含相对位置偏置）"""
    def __init__(self, dim, window_size, num_heads):
        super().__init__()
        self.dim = dim
        self.window_size = window_size  # (Wh, Ww)
        self.num_heads = num_heads
        head_dim = dim // num_heads
        self.scale = head_dim ** -0.5

        self.qkv = nn.Linear(dim, dim * 3)
        self.proj = nn.Linear(dim, dim)

        # 相对位置偏置表
        # (2*Wh-1) * (2*Ww-1) 个可能的相对位置
        self.relative_position_bias_table = nn.Parameter(
            torch.zeros((2*window_size[0]-1) * (2*window_size[1]-1), num_heads)
        )
        nn.init.trunc_normal_(self.relative_position_bias_table, std=0.02)

        # 计算每个token对的相对位置索引
        coords_h = torch.arange(window_size[0])
        coords_w = torch.arange(window_size[1])
        coords = torch.stack(torch.meshgrid([coords_h, coords_w], indexing='ij'))  # (2, Wh, Ww)  # torch.stack沿新维度拼接张量
        coords_flatten = torch.flatten(coords, 1)  # (2, Wh*Ww)

        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # (2, N, N)
        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # (N, N, 2)
        relative_coords[:, :, 0] += window_size[0] - 1
        relative_coords[:, :, 1] += window_size[1] - 1
        relative_coords[:, :, 0] *= 2 * window_size[1] - 1
        relative_position_index = relative_coords.sum(-1)  # (N, N)
        self.register_buffer("relative_position_index", relative_position_index)

    def forward(self, x, mask=None):
        B_, N, C = x.shape  # B_为窗口总数
        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads)
        qkv = qkv.permute(2, 0, 3, 1, 4)
        q, k, v = qkv.unbind(0)

        attn = (q @ k.transpose(-2, -1)) * self.scale

        # 添加相对位置偏置
        # 用index从偏置表查找→view(N,N,heads)→permute为(heads,N,N)→unsqueeze(0)加batch维以广播加到注意力分数上
        relative_position_bias = self.relative_position_bias_table[
            self.relative_position_index.view(-1)
        ].view(N, N, -1).permute(2, 0, 1).contiguous()
        attn = attn + relative_position_bias.unsqueeze(0)  # unsqueeze增加一个维度

        # 移位窗口的mask
        if mask is not None:
            nW = mask.shape[0]
            attn = attn.view(B_ // nW, nW, self.num_heads, N, N)
            attn = attn + mask.unsqueeze(1).unsqueeze(0)  # 被mask位置设为-inf
            attn = attn.view(-1, self.num_heads, N, N)

        attn = attn.softmax(dim=-1)
        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
        x = self.proj(x)
        return x

def window_partition(x, window_size):
    """将feature map划分为窗口"""
    B, H, W, C = x.shape
    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
    return windows  # (num_windows*B, window_size, window_size, C)

def window_reverse(windows, window_size, H, W):
    """将窗口还原为feature map"""
    B = int(windows.shape[0] / (H * W / window_size / window_size))
    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
    return x

import torch
from transformers import ViTForImageClassification, ViTImageProcessor
from PIL import Image

# 加载预训练模型和处理器
model_name = 'google/vit-base-patch16-224'
model = ViTForImageClassification.from_pretrained(model_name)
processor = ViTImageProcessor.from_pretrained(model_name)

model.eval()  # eval()评估模式

# 推理
image = Image.open('image.jpg').convert('RGB')
inputs = processor(images=image, return_tensors="pt")

with torch.no_grad():  # 禁用梯度计算，节省内存
    outputs = model(**inputs)
    logits = outputs.logits
    predicted_class_idx = logits.argmax(-1).item()  # 将单元素张量转为Python数值
    predicted_class = model.config.id2label[predicted_class_idx]
    confidence = torch.softmax(logits, dim=-1).max().item()

print(f"预测类别: {predicted_class}, 置信度: {confidence:.4f}")

import timm
import torch
from PIL import Image
from timm.data import resolve_data_config, create_transform

# timm提供了几乎所有主流ViT变体
model = timm.create_model('vit_base_patch16_224.augreg_in21k_ft_in1k', pretrained=True)
model.eval()

# 自动获取模型对应的数据预处理
config = resolve_data_config(model.pretrained_cfg)
transform = create_transform(**config)

image = Image.open('image.jpg').convert('RGB')
input_tensor = transform(image).unsqueeze(0)

with torch.no_grad():
    output = model(input_tensor)
    probabilities = torch.softmax(output, dim=-1)
    top5_prob, top5_idx = probabilities.topk(5)

for i in range(5):
    print(f"Top-{i+1}: class={top5_idx[0][i].item()}, prob={top5_prob[0][i].item():.4f}")

# 列出所有可用的ViT模型
vit_models = timm.list_models('vit_*', pretrained=True)
print(f"可用ViT模型数量: {len(vit_models)}")

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
import timm

# 加载预训练ViT并修改分类头
model = timm.create_model('vit_base_patch16_224', pretrained=True, num_classes=10)

# 冻结backbone，只训练分类头（适合小数据集）
for name, param in model.named_parameters():
    if 'head' not in name:
        param.requires_grad = False

# 或者：全模型微调（适合中等数据集），使用较小学习率
optimizer = torch.optim.AdamW([
    {'params': model.head.parameters(), 'lr': 1e-3},           # 分类头大学习率
    {'params': [p for n, p in model.named_parameters()
                if 'head' not in n and p.requires_grad], 'lr': 1e-5}  # backbone小学习率
], weight_decay=0.05)

scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)

# 训练循环
def train_one_epoch(model, dataloader, optimizer, criterion, device):
    model.train()
    total_loss, correct, total = 0, 0, 0
    for images, labels in dataloader:
        images, labels = images.to(device), labels.to(device)  # 移至GPU/CPU

        outputs = model(images)
        loss = criterion(outputs, labels)

        optimizer.zero_grad()  # 清零梯度
        loss.backward()  # 反向传播计算梯度
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        optimizer.step()  # 更新参数

        total_loss += loss.item()
        correct += (outputs.argmax(1) == labels).sum().item()
        total += labels.size(0)

    return total_loss / len(dataloader), correct / total

pos_embed_2d = pos_embed[:, 1:].reshape(1, 14, 14, D).permute(0, 3, 1, 2)
pos_embed_2d = F.interpolate(pos_embed_2d, size=(24, 24), mode='bicubic', align_corners=False)  # F.xxx PyTorch函数式API
new_pos_embed = torch.cat([pos_embed[:, :1], pos_embed_2d.flatten(2).transpose(1, 2)], dim=1)