Skip to content

训练显存全景优化:检查点重计算、卸载与通信重叠

构建大模型训练显存全景账本,精解全量与选择性重计算、CPU/NVMe 卸载及通信计算异步重叠技术。

当前:讲解模式 — 侧重直觉建立、生活类比与分步拆解快捷键 M 切换
概念定义 · 什么是训练显存优化(激活重计算 / Offload / 通信重叠)?

训练大模型时,最先撑爆 GPU 显存的往往不是模型参数本身,而是前向传播时为了给反向传播求导而必须暂存的海量中间激活值(Activations)。

显存优化技术 就是用工程巧思在有限显存里塞下更大模型和更长序列:激活重计算(Checkpointing) 用“多算一点时间”换“少存 80% 激活显存”;Offload 把暂时不用的优化器状态挪去 CPU 内存;通信计算重叠(Overlap) 则让网卡传数据的同时 GPU 照常算下一层,把等待时间藏到零。

01 问题从何而来:权重已经切干净了,怎么还是 OOM? ​

很多工程师第一次在大集群上训 70B 大模型时都会遭遇一件怪事:明明已经开了 64 卡 ZeRO-3 / FSDP,每张卡的静态权重、梯度和 优化器 状态加起来还不到 18 GB,手里握着整整 80 GB 显存的 H100,怎么一跑 8192 长序列训练,第一步就爆了 CUDA Out of Memory?

罪魁祸首叫动态激活值(Activations)!在 反向传播 求梯度时,链式法则要求记住前向传播经过每一层时的中间结果。层数越深(80 层)、文章越长(8K–128K)、批次越大,这堆草稿纸就呈线性甚至平方级疯长——70B 模型不加治理时,单卡激活显存轻轻松松就能冲破 100 GB,瞬间把显卡压垮!

类比 · 画家寸土寸金的工作台

把 GPU 的 80 GB 高带宽显存(HBM)想象成一位大师面前寸土寸金的画桌:桌上既要摆颜料盒与参考画册(静态参数与优化器状态),又要摊开作画每一步留下的几十张草稿纸(动态激活值),回头改画时得对照着看。

桌面彻底铺满怎么办?画家有三套绝技:

  1. 梯度检查点(Checkpointing):只留最关键的几页大纲草稿,中间细节全撕掉腾桌子,回头要改画时照着大纲现场重新速写出来——用一点点额外时间换出大片桌面!
  2. 异构卸载(Offload):把暂时不翻的厚重参考画册搬到旁边的书架(CPU 内存甚至 NVMe 硬盘)上,要用前提前让助手抱回桌上;
  3. 异步重叠(Overlap):右手正在给第 10 层上色,左手同时让助手去书架取第 11 层的颜料、顺便把刚干透的第 9 层草稿搬走——让画笔一刻不停,把搬运耗时彻底藏在幕后!
核心设问

全量重计算虽然能把激活显存砍掉 90%,却要白白多花 33% 的额外算力——有没有办法只花 4% 的算力,就省下 70% 的激活显存?单机显存实在装不下时怎么借 CPU 内存不卡顿?万卡集群里又如何用多条流把通信、拷贝与计算严丝合缝地叠在一起?

02 核心直觉与生活类比:选择性重计算、借用书架与三轨并发 ​

现代大模型训练系统能在一张 80GB 显卡上把算力利用率(MFU)压榨到 50%+,靠的是这三件环环相扣的利器。

类比 · 选择性重计算:只丢掉“占地极大、重画却只要一秒”的草稿!

经典的全量梯度检查点(Chen et al., 2016 ↗)有点一刀切:它把每一层 Transformer 里面所有中间张量全扔掉,反向时整层重新算一遍。可一整层里 95% 以上的计算量全花在几块巨型矩阵乘法(GEMM)上,重算一次前向就多交了整整 1/3 的电费!

Megatron-SP & Selective Recomputation (2023) ↗ 拿放大镜把单层算子按“显存/算力性价比”排了个队,发现了一个惊天秘密:

  • 注意力 Softmax、Dropout、LayerNorm、SwiGLU 门控激活这些算子,算起来快如闪电(加起来占总 FLOPs 不到 4%),却贪婪地吃掉了整整 70% 的激活显存!
  • 选择性重计算于是极其精明:昂贵的巨型矩阵乘输入死守不丢,绝不重算;只把这几个“大肚量、小算力”的轻量算子中间结果扔掉,反向时瞬间重算(事实上 FlashAttention ↗ 天生就是把 O(S2) 注意力矩阵选择性重算融合进了片上 SRAM)!最终只多花 2%–8% 算力,就切掉了绝大部分激活显存。
类比 · ZeRO-Offload 与三轨重叠:让 CPU 管厚账本,让三条传送带同时转起来

对于卡数有限、想在单机 8 卡上微调 70B 大模型的团队,ZeRO-Offload (2021) ↗ 看到了一个完美的硬件互补:

  • GPU 算力恐怖,但显存金贵(80 GB);
  • 主机 CPU 算力弱,但插满 DDR5 内存轻松上 TB 级,而且 AdamW 优化器 的逐元素更新本来就不是算力密集型,CPU 拿多核 AVX-512 也能算得飞快!

于是把重算力的 BF16 前反向留在 GPU,把肥硕的 12Ψ 优化器状态整块卸载到 CPU 内存(甚至在 ZeRO-Infinity (2021) ↗ 里进一步卸载到 NVMe SSD 阵列)。

而为了让 GPU 不干等网络或 PCIe 拷贝,现代框架会在显卡里同时拉起三条独立 CUDA 流水轨道:

  1. Compute Stream:Tensor Core 专心狂算当前层矩阵乘;
  2. Comm Stream:网卡悄悄在后台预取下一层 FSDP 权重、同时把上一层算完的梯度做 Reduce-Scatter;
  3. Copy Stream:DMA 引擎借着 CPU 锁页内存(Pinned Memory),悄悄把检查点激活异步搬进搬出!

03 把关键公式读成人话 ​

先看单卡在 混合精度 + FlashAttention + TP/SP 下的激活显存账本:

Mact无重算≈34Lsbht→逐层全量检查点Mact全检查点≈2Lsbht

把激活缩放公式读成直觉:L 是层数、s 是序列长度、b 是微批次大小、h 是隐藏维度、t 是张量并行度。没有重计算时,每一层要缓存高达 34sbh 字节的中间草稿;开启逐层全量检查点后,每层只留 1 份 BF16 输入激活(2sbh 字节),激活显存直接暴降 17 倍!代价是总 FLOPs 从原本的 6Ψ(1 次前向 2Ψ + 1 次反向 4Ψ)涨到 8Ψ,恰好多了 26=33.3% 的算力。

再看衡量大集群训练真实效率的终极指标 MFU(Model FLOPs Utilization) 与重叠公式:

MFU≈6Ψ⋅Tokens/secNGPU⋅PeakFLOPs,Tstepoverlap≈max(Tcomp,Tcomm)

**把 MFU 与重叠公式读成直觉:**MFU 告诉你花了大价钱租来的 GPU,到底有百分之几的理论算力真正用在了给模型学知识上(工业界优秀水平在 45%–60%)。串行跑时一步耗时是“算的时间 + 传的时间”;通过多 Stream 异步重叠后,只要通信时间不超过计算时间,总耗时只取决于两者中较大的那个,通信开销在账面上就彻底“隐身”了!

04 它在模型里怎么工作 & 与上下游的关系 ​

显存与通信优化是把所有分布式维度拧成一股绳的“系统总调度师”:

  • 兜底静态并行之外的动态显存:ZeRO / FSDP 搞定了 16Ψ 静态显存,SP / CP 把激活按并行度切分,而当序列冲向百万级(见 长上下文建模)或 流水线并行 积压多份在途微批次时,仍必须靠检查点重计算与激活卸载守住 80 GB 红线。
  • 与推理及微调技术彼此呼应:在消费级显卡上做 LoRA 微调 时,虽然主干权重冻结省掉了优化器状态,但训练长对话仍必须开启 gradient_checkpointing 压住激活;而在底层算子上,永远无条件开启 FlashAttention 既是加速神器,也是免费消除 O(S2) 激活的自带重计算。

05 演化对比与避坑备忘 ​

优化手段瞄准哪块显存省显存幅度速度/算力代价一句话建议
FlashAttention注意力 O(S2) 矩阵彻底消除平方级项反而提速 2–4×无条件永远开启
选择性重计算Norm / SwiGLU 等轻量激活省 60%–75% 激活仅 +2%–8% 算力追求极限 MFU 的首选
全量重计算整层所有中间激活省 85%–95% 激活+33% 额外算力长上下文或显存爆红时救命
Activation Offload检查点激活搬去 CPU近似清空检查点 HBM重叠好时仅 +0%–5%超长序列(128K+)深层模型
ZeRO-Offload优化器状态 (12Ψ)省 75% 静态显存大 Batch 下可控单机/小集群微调 30B–70B

最后记住三个最常让工程师深夜排查的显存与性能暗坑:

  1. PyTorch 检查点一定要写 use_reentrant=False,且不必“全开或全关”:旧版默认可重入模式和 FSDP、torch.compile 冲突不断;另外,如果显存只差 10 GB 就爆了,完全没必要给全部 80 层都开全检查点白白掉速 33%——只需给前 20 层开检查点、后 60 层正常算,就能把显存严丝合缝贴在 76 GB 榨出最高 MFU。
  2. 显存只用了 65 GB / 80 GB 却报 OOM?多半是碎片,别乱调 empty_cache():变长序列容易把显存池切得支离破碎,拼不出一块连续大内存。千万别在训练循环里疯狂调用 torch.cuda.empty_cache()(它会触发全卡同步和昂贵重分配,把训练拖成蜗牛);正确解法是加环境变量 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True,用虚拟内存页动态拼接碎块。
  3. CPU Offload 忘了开 pin_memory=True,重叠当场失效:普通可分页 CPU 内存无法让 GPU 的 DMA 引擎直接异步搬运,non_blocking=True 会悄悄退化成卡死主线程的同步拷贝,直接毁掉三轨并发的提速效果!

需要查阅单层逐算子字节账本、三轨异步流 Mermaid 时序图以及可运行的 SelectiveCkptSwiGLUFFN、CPUOffloadHook 与 70B 显存估算器代码?按快捷键 M 或点击顶部 技术 Wiki 随时切换。

在千亿参数、十万字 长上下文建模 的大语言模型训练中,显存墙(Memory Wall) 往往比算力墙更早到来。即便通过 ZeRO-3 / FSDP 将 混合精度 静态模型状态分片到数百张 GPU,反向传播必须缓存的中间激活值(Activations) 仍会随着批大小 b、序列长度 s 与层数 L 呈线性乃至平方级爆炸。要在一张 80GB HBM 显卡上压榨出最高的有效算力利用率(MFU),工程师必须掌握三件核心武器:精准的显存账本核算、以算力换显存的梯度检查点与选择性重计算、异构分级存储卸载(Offload),以及把 TP/SP/CP 与 PP/EP 通信全部隐藏在幕后的异步重叠调度(Overlap)。

直观理解

把 GPU 显存(HBM)想象成画家面前寸土寸金的工作台:工作台上既要放颜料与画册(静态参数与优化器状态),又要摊开每一步的草图(动态激活值)以便回头修改(反向传播)。如果草图铺满了桌面,画家可以采取三种策略:一是梯度检查点——只留关键几页草图,回头修改时现画中间草稿(用一点额外时间换出大片桌面);二是 Offload 卸载——把暂时不用的画册放到旁边的书架(CPU 内存甚至 NVMe 硬盘)上随取随还;三是通信计算重叠——右手正在上色时,左手提前让助手把下一张画纸递过来,让工作台和画笔一刻不闲着。

问题动机与演进背景 ​

  1. 静态显存解决后,激活显存成为最大怪兽:以 70B 参数(L=80,h=8192)、序列长度 s=8192 为例,即便用 64 卡 ZeRO-3 将每卡静态权重+优化器压至不到 18 GB,如果不加优化地缓存全部前向激活,单卡激活显存仍可飙升至 100+ GB 导致瞬间 OOM!
  2. 全量重计算(Full Activation Checkpointing)的算力浪费:经典梯度检查点(Chen et al., 2016)在每个 Transformer 层边界存一份输入,反向时重算整层前向。这能把激活显存压低 5–10 倍,但会付出 33% 额外总算力(多跑一次完整前向) 的沉重代价。Korthikanti et al. (2023) 的选择性重计算(Selective Recomputation) 揭示了一个颠覆性事实:注意力中的 Softmax、Dropout、Mask 与投影后操作占据了近 70% 的激活显存,却只消耗了不到 4% 的总 FLOPs!只重算这些“大显存、小算力”算子,即可用极低代价换取绝大部分显存收益。
  3. 单机/小集群训大模型的刚需与集群 MFU 瓶颈:对于缺乏百卡集群的研究团队,ZeRO-Offload / ZeRO-Infinity 借助主机 TB 级 DDR5 内存与 PCIe NVMe 阵列打破了 GPU 显存上限;而在万卡集群上,算子本身已高度优化,决定训练成本高低的胜负手转移到了 通信与计算异步重叠(Communication-Computation Overlap) 以及避免显存碎片。

核心原理与数学推导 ​

1. Transformer 训练显存全景账本 ​

GPU 总显存消耗由四大部分组成:

Mtotal=Mstatic+Mactivation+Mtemporary+Mfragmentation
  1. 静态模型状态 Mstatic(混合精度 + AdamW,详见 ZeRO 推导):

    Mstatic=2Ψ⏟BF16 权重+2Ψ⏟BF16 梯度+12Ψ⏟FP32 主权重与 m,v=16Ψ 字节
  2. 动态激活显存 Mactivation(不含重计算,BF16 精度): 依据 Megatron-LM 精确逐算子统计,设微批次大小 b、序列长度 s、隐藏维 h、注意力头数 a、总层数 L。单个标准 Transformer 层(含 Self-Attention 与 4h 宽度 MLP)需保留用于反向传播的激活字节数为:

    • Self-Attention 部分:QKV 投影输入 (2bsh) + QK⊤ 输入 (4bsh) + Softmax 输出与注意力 Dropout 掩码 (5abs2) + 输出投影输入 (2bsh) + 残差 Dropout (bsh) ≈11bsh+5abs2;
    • MLP 部分:第一层线性输入 (2bsh) + GeLU/SwiGLU 激活输入 (8bsh) + 第二层线性输入 (8bsh) + Dropout (bsh) ≈19bsh;
    • 两个 LayerNorm 输入:4bsh。

    汇总全网络 L 层(开启张量并行 t 与序列并行 SP 后):

    Mactfull=L⋅sbh(34t+5ash⋅t) 字节

    (注:采用 FlashAttention 后,显式存储 O(s2) 注意力矩阵的 5abs2 项被彻底消除,仅剩极小的 LogSumExp 统计向量 O(abs),公式大幅简化为约 34Lsbh/t 字节!)

  3. 临时缓冲区与 CUDA 显存碎片:通信桶(NCCL Buckets)、cuBLAS GEMM 工作区(Workspace)及 PyTorch Caching Allocator 的内存池碎片通常额外占 10%–20% 冗余。

2. Activation Checkpointing:全量重计算与选择性重计算 ​

全量检查点(Full Checkpointing) ​

将 L 层网络按每隔 k 层(Transformer 中最常取 k=1,即逐层检查点)保存一次输入激活,丢弃层内所有中间张量。在反向传播到第 l 层时,从检查点 h(l) 重新执行一次局部前向恢复所需中间激活,再求梯度。

  • 最优理论缩放:若每隔 L 层存一个检查点,峰值激活显存降至 O(L);
  • 逐层检查点(k=1):全网络仅需缓存 L 份层输入激活,总激活显存从 34Lsbh 骤降至:Mactckpt=2Lsbh(单层重算峰值再加 1 层激活)激活显存缩减超过 15 倍!
  • 计算代价:每个标准训练步包含 1 次前向(2Ψ FLOPs/Token)与 1 次反向(4Ψ FLOPs/Token,合计 6Ψ)。开启全量重计算多出 1 次前向(+2Ψ),总算力升至 8Ψ,增幅为 26=33.3%。

选择性激活重计算(Selective Activation Recomputation) ​

观察单层各项算子的“显存-算力比”:

  • 巨型矩阵乘法(QKV Proj、O Proj、MLP Up/Gate/Down)占总计算量的 95%+;
  • 逐元素与规约算子(Softmax、Attention Dropout、LayerNorm、SiLU/SwiGLU 门控激活、词表交叉熵)只占总计算量的 不足 5%,却贡献了极高比例的激活显存!

策略:坚决保留大 GEMM 的输入激活避免重算昂贵矩阵乘,仅丢弃并在反向时重算 Attention Core(已被 FlashAttention 原生内置)、SwiGLU 激活内部与 RMSNorm/LayerNorm 输出。这样仅需付出 2%–8% 的额外计算开销,即可省去 60%–75% 的激活显存,在显存充裕度适中时 MFU 显著高于全量重计算。

3. ZeRO-Offload 与 ZeRO-Infinity:突破 GPU 显存物理极限 ​

当 GPU 显存实在装不下时,利用硬件存储金字塔(GPU HBM ↔ CPU DRAM ↔ NVMe SSD)做异构卸载:

  • ZeRO-Offload(GPU + CPU 协同):
    • 将计算密集型的 BF16 前向与反向传播留在 GPU 上执行;
    • 将显存占大头(12Ψ)但计算极轻(纯逐元素访存密集型)的 FP32 Master Weights 与 AdamW 优化器更新完全卸载到 CPU 内存与多核 AVX-512 SIMD 引擎中!
    • 单步 PCIe 双向通信量仅为 2Ψ(回传梯度至 CPU)+2Ψ(下发新权重至 GPU)=4Ψ 字节。只要单步 GPU 计算量 6BΨ 满足计算时间大于 PCIe 传输时间(即微批次 B 足够大),吞吐几乎无损。
  • ZeRO-Infinity(GPU + CPU + NVMe 全栈卸载):
    • 结合 ZeRO-3 的按层动态拉取机制,将全部权重、梯度、优化器乃至检查点激活卸载至多盘 RAID-0 NVMe SSD 阵列,通过带宽中心分区(Bandwidth-Centric Partitioning)聚合全集群所有节点的 PCIe 通道并发读写,实现单节点 8 卡即可微调万亿参数级模型。

4. 通信与计算重叠(Communication-Computation Overlap) ​

大规模集群中,GPU 真正有效的算力利用率由 MFU(Model FLOPs Utilization) 衡量:

MFU=实际模型每秒有效 FLOPsGPU 硬件理论峰值 FLOPs≈6Ψ⋅Tokens/secNGPU⋅PeakFLOPsBF16/FP8

若通信与计算串行执行,总步耗时 Tstep=Tcomp+Tcomm;通过多 CUDA Stream 异步并发调度,理想重叠下总步耗时逼近:

Tstepoverlap=max(Tcomp,Tcomm)

现代框架在四大环节系统化实施重叠:

  1. DP / ZeRO-2 反向梯度桶重叠:反向传播从顶层向底层逐层算出梯度后,每填满一个 Bucket(如 25 MB)立刻在独立 comm_stream 触发异步 All-Reduce / Reduce-Scatter,与底层的反向矩阵乘并行;
  2. FSDP / ZeRO-3 权重异步预取(Prefetching):在 compute_stream 计算第 l 层时,comm_stream 提前发起第 l+1 层(反向时为第 l−1 层)的 All-Gather;
  3. TP 细粒度微块分解(Async TP):将大矩阵乘沿行/列切分为 4–8 块,通信完第 1 块立刻启动第 1 块 GEMM;
  4. Activation Offload 异步预取:前向刚算完的激活检查点立即通过 copy_stream 异步 D2H 拷贝至 CPU 锁页内存(Pinned Memory),反向提前 1–2 层再异步 H2D 拷回 GPU。

算法架构与数据流图 ​

下图展示了 GPU 算力流(Compute Stream)、网络通信流(Comm Stream)与 PCIe 卸载流(Copy Stream)三轨并行的异步重叠时间线:

图表加载中...

复杂度与横向对比 ​

优化技术针对显存区域显存节省幅度额外计算 / 耗时代价实现复杂度最佳使用时机
FlashAttentionAttention O(S2) 激活消除平方级激活反而提速 2×–4×极低(开箱即用)无条件永远开启
选择性重计算Norm / SwiGLU / 局部激活减少 60%–75% 激活仅 +2%–8% 算力中(需按模块定制)追求极限 MFU 的大规模预训练首选
全量重计算 (Ckpt)全部层内中间激活减少 85%–95% 激活+33% 额外算力极低(一行代码)长上下文训练或显存严重吃紧时
Activation Offload检查点激活搬移至 CPU近似消除检查点 HBM异步重叠下仅 +0%–5%中(需锁页内存+流同步)超长上下文(128K+)+ 多层模型
ZeRO-Offload优化器状态 (12Ψ) 移至 CPU省去 75% 静态显存大 Batch 下开销可控低(DeepSpeed/FSDP 内置)单机/小集群微调 30B–70B 大模型
ZeRO-Infinity全量状态卸载至 NVMe突破数百 GB–TB 极限显著受限于 PCIe/NVMe 带宽中极端资源受限下的超大模型实验

核心 PyTorch 参考实现 ​

下面代码展示两项实用工程技巧:一是使用 torch.utils.checkpoint 构建选择性激活重计算(仅重算轻量非线性/Norm 块,保留重型线性层或支持分层开关);二是使用 PyTorch saved_tensors_hooks 实现 GPU ↔ CPU 锁页内存异步激活卸载(Activation Offloading):

python
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.checkpoint import checkpoint


class SelectiveCkptSwiGLUFFN(nn.Module):
    """选择性激活重计算示例:保留巨型矩阵乘外层接口或按需仅重算轻量门控/归一化子图。"""

    def __init__(self, d_model: int, d_ff: int, selective_ckpt: bool = True):
        super().__init__()
        self.selective_ckpt = selective_ckpt
        self.norm = nn.RMSNorm(d_model)
        self.w_gate = nn.Linear(d_model, d_ff, bias=False)
        self.w_up = nn.Linear(d_model, d_ff, bias=False)
        self.w_down = nn.Linear(d_ff, d_model, bias=False)

    @staticmethod
    def _swiglu_act(gate: torch.Tensor, up: torch.Tensor) -> torch.Tensor:
        # 仅占极少 FLOPs 却需缓存巨大 [B, S, d_ff] 中间张量的逐元素门控算子
        return F.silu(gate) * up

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: [B, S, D]
        h = self.norm(x)
        gate = self.w_gate(h)  # [B, S, d_ff]
        up = self.w_up(h)      # [B, S, d_ff]
        if self.selective_ckpt and self.training:
            # 仅对轻量 SwiGLU 门控算子启用非重入检查点,免去缓存额外中间激活
            act = checkpoint(self._swiglu_act, gate, up, use_reentrant=False)
        else:
            act = self._swiglu_act(gate, up)
        return x + self.w_down(act)


class CPUOffloadHook:
    """基于 PyTorch saved_tensors_hooks 的轻量激活卸载上下文(自动将大激活卸载到 CPU 内存)。"""

    def __init__(self, min_numel: int = 4096):
        self.min_numel = min_numel

    def pack_hook(self, tensor: torch.Tensor):
        # 仅卸载超过阈值的激活张量,小标量/参数留在原设备避免搬运开销
        if tensor.is_cuda and tensor.numel() >= self.min_numel:
            cpu_buf = torch.empty(tensor.shape, dtype=tensor.dtype, pin_memory=True)
            cpu_buf.copy_(tensor, non_blocking=True)
            return ("cpu_offloaded", tensor.device, cpu_buf)
        return ("kept", None, tensor)

    def unpack_hook(self, packed):
        tag, orig_device, buf = packed
        if tag == "cpu_offloaded":
            return buf.to(orig_device, non_blocking=True)
        return buf

    def __call__(self):
        return torch.autograd.graph.saved_tensors_hooks(self.pack_hook, self.unpack_hook)


def estimate_transformer_memory_gb(
    num_params_b: float,
    layers: int,
    hidden: int,
    batch_size: int,
    seq_len: int,
    dp_size: int = 64,
    tp_size: int = 8,
    zero_stage: int = 3,
    full_ckpt: bool = False,
) -> dict[str, float]:
    """快速估算混合精度 + FlashAttention 下单卡静态显存与激活显存 (GB)。"""
    psi = num_params_b * 1e9
    if zero_stage == 1:
        static_bytes = (4 * psi + 12 * psi / dp_size) / tp_size
    elif zero_stage == 2:
        static_bytes = (2 * psi + 14 * psi / dp_size) / tp_size
    else:
        static_bytes = (16 * psi / dp_size) / tp_size

    # 开启 FlashAttention 与 SP 后,无检查点约 34*L*b*s*h/tp,全检查点约 2*L*b*s*h/tp
    act_factor = 2.0 if full_ckpt else 34.0
    act_bytes = act_factor * layers * batch_size * seq_len * hidden / tp_size
    gib = 1024 ** 3
    return {
        "static_GB": round(static_bytes / gib, 2),
        "activation_GB": round(act_bytes / gib, 2),
        "total_est_GB": round((static_bytes + act_bytes) / gib, 2),
    }


if __name__ == "__main__":
    # 1. 估算 70B 模型在 64 卡 (DP=8, TP=8) 序列长 8192 下的显存账本
    no_ckpt = estimate_transformer_memory_gb(70, 80, 8192, batch_size=1, seq_len=8192, dp_size=8, tp_size=8, zero_stage=3, full_ckpt=False)
    with_ckpt = estimate_transformer_memory_gb(70, 80, 8192, batch_size=1, seq_len=8192, dp_size=8, tp_size=8, zero_stage=3, full_ckpt=True)
    print(f"70B (DP=8, TP=8, S=8192) 无检查点: {no_ckpt} | 全检查点: {with_ckpt}")

    # 2. 验证选择性重计算与卸载 Hook 的前向-反向正确性
    block = SelectiveCkptSwiGLUFFN(d_model=64, d_ff=128, selective_ckpt=True)
    x = torch.randn(2, 16, 64, requires_grad=True)
    offloader = CPUOffloadHook(min_numel=512)
    with offloader():
        y = block(x)
    y.sum().backward()
    print(f"选择性检查点 + Offload Hook 验证通过 | 输入梯度范数: {x.grad.norm():.4f}")

工程实践与常见陷阱 ​

工程实践

  1. 始终指定 use_reentrant=False:PyTorch 2.x 强烈推荐在 torch.utils.checkpoint.checkpoint 中显式设置 use_reentrant=False。旧版可重入实现存在大量隐蔽缺陷(不支持无梯度的顶层输入、与 DDP/FSDP 嵌套和 torch.compile 容易发生冲突且难以处理早停计算图)。
  2. 显存碎片诊断与 expandable_segments:有时监控显示只用了 62 GB / 80 GB 却报 OOM,这通常是由于变长序列或动态内存池切碎导致找不到连续大块显存。设置环境变量 PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True 可借助 CUDA 虚拟内存映射动态拼接物理页,显著消除碎片导致的假性 OOM。
  3. 精细调优分层检查点比例(Layer-wise Partial Checkpointing):不必在“0 层检查点(OOM)”与“全部 80 层检查点(-33% 速度)”之间二选一。如果显存只超标 15 GB,只需对前 k 个 Transformer 层开启全检查点、其余 L−k 层保持不重计算,即可把显存严丝合缝地卡在 76 GB/80 GB 边缘并榨干最高 MFU。

常见陷阱

  1. 重计算区间的随机状态失配(Dropout / RNG Desync):若前向传播和反向重计算时的随机数生成器(RNG)状态不同,Dropout 会抹掉不同的神经元,导致梯度数学错误甚至训练发散。PyTorch checkpoint(..., preserve_rng_state=True) 默认会保存并恢复 RNG 状态;自研自定义反向算子时务必自行维护 RNG 快照。
  2. 在循环中滥用 torch.cuda.empty_cache():调用 empty_cache() 会强制触发全 GPU 同步并归还缓存页给驱动,随后下次分配又得重新走昂贵的 cudaMalloc,反而让训练速度断崖式变慢且通常无法解决真正的峰值 OOM。应只在明确发生阶段切换(如训练切评测)时偶尔调用。
  3. 非锁页内存(Pageable Memory)拖垮 Offload 重叠:若 CPU 缓冲区未设置 pin_memory=True,CUDA 无法通过 DMA 引擎执行真正的异步 copy_(non_blocking=True),传输会退化为阻塞主线程的同步拷贝,彻底破坏通信/拷贝与计算的重叠效果。

延伸阅读与参考论文 ​

  • Chen, T., et al. (2016). Training Deep Nets with Sublinear Memory Cost (Activation Checkpointing). (arXiv:1604.06174 ↗)
  • Ren, J., et al. (2021). ZeRO-Offload: Democratizing Billion-Scale Model Training. USENIX ATC 2021. (arXiv:2101.06840 ↗)
  • Rajbhandari, S., et al. (2021). ZeRO-Infinity: Breaking the GPU Memory Wall for Extreme Scale Deep Learning. SC21. (arXiv:2104.07857 ↗)
  • Korthikanti, V. A., et al. (2023). Reducing Activation Recomputation in Large Transformer Models (Selective Recomputation). MLSys 2023. (arXiv:2205.05198 ↗)
  • Dao, T., et al. (2022). FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. NeurIPS 2022. (arXiv:2205.14135 ↗)
  • Wang, S., et al. (2023). Overlap Communication with Dependent Computation via Decomposition in Large Deep Learning Models (Async TP). ASPLOS 2023. (ACM DL ↗)