ai学术篇 1.模型训练加速

前言

本文主要介绍模型训练所涉及的基础知识,以及在此基础上如何提高训练效率、加速模型训练。

姑且将 AI 系列后续内容分为以下 4 个部分:

  1. 学术篇: LLM 基础知识、模型训练、各类算法的原理与实现等。
  2. 开发篇: Agent 框架、各类 AI 应用的开发等。
  3. 运维篇: Agent 应用的部署、推理参数测试等。
  4. 杂项: AI 渗透、视频生成、音频生成、超分辨率等其他内容。

本来打算等 SMT 训练完成后再写这篇文章,但今天开始训练时,又学到了不少与训练效率相关的知识。为了梳理今天学到的内容,索性一边整理,一边把它们写成博客。

本篇快写完了,先做个总结。

总体来说,训练效率优化主要分为两步:首先优化代码执行效率,减少不必要的计算开销;然后在不超出硬件承载能力的前提下,尽可能提高 Batch Size,充分利用显存和计算资源,从而提升整体训练速度。

不过,调整 Batch Size 不只是性能优化,也可能改变训练行为,进而影响梯度更新、收敛过程和最终结果。因此,在复现他人的源码时,如果目标是尽可能保持原有训练行为,就应优先优化代码执行效率,而不是随意修改 Batch Size 等训练参数。(因此,这次复现只需优化代码执行效率,保持原有训练参数不变,直接部署到服务器训练即可,之前纠结于调整 Batch Size 加速训练其实没有必要。)


1. 基础知识

1.1 GPU 利用率(GPU Utilization)

GPU 利用率主要衡量 GPU 在一段时间内处于活动状态的时间比例。

例如,nvidia-smi 中的 utilization.gpu 表示在最近一个采样周期内,GPU 有多少时间在干活(即至少有一个任务正在执行)。

1.2 显存占用率(Memory Usage)

显存占用率衡量的是显存资源的使用情况,可以通过以下指标计算:

1
memory.used / memory.total

其中,memory.used 表示已使用的显存,memory.total 表示总显存。

在每个 batch 执行相同训练操作的前提下,可以将显存占用率简化理解为:一个 batch 完整训练所需的显存资源与 GPU 总显存的比例。

实际显存占用还可能包含 CUDA 上下文、缓存分配器预留的显存等额外开销。

1.3 资源利用率

计算资源主要指 GPU 内部负责执行运算的硬件单元,例如 SM(流式多处理器)及其中的 CUDA Core、Tensor Core 等。

可以将这些计算单元比作工厂里的工位:计算资源利用率反映的是这些硬件单元在执行任务时的实际繁忙程度。 如果部分计算单元没有得到充分利用,就意味着 GPU 仍有潜在的计算能力未被发挥出来。

怎么判断:

  • 一般先看功耗:power.draw / power.limit。 用 nvidia-smi 的 power.draw 除以该卡功耗上限(power.limit),近似反映计算单元被铺满的程度。这个方式方便快捷,日常一般就看它——功耗高说明计算单元在满负荷运转,功耗低说明大量计算单元闲着。
  • 要精确看吞吐:steps/s 或 samples/s。 这是最准确的依据,但 nvidia-smi 看不到,需要在训练代码里自己计时统计(如每个 step 记录时间戳,算每秒处理的 batch 数或样本数)。吞吐随 batch 增大而上涨,涨到不再涨,说明计算资源已吃满。

 

 

2. 训练计算流程原理

训练过程中,同一个 Batch 内的样本并行计算,而不同 Batch 的训练步骤通常按顺序执行。

  • batch 内部: 并行计算。一个 Batch 中的样本一起输入 GPU,由多个计算单元并行处理。若计算任务超过硬件的即时处理能力,就会分批执行。
  • batch 之间: 依次执行。 标准训练流程中,通常需要完成当前 Batch 的前向传播、反向传播和参数更新,才能开始下一个 Batch 的训练。

为什么 batch 之间必须串行: 下一个 batch 的计算要用更新后的权重,而权重更新要等上一个 batch 的梯度算完。后一步依赖前一步的结果,无法同时进行。

显存里同一时刻只有一个 batch 的中间结果,所以显存是复用的:上一个 batch 的中间结果(各层激活值等)在反向传播算完梯度后不再需要,会被释放或覆盖,下一个 batch 的前向再从这块空间重新分配。因此显存占用不随 batch 数量累积增长,而是稳定在一个 batch 所需的峰值附近。

3. 资源利用耗时计算原理

前提

假设数据无限供应、显存无限,且每个样本处理时间相同,因此同样大小的 batch 处理时间相同。

在这个前提下,GPU 能做到不空等、一直在连续跑;采样时间内 GPU 一直有 batch 可处理,利用率达到 100%,此时采样时间内能处理的 batch 数量达到最大值 M。

实际中每个 batch 的处理速度并不完全相同,所以利用率 100% 时采样时间内的 batch 数量对应的指标其实是吞吐(steps/s 或 samples/s),需要在训练代码里自己计时统计,nvidia-smi 看不到。这里分析的是加速训练的因素,因此设定每个 batch 处理速度相同。


理想模型:一个样本作为一块

有 b 个计算单元,并行处理 b 个样本(资源 100% 利用),所需时间 t。

  1. 没吃满阶段(样本数 ≤ b): batch 加大,处理时间不变,仍为 t,吞吐随 batch 线性上涨。
  2. 吃满之后(样本数 > b): 处理时间 = ⌈样本数 / b⌉ × t。例如 b+1 个样本需要 2t,因为多出的 1 个样本要等下一轮计算单元空出来才能处理。

补充:这里隐含"每个样本正好占用 1 个计算单元、且耗时相同"的假设。若样本耗时不同,波次会出现"短板效应"——同一波里最慢的样本决定该波结束时间,部分计算单元会空转等待。


现实模型:一个样本被切成多个小块

一个样本会被切成多个小块。用 N 表示计算单元数(并行处理 N 个小块),s 表示一波(并行算一次小块)的时间,一个样本被切成 n 个小块。

  1. 一个 batch 的总块数 ≤ N: 一波算完,耗时 s。
  2. 总块数 > N: 耗时 = ⌈总块数 / N⌉ × s。

多加 1 个样本举例: 假设总块数刚好占满所有计算单元(正好排满整数波),此时多加 1 个样本,总块数增加 n,多出约 ⌈n / N⌉ 波的时间,每波只有 s。因为 s 远小于整个 batch 的耗时,所以增量很小,不会像理想模型那样直接变成 2t,曲线看起来是斜坡。


对比

  • 理想模型: 多 1 个样本,可能多整整一轮,t 变 2t(阶梯状跳变)。
  • 现实模型: 多 1 个样本,只多几个小波,耗时略增(近似斜坡)。

补充:两个模型的差异本质是并行粒度不同。

理想模型把样本当作不可分割的最小调度单位,资源利用率在"未满"与"满"之间突变;

现实模型把样本拆成小块,调度单位更细,能填满计算单元的空隙,因此耗时随 batch 增长更平滑。

实际 GPU 训练介于两者之间:粒度比"整样本"细,但受 kernel 启动开销、同步屏障、尾部效应(最后不足一波的部分)影响,斜坡上仍会有小台阶,不会完全平滑。

 

 

4. GPU 利用率、显存占用率、资源利用率三者关系举例

工厂(GPU)来了一批订单(batch),订单里每个产品提供了一份原材料(样本),材料先存进仓库(显存);100 名工人(计算单元,如 SM、CUDA Core)从仓库领材料干活,把每个产品做出来。

  • 工厂 = GPU
  • 一批订单 = 一个 batch
  • 订单里的每个产品原材料 = 一个样本
  • 仓库 = 显存
  • 100 名工人 = 计算单元(SM、CUDA Core)

三个指标分别看什么

指标 工厂里的对应 看的是
GPU 利用率 工厂有多少时间在开工(哪怕只开一个工位) 时间
显存占用率 仓库被占了多少 空间
资源利用率 多少工位真正在干活 计算单元

举例

情况 A:活太少,工位大量闲置

工厂接到一批订单,但订单里只有 2 个产品,而工厂有 100 个工位。

  • GPU 利用率:很高(接近 100%)。因为工厂确实在开工,采样那一刻有工人在干活。(假设采样时间约等于做一个产品所需的时间,这里只有 2 个产品、2 个工人同时开工,整个采样窗口内工人一直在干活。)
  • 资源利用率:很低(2/100 = 2%)。只有 2 个工位在干活,98 个闲着。
  • 显存占用率:很低。订单少,仓库里只放了 2 份材料。

这说明:利用率高 ≠ 算力吃满。工厂开着门、有人在干活,但绝大多数工位是空的。

 

 

情况 B:活很多,但仓库爆了

订单里塞了 10000 个产品,仓库装不下,直接 OOM 报错(爆仓)。

  • 显存占用率:超过容量上限,OOM。

这说明:显存是硬约束。batch 再大、算力再足,仓库装不下就做不下去,此时该考虑混合精度、梯度检查点等省显存手段。

 

 

情况 C:工位和仓库都够,但原料送不上来(多 batch 情形)

工位 100 个、仓库也空着,但送订单的卡车(CPU 准备数据)太慢,工人干完一单(batch)就得等下一单到达才能干活。

  • GPU 利用率:忽高忽低、经常掉到 0(工人在等原料)。(假设干完一单后,要等同样长的时间才能开始下一单,而采样窗口覆盖"这一单开始到下一单开始"这一段,则利用率为 50%。)
  • 资源利用率:忙的时候高,闲的时候低。
  • 显存占用率:不高(仓库没堆满)。

这说明:瓶颈在数据供应(输入侧),不在算力和显存。

 

 

情况 D:工位和仓库都满,活也源源不断

  • GPU 利用率:稳定 90% 以上。
  • 资源利用率:高(工位铺满)。
  • 显存占用率:高但没爆。

这才是真正满负荷的理想状态。

5. GPU 利用率低的原因与解决办法

GPU 利用率没满,最常见的原因是输入侧(CPU 侧)跟不上:在采样时间内,GPU 在等 CPU 处理的事情多。CPU 侧常见的有三种情况:数据准备跟不上、kernel 提交慢、同步操作打断流水线。

GPU 利用率没满,多数情况下(尤其是单机单卡、中小模型)主因在 CPU 侧:数据准备跟不上、kernel 提交慢、同步操作打断流水线。因此排查时应优先从 CPU 侧入手。

但大模型、多卡、长序列等场景下,多卡通信、显存带宽、GPU 内部依赖也可能成为主因,CPU 侧不再是唯一重点。

5.1 数据准备跟不上

现象: GPU 在等 CPU 提供数据。典型信号是 utilization.gpu 忽高忽低、经常掉到 0,而 power.draw 也不高。

解决办法:异步准备数据。 用后台线程/进程提前把 batch 准备好、放进队列,让训练函数直接从队列取到 GPU 上计算,而不是临时现准备。

PyTorch 中对应 DataLoader 的 num_workers > 0(多进程预取)、pin_memory=True(锁页内存加速 H2D 拷贝)、prefetch_factor 控制预取批数。

若 num_workers=0,数据加载和训练串行,GPU 必然周期性空等。

5.2 小模型中 kernel 多且每个 kernel 计算量不大

现象: 有数据可算,但 CPU 提交 kernel 的速度跟不上 GPU 执行的速度,GPU 算完一个 kernel 后要等下一个指令。

kernel 是 GPU 上执行计算的最底层的任务单位。CPU 提交一个 kernel,GPU 执行一个 kernel。

  • 模型里每个操作对应一个或几个 kernel。
  • 每个 kernel 的计算量由参数规模、batch、序列长度共同决定。
  • CPU 提交完一个 kernel 后,立即开始准备下一个,不等 GPU 算完。

GPU 空等的情况: 若 CPU 提交一个 kernel 需要 20 微秒,而 GPU 执行它只需 5 微秒,那么 GPU 算完后要再等 15 微秒才能拿到下一个 kernel。这 15 微秒 GPU 处于空闲,会被计入未利用的时间,拉低 GPU 利用率。

解决方法:

  • 加大 batch。 让每一步 GPU 计算所需时间增加,从而摊薄 CPU 提交开销。这是提高资源利用率最直接的手段,但它会改变训练行为。
  • torch.compile(算子融合)。 把多个小操作合并成一个大 kernel。比如"线性层 + 偏置 + 激活"原本是 3 个 kernel,合并后只发 1 次,CPU 发指令的次数直接减少。

note1:

算子融合除了减少 CPU 提交次数,还能减少 kernel 间的显存读写往返(中间结果不落显存),往往同时提升速度和降低显存占用。类似的还有手写融合算子、使用 torch.jit.script 等。

note2:

加大 batch 主要会影响以下训练行为:

  1. 每个 epoch 的更新步数变少:数据量不变,batch 乘 k,步数除以 k。同样 epoch 数下,总共更新的次数少了。
  2. 梯度噪声变小:每步梯度更准,但小 batch 的噪声有时有助于跳出尖锐极小值,所以 batch 过大可能泛化略差。
  3. 最优学习率变了:步数少了、梯度更可靠了,原来的学习率偏保守,通常需要按比例调大(如线性缩放规则)。
  4. 显存占用上升:batch 变大,每一步 forward 产生的中间计算结果(激活值)变多,所以每一份 batch 显存占用增加,可能 OOM。
  5. BatchNorm 类层的统计量变化(如果模型用了):batch 统计更稳定,行为会有细微差别。

5.3 大量同步操作

同步就是 CPU 停下来,等 GPU 把手上的活全算完,再往下走。

常见的触发点:loss.item()、print(tensor)、tensor.cpu()、.numpy()、每步都调 torch.cuda.synchronize()。其中 print(tensor) 之所以触发同步,是因为打印/格式化需要具体数值,必须把数据从 GPU 拷回 CPU。

CPU 停着等的这段时间,没法发新指令(kernel);GPU 算完后,要等 CPU 醒来,处理完触发同步的代码、然后再发下一批指令,这中间 GPU 又闲了。

完整时间线:

  1. CPU 发完一批 kernel,遇到同步点(如 loss.item()),CPU 停下来等 GPU 算完。
  2. GPU 把队列里的 kernel 全部算完。此时队列空了。
  3. CPU 被唤醒,拿到结果,处理完同步点后面的代码(比如 print、转成 Python 数字)。
  4. CPU 重新开始发下一批 kernel,又要经历一次 kernel 提交的开销 (准备kernel到发送给GPU的这段时间)。
  5. 在第 2 步结束到第 4 步发出新的 kernel 之间,GPU 是空的。

所以 GPU 空等的这一段,包含 CPU 被唤醒的延迟、处理同步点后代码的时间,以及准备发出 kernel 所需的时间。

日志/打印改为每 N 步一次(如 if step % 100 == 0),loss 累加用 tensor 在 GPU 上累积、最后统一取一次,避免每步 .item()。真正必须同步的场合(如验证、保存 checkpoint)尽量放在 step 边界之外。

或者只取每第N步的loss记录日志。

 

 

6. 不同场景下的调优策略

6.1 加速常用的 4 种方法

手段 提什么 风险 加速原理
异步数据提供 GPU 利用率 无 数据加载与 GPU 计算重叠,减少 GPU 等数据的时间,从而提高 GPU 利用率
更快的 attention 速度 + 显存 低 分块计算、不物化完整的"序列长度×序列长度"attention 矩阵,减少显存读写和显存占用,序列越长收益越大
混合精度 AMP 速度 + 显存 低 大部分计算降为 16 位浮点,走 Tensor Core 加速矩阵运算,同时减少显存占用,使更大 batch 成为可能
torch.compile kernel 开销 + 显存 低~中 算子融合把多个小 kernel 合成一个,减少 CPU 提交次数和 kernel 间的显存读写往返

6.2 场景一:复现已有工作(论文/原项目)

在已有源代码的基础上,不去修改batch(修改batch会改变原本的训练行为,详细看5.2的note2部分)。

我们能做的仅有优化内部代码从而加速训练

  1. 添加异步数据提供(减少GPU的数据等待时间)
  2. 添加混合精度 AMP训练
  3. 网络使用更快的 attention
  4. 判断是否适合使用torch.compile(判断标准看第7小节)

在已有源代码的基础上,不改 batch(batch 由论文或原项目定,改它可能改变训练行为,见 5.2 的note2说明),只通过优化内部代码来加速训练:

  1. 异步数据提供——减少 GPU 等数据的时间。
  2. 混合精度 AMP——加速计算、降低显存。
  3. 更快的 attention——模型有 attention 时使用。
  4. 使用 torch.compile ——判断判断是否适合的标准见第 7 节。

6.3 场景二:自己训练模型

第一步:写代码时,先把这些手段配上

不用等发现瓶颈再加,写代码时直接配好,跑起来就是"已经拉满"的起点:

  1. 异步数据提供。
  2. 混合精度 AMP:bf16 优先(通常不用 scaler);fp16 必须配 GradScaler。走 Tensor Core 加速计算、降低显存。
  3. 更快的 attention(模型有 attention 时)。
  4. torch.compile:如果模型结构固定、不会频繁修改,且符合使用要求,可以加上。

配好这些,GPU 利用率和显存占用基本就是当前代码能做到的较优状态,接下来只需调 batch。

第二步:调 batch

在计算资源和显存这两个约束下增大 batch,直到某个条件先达到 90% 左右为止;两个条件都未到 90% 时,继续加 batch。谁先到阈值就停在谁那里:

  • 计算资源先到 90%:停,再加没有明显速度收益。判断信号是功耗接近上限(power.draw / power.limit 接近 90% 左右即可,阈值本身留有余量,不必精确到顶)。
  • 显存先到 90% 左右:也停,再加有 OOM 风险。

注意:

  • 不能超出显存是强制要求。超了可能直接 OOM,也可能触发换页/卸载到主机内存等机制,大幅降低训练效率。
  • 计算资源先到顶后仍可继续加 batch,只是每个 batch 的处理时间会缓慢增加,速度收益递减。
  • 一般来说,某个值先到 90% 时,训练速度就已经接近最大值了——因为很难精确计算“在显存范围内,超出多少计算资源还能继续提高整体速度”,所以用 90% 作为“大致到位”的经验阈值即可,不必追求精确最优点。

 

 

7. 三种加速方法的实现

训练加速主要可以从三个方面入手:编译模型、优化 Attention 计算、降低计算精度。它们分别减少模型执行开销、显存读写开销和单次计算成本。

7.1 torch.compile:编译模型

作用: 减少模型运行时的调度开销,并在适当情况下融合多个算子,从而减少 GPU Kernel 启动次数和中间结果的显存读写。

PyTorch 默认采用动态图执行方式,模型中的运算通常由 Python 逐步调度。torch.compile 会对模型进行编译,生成经过优化的执行代码。

实现: 在模型初始化后添加一行代码。

1
2
3
4
5
6
7
# 初始化模型
self.rnn = RNN().cuda()
self.teacher = Teacher().cuda()

# 编译模型
self.rnn = torch.compile(self.rnn)
self.teacher = torch.compile(self.teacher)

主要优化方式:

  • 算子融合: 将多个可以融合的运算合并执行,减少中间结果的显存读写和 Kernel 启动次数。
  • 减少调度开销: 降低 Python 逐个调度运算的开销,尤其适用于包含大量细碎运算的模型。

编译通常不会改变模型的数学计算目标,但浮点运算顺序可能发生变化,因此结果不一定逐位相同。

使用时需要注意:

  1. 首次运行会产生编译开销。 编译可能耗费数十秒甚至更久,具体取决于模型和配置。短任务可能还没来得及获得加速,实验就已经结束。
  2. 输入形状变化可能触发重新编译。 例如 Batch Size 或序列长度发生变化时,可能需要生成新的编译结果。
  3. 部分代码可能无法完整编译。 动态控制流、不受支持的 Python 操作等可能导致计算图中断,降低优化效果。

编译缓存默认位于本机缓存目录,不会自动随项目迁移。更换设备、软件环境或模型代码时,可能需要重新编译或生成新的缓存。

如何判断是否值得使用?

与其从各种角度去判断,不如直接从结果上判断是否能用。简单快捷。

采用 A/B 对比:

  1. 不使用 torch.compile,运行一段时间,记录稳定后的训练速度。
  2. 使用 torch.compile,首次编译和预热阶段后,以相同条件记录稳定后的速度。
  3. 对比两者的稳态速度,判断是否有利于加速。

如果模型结构和输入形状相对固定,且训练时间较长,通常值得尝试;如果加速效果不明显,就没有必要强行使用。

Windows 中文系统的编码问题

某些 PyTorch 编译环境在 Windows 中文系统下可能出现 UnicodeDecodeError。原因可能是编译器读取内置模板文件时,使用了与文件内容不匹配的默认编码。

可以尝试启用 Python UTF-8 模式。

方法一:在代码最顶部设置,必须早于 import torch。

1
2
3
4
import os
os.environ["PYTHONUTF8"] = "1"

import torch

方法二:如果在 PyCharm 中运行,可以在运行配置的环境变量中添加:PYTHONUTF8=1

7.2 更快的 Attention:FlashAttention

作用: 优化 Transformer 中 Attention 的计算过程,减少显存读写,提高计算速度并降低显存占用。

普通 Attention 需要生成一个序列长度 × 序列长度的注意力分数矩阵,并将中间结果写入显存,再读取出来进行后续计算。序列越长,这部分计算和显存开销通常越大。

FlashAttention 通过分块计算,利用 GPU 的高速片上存储处理计算过程,避免将完整的注意力分数矩阵写入显存。

主要优势:

  • 更快: 减少中间结果的显存读写。
  • 更省显存: 不需要显式保存完整的注意力分数矩阵。
  • 计算精确: 不属于近似 Attention 算法,但浮点运算顺序不同可能导致微小数值差异。

PyTorch 中的实现

1
2
3
import torch.nn.functional as F

output = F.scaled_dot_product_attention(q, k, v)

PyTorch 会根据硬件、输入形状和数据类型等条件,自动选择合适的 Attention 实现,其中可能包括 FlashAttention 内核。

x-transformers 中的实现

如果当前版本支持 attn_flash 参数,可以在初始化 Decoder 时开启:

1
2
3
4
5
6
7
8
self.decoder = Decoder(
dim=cfg.d_model,
depth=cfg.decoder_depth,
heads=cfg.n_heads,
rotary_pos_emb=True,
use_rmsnorm=True,
attn_flash=True,
)

具体参数名称和底层实现取决于 x-transformers 的版本。开启该选项后,也不代表一定会使用 FlashAttention 内核,实际效果需要测试。

7.3 混合精度训练:降低计算精度

作用: 计算密集的算子使用 FP16 或 BF16 提高计算速度、减少显存占用;对数值精度敏感的运算则根据需要保留 FP32。

混合精度并不是将整个模型统一转换为 16 位,而是让不同运算使用合适的精度。

实现: 使用 PyTorch 的 autocast。

1
2
3
4
self.amp = torch.amp.autocast(
"cuda",
dtype=torch.bfloat16,
)

1. 混合精度的工作原理

典型情况下,各部分的精度处理如下:

  • 模型权重: 如果模型以 FP32 初始化,权重默认仍保持 FP32,不会因为进入 autocast 就永久转换成 BF16。
  • 矩阵乘、卷积等算子: 通常可以使用 BF16 执行,以利用 GPU 的低精度计算能力。
  • Softmax、LayerNorm、Loss 等运算: 根据具体算子的精度规则,部分运算会使用 FP32,以提高数值稳定性。
  • 优化器状态: 如果使用常规 FP32 模型参数和优化器配置,优化器状态通常也保持 FP32。

具体使用哪种精度由 PyTorch 的自动混合精度规则决定,并非所有敏感算子都会无条件使用 FP32。

2. 训练代码为什么这样排布?

1
2
3
4
5
6
7
8
9
10
model = Model().cuda()

for x, y in loader:
with self.amp:
out = model(x.cuda())
loss = loss_fn(out, y.cuda())

loss.backward()
optimizer.step()
optimizer.zero_grad()

(1)model = Model().cuda():初始化模型

创建模型并将其移动到 GPU。这里没有指定其他数据类型,因此模型参数默认保持 FP32。

这使得后续可以在 FP32 主参数的基础上,通过 autocast 让部分运算使用 BF16。

(2)with self.amp::开启自动混合精度

进入 autocast 上下文后,范围内的运算会根据 PyTorch 的精度规则自动选择 BF16 或 FP32。

(3)out = model(x.cuda()):前向传播

将输入数据移动到 GPU,并执行模型的前向计算。

例如,矩阵乘法可能使用 BF16 计算。此时,原本的 FP32 权重不会被永久修改;对于支持自动转换的运算,PyTorch 会在计算时使用适当的精度。

(4)loss = loss_fn(out, y.cuda()):计算 Loss

将 Loss 计算放在 with 内,是为了让它也处于自动混合精度的管理范围内。

例如,使用交叉熵损失时,PyTorch 的相应实现会根据精度规则选择合适的计算精度,部分计算可能提升到 FP32,以改善数值稳定性。

需要注意,把 Loss 放在 with 内,并不意味着它一定使用 FP32。具体精度取决于所用的 Loss 算子及其实现。如果放在外面,也不代表一定会用 BF16 计算。

(5)loss.backward():反向传播

在 with 外执行反向传播即可。反向运算会依据对应前向运算的精度规则执行,不需要再额外包一层 autocast。

(6)optimizer.step():更新模型参数

优化器根据梯度更新参数。如果模型参数保持 FP32,参数更新就作用于 FP32 权重,有助于保留较小的更新量。

 

 

3. 为什么混合精度能加速?

  • 提高计算效率: GPU 对 BF16、FP16 等低精度运算通常具有更高的计算吞吐量。
  • 减少显存读写: 16 位张量的存储空间通常只有 32 位张量的一半。
  • 保留必要的数值精度: 不强制所有运算都使用低精度,而是通过自动精度规则兼顾速度与稳定性。

其中,BF16 的数值范围接近 FP32,通常比 FP16 更不容易发生数值溢出或下溢。在支持 BF16 的 GPU 上,可以优先尝试 BF16 混合精度训练。

补充图: