🏠 总目录📚 本教程 09 · log 域运算 ← →

NUMPY / 09 · 09 · log 域运算:logaddexp、logsumexp 与 log1p

结果明明有限,中途为什么先溢出了?

不是所有计算都适合先 exp 再 log。有时换一条等价路径,才能保住那个本来存在的结果。

你能解释 max-shift 的还原过程,也能区分溢出与相近数相减丢精度。

logsum 机制示意固定示例为 a=1000、b=999:先减去 m=1000,算 log(1+exp(-1)),再加回 m,约为 1000.3133。a=1000,b=999m = max(a,b) = 1000先缩小 exp 的输入exp(0) + exp(-1)取 log,再加回 m1000 + log(1+exp(-1))得到有限结果约 1000.3133
固定示例为 a=1000、b=999:先减去 m=1000,算 log(1+exp(-1)),再加回 m,约为 1000.3133。

可选小实验 · 浏览器里的简化示意

换一条路径,保住那个有限结果。

猜测可以略过,操作也可以略过。这里不运行 NumPy,不测性能;完整代码与直接结果始终可读。

a, b = 1000.0, 999.0
m = max(a, b)
m + np.log(np.exp(a-m) + np.exp(b-m))
# 约 1000.3132616875

默认 a=1000、b=999。直接 exp 会溢出,max-shift 后的结果约为 1000.3133。

不操作,直接看结果和使用条件

m=1000 后,两个 exp 的输入变成 0 与 -1。先算 log(1+exp(-1)),再把 m 加回去;这个等式不需要先形成 exp(1000)。控件中的 JavaScript 算术只是示意,原章代码与数值范围仍需在目标 NumPy 环境核对。

logsum 机制示意机制关系;完整条件见图注。a=1000,b=999m = max(a,b) = 1000先缩小 exp 的输入exp(0) + exp(-1)取 log,再加回 m1000 + log(1+exp(-1))得到有限结果约 1000.3133
固定示例为 a=1000、b=999:先减去 m=1000,算 log(1+exp(-1)),再加回 m,约为 1000.3133。
阅读范围、用时与原有实验记录
实验记录怎么读

本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。

⏱ 76 分钟 | ⭐ log(exp(a)+exp(b)) 可以在减去最大值后再求指数,让原本有限的结果免受中间溢出的影响。

01 / 完整解释

先拆开溢出的那条路径。

🎯 一句话

一串小概率的乘积可能舍入成 0,一串大指数的和可能在取对数前就变成无穷。 在对数域里,正数的乘积可以写成对数之和,指数的和则可以先平移再计算。logaddexp 就是两项指数求和再取对数的版本。

📌 softmax 减 max 的那道手撕题在 ML 基础 · 附录 C · 手撕代码速查 第 1 题,这里不重复。 那边给的是「白板上怎么写」,⭐ 这一章给的是它背后那条通用规则、以及 800 这个阈值是怎么来的。

🧩 一、logaddexp:这一族最小的形式

先看它在解决什么问题:

import numpy as np
import warnings

a, b = 800.0, 801.0

with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter("always")
    naive = np.log(np.exp(a) + np.exp(b))
    print("naive  log(exp(a)+exp(b)) =", naive, "|", w[0].message if w else "无警告")

print("np.logaddexp(a, b)        =", np.logaddexp(a, b))
m = max(a, b)
print("闭式 max + log1p(exp(-|a-b|)) =", m + np.log1p(np.exp(-abs(a - b))))
print("两者逐位相同:", np.logaddexp(a, b) == m + np.log1p(np.exp(-abs(a - b))))

z = np.array([800., 801., 802.])
print()
with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter("always")
    print("naive log(sum(exp(z)))    =", np.log(np.sum(np.exp(z))),
          "|", w[0].message if w else "无警告")
mz = z.max()
print("mz + log(sum(exp(z-mz)))  =", mz + np.log(np.sum(np.exp(z - mz))))
print("np.logaddexp.reduce(z)    =", np.logaddexp.reduce(z))

对照

naive log(exp(a)+exp(b)) = inf | overflow encountered in exp

np.logaddexp(a, b) = 801.3132616875182

闭式 max + log1p(exp(-|a-b|)) = 801.3132616875182

两者逐位相同: True

naive log(sum(exp(z))) = inf | overflow encountered in exp

mz + log(sum(exp(z-mz))) = 802.4076059644444

np.logaddexp.reduce(z) = 802.4076059644444

⭐ 对有限实数 a、b,先提取公共因子 exp(max(a,b))。平移后,较大的指数输入变成 0,对应 exp(0)=1。另一项的指数输入是 −|a−b|。取对数后,公共因子给出加回去的最大值。

log(eᵃ + eᵇ) = max(a,b) + log(1 + e^−|a−b|)

平移后的指数非正,exp 的结果不会超过 1。非常小的项在浮点运算中仍可能舍入成 0。上面的两项实验中,np.logaddexp 与手写公式得到同一个浮点值。

⭐ 指数和的对数(log-sum-exp,LSE)把同一运算推广到多个输入。np.logaddexp.reduce(z) 沿轴逐项合并。手写 max-shift 则先减去该组的最大值 m,计算平移后的指数和,取对数后加回 m。上面两种算法都显示为 802.4076059644444。浮点舍入随计算顺序而变,其他输入的结果可以有小量差异。NumPy 可用 logaddexp.reduce,SciPy 另提供 scipy.special.logsumexp。

⚠️ 注意 naive 那两行的输出还带了一条 RuntimeWarning: overflow encountered in exp ——这是浮点比整数强的地方:08 章那个整数回绕连这条警告都不给你。但警告默认只打到 stderr、跑批时通常被淹掉,所以第六节要讲怎么把它变成异常。

同一批两行分数,怎样给每行算一个对数总量?

设有两笔订单,每笔都有三个候选类别。表中是演示用的对数权重,每行是一笔订单,每列是一种类别。要把每行的权重归一化,得先求这一行的总权重。第一行若用 float64 直接求 exp(800) 就会溢出,我们沿用上面的平移技巧。

用 z[i,j] 表示第 i 行、第 j 列的对数权重,两种下标都从 0 数。每行的最大值记作 m[i]。把该行每个指数项写成 exp(m[i]) × exp(z[i,j]−m[i]),就能从三个加数中提出共同因子 exp(m[i])。取自然对数时,乘法变成加法,得到该行的对数总权重 m[i] + log(sum(exp(z[i,j]−m[i]))),求和遍历 j=0,1,2。

每行单独平移并还原总量
步骤第 0 行第 1 行
输入[800, 801, 802][−1, −2, −3]
最大值802−1
减去最大值[−2, −1, 0][0, −1, −2]
指数和0.135335 + 0.367879 + 1 ≈ 1.5032151 + 0.367879 + 0.135335 ≈ 1.503215
取对数,再加回最大值802 + 0.407606 ≈ 802.407606−1 + 0.407606 ≈ −0.592394

先预测形状。 axis=1 沿列合并,每行留一个结果。保留维度时结果是 (2, 1),可以把每行的指数和广播给原表 (2, 3) 的三列,供该行作分母。去掉维度只剩 (2,),广播从右对齐时会拿 2 对比原表的 3,在此例无法相除。轴与广播的规则可回看 第 02 章 和 第 03 章。

import numpy as np

z = np.array([[800, 801, 802],
              [-1, -2, -3]], dtype=np.float64)      # (2, 3)
m = z.max(axis=1, keepdims=True)                     # (2, 1)
shifted = z - m                                     # (2, 3)
weights = np.exp(shifted)                           # (2, 3)
mass = weights.sum(axis=1, keepdims=True)           # (2, 1)
lse = m + np.log(mass)                              # (2, 1)
one_per_row = np.logaddexp.reduce(z, axis=1)         # (2,)

print(lse.shape, lse.round(6).tolist())
# (2, 1) [[802.407606], [-0.592394]]
print(one_per_row.shape, one_per_row.round(6).tolist())
# (2,) [802.407606, -0.592394]
normalized = weights / mass                        # (2, 3)
print(normalized.sum(axis=1).round(12).tolist())
# [1.0, 1.0]

m 和 mass 对应表里的最大值和指数和。lse 是总权重的对数,weights / mass 直接用平移后的权重除以同行的指数和,公共因子会约掉。最后核对每行的和约为 1。若一行有极大的共同偏置,例如 [1e20, 1e20],加回最大值时 log(2) 可能被舍入掉。留在平移后的尺度上归一化,可以保住两项各占一半的结果。NumPy 的轴归约说明

输入有无穷或空行时,先决定总量和归一化分别该做什么。 −inf 可以表示零权重。如果行内只含有限值和 −inf,至少要有一个有限值,才能用该行最大值平移。全为 −inf 的一行没有这样的平移量。

按行计算时,区分总权重与归一化
输入情况总权重的对数归一化
[0, −inf]log(1 + 0) = 0可归一化为 [1, 0]。
[−inf, −inf]总权重为 0,对数取 −inf。直接平移会遇到 −inf − (−inf),得到 NaN。分母为 0,此行应单独处理。
空行空和为 0,对数取 −inf。max 找不到最大值。没有候选可归一化。
含 NaN 或 +infNaN 表示未知或无效。没有 NaN 时,含 +inf 的一行总量为 +inf。有限权重接口应拒绝这些输入,避免把未知值或无穷当作概率。

若只需要总量,np.logaddexp.reduce 能处理表中的全零权重和空行。空归约使用的初始值是 −inf,因为给任意有效权重加零,权重不变。若还要归一化,请单独检查行中是否有有限值,并排除 NaN 和 +inf。本章后面的 BCE 示例采用它自己的有限输入约定。

import numpy as np

rows = np.array([[0.0, -np.inf], [-np.inf, -np.inf]])
print(np.logaddexp.reduce(rows, axis=1).tolist())     # [0.0, -inf]
empty_rows = np.empty((2, 0))
print(np.logaddexp.reduce(empty_rows, axis=1).tolist())  # [-inf, -inf]
自查:改用 axis=0 会合并哪些格子?

每列各合并两个数,归约结果是 (3,),保留维度则是 (1, 3)。例如第 0 列合并 800 与 −1,得到 800 + log(1 + exp(−801))。exp(−801) 在 float64 中舍入为 0,因此显示为 800。这个结果按列广播,逐行归一化则应继续用 axis=1。

🧩 二、⭐ 为什么「log 域相加」是通解,不只是一个技巧

上面看到的是「防溢出」。它真正的价值是另一半:防下溢。

import numpy as np

rng = np.random.default_rng(0)
p = rng.uniform(1e-4, 1e-3, size=2000)      # 2000 个小概率

print("直接连乘 np.prod(p)     =", np.prod(p))
print("log 域相加 sum(log(p))  =", np.sum(np.log(p)))
print("换回来 exp(那个和)      =", np.exp(np.sum(np.log(p))))

c = np.cumprod(p)
first_zero = int(np.argmax(c == 0.0)) if (c == 0.0).any() else -1
print("连乘到第", first_zero + 1, "个就变成 0 了")
print("这时 log 域的值还是", np.cumsum(np.log(p))[first_zero])

对照

直接连乘 np.prod(p) = 0.0

log 域相加 sum(log(p)) = -15314.752401524813

换回来 exp(那个和) = 0.0

连乘到第 99 个就变成 0 了

这时 log 域的值还是 -751.0149574628322

💀 只乘到第 99 个,答案就变成 0 了——而你要乘 2000 个。之后无论再乘什么,结果都是 0:你不是「精度差了点」,你是把整个量丢了。

⭐ log 域里,同一个量是 −15314.75,好端端地待在那儿。

这就是「通解」的意思:

原始域 log 域
连乘 p1 * p2 * ... * pn 连加 log p1 + log p2 + ... + log pn
相加 e^a + e^b np.logaddexp(a, b)
归一化 pi / sum(pj) log pi − logsumexp(log p)
比大小 ⭐ 直接比 log 值(log 单调递增,不用换回来)

⚠️ 最后一行 exp(那个和) 还是 0.0,这不是 bug:真实答案 e^−15314 本来就远小于 float64 能表示的最小正数。⭐ 结论是:能不换回原始域就别换。argmax、排序、比较、加权(配合 logsumexp)全都可以在 log 域里做完。

02 / 完整解释

溢出和有效位丢失,各有解法。

🧩 三、800 这个数是从哪来的:真实的溢出阈值

import numpy as np

for t in (np.float64, np.float32, np.float16):
    f = np.finfo(t)
    print(f"{np.dtype(t).name:<8} max={float(f.max):<24} log(max)={np.log(float(f.max)):.2f}  "
          f"eps={float(f.eps):.3e}  tiny={float(f.tiny):.3e}")

print()
print("exp(float32(88))  =", np.exp(np.float32(88)))
print("exp(float32(89))  =", np.exp(np.float32(89)))
print("exp(float64(709)) =", np.exp(np.float64(709)))
print("exp(float64(710)) =", np.exp(np.float64(710)))
print("exp(float16(11))  =", np.exp(np.float16(11)))
print("exp(float16(12))  =", np.exp(np.float16(12)))
print()
print("下溢那一头  exp(-745.0) =", np.exp(-745.0))
print("           exp(-746.0) =", np.exp(-746.0))
print()
print("np.exp(90) (float64)   =", np.exp(90))
print("np.exp(np.float32(90)) =", np.exp(np.float32(90)))
浮点范围与精度
浮点类型maxlog(max)epstiny
float641.7976931348623157e+308709.782.220e-162.225e-308
float323.4028234663852886e+3888.721.192e-071.175e-38
float1665504.011.099.766e-046.104e-05

越过边界时的实测输出

  • exp(float32(88)) = 1.6516363e+38
  • exp(float32(89)) = inf
  • exp(float64(709)) = 8.218407461554972e+307
  • exp(float64(710)) = inf
  • exp(float16(11)) = 5.987e+04
  • exp(float16(12)) = inf
  • 下溢那一头 exp(-745.0) = 5e-324
  • exp(-746.0) = 0.0

⭐ exp 的临界指数就是 log(该 dtype 的最大值),一个 np.finfo 就查出来:

dtype max 临界指数 log(max) 实测最后一个不炸的整数
float64 1.7976931348623157e+308 709.78 709
float32 3.4028234663852886e+38 88.72 88
float16 65504.0 11.09 11

⚠️⚠️ 这张表是本章最实用的一段,因为三个数差得极远:

np.exp(90) (float64)   = 1.2204032943178408e+39
np.exp(np.float32(90)) = inf

同一个 90,float64 下是个有限的正常数字,float32 下直接 inf。 ⭐ 所以「多大算大」这个问题没有统一答案,只有 per-dtype 的答案——你在 float64 里调通的代码,切到 float32 训练时可能当场出 nan,而你什么都没改。

⭐ float16 的 11.09 尤其值得记住:exp(12) 就炸了。半精度下 logits 稍微拉开一点就没法直接 exp——这也是为什么框架的 softmax / attention 内部会把 exp 那一步升到 float32 再算。该选哪个精度训练是 AI 基础设施 · 06 · 混合精度 的题;本章只负责告诉你每个精度的 exp 在哪一格炸。

下溢那一头:exp(-745.0) 给 5e-324(已经是次正规数,只剩 1 位有效数字),exp(-746.0) 直接是 0.0。⭐ 这解释了上一节「连乘到第 99 个就归零」:那时累积的 log 值是 −751.01,已经越过 −745 那道线了。


🧩 四、log1p / expm1:不是「全丢」,是悄悄丢了几位

import numpy as np

for x in (1e-16, 1e-10, 1e-8, 1e-5):
    naive, good = np.log(1 + x), np.log1p(x)
    rel = abs(naive - good) / good if good != 0 else float("inf")
    print(f"x={x:<8.0e} log(1+x)={naive:<24.17g} log1p(x)={good:<24.17g} 相对误差={rel:.2e}")

print()
for x in (1e-16, 1e-10, 1e-8, 1e-5):
    naive, good = np.exp(x) - 1, np.expm1(x)
    rel = abs(naive - good) / good if good != 0 else float("inf")
    print(f"x={x:<8.0e} exp(x)-1={naive:<24.17g} expm1(x)={good:<24.17g} 相对误差={rel:.2e}")

print()
print("float64 的 eps =", np.finfo(np.float64).eps)
print("1 + 1e-16 == 1 吗:", 1 + 1e-16 == 1)
小量的对数:逐行比较
xlog(1+x)log1p(x)相对误差
1e-1609.9999999999999998e-171.00e+00
1e-101.000000082690371e-109.9999999995000007e-118.27e-08
1e-089.9999998892252911e-099.999999950000001e-096.08e-09
1e-059.9999500003988414e-069.9999500003333302e-066.55e-12
小量的指数:逐行比较
xexp(x)-1expm1(x)相对误差
1e-1609.9999999999999998e-171.00e+00
1e-101.000000082740371e-101.00000000005e-108.27e-08
1e-089.9999999392252903e-091.0000000049999999e-081.11e-08
1e-051.0000050000069649e-051.0000050000166668e-059.70e-12

float64 的 eps = 2.220446049250313e-16

1 + 1e-16 == 1 吗: True

成因只有一句:float64 的 eps 是 2.22e-16,意思是「1 附近能分辨的最小间隔」。 1 + 1e-16 就等于 1(实测 True),所以 log(1 + 1e-16) 只能是 log(1) = 0 ——那个 x 在做加法的那一瞬间就被扔掉了,log 是无辜的。

⭐ 真正难查的不是 x=1e-16 那一行,是 x=1e-10 那一行:

x 出了什么事 你会发现吗
1e-16 结果是 0,相对误差 100% ⭐ 会。0 太扎眼了
1e-10 结果是 1.000000082690371e-10,相对误差 8.3e-8 💀 不会。它看起来完全正常,只是悄悄丢了 7 位有效数字
1e-5 相对误差 6.6e-12 无所谓

💀 一个「看起来对、其实只剩 8 位有效数字」的中间量,会一路往下游传,最后表现成「模型指标差了 0.3%,查不出原因」。

⭐ 判据很简单:只要你在算 log(1 + 很小的东西) 或者 exp(很小的东西) - 1,就换成 log1p / expm1。不用先判断它多小,log1p(5.0) 和 log(6.0) 也是一样的答案,换过去没有代价。

⚠️ log1p 在站内出现过 11 次,全部是特征工程的长尾变换(把 amount 压平)。那个用途是对的,⭐ 但它顺带还有本节这个数值用途,站里从没提过。两个用途没有冲突——np.log1p(df["amount"]) 同时享受了两者。

03 / 完整解释

把稳定写法带进 loss。

🧩 五、一个真实现场:BCE 为什么要写成 log 域

站内 ML 基础 · 18 · 挑战项目 A · 手搓 mini-torch 有一条要求是「BCE 要用 logsumexp 形式」。这一节把那句话展开。

下面只算无权重、逐元素 BCE:输入是可表示为 float64 的有限实数 logits,目标 y∈[0,1](含 0/1 硬标签和区间内软标签),形状须可广播。教学函数显式转成 float64;非有限值或越界目标报 ValueError,不把它们当作正常样本。

import numpy as np
import warnings

x = np.array([-800., -50., 0., 50., 800.])

with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter("always")
    naive = np.log(1 + np.exp(x))              # softplus 的教科书写法
    print("naive log(1+exp(x)) =", naive, "|", w[0].message if w else "无警告")

print("np.logaddexp(0, x)  =", np.logaddexp(0, x))   # 同一个东西,不会炸

def bce_naive(z, y):
    p = 1 / (1 + np.exp(-z))
    return -(y * np.log(p) + (1 - y) * np.log(1 - p))

def bce_stable(z, y):
    z = np.asarray(z, dtype=np.float64)
    y = np.asarray(y, dtype=np.float64)
    if (not np.all(np.isfinite(z)) or not np.all(np.isfinite(y))
            or np.any((y < 0) | (y > 1))):
        raise ValueError("finite logits and targets in [0, 1] required")
    tail = np.log1p(np.exp(-np.abs(z)))
    return np.maximum(z, 0) * (1 - y) + np.maximum(-z, 0) * y + tail

z = np.array([-800., -30., 0., 30., 800.])
y = np.array([1., 1., 1., 0., 0.])
with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter("always")
    print()
    print("naive  BCE =", bce_naive(z, y), "| 警告", [str(i.message) for i in w])
print("stable BCE =", bce_stable(z, y))

对照

naive log(1+exp(x)) = [ 0. 0. 0.69314718 50. inf] | overflow encountered in exp

np.logaddexp(0, x) = [0.00000000e+00 1.92874985e-22 6.93147181e-01 5.00000000e+01

8.00000000e+02]

naive BCE = [ inf 30. 0.69314718 30.00102056 inf] | 警告 ['overflow encountered in exp', 'divide by zero encountered in log', 'divide by zero encountered in log']

stable BCE = [8.00000000e+02 3.00000000e+01 6.93147181e-01 3.00000000e+01

8.00000000e+02]

三处出事,严重程度递增:

位置 naive stable 说明
z=±800 inf 800.0 ⭐ 会炸掉整个 batch 的 loss
x=-50 那一格 0.0 1.93e-22 小量被吃掉——log(1+exp(-50)) 里的 1+ 把它抹平了
💀 z=30, y=0 30.00102056 30.0 💀 既没报错也没出 inf,就是错的

💀 最后一行才是这一节的价值。p = 1/(1+exp(-30)) 约等于 1 − 9.36e-14,接着算 1 - p 时前 13 位全被抵消掉——这是上一节 log1p 那个坑的同一种病,只是换了个身份出现。它不报警告、不出 inf、数量级也对,只是从第 4 位小数开始就是错的。

⭐ np.logaddexp(0, x) 就是 softplus 的正确写法,也是 log(1+exp(x)) 这个式子在 NumPy 里的标准答案。记住这一个搭配,比记住整个推导有用。

⚠️ softplus 稳定,不代表任意等价变形都保住小损失。旧写法 np.logaddexp(0,-z)+(1-y)*z 在 z=-50,y=0 会把约 50 与 −50 相加,float64 得到 0;新函数拆成非负线性项,再加 log1p(exp(-abs(z))),避免这次相消。(z,y)=(-50,0) 与 (50,1) 均约为 1.9287498479639178e-22;(-800,1) 与 (800,0) 均为 800。正确极端标签在 ±800 的真损失已低于 float64 可表示范围,可以下溢成 0;稳定计算不等于无限精度。

依据:PyTorch 2.14 的 BCE 定义与目标范围、NumPy 2.3 log1p 的小量精度说明。这里的非负项写法由同一 BCE 定义代数整理,并用高精度标量参考核对;没有声称与某个框架内核逐位一致或完成模型训练验证。


🧩 六、np.errstate:让它报错,而不是静默出 inf

import numpy as np

print("默认行为 exp(800) =", np.exp(np.array([800.0])))

for kind, expr in [
    ("over",    lambda: np.exp(np.array([800.0]))),
    ("invalid", lambda: np.array([np.inf]) - np.inf),
    ("divide",  lambda: np.array([1.0]) / np.array([0.0])),
    ("under",   lambda: np.exp(np.array([-800.0]))),
]:
    try:
        with np.errstate(**{kind: "raise"}):
            r = expr()
        print(f"{kind:<8} 没抓到,结果 = {r}")
    except FloatingPointError as e:
        print(f"{kind:<8} FloatingPointError: {e}")

print()
print("nan 的检测  np.isnan([nan, 1.0])    =", np.isnan(np.array([np.nan, 1.0])))
print("inf 的检测  np.isfinite([inf, 1.0]) =", np.isfinite(np.array([np.inf, 1.0])))
print("nan == nan  ->", np.nan == np.nan, "  所以只能用 isnan")

对照

默认行为 exp(800) = [inf]

over FloatingPointError: overflow encountered in exp

invalid FloatingPointError: invalid value encountered in subtract

divide FloatingPointError: divide by zero encountered in divide

under FloatingPointError: underflow encountered in exp

因果链

nan 的检测 np.isnan([nan, 1.0]) = [ True False]
inf 的检测 np.isfinite([inf, 1.0]) = [False True]
nan == nan -> False 所以只能用 isnan

四种浮点错误,errstate 全都能变成异常:

种类 什么时候触发 该不该 raise
over 结果太大 → inf ⭐ 该。几乎一定是 bug
invalid inf - inf、0/0、sqrt(-1) → nan ⭐ 最该。nan 会污染下游所有计算
divide 除以 0 → inf,log(0) → -inf ⭐ 该,除非你确实想要 -inf(log 域里 -inf 表示概率 0,是合法的)
under 结果太小 → 0 ⚠️ 通常不该。归一化之后大量小数下溢是正常的,开了会满地噪声

⭐ 推荐用法:不要全局 np.seterr,用 with np.errstate(...) 只包住你怀疑的那几行:

import numpy as np

def normalize(x):
    with np.errstate(divide="raise", invalid="raise"):    # 只管这一段
        return x / x.sum()

print(normalize(np.array([1., 2., 3.])))
try:
    print(normalize(np.array([0., 0., 0.])))              # 0/0
except FloatingPointError as e:
    print("提前抓住了:", e)

print("with 之外:", np.array([0., 0., 0.]) / 0.0)          # 同一件事,又变回静默

要点

[0.16666667 0.33333333 0.5 ]

提前抓住了: invalid value encountered in divide

with 之外: [nan nan nan]

⚠️ 最后一行是这段的重点:errstate 的作用域严格限于 with 块内,出了块同一件事又静默出 nan。所以它是「在可疑的地方装一个报警器」,不是「全局保险」。

💀💀 一条必须记住的边界:np.errstate 不能保证捕获整数数组回绕。08 章的 int32 数组最大值加 1 在 all="raise" 中仍得到 −2147483648;但部分整数标量运算受错误设置影响,例如 np.int16(32000) * np.int16(3) 可在 over="raise" 下抛 FloatingPointError。要分清标量、数组和具体运算,不能把浮点保护当作通用整数范围检查。

04 / 完整解释

用输入范围检查自己的实现。

🔗 这一章连到哪里

相关的地方 为什么
ML 基础 · 附录 C · 手撕代码速查 ⭐ 第 1 题「Softmax + 交叉熵」是白板上怎么写,那是面试的得分点,本章不重复。⭐ 两边是「动作」和「阈值」的关系:那里说「减 max 防溢出」,这里告诉你 float64 是 709.78、float32 是 88.72、float16 是 11.09
ML 基础 · 18 · 挑战项目 A · 手搓 mini-torch 那里有两处把「用 logsumexp 技巧」「BCE 要用 logsumexp 形式」当命令给出。⭐ 本章第五节就是把那两句话展开——包括 z=30, y=0 那个既不报错也不出 inf、只是从第 4 位小数开始错的例子
08 · 整数 dtype 的真相 💀 np.errstate 不能通用地捕获整数数组回绕;08 章数组加法在 all="raise" 中仍回绕,但部分整数标量运算会受设置影响。两章一起核对保护范围
AI 基础设施 · 06 · 混合精度 该选哪个精度训练、loss scaling 怎么配,是那一章的题(工程选型)。本章只给数值行为:每个 dtype 的 exp 在哪一格炸。⭐ float16 的 11.09 正是那边要 loss scaling 的原因之一
数学原理 · 05c · SVD 与实践 ⚠️ 那里也讲「数值稳定」,但说的是线性代数意义(条件数、正规方程为什么把 κ 平方掉)。本章只讲浮点表示 + exp/log 一族。两边不重叠,撞上「数值不稳定」这个词时先分清是哪一种
ML 基础 · 16 · 特征工程基础 那里用 np.log1p 做长尾变换。⭐ 本章第四节说的是同一个函数的另一个用途(小量的有效数字),两个用途不冲突,一行代码同时享受

✅ 检查点

  1. 怎样用最大值写出 np.logaddexp(800, 801) 对应的数学式?为什么平移后求指数不会溢出?
  2. NumPy 里有 logsumexp 这个函数吗?不装 scipy 的话该写什么?
  3. 2000 个 1e-4 到 1e-3 之间的概率连乘,np.prod 给什么?乘到第几个就出问题了?log 域给的是多少?
  4. float64 / float32 / float16 的 exp 临界指数各是多少?这三个数怎么查出来的?
  5. np.exp(90) 是 inf 吗?
  6. log(1 + 1e-16) 为什么是 0?这是 log 的问题吗?
  7. log(1+x) 在 x=1e-16 和 x=1e-10 两种情况下,哪一种更危险?为什么?
  8. log(1 + exp(x)) 的正确写法是什么?
  9. naive BCE 在 z=30, y=0 上给出 30.00102056 而正确答案是 30.0 —— 它报错了吗?成因是什么?
  10. np.errstate 的四种错误里,哪一种通常不该开 raise?为什么?
  11. np.errstate(all="raise") 能不能兜住整数溢出?
👀 答案
  1. 代入得 801 + log(1 + exp(−1)),约为 801.3132616875。这里求的是 exp(−1),非正的指数使指数结果不超过 1。
  2. NumPy 可用 np.logaddexp.reduce(z) 沿指定轴归约,SciPy 另提供 scipy.special.logsumexp。两种算法在实数运算中等价,浮点值可能略有不同。
  3. np.prod 给 0.0。💀 乘到第 99 个就变成 0 了(那时累积 log 值是 −751.01,已越过 −745 那道下溢线)。log 域给 −15314.752401524813,好端端地待着。
  4. 709.78 / 88.72 / 11.09。用 np.log(np.finfo(dtype).max) 查——exp 的临界指数就是「该 dtype 最大值的对数」。实测最后一个不炸的整数分别是 709 / 88 / 11。
  5. float64 下不是:np.exp(90) = 1.2204032943178408e+39,一个有限的正常数字。⚠️ 但 np.exp(np.float32(90)) 是 inf。「多大算大」没有统一答案,只有 per-dtype 的答案。
  6. 因为 float64 的 eps 是 2.22e-16,1 + 1e-16 就等于 1(实测 True)。不是 log 的问题——那个 x 在做加法的那一瞬间就被扔掉了。
  7. x=1e-10 更危险。1e-16 那种结果直接是 0,相对误差 100%,太扎眼一定会被发现;1e-10 给的是 1.000000082690371e-10,看起来完全正常,只是悄悄丢了 7 位有效数字(相对误差 8.3e-8),会一路传到下游变成「指标差 0.3% 查不出原因」。
  8. np.logaddexp(0, x)。它就是 softplus 的标准写法。
  9. ⚠️ 没报错,也没出 inf,数量级还是对的。成因:p = 1/(1+exp(-30)) 约等于 1 − 9.36e-14,算 1 - p 时前 13 位全被抵消——和第四节 log1p 那个坑是同一种病,只是换了身份。正确写法 bce_stable(z, y) 的非负项写法给出显示为 30.0 的结果,也保留正确标签在 ±50 时的小损失。
  10. under(下溢)通常不该开。归一化之后大量小数下溢是正常现象,开了满地噪声。最该开的是 invalid ——nan 会污染下游所有计算。
  11. 不能当通用保护。 08 章的 int32 数组最大值加 1 即使放在 np.errstate(all="raise") 里,仍静默回绕为 −2147483648;部分整数标量运算却会报告溢出,例如 np.int16(32000) * np.int16(3) 在 over="raise" 中抛出 FloatingPointError。应区分具体标量或数组运算。

本节回顾

⚡ 走神救援

⭐ 核心恒等式:log(e^a + e^b) = max(a,b) + log(1 + e^−|a−b|)。 对有限实数,平移后的指数非正,exp 不会溢出,极小项仍可能下溢。按行归约时先写出形状,若还要把每行分母广播回该行,就用 keepdims=True 保留被归约的轴。

NumPy 可用 np.logaddexp.reduce 计算每组的对数总权重。手写 max-shift 前先确认每组有有限的最大值。全为 −inf 的一组总权重是 0,无法归一化。

⭐ 它真正的价值在防下溢那一半:几千个小概率连乘,np.prod 直接给 0.0——而且乘到第一百个左右就已经归零了;log 域里同一个量是个正常的负数。所以连乘换连加、归一化换成减 logsumexp,⭐ 能不换回原始域就别换(比大小直接比 log 值)。

⚠️⚠️ 「多大算大」只有 per-dtype 的答案:同一个指数 90,float64 下是个有限的数,float32 下就是 inf。溢出阈值大致是 float64 约 709、float32 约 88、float16 约 11。

log1p / expm1:1 + 1e-16 == 1 为真,所以 log(1+1e-16) 只能是 0——⭐ 不是 log 的错,是加法先把它扔了。

💀 但真正危险的不是那个明显归零的,而是中间那一档:结果看起来完全正常,却悄悄丢了七位有效数字,然后一路传到下游。⭐ 判据很简单:只要在算 log(1+很小) 或 exp(很小)-1,就换 log1p / expm1。

下一节 👉 10-随机数种子与可复现.md

打卡记录保存在你的浏览器里,首页能看到总进度

计算路径稳定后,实验还需要可复现。随机数生成器现在处于哪一个状态?