大模型算法: 反向传播

爆款方案 · 第 03 期 / 共 30 期

反向传播:

一次前向,为什么必须把整条路都记下来

上一期算出 4.61 这个数。这一期讲它怎么变成 70 亿个「你该往哪改、改多少」------ 以及为什么教科书里的数值微分,在真实模型上要跑 22.7 天。

热度 ★★★★★门槛 中15 秒投流版 + 75 秒正片版抖音 / 视频号 / 小红书 / B站

7B 模型,一次反向传播 0.42 毫秒 ,拿到全部 70 亿个梯度。

同样的事换成数值微分:22.7 天。慢 46 亿倍。------主钩子。同一个目标、两种做法、一个天上一个地下。3 秒内完成量级冲击,不需要任何前置知识。

第 1 章 · 选题判断

为什么第 3 期是它

第 02 期结尾留了个问题没答:交叉熵算出 4.61 这个数,可模型有 70 亿个参数,每一个都要知道「我该往哪改、改多少」。一个标量,怎么变成 70 亿个方向?

答案就是反向传播。它做的事听起来平淡:把链式法则在图上一层层倒着走。但它的计算成本结构 才是真正惊人的地方 ------ 不管你有一百个参数还是七千亿个,求全部梯度,只需要一次前向 + 一次反向,也就是大约 3 倍前向的算力。这个性质不是工程优化,是反向模式自动微分的数学结论。

0.42 ms

一次反传拿到 70 亿个梯度

(按 1e14 FLOP/s 估)

22.7 天

同样的梯度用数值微分

2.69×

梯度检查点省下的激活显存

(本机实测)

它还有个容易被忽略的身份:反向传播不是「深度学习发明的算法」。反向模式自动微分 1970 年就由 Linnainmaa 写进硕士论文,Werbos 1974 年把它用在神经网络上,Rumelhart、Hinton、Williams 1986 年那篇 Nature 才让它流行起来。搞清楚这条脉络,「反向传播」这四个字就不会再被当成玄学。

这一期还是后面所有期的地基:04 期 的 Adam 更新的是这里算出来的梯度;18 期 混合精度会在这里静默下溢(本期实测:0.5 连乘 25 层,fp16 的梯度直接变 0);20 期 的 ZeRO 与 21 期 FlashAttention 的重算策略,本质都是在处理本节要讲的这笔「显存账」。

第 2 章 · 算法内核

口播背后必须站得住的东西

下面每一条都是上镜稿的「证据层」。凡标「实测」的,都是本机跑出来的数;凡标「估算」的,都写清了假设。

2.1定义:它只做一件事 ------ 向量-雅可比积

设一个节点 y = f(x),已知上游传回来的 ȳ = ∂L/∂y(和 y 同形),那么要往下传的就是:

x̄ = ȳ · Jf(x) ,其中 Jf = ∂y/∂x这一步叫 VJP(vector-Jacobian product)。反向传播 = 沿逆拓扑序,每个节点做一次 VJP

关键在于:它从不显式构造雅可比矩阵 。一个 4096×4096 的线性层,雅可比是 1677 万个元素;而 VJP 只做两次矩阵乘法,输出和输入同形。这是「反向模式能用在 70 亿参数上」的根本原因 ------ 空间和时间都只和图规模成正比,与参数量无关。

cost(反向) ≈ 2 × cost(前向)   memory(反向) = O(前向中间量)「2 倍」是矩阵乘主导网络的常用经验值,与算子构成有关;本期实测的小网络上 1 次前向+1 次反向 ≈ 1.7 倍前向耗时

2.2为什么必须「存」:局部导数依赖当时的输入

这一节是整期最值钱的部分,因为它解释了显存账单的来源 。反向时每个节点要算局部导数,而这个导数往往依赖于前向时的输入值或输出值:

算子 反传时需要什么 于是前向必须留下
relu(z) 导数 1z\>0 一个布尔 mask(可以压成 1 bit)
tanh(z) 导数 1−tanh²(z) 输出本身即可,不必存输入
softmax(z) J = diag(q) − qqᵀ 输出 q(第 02 期那个 q)
x @ W ∂/∂x = ȳWᵀ,∂/∂W = xᵀȳ 两个输入都要
LayerNorm(x) 依赖均值与方差 统计量,或输入 x
注意力 softmax(QKᵀ)V 依赖注意力矩阵 n×n 的注意力矩阵 ← 这就是 FlashAttention 要重算它的原因

看最后一行:一个 4096 长度、32 头的注意力层,注意力矩阵就是 32×4096×4096 ≈ 5.4 亿个元素。整条前向如果都存下来,就是「层数 × 这个数」。所以「必须存」不是实现细节,它是 Transformer 训练显存的第一大来源,也是第 21 期 FlashAttention(不存、重算)、第 20 期 ZeRO(把这些切到别的卡上)要解决的问题。

2.3扇出必须累加:最贵的那个「不报错的 bug」

如果某个值在图里被用了两次,它就有两条下游路径。总梯度是两条路径各自贡献之和 ------ 因为多元链式法则本来就是求和,不是取其一。

前向:算一步,就把这一步的输入留在显存里t = tanh(x) s = t × x L = sx1.50t0.9051s1.3577L1.3577tanh× x=x 还被 s 直接乘了一次 ------ 一个值,两条出边反向:从 ∂L/∂L = 1 出发,每退一步乘一个局部导数∂L/∂x = 1.1762∂L/∂t = 1.5000∂L/∂s = 1.00∂L/∂L = 1× x = 0.9051× (1−t²)这一路贡献 ∂s/∂x · ∂L/∂s = t = 0.9051两条路在 x 上相加:0.2711 + 0.9051 = 1.1762

图 1 L = x·tanh(x) 在 x = 1.5 处的前向与反向。上半部分是前向:t = tanh(x)、s = t·x、L = s,绿色是各节点的值,全部要留在显存里。下半部分是反向:从 ∂L/∂L = 1 出发,每退一步只乘一个局部导数。注意 x 有两条出边 (进 tanh、直接进乘法),所以 ∂L/∂x 收到两份贡献:0.2711 + 0.9051 = 1.1762。

与中心差分对拍:数值解 1.96e+20,误差 9.1e-11。

一个实现细节值得单独说:几乎所有自动微分框架里,梯度的累积都是 p.g = p.g + vjp(...)。把加号写成等号,程序不会报错、loss 曲线看起来也正常下降,只是这个参数收到的梯度永远缺一块。这是我在 review 别人的手写反传时最常发现的错误。

实测:漏掉一支梯度,误差有多大

取 y = Σ sin(x·w)·(x² + x),x 在表达式里出现 3 次 。

正确写法(三支相加)与中心差分对比:最大误差 5.2e-10。

错误写法(只留最后一支,覆盖前面的):逐元素最大相对误差 73% ------ 已经和真值完全不是一个量级,但这段代码不会抛任何异常。

2.4数值微分的地板:为什么它只能做「体检」,不能做训练

数值微分用 (f(x+h) − f(x−h)) / 2h 逼近。它有两项误差在互相拉扯:

误差 ≈ (h²/6)·|f‴| + (ε·|f|)/h  → 最优 h ≈ ε1/3,最小误差 ≈ ε2/3ε 是浮点机器精度:fp64 ≈ 2.2e−16,fp32 ≈ 1.2e−7

第一项是截断误差 :h 越大,用割线代替切线越不准,按 h² 涨。第二项是舍入误差:h 越小,两个几乎相等的数相减,有效位被吃光,按 1/h 涨。两者相交处就是精度天花板。

1e-141e-121e-101e-81e-61e-41e-21e01e21e-121e-101e-81e-61e-41e-21e0扰动步长 h(对数轴)与解析梯度的误差最优点 h = 1e−5误差 5.1e−12 ------ 这就是天花板h 太大:截断误差 ∝ h²h 太小:舍入误差 ∝ 1/h实测:中心差分vs 解析梯度灰虚线 = 理论渐近线(+2 / −1)

图 2 实测:二层 MLP 的交叉熵损失,对其中一个参数做中心差分,与解析梯度(也就是反向传播算出来的值)比较。横轴是扰动步长 h(对数),纵轴是误差(对数)。

左侧陡降段斜率 +2(截断误差 ∝ h²),右侧回升段斜率 −1(舍入误差 ∝ 1/h),中间触底于 h ≈ 1e-05、误差 5.1e-12。**这就是数值微分的物理极限:fp64 下最好也只能到 1e−11 量级。**虚线是两条理论渐近线。

步长 h 实测误差 诊断
1e−1 8.0e−04 h 太大:曲线被切线的二次项吃掉
1e−2 8.0e−06 仍偏大
1e−4 8.0e−10 即将触底
1e−5 5.1e−12 最优点(理论 ε1/3≈6e−6)
1e−8 6.0e−09 h 太小:两个几乎相等的数相减
1e−12 7.6e−05 完全被舍入噪声淹没

三个直接推论,都是实践里会踩的:

  • **梯度检查的容差不能设成 1e−12。**先转 fp64、用中心差分、容差取 1e−4 ~ 1e−6(相对值),否则你的 CI 会随机红。
  • **fp32 根本做不了梯度检查。**ε2/3 ≈ 2.4e−5,也就是说误差本身就有 1e−5 量级 ------ 你分不清是代码错了 0.1% 还是浮点噪声。
  • **它慢得和参数量成正比。**每个参数要 2 次前向。本期小网络 57 个参数,实测数值微分 2.93 ms,而一次前向+反向只要 0.049 ms,实测差 60 倍。把这个比例套到 70 亿参数上就是开头的 22.7 天。

2.5三种求导,只有一种能用在 70 亿参数上

方式 一次传播得到什么 拿到全梯度要几次 能不能用于训练
数值微分 一个方向的近似导数 2 × 参数量(140 亿) 不能。慢、且精度只有 1e−11 量级
符号微分 一个导数表达式 1 不能。表达式随图规模膨胀,且无法处理控制流 / 数据依赖的图
前向模式 AD 一个输入方向的 JVP 参数量(70 亿) 不能。方向数 = 输入维数
反向模式 AD 一个输出方向的 VJP 输出维数 = 1 能。这就是反向传播

这张表的关键在最后两行:前向模式和后向模式是同一个数学对象的两面 ,成本分别是「输入维数」和「输出维数」次图遍历。神经网络恰好是「输入几亿维、输出一维」的极端形状,所以反向模式赢了 9 个数量级。这不是工程技巧,是问题结构决定的。

顺带解释一个日常疑惑:loss.backward() 不带参数,是因为 loss 是标量,∂L/∂L 只能是 1。如果你对一个向量调用 backward(),框架就必须让你传 grad_output ------ 它在问「你要对哪个输出方向求导」。

2.6显存账单:激活值不是最大的,但只有它能省

以 7B 模型、32 层、d=4096、序列 2048、bf16 混合精度 + Adam 为例。激活值按每层每 token 需要留下的张量逐个累加(不含可重算的注意力矩阵):

每层每 token 要留的张量 元素数 bf16 占用
attn 输入(残差流) 4,096 8.0 KB
q / k / v 投影 12,288 24.0 KB
attn 输出投影输入 4,096 8.0 KB
mlp 归一化输入 4,096 8.0 KB
gate / up 投影 22,016 43.0 KB
SiLU 激活输出 11,008 21.5 KB
down 投影输入 11,008 21.5 KB
合计 68608 134.0 KB
项目 占用 随 batch 变化? 能省吗
参数(bf16) 13.0 GB 否 只能量化 / 切分
梯度(bf16) 13.0 GB 否 只能切分
fp32 主权重 26.1 GB 否 不能,精度兜底
Adam 一阶 m 26.1 GB 否 不能
Adam 二阶 v 26.1 GB 否 不能
训练状态小计 104.3 GB 否 ---
激活值(1 条 2048 token) 8.4 GB 是,线性 能,靠重算
激活值(batch = 8) 67.0 GB --- ---
合计(batch = 8) 171.3 GB --- ---

三个结论,可以直接当结论用:

  • batch = 1 就已经 112.7 GB,一张 80G 的卡放不下。所以「显存不够就减 batch」在 7B 全量训练上根本减不下去。
  • 激活值占 39%(batch=8) ,不是最大的那一项 ------ 但它是唯一可以靠多算一遍换回来的。其他五项是必须常驻的状态。
  • 这也是为什么「训 7B 要 8 张 80G 卡」这句话是对的,但原因不是模型太大,而是优化器状态 + 激活值这两笔账。
口径说明(避免被专业观众挑)

① 上表是核算(按张量字节数逐项累加),不是采样测量;② 未计入注意力 n×n 矩阵 ------ 现代实现默认重算或用 FlashAttention 融合,不会物化它;③ 未计入通信 buffer、临时 workspace、碎片,实际峰值会更高;④ Adam 状态按 4+4 字节、主权重按 4 字节计,若用 8-bit 优化器(如 bitsandbytes)可再砍一半以上。

2.7梯度检查点:用算力换显存,最优在 √L

既然激活值可以重算,那就别全存。每 k 层只在段的入口 存一个检查点,反向时进入这一段再重算一遍前向。

显存从 O(L) 变成 L/k + k(存 k 个段的入口 + 重算一段的中间量),对 k 求极小得 k = √L,此时显存 ≈ 2√L;代价是每个 batch 多算 (1 − 1/k) 次前向。

02468101210.816.322.342.052.082.3106.32011.040每隔 k 层存一个检查点(k=1 就是全存)峰值显存 MBk = 8:只有 4.0 MB比全存省 2.69 倍理论最优k = √L = 6.3代价+29% 算力k 两端都会退化到全存

图 3 实测:40 层 × 512 维 × batch 64 的网络,用 tracemalloc 记录每次运行的峰值 内存分配(单位 MB)。k=1 是全存基线 10.8 MB;k=8 降到 4.0 MB,省 2.69 倍;k 继续增大反而回升 ------ 因为最后要重算的整段本身也要占内存。两端都退化回全存,最优点确实落在 √L ≈ 6.3 附近。

k(每 k 层存一个) 峰值显存 省了多少 额外算力(按 FLOP 计)
1 10.8 1.00× +0%
2 6.3 1.72× +17%
4 2.3 2.53× +25%
5 2.0 2.69× +27%
8 2.0 2.69× +29%
10 2.3 2.53× +30%
20 6.3 1.72× +32%
40 11.0 0.98× +32%

两个必须说清楚的点:

  • 梯度值完全不变。 实测 k=8 与全存的梯度总和之差 0.0e+00 ------ 重算只是重做前向,数学上一模一样。
  • **额外算力是 +29%,不是零。**口播里说「用算力换显存」,很多内容会说成「几乎免费」,这不准确。反向=2 单位、前向=1 单位时,k=8 的总成本从 3 单位变成 3.875 单位。GPU 上这个比例会因为访存/计算重叠而偏离,但量级是对的。

顺带一提上界:Chen 等人 2016 年的 sublinear memory 方案把重算做成递归的,能把显存压到 O(√n) 且常数更小;而 FlashAttention 走的是另一条路 ------ 不存注意力矩阵,反向时只重算一小块(正好是第 21 期的主题)。

2.8最阴的一个坑:fp16 下梯度会变成 0,而不是变小

反向传播是一串连乘。乘积一旦小于浮点能表示的最小值,得到的不是「很小的数」,而是精确的 0。而梯度为 0 的参数,从此再也不更新。

精度 最小正规数 0.5 连乘降到 0 的层数 1.5 连乘溢出
fp16 6.10e-05 第 25 层 第 28 层(max 65504)
fp32 1.18e−38 第 150 层 第 193 层

这就是 loss scaling 存在的唯一理由:把 loss 先乘一个常数(比如 2¹²)再反传,整个梯度链被同比例抬起,避开下溢区;更新参数前再除回去。bf16 因为指数位和 fp32 一样宽(8 位),几乎没有这个问题 ------ 它的代价在尾数只有 8 位(约 3 位十进制有效数字),所以需要 fp32 主权重兜底。两个格式的病完全不同,别混为一谈。

这条为什么值得单独讲

因为它的失败模式是静默的:不报错、不 NaN、loss 照常下降,只是某一部分参数永远学不动。这跟 4.3 的「加号写成等号」是同一类 bug ------ 都会让训练「看起来还行,其实少了一半」。视频里讲这种坑,比讲公式更容易被专业观众记住。

2.9可运行的最小实现:43 行的一个自动微分引擎

复制代码
import numpy as np

class T:
    # 反向模式自动微分:每个节点记住「父节点 + 局部 VJP」
    def __init__(self, v, parents=()):
        self.v = np.asarray(v, dtype=np.float64)   # 前向值:必须留着
        self.g = np.zeros_like(self.v)             # 梯度:扇出时累加
        self.parents = list(parents)               # [(父节点, 局部反传)]

    def __add__(self, o):
        o = o if isinstance(o, T) else T(o)
        return T(self.v + o.v, [(self, lambda g: g), (o, lambda g: g)])

    def __mul__(self, o):
        o = o if isinstance(o, T) else T(o)
        # 局部导数 = 对方的值 -> 所以前向一定要把两个输入都存下来
        return T(self.v * o.v, [(self, lambda g, o=o: g * o.v),
                                (o, lambda g, s=self: g * s.v)])

    def __matmul__(self, o):
        return T(self.v @ o.v, [(self, lambda g, o=o: g @ o.v.T),
                                (o, lambda g, s=self: s.v.T @ g)])

def tanh(a):
    t = np.tanh(a.v)
    return T(t, [(a, lambda g: g * (1.0 - t * t))])   # 用输出重算,不必存输入

def relu(a):
    m = a.v > 0
    return T(a.v * m, [(a, lambda g: g * m)])

def backward(root):
    order, seen = [], set()
    def topo(t):                        # 拓扑排序:父在前,子在后
        if id(t) in seen:
            return
        seen.add(id(t))
        for p, _ in t.parents:
            topo(p)
        order.append(t)
    topo(root)
    root.g = np.ones_like(root.v)       # dL/dL = 1(这就是 backward() 不用传参的原因)
    for t in reversed(order):           # 逆拓扑序 = 反向
        for p, vjp in t.parents:
            p.g = p.g + vjp(t.g)        # 必须是 +=,不是 =

# ---- 性质 1:扇出必须累加 ----
x = T(1.5)
y = tanh(x) * x
backward(y)
assert abs(y.v - 1.3577) < 1e-4
assert abs(x.g - 1.1762) < 1e-4, x.g            # 0.2711 + 0.9051

# ---- 性质 2:与中心差分对拍(relu + 两层矩阵乘)----
rng = np.random.default_rng(0)
X = T(rng.normal(size=(4, 5)))
W1 = T(rng.normal(scale=.5, size=(5, 6)))
W2 = T(rng.normal(scale=.5, size=(6, 1)))

def loss_value():                      # 参数变了就重建一次图,用于数值微分
    h = relu(X @ W1)
    out = h @ W2
    return float((out * out).v.mean())

h = relu(X @ W1); out = h @ W2
backward((out * out) * T(1.0 / 4.0))   # 损失 = (1/4)·Σout²,故 dL/dout = out/2

def numgrad(node, idx, eps=1e-6):
    old = node.v[idx]; node.v[idx] = old + eps; lp = loss_value()
    node.v[idx] = old - eps; lm = loss_value(); node.v[idx] = old
    return (lp - lm) / (2 * eps)

e = max(abs(numgrad(W2, (i, 0)) - W2.g[i, 0]) for i in range(6))
assert e < 1e-6, e                     # 实测 3.9e-12
print("ok", y.v, x.g, e)

这 43 行里,四件事全都对上了前面的结论:self.v 就是那笔显存账 (为了算局部导数必须留);p.g = p.g + ... 就是扇出累加 ;root.g = 1 就是 backward() 不带参的原因 ;逆拓扑序就是保证「上游的梯度先算完,才能往下游传」。

一个实现细节:tanh 的 VJP 用的是闭包里的 t(输出),不是输入 ------ 这就是 4.2 那张表里「用输出重算,不必存输入」的例子。真实的框架(PyTorch 的 save_for_backward)就是让每个算子自己声明「我反传时需要留什么」,而不是无脑全存。

2.10性质小结(可直接当结论用)

  • **成本与参数量无关。**一次前向 + 一次反向 ≈ 3 倍前向算力,拿到全部梯度。这是「深度学习能训练」的计算基础。
  • **代价是内存,不是时间。**反向需要的局部导数依赖前向值,所以必须留 ------ 这就是激活值显存的来源,也是 checkpoint / FlashAttention / ZeRO 的动机。
  • **扇出处必须累加。**多元链式法则是求和。写成覆盖不报错,静默错。
  • **它算的是精确值。**自动微分没有近似(只有浮点舍入),这与数值微分的 1e−11 地板有本质区别 ------ 所以梯度检查只是「体检工具」,不是训练手段。
  • **只对「少输出」高效。**输出一维时是 1 次遍历,输入一维时是 1 次遍历 ------ 神经网络正好是前者。
  • **它不负责更新参数。**反向传播只产出梯度;拿梯度怎么走是优化器的事(下一期)。把它叫「反向传播算法」时,别把它当成优化算法。
  • **精度会静默吃掉梯度。**fp16 下 0.5 连乘 25 层即为 0,必须配 loss scaling。

第 3 章 · 30 期排期

不重复清单(按调用频次从高到低)

按「大模型里被用到的频次 × 理解依赖关系」排定。前面的讲不透,后面会变成名词堆砌。每天一期,不回头重复。

期号 算法 / 机制 类别 爆点方向
01 Scaled Dot-Product Attention ✓ 注意力 1000 字 = 100 万次计算
02 Softmax 与交叉熵损失 ✓ 目标函数 自信地答错,罚 6.6 倍
03 反向传播与自动微分(本期) 训练 0.42 毫秒 vs 22.7 天
04 SGD → Momentum → Adam → AdamW 优化 为什么 Adam 会「记仇」
05 LayerNorm / RMSNorm 归一化 去掉均值那一项,省了多少算力
06 残差连接 结构 没有它,100 层网络根本训不动
07 位置编码:正弦 → 可学习 → RoPE 位置 AI 为什么会「数不清第几个字」
08 多头注意力:MHA / MQA / GQA 注意力 把 32 个头砍到 8 个,效果几乎不掉
09 KV Cache 与增量解码 推理 聊到第 50 轮,显存怎么爆的
10 因果掩码与自回归生成 解码 训练能并行、推理必须串行的根因
11 解码策略:贪心 / Beam / Top-k / Top-p / 温度 解码 同一个问题两次答案不同的真相
12 BPE 与 SentencePiece 分词 预处理 AI 数不清「strawberry 有几个 r」
13 词嵌入与分布假设 表示 为什么「国王 − 男人 + 女人 ≈ 女王」
14 前馈网络与 SwiGLU 门控 结构 大模型 2/3 的参数其实在这里
15 正则化:Dropout / 权重衰减 / 早停 训练 为什么大模型反而不怕过拟合
16 参数初始化:Xavier / He 训练 初始化错了,再好的模型也训不起来
17 学习率调度:Warmup + Cosine 训练 为什么前 2000 步要「慢慢加速」
18 混合精度训练与梯度裁剪 工程 bf16 和 fp16,差的不是一个字母
19 数据并行与 AllReduce 分布式 一千张卡,梯度怎么对齐
20 ZeRO / 张量并行 / 流水线并行 分布式 一个模型装不进一张卡怎么办
21 FlashAttention:分块 + online softmax 加速 不改数学,只改访存,快 3 倍
22 稀疏注意力与滑动窗口 注意力 只看邻居 512 个词够不够
23 线性注意力与 Mamba(状态空间模型) 注意力 把 n² 干掉之后还剩什么
24 MoE 混合专家与路由负载均衡 结构 671B 参数,每次只激活 37B
25 对比学习与 InfoNCE 表示 Embedding 模型凭什么判断「像」
26 向量检索:HNSW / IVF-PQ 检索 十亿条向量里,毫秒级找最近邻
27 BM25 与混合检索 检索 RAG 里为什么还要留一个「老算法」
28 量化:INT8 / GPTQ / AWQ 压缩 把 16 位压到 4 位,精度只掉一点
29 知识蒸馏与 KL 散度 压缩 小学生怎么学会教授的解题直觉
30 RLHF:PPO 与 DPO 对齐 「有用、诚实、无害」是算出来的

备选池(主线写完或需要换题时顺延):投机解码 Speculative Decoding、约束解码 / JSON Mode、前缀树缓存 RadixAttention、课程学习、长上下文外推、视觉编码器中的卷积与 Patch Embedding。

第 03 期 · 反向传播与自动微分(Backpropagation & Automatic Differentiation)

参考:Linnainmaa, The representation of the cumulative rounding error of an algorithm as a Taylor expansion of the local rounding errors , 1970;Werbos, Beyond Regression , 1974;Rumelhart, Hinton & Williams, Learning representations by back-propagating errors , Nature 1986;Griewank & Walther, Evaluating Derivatives ;Baydin et al., Automatic Differentiation in Machine Learning: a Survey , JMLR 2018;Chen et al., Training Deep Nets with Sublinear Memory Cost , 2016;Micikevicius et al., Mixed Precision Training , ICLR 2018。

文中所有「实测」数字由 NumPy 在本机跑出(种子固定,脚本可复现):手写反传 vs 中心差分最大差 1.8e-10;数值微分误差曲线为 fp64 下 27 个步长的实测;检查点显存由 tracemalloc 记录峰值分配(40 层 × 512 维 × batch 64)。「7B 模型的 0.42 ms / 22.7 天」是按 3×2·N·T 与 2N×2·N·T FLOP 在 1e14 FLOP/s 下的估算 ,非本机实测;显存表为逐项核算 ,非采样。

作者:小算 · 高级算法工程师

相关推荐
电科_银尘30 分钟前
【大模型算法与工程 27】训练配方:批量、学习率、精度与梯度裁剪
学习·算法·机器学习
专注仿真1 小时前
智能体训练之模仿学习:GAIL 算法详解与实战
python·算法·仿真·多智能体强化学习·afsim智能体训练
leobertlan3 小时前
痛苦系列 | DSP-04 截断时空的“窗”:FIR 滤波器设计与线性相位
算法
秋天的怀念_David4 小时前
算法一千零一夜 · 第三十五夜 · 恢复风暴
java·程序人生·算法
泯泷6 小时前
别再“裸聊”大模型了!你家的 AI 为什么总胡说八道?根子在 RAG
人工智能·算法·架构
2601_967980117 小时前
Python中heapq模块的各种用法实例
数据结构·python·算法·应用实例·heapq模块
漂流瓶jz9 小时前
UVA-1615 高速公路 题解答案代码 算法竞赛入门经典第二版
数据结构·算法·贪心算法·贪心·aoapc·算法竞赛入门经典·uva
凌冰_19 小时前
数据结构 - 时间空间复杂度(一)
数据结构·算法·软件工程