每日基础课

1. 生活类比 就像你开了一家小超市做日常算账： - FP16（半精度）是草稿纸：记数快、占地方小，你在上面快速做成千上万笔流水乘除法（矩阵乘法），哪怕抹掉微小的零头也不影响大局。 - FP32（单精度）是正式总账本：字体工整、位数精确，每一笔草稿算出来的总利润，最终必须精确汇总更新到总账本上，否则几分钱的误差积少成多，年底账目直接崩溃。

2. 必要公式与符号解释 在 FP16 训练中最核心的机制是 Loss Scaling（损失缩放）： $$g_{scaled} = S \times g$$ $$w_{t+1} = w_{t} - \eta \times \frac{\text{unscale}(g_{scaled})}{m}$$

• **$g$**：原始反向传播求出的梯度。在深层模型中，很多梯度极其微小（如 $10^{-6}$），FP16 最小只能表示到约 $6 \times 10^{-5}$，小梯度会直接变成 0（这叫梯度下溢）。
• **$S$**：损失放大系数（Scale Factor，如 1024 或 65536）。在前向算完 Loss 后先乘 $S$，把梯度整体往右推到 FP16 的安全显示区间。
• **$g_{scaled}$**：放大后的梯度，安全地用 FP16 进行反向传播。
• **$w_t$：保存的 FP32 权重副本（Master Weight）**。
• **$\text{unscale}(\cdot)$**：在更新权重前，把梯度除以 $S$ 还原真实大小，并检查有没有出现 `NaN` 或 `Inf`。
• **$\eta$**：学习率。

3. 它解决什么问题？没有它会怎样？ - 解决的问题：显存不够用、训练太慢。 - 没有它会怎样： - 全用 FP32：显存占用大一倍，Batch Size 被迫开得很小，GPU 的 Tensor Core（专用加速核心）完全发挥不出性能。 - 全用 纯 FP16：深层网络梯度直接下溢为 0，或者某些层数值爆炸变成 `NaN`，模型根本不收敛。

4. 在音视频与说话人日志中的实际位置 在音视频理解（如 VideoMAE、CLIP）和说话人日志（如 ECAPA-TDNN、Whisper、PyAnnote）中： - 音频梅尔频谱特征长、视频帧序列维度极大，显存瓶颈通常卡在长序列自注意力矩阵（Attention Map）和 1D/2D 卷积特征图。 - 混合精度能直接将这些中间激活值的显存砍掉近 50%，让你能把 30 秒甚至数分钟的完整音频切片直接喂进模型训练说话人重叠检测，而不用切碎。

外部资料推荐： - 想吃透数值表示与缩放原理，推荐在 Dive into Deep Learning 中先看直觉和公式，再运行章节中的代码。 - 想掌握框架标准写法，推荐在 PyTorch Tutorials 中对照官方示例掌握张量与训练写法。

实现思路： 1. 构建一个简单的说话人特征提取模块。 2. 实例化 `GradScaler`（用于 FP16 动态梯度缩放）。 3. 使用 `with torch.autocast(...)` 上下文包裹前向传播与 Loss 计算。 4. 使用 `scaler.scale(loss).backward()` 完成放大的反向传播。 5. 使用 `scaler.step(optimizer)` 先 unscale 梯度再更新权重，最后 `scaler.update()` 刷新缩放因子。

完整可运行代码：

import torch
import torch.nn as nn
import torch.optim as optim

# 1. 检测硬件支持
device = "cuda" if torch.cuda.is_available() else "cpu"
amp_dtype = torch.float16 if device == "cuda" else torch.bfloat16
print(f"当前运行设备: {device}, 使用精度类型: {amp_dtype}")

# 2. 构造一个用于音频/说话人嵌入提取的轻量模型
class AudioSpeakerEncoder(nn.Module):
    def __init__(self, in_features=80, embed_dim=128, num_classes=10):
        super().__init__()
        # Conv1d 提取时序特征 (Batch, Channel, Time)
        self.conv = nn.Conv1d(in_channels=in_features, out_channels=64, kernel_size=3, padding=1)
        self.bn = nn.BatchNorm1d(64)
        self.relu = nn.ReLU()
        self.pool = nn.AdaptiveAvgPool1d(1)  # 全局时序池化
        self.fc = nn.Linear(64, embed_dim)
        self.classifier = nn.Linear(embed_dim, num_classes)

    def forward(self, x):
        feat = self.relu(self.bn(self.conv(x)))
        pooled = self.pool(feat).squeeze(-1) # (Batch, 64)
        embed = self.fc(pooled)              # 说话人嵌入向量
        logits = self.classifier(embed)      # 分类 logits
        return logits, embed

model = AudioSpeakerEncoder().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.AdamW(model.parameters(), lr=1e-3)

# 3. 初始化混合精度的 GradScaler（如果在 CPU 上测试 bfloat16，scaler 会自动 pass）
scaler = torch.amp.GradScaler(device, enabled=(device == "cuda"))

# 4. 模拟输入数据: (Batch=8, Mel=80, Time=200)
batch_size = 8
fake_mel_specs = torch.randn(batch_size, 80, 200, device=device)
fake_speaker_labels = torch.randint(0, 10, (batch_size,), device=device)

# 5. 标准混合精度训练循环单步演示
model.train()
optimizer.zero_grad()

# 【核心步骤 A】用 autocast 包裹前向计算与损失计算
with torch.amp.autocast(device_type=device, dtype=amp_dtype):
    logits, embed = model(fake_mel_specs)
    loss = criterion(logits, fake_speaker_labels)

print(f"--> 前向输出 logits 内部计算精度: {logits.dtype}")
print(f"--> Loss 数值: {loss.item():.4f}")

# 【核心步骤 B】使用 scaler 缩放 loss 并反向传播
scaler.scale(loss).backward()

# 【核心步骤 C】如果需要做梯度裁剪，必须先显式 unscale
scaler.unscale_(optimizer)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# 【核心步骤 D】scaler.step 负责内部 unscale、跳过 inf/nan 并更新权重
scaler.step(optimizer)

# 【核心步骤 E】根据本次步长梯度是否溢出，更新下一个 step 的 scale factor
scaler.update()

print("--> 混合精度训练单步迭代成功完成！")