阅读范围、用时与原有实验记录
实验记录怎么读
本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。
⏱ 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.503215 | 1 + 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 或 +inf | NaN 表示未知或无效。没有 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)))
| 浮点类型 | max | log(max) | eps | tiny |
|---|---|---|---|---|
| float64 | 1.7976931348623157e+308 | 709.78 | 2.220e-16 | 2.225e-308 |
| float32 | 3.4028234663852886e+38 | 88.72 | 1.192e-07 | 1.175e-38 |
| float16 | 65504.0 | 11.09 | 9.766e-04 | 6.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)
| x | log(1+x) | log1p(x) | 相对误差 |
|---|---|---|---|
| 1e-16 | 0 | 9.9999999999999998e-17 | 1.00e+00 |
| 1e-10 | 1.000000082690371e-10 | 9.9999999995000007e-11 | 8.27e-08 |
| 1e-08 | 9.9999998892252911e-09 | 9.999999950000001e-09 | 6.08e-09 |
| 1e-05 | 9.9999500003988414e-06 | 9.9999500003333302e-06 | 6.55e-12 |
| x | exp(x)-1 | expm1(x) | 相对误差 |
|---|---|---|---|
| 1e-16 | 0 | 9.9999999999999998e-17 | 1.00e+00 |
| 1e-10 | 1.000000082740371e-10 | 1.00000000005e-10 | 8.27e-08 |
| 1e-08 | 9.9999999392252903e-09 | 1.0000000049999999e-08 | 1.11e-08 |
| 1e-05 | 1.0000050000069649e-05 | 1.0000050000166668e-05 | 9.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
因果链
四种浮点错误,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 做长尾变换。⭐ 本章第四节说的是同一个函数的另一个用途(小量的有效数字),两个用途不冲突,一行代码同时享受 |
✅ 检查点
- 怎样用最大值写出
np.logaddexp(800, 801)对应的数学式?为什么平移后求指数不会溢出? - NumPy 里有
logsumexp这个函数吗?不装 scipy 的话该写什么? - 2000 个 1e-4 到 1e-3 之间的概率连乘,
np.prod给什么?乘到第几个就出问题了?log 域给的是多少? - float64 / float32 / float16 的
exp临界指数各是多少?这三个数怎么查出来的? np.exp(90)是inf吗?log(1 + 1e-16)为什么是 0?这是log的问题吗?log(1+x)在 x=1e-16 和 x=1e-10 两种情况下,哪一种更危险?为什么?log(1 + exp(x))的正确写法是什么?- naive BCE 在
z=30, y=0上给出 30.00102056 而正确答案是 30.0 —— 它报错了吗?成因是什么? np.errstate的四种错误里,哪一种通常不该开 raise?为什么?np.errstate(all="raise")能不能兜住整数溢出?
👀 答案
- 代入得
801 + log(1 + exp(−1)),约为 801.3132616875。这里求的是exp(−1),非正的指数使指数结果不超过 1。 - NumPy 可用
np.logaddexp.reduce(z)沿指定轴归约,SciPy 另提供scipy.special.logsumexp。两种算法在实数运算中等价,浮点值可能略有不同。 np.prod给 0.0。💀 乘到第 99 个就变成 0 了(那时累积 log 值是 −751.01,已越过 −745 那道下溢线)。log 域给 −15314.752401524813,好端端地待着。- 709.78 / 88.72 / 11.09。用
np.log(np.finfo(dtype).max)查——exp的临界指数就是「该 dtype 最大值的对数」。实测最后一个不炸的整数分别是 709 / 88 / 11。 - float64 下不是:
np.exp(90) = 1.2204032943178408e+39,一个有限的正常数字。⚠️ 但np.exp(np.float32(90))是inf。「多大算大」没有统一答案,只有 per-dtype 的答案。 - 因为 float64 的
eps是 2.22e-16,1 + 1e-16就等于 1(实测True)。不是log的问题——那个 x 在做加法的那一瞬间就被扔掉了。 - x=1e-10 更危险。1e-16 那种结果直接是 0,相对误差 100%,太扎眼一定会被发现;1e-10 给的是 1.000000082690371e-10,看起来完全正常,只是悄悄丢了 7 位有效数字(相对误差 8.3e-8),会一路传到下游变成「指标差 0.3% 查不出原因」。
np.logaddexp(0, x)。它就是 softplus 的标准写法。- ⚠️ 没报错,也没出
inf,数量级还是对的。成因:p = 1/(1+exp(-30))约等于1 − 9.36e-14,算1 - p时前 13 位全被抵消——和第四节log1p那个坑是同一种病,只是换了身份。正确写法bce_stable(z, y)的非负项写法给出显示为 30.0 的结果,也保留正确标签在 ±50 时的小损失。 under(下溢)通常不该开。归一化之后大量小数下溢是正常现象,开了满地噪声。最该开的是invalid——nan会污染下游所有计算。- 不能当通用保护。 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