读前准备。先跟着本章手算取余。到洗牌时会用到 第 02 章的数组形状与轴和第 06 章的整数数组索引。
运行代码需要 Python 和 NumPy 1.25 或以上版本。多进程示例需保存为 .py 文件。固定输出在 Windows、NumPy 2.3.5 上核对。
阅读范围、用时与原有实验记录
实验记录怎么读
本页原有耗时、内存、报错和环境值保留为原文记录;本轮内容审校未逐项复跑这些实验。版本、硬件、数据和测量方法都会影响结果,示例中的倍数也不是保证。需要复现时先核对依赖版本,再在同一输入下比较。
01 / 完整解释
相同种子,不等于相同运行状态。
🎯 一句话
假设四个任务要给四份订单数据随机抽样。你在每个任务开头都写了 np.random.seed(42),四份结果却从同一个数开始。把实验重跑一次,这个现象又出现了。要解释它,先看程序怎样一边出数,一边记住自己走到了哪一步。
🧩 一、从种子和状态开始
伪随机数(pseudorandom numbers)是用确定的计算规则生成、在抽样中用来模拟随机选择的一串数。
种子(seed)是建立起点的输入。状态(state)是继续生成时要读取的内部记录。抽过数后,状态会更新。
教学用状态模型。为了看清重开和续跑的差别,假设内部只存一个整数。演示参数是乘数 3、增量 1 和除数 7。每一步把状态乘 3、加 1,再取除以 7 的余数,余数也作为本步的输出。
s(t+1) = (3 × s(t) + 1) mod 7
t 是已经完成的步数,从 0 开始。s(t) 是当前状态,s(t+1) 是再抽一次之后的状态。
mod 7 表示取余数,所以状态只会是 0 到 6 之间的整数。演示里选种子 2,并直接令初始状态 s(0) = 2。
| 第几次抽样 | 代入与取余(粗体为输出) |
|---|---|
| 第 1 次 | 3 × 2 + 1 = 7,7 = 1 × 7 + 0 |
| 第 2 次 | 3 × 0 + 1 = 1,1 = 0 × 7 + 1 |
| 第 3 次 | 3 × 1 + 1 = 4,4 = 0 × 7 + 4 |
第二次抽完时存下状态 1,恢复后下一次得到 4。用种子 2 重开,下一次又得到 0。这条短规则只用来演示状态怎样更新,循环很短,实际采样使用 NumPy 的生成器。
def draw(state, count):
values = []
for _ in range(count):
state = (3 * state + 1) % 7 # % 表示取余数
values.append(state)
return state, values
saved_state, first_two = draw(state=2, count=2)
_, continued = draw(state=saved_state, count=1)
_, restarted = draw(state=2, count=1)
print(first_two, saved_state) # [0, 1] 1
print(continued, restarted) # [4] [0]
draw 接收起始状态和抽样次数。range(count) 让循环恰好运行 count 次。循环里的 _ 表示这一步只需重复执行,当前编号用不到。
函数返回结束状态和结果列表。saved_state, first_two 依次接住两个值,_, continued 表示这一回只保留输出。想续跑,就把 saved_state 用作下一次调用的起点。
本章聚焦 NumPy 的随机流。训练调试手册继续处理多库随机源与计算确定性,版本回溯与可复现还要记录代码、数据和环境。Kaggle 工程实践中记录种子的做法也依赖这些条件。
🧩 二、两代抽样接口:同一个种子,给的数不一样
手算例子直接把状态当输出。实际抽样还要让输出符合要求,例如从 0 到 99 取整数。应用程序编程接口(Application Programming Interface,API)就是代码调用这套功能的入口。
rng 存放这个对象,名字来自 random number generator。先预测下面三次比较。旧接口 randint(0, 100, 5) 和新接口 integers(0, 100, 5) 都取 5 个整数,候选范围是 0 到 99。array_equal 检查两份数组的形状和每个值。
import numpy as np
np.random.seed(42); a1 = np.random.randint(0, 100, 5)
np.random.seed(42); a2 = np.random.randint(0, 100, 5)
print("legacy seed(42) 两次 ->", a1, "/", a2, " 一致:", np.array_equal(a1, a2))
b1 = np.random.default_rng(42).integers(0, 100, 5)
b2 = np.random.default_rng(42).integers(0, 100, 5)
print("default_rng(42) 两次 ->", b1, "/", b2, " 一致:", np.array_equal(b1, b2))
print("同一个种子 42,两代 API 给的数一样吗:", np.array_equal(a1, b1))
| 比较 | 运行结果 |
|---|---|
| 旧接口重放 | 两次都是 [51 92 14 71 60]。 |
| 新接口重放 | 两次都是 [8 77 65 43 43]。 |
| 两代互比 | 两组数组不同。 |
- 旧接口
RandomState用梅森旋转算法(Mersenne Twister,MT19937)产生原始随机数据。- 新接口
default_rng(42)新建一个Generator,本例由 PCG64 负责更新状态、产生比特。PCG 是置换同余生成器(Permuted Congruential Generator)的缩写。
np.random.seed(42) 只重置旧接口的共享状态。default_rng(42) 使用传入的 42,default_rng() 省略种子时从操作系统取得随机输入。
要重放随机流,记录 NumPy 版本和构建、比特生成器、调用顺序和参数(包括输出大小)、运行环境和机器配置。详情见 NumPy 随机流兼容政策。
🧩 三、💀 全局状态:任何人都能动它
假设你正在用遗留 API 抽三条订单,另一段代码也调用同一个模块级接口。下面用相同的整数抽样模拟它提前取走一条。现代生成器的对照组则在中途调用一次遗留接口。
import numpy as np
np.random.seed(42)
direct = np.random.randint(0, 100, 3)
np.random.seed(42)
discarded = np.random.randint(0, 100)
shifted = np.random.randint(0, 100, 3)
print(direct, discarded, shifted) # [51 92 14] 51 [92 14 71]
rng = np.random.default_rng(42)
baseline = rng.integers(0, 100, 3)
rng = np.random.default_rng(42)
np.random.rand() # 这次抽样只使用遗留模块的共享状态
isolated = rng.integers(0, 100, 3)
print(isolated, np.array_equal(baseline, isolated)) # [ 8 77 65] True
相同的整数抽样先取走了 51,所以后面的三个整数变成 [92 14 71]。换成别的分布或参数,消耗的底层比特数也可能变,不能把这个观测套成「任何调用都只跳过一个整数」。
此处的 rng 来自 default_rng(42),拥有独立状态,旧接口的调用不会推进它。两个函数若共用同一个 rng,仍会轮流推进这份状态。
通常在调用方建好 rng,再传给抽样函数。额外的调试抽样可以使用另一个生成器,避开主流程的状态。
停一下。同一个对象会接着抽,新建同种子的对象会从头抽。下一节看看四个任务都从头抽会发生什么。
02 / 完整解释
给 worker 分配各自的子流。
🧩 四、💀💀 招牌坑:四个任务,同一个种子
工作进程(worker process)是负责执行任务的子进程。进程池(process pool)管理这些进程。一个进程可能处理多个任务。代码里有四项结果,因为 map 按输入顺序为四个任务各收集一项。
每个任务抽一个 0 到 9999 的整数。运行前先预测三种做法的差别。
- 全部重置成 42。比较四个任务的首个输出。
- 不指定种子。启动两轮进程池,观察结果是否重放。
- 从同一个根种子派生四个起点。比较两轮里同一个任务的结果。下一节展开派生步骤。
把代码保存为 rng_workers.py,运行 python rng_workers.py。if __name__ == "__main__": 让进程池只在直接运行脚本时创建。子进程导入脚本时可以读取任务函数。
import numpy as np
from multiprocessing import get_context
def fixed_seed(task_id):
np.random.seed(42)
return int(np.random.randint(0, 10000))
def no_seed(task_id):
return int(np.random.randint(0, 10000))
def child_seed(seed_seq):
rng = np.random.default_rng(seed_seq)
return int(rng.integers(0, 10000))
if __name__ == "__main__":
context = get_context("spawn")
with context.Pool(4) as pool:
print("每个任务都重置成 42", pool.map(fixed_seed, range(4)))
for run in (1, 2):
with context.Pool(4) as pool:
print("未记录种子", run, pool.map(no_seed, range(4)))
for run in (1, 2):
children = np.random.SeedSequence(42).spawn(4)
with context.Pool(4) as pool:
print("按任务分配子序列", run, pool.map(child_seed, children))
- 各自重置为 42
- 观察 四项都是 7270。同样的起点和抽样产生同样的选择。
- 复跑 保留种子 42 和抽样配置。
- 未管理遗留状态
- 观察 两轮通常不同。启动方式和调度都会影响结果。
- 复跑 这段代码没有记录起点和分配关系。
- 按任务派生子流
- 观察 两轮都是
[4974, 746, 7031, 8994]。 - 复跑 保留根种子、任务到子流的对应关系和抽样调用。
- 进程池的
spawn - 启动一个新的 Python 解释器来导入脚本,可用于 Windows 和 POSIX。示例里的 NumPy
spawn则负责派生抽样起点。 - 进程池的
fork - 支持它的 POSIX 系统可以从父进程继承状态,其中包括旧接口的随机状态。
两种启动方式下,任务主动重置同一个种子并进行同样的抽样,都会得到相同输出。省去重置时,观察几项不同的输出也无法判断子流是否独立。
例如四个任务给同一张图做随机裁剪,共用相同抽样流程和起点就会选中相同区域。只看训练损失通常找不到这类重复。
同种子、同抽样的四个任务都从 7270 开始。几项不同的输出也不足以判断独立性。
🧩 五、用 SeedSequence 派生可复跑的子流
要让每个任务下次都抽到自己的那一串数,需要为它保存可追踪的起点。种子序列(SeedSequence)把根种子与子节点在派生树里的位置混合,产生用来初始化生成器的数据。
ss = np.random.SeedSequence(42)↓ children = ss.spawn(4) 派生四个子节点
- 任务 0
位置(0,)
首抽 4974 - 任务 1
位置(1,)
首抽 746 - 任务 2
位置(2,)
首抽 7031 - 任务 3
位置(3,)
首抽 8994
i 的进程用 rng = np.random.default_rng(children[i]) 初始化。每个任务随后抽一个 0 到 9999 的整数。数值来自上一节的运行结果。位置 (2,) 是只有一个元素的元组,表示从根走到编号 2 的孩子。逗号表明括号里是元组。按这些位置初始化的随机子流以极高概率相互独立,两条流仍可能碰巧抽到相同整数。
用 42 新建根,再派生 3 个,得到位置 (0,)、(1,)、(2,)。
从同一个已派生 3 个孩子的根再派生 1 个,下一个位置是 (3,)。
下面的列表推导式 [int(k.integers(0, 10000)) for k in kids] 依次取出每个孩子 k,各抽一个整数,再把结果排进列表。先看两种方式是否都从新根开始。
import numpy as np
parent = np.random.default_rng(42)
kids = parent.spawn(3) # ⭐ Generator 自己就有 spawn
print("parent.spawn(3) 各抽一个:", [int(k.integers(0, 10000)) for k in kids])
ss = np.random.SeedSequence(42) # 也可以直接从 SeedSequence 出发
print("SeedSequence(42).spawn(3):",
[int(np.random.default_rng(c).integers(0, 10000)) for c in ss.spawn(3)])
两种写法都输出 [4974, 746, 7031]。parent.spawn(3) 需要 NumPy 1.25 或更高版本。新建根后改为派生 4 个孩子,前三个位置仍相同。
要让任务 2 换一个工作进程仍能重放,就让它继续使用位置 (2,),并保留生成器配置、环境和抽样调用。任务需要多次抽样时,在任务开头建一次生成器并复用。
停一下。用稳定的任务编号找子节点。进程号会变,任务也可能换到别的进程。下一节继续用生成器抽样,再让订单与标签一起换位置。
NumPy 并行随机数指南还介绍了其他划分随机流的方法。PyTorch 的 DataLoader 有自己的 worker 初始化机制,详情见 AI 基础设施第 22 章。
03 / 完整解释
恢复现场,需要的不只是起点。
🧩 六、Generator 的抽样与洗牌接口
先分清抽样和洗牌。抽样从候选里挑若干项。洗牌保留全部项目,只调整顺序。
integers(0, 10, 5) 取 5 个 0 到 9 的整数。加上 endpoint=True 后,10 也在候选范围内。一次输出里没有 10,仍可能包含这个候选。
choice(10, 4, replace=False) 从编号 0 到 9 抽 4 个,不放回,所以同一编号最多选一次。省略 replace 时默认有放回,同一编号可以再次抽中。
订单 0 抽完放回,可继续抽到 0。例如依次得到 [0, 1, 1]。Bootstrap(自助抽样)利用有放回抽样构造样本。
订单 0 抽完移出候选。只有两笔订单时,第三次没有可选的订单,choice(2, 3, replace=False) 会报 ValueError。
连续数值怎样分布。把可能抽到的数放到横轴上。图里,同样宽的两段在均匀分布下机会相同,在正态分布下越靠近中心通常越容易抽到。这里对照的是分布形状。
random(3) 从 0 到 1 取 3 个均匀浮点数,包含 0、排除 1。区间记号中的方括号表示包含端点,圆括号表示排除端点。比如 [0, 0.25) 和 [0.75, 1) 等宽,各占四分之一的机会。
normal(0, 1, 3) 取 3 个标准正态样本。第一个参数 0 是分布中心,第二个参数 1 是标准差,用来描述分散程度,第三个参数 3 是抽样个数。标准差越大,分布越宽。
第一组代码连续使用同一个 rng,每次调用都会推进状态。最后用新建的 orders_rng 单独验证放回边界,便于比较。表中的小数做了四舍五入。
import numpy as np
rng = np.random.default_rng(42)
print("integers (右端默认不含)", rng.integers(0, 10, 5))
print("integers endpoint=True ", rng.integers(0, 10, 5, endpoint=True))
print("random [0,1) ", np.round(rng.random(3), 4))
print("normal ", np.round(rng.normal(0, 1, 3), 4))
print("choice 无放回 ", rng.choice(10, 4, replace=False))
print("permutation (返回新的) ", rng.permutation(8))
a = np.arange(8)
rng.shuffle(a); print("shuffle (原地改) ", a)
# 只有两个候选编号,比较抽三次时的行为。
orders_rng = np.random.default_rng(42)
print("有放回,允许重复:", orders_rng.choice(2, 3).tolist()) # [0, 1, 1]
try:
orders_rng.choice(2, 3, replace=False)
except ValueError:
print("无放回:两个候选不能抽三个")
| 调用与约定 | 本次输出 |
|---|---|
| integers (右端默认不含) | [0 7 6 4 4] |
| integers endpoint=True | [9 0 7 2 1] |
| random [0,1) | [0.9756 0.7611 0.7861] |
| normal | [-0.0168 -0.853 0.8794] |
| choice 无放回 | [1 6 8 7] |
| permutation (返回新的) | [1 0 5 4 3 6 7 2] |
| shuffle (原地改) | [6 1 2 7 3 5 0 4] |
| 两项放回抽三次 | [0, 1, 1] |
| 两项无放回抽三次 | ValueError,候选不足 |
两代接口速查。迁移时先核对输入和结果的含义。
遗留(np.random.*) |
现代(rng.*) |
行为提示 |
|---|---|---|
seed(42) |
rng = np.random.default_rng(42) |
⭐ 从「播种」变成「建对象」 |
randint(0, 10) |
integers(0, 10) |
⭐ 新的多一个 endpoint= 参数,可以含右端 |
rand(3, 4) |
random((3, 4)) |
⚠️ 形状要写成元组,不是两个位置参数 |
randn(3) |
standard_normal(3) |
—— |
choice / shuffle / permutation |
同名 | 用途相近,迁移时核对参数、维度和输出 |
RandomState(42) |
Generator(PCG64(42)) |
新代码优先用 Generator。需要重放旧代码的流时保留旧接口。 |
对照二维数组的三种洗牌。回想第 02 章,沿 axis=1 改变列位置。先看多行是共用一次排列,还是各自抽一次排列,再看原数组是否被修改。
import numpy as np
m = np.arange(12).reshape(3, 4)
print("原始\n", m)
print("permutation(m, axis=1) 整列一起搬(各行同一套顺序)\n",
np.random.default_rng(0).permutation(m, axis=1))
print("permuted(m, axis=1) 每行独立打乱\n",
np.random.default_rng(0).permuted(m, axis=1))
a = np.arange(6)
b = np.random.default_rng(0).permutation(a)
print("\npermutation 返回新数组,原数组不动:", a, "->", b)
c = np.arange(6)
np.random.default_rng(0).shuffle(c)
print("shuffle 原地改:", c)
| 行 | 第 0 列 | 第 1 列 | 第 2 列 | 第 3 列 |
|---|---|---|---|---|
| 0 | 0 | 1 | 2 | 3 |
| 1 | 4 | 5 | 6 | 7 |
| 2 | 8 | 9 | 10 | 11 |
| 行 | 第 0 列 | 第 1 列 | 第 2 列 | 第 3 列 |
|---|---|---|---|---|
| 0 | 2 | 0 | 1 | 3 |
| 1 | 6 | 4 | 5 | 7 |
| 2 | 10 | 8 | 9 | 11 |
| 行 | 第 0 列 | 第 1 列 | 第 2 列 | 第 3 列 |
|---|---|---|---|---|
| 0 | 2 | 0 | 1 | 3 |
| 1 | 7 | 6 | 5 | 4 |
| 2 | 9 | 11 | 8 | 10 |
一维例子里,两种方法都得到 [3, 2, 5, 4, 0, 1]。permutation 返回新数组,shuffle 改动原数组。
| 函数 | 怎样重排 | 原数组 |
|---|---|---|
permutation(m, axis=1) |
整列一起搬,三行用同一套顺序 | ❌ 返回新的 |
permuted(m, axis=1) |
每行各自抽一次排列,两行偶尔也能抽到相同顺序 | 默认返回新的,out=m 时写回 m |
shuffle(m, axis=1) |
整列一起搬 | ⭐ 原地改 |
用同一组下标搬动两张表。有 4 笔订单,X 的每一行存一个耗时,单位是分钟。y 的同位置存标签,超过 20 分钟为 1,其余为 0。打乱后,每个耗时还应和它原来的标签配在一起。下面是本例抽到的下标 [2, 0, 1, 3]。
| 新位置 | 来源下标 | 耗时(分钟) | 标签 |
|---|---|---|---|
| 0 | 2 | 15 | 0 |
| 1 | 0 | 8 | 0 |
| 2 | 1 | 23 | 1 |
| 3 | 3 | 30 | 1 |
import numpy as np
X = np.array([[8], [23], [15], [30]])
y = np.array([0, 1, 0, 1])
rng = np.random.default_rng(0)
idx = rng.permutation(len(X))
X_shuffled = X[idx]
y_shuffled = y[idx]
print(idx.tolist()) # [2, 0, 1, 3]
print(X_shuffled[:, 0].tolist()) # [15, 8, 23, 30]
print(y_shuffled.tolist()) # [0, 0, 1, 1]
assert np.array_equal(y_shuffled, X_shuffled[:, 0] > 20)
len(X) 给出行数 4。permutation(4) 把 0 到 3 各用一次。X[idx] 和 y[idx] 用同一组原位置重排,第 0 轴上的订单与标签仍然成对。
X_shuffled[:, 0] 取出每笔订单的耗时。最后的断言逐项检查,超过 20 分钟的订单是否仍配到标签 1。
如果只移动耗时,23 分钟会移到新位置 2,和那里原有的标签 0 配错。分别调用两次 shuffle 也可能错位。两个结果的形状仍然相同。
接口参数可查阅 NumPy 放回抽样说明和正态抽样说明。
🧩 七、保存并恢复抽样状态
回到手算例子。存下第二步的状态 1 才能接着得到 4。实际程序要保存比特生成器的状态快照。下面固定使用 PCG64,比对不中断时的下一批数字和新对象从快照恢复后得到的数字。
import json
import numpy as np
rng = np.random.Generator(np.random.PCG64(0))
rng.random(100)
checkpoint = json.dumps(rng.bit_generator.state)
expected = rng.random(3)
restored = np.random.Generator(np.random.PCG64(0))
restored.bit_generator.state = json.loads(checkpoint)
actual = restored.random(3)
print(np.round(actual, 6)) # [0.479988 0.232373 0.801881]
print(np.array_equal(expected, actual)) # True
- 生成并记录。一次
rng.random(100)生成 100 个值。json.dumps将此时的状态字典转为 JSON(JavaScript Object Notation)文本,存进变量checkpoint。 - 接着抽。让原对象再抽 3 个值,留作参照。
- 恢复并比较。让新建的 PCG64 使用
json.loads还原出的状态,再抽 3 个值。两份原始数组逐元素相等,打印时才四舍五入。
这里的文本存在内存中。需要跨程序运行保存时,可以把文本写入文件,恢复时再读取。
这里的 JSON 转换适用于 PCG64。别的比特生成器的状态字典可能含 NumPy 数组,存取时要保留形状和类型,并用同类生成器恢复。
训练中途重启时,还需保存其他随机源、数据读取位置、模型和优化器状态。如果恢复后要继续派生子流,也要保存派生进度或完整的任务分配方案。详情见 模型上线之后第 17 章。
🚦 八、五条规矩
| 检查项 | 怎么做 |
|---|---|
| 随机源 | 新代码优先用 Generator。兼容旧库时分别管理旧接口、现代生成器及其他库的状态。 |
| 创建时机 | 为每个需要持续抽样的任务建一次 rng,把它传给该任务中的抽样函数。 |
| 并行分配 | 给每个任务分配可追踪的子流,保存任务标识与子流的对应关系。 |
| 恢复条件 | 从头重放要记种子、环境、比特生成器及抽样调用。从中途恢复还要记状态与进度。 |
| 结果波动 | 比较两种模型时,事先选定一组种子,报告每次结果及均值、标准差,避免只挑最有利的一次。 |
固定同一套随机输入有助于排查代码改动。比较两种模型时,可以事先定好一组种子,在每个种子下分别运行两种模型,再记录对应的差值。
准确率从 70.0% 到 70.3%,差值是 +0.3 个百分点。先看每次差值和平均差值,再看差值的分散程度,避免把一次提升当成稳定结果。
停一下。洗牌时对齐数据和标签。续跑时恢复当前状态。下一节用检查题回忆这两种操作各要保存什么。
04 / 完整解释
留下能复建的随机过程。
🔗 这一章连到哪里
| 相关课程 | 读到什么 |
|---|---|
| 07 · 把循环改写成数组运算 | 回看部分实验如何用 default_rng(0) 固定输入数组。重放这些输入和复现计时结果需要不同的条件。 |
| 09 · log 域运算 | 上一章处理相同输入下的数值稳定性。本章处理用随机方法生成的输入怎样对上。 |
| 11 · 从 NumPy 到 PyTorch | 下一章检查跨库的数组操作语义。扩展到训练时,还要分别管理 NumPy 的 Generator 与 PyTorch 的随机状态。 |
| ML 基础 · 11 · 训练调试手册 | 检查 Python、NumPy、PyTorch 及 GPU 运算的可复现设置。 |
| AI 基础设施 · 22 · 数据管线与存储 | 跟踪 DataLoader 怎样初始化工作进程并处理数据。 |
| Kaggle · 04 · 超参数调优与工程实践 | 把种子和配置一起记录到实验中,再比较模型设置。 |
| 模型上线之后 · 17 · 版本回溯与可复现 | 用代码版本、数据指纹和环境记录定位完整运行。 |
✅ 检查点
先在纸上预测结果,再跑相应的代码块核对。前 5 题检查起点和共享状态,第 6–9 题检查子流、抽样和洗牌,最后两题检查恢复和评估。
- 教学模型的第三步得到 4。存下 4 后读档,第四步是多少?用种子 2 重开又是多少?
- 同样传入 42,遗留和现代整数抽样示例为什么各自能重放,却得出不同的数组?
- 只调用
np.random.seed(42),能否控制后面的default_rng()?两个函数共享同一个rng时,额外抽样会怎样? - 在第三节的遗留实验中先取走哪个整数?随后的三个数是什么?
- 四个任务都主动重置同样的种子,为什么在
spawn下也会重复?如果省去重置,能凭四个值不同就确认独立吗? - 同一个
ss执行spawn(3)后再spawn(1),最后一个孩子的位置是什么?怎样让任务换到另一个 worker 执行时仍抽到同一组数? - 将
integers(0, 10)改成integers(0, 10, endpoint=True),候选范围变在哪里?若有两个候选,choice哪种设置能抽三次? - 二维数组中,
permutation(m, axis=1)、permuted(m, axis=1)与shuffle(m, axis=1)怎样搬列?哪一个就地改动原数组? - 用下标
[2, 0, 1, 3]打乱订单,若只移动X,23 分钟会对应哪个错误标签? - 训练第 30 轮结束后想继续抽数,为什么只存种子不够?
- 同一组种子下,新旧模型的指标差为 +0.3、−0.1、+0.1 个百分点。平均差是多少?每次都改善了吗?
👀 答案
- 第四步是
(3 × 4 + 1) mod 7 = 13 mod 7 = 6,因为13 = 1 × 7 + 6。重开则从 2 算起,第一步输出 0。 - 在相同的版本、环境、比特生成器和调用条件下,各自重放。示例的遗留接口基于 MT19937,现代接口默认用 PCG64,两条生成与采样路径给出不同结果。
- 模块级
seed只重置遗留共享状态。default_rng()从系统取随机输入。两个函数共享同一对象时,先执行的抽样会推进状态,影响后续结果。 - 先取走 51,接着得到
[92 14 71]。这里两处调用抽的是同一范围的整数。 - 子进程重新启动后,任务代码仍会把状态重置到同一个起点。省去重置后,观察到的不同值也无法证明独立,尤其还要考虑
fork可能继承状态。 - 最后一个位置是
(3,)。保存逻辑任务到子节点的映射,换进程时给它同一子节点,并保持抽样配置和顺序。 - 右端点 10 加入候选,整数范围变为 0 到 10。两个候选允许有放回抽三次。无放回最多抽两次。
permutation和shuffle用同一排列移动整列,其中shuffle就地修改。permuted对每一行分别抽排列,默认返回新数组。- 23 分钟被移到新位置 2,原标签序列在位置 2 是 0。用同一个
idx同时索引X和y会得到正确标签 1。 - 种子用于初始化。续跑要存下当时的比特生成器状态,用匹配的类型恢复。完整训练还要恢复数据读取位置等其他进度。
- 三次差值相加为
0.3 − 0.1 + 0.1 = 0.3个百分点,再除以 3 得 +0.1 个百分点。第二次下降。可用sum([0.3, -0.1, 0.1]) / 3核对,浮点结果约为 0.1。这三次的均值和逐次结果可以一并报告,观察是否有稳定改善还需结合实验的波动。
本节回顾
从头重放记录种子、比特生成器、调用和环境。并行抽样记录任务与子流的对应。从中途继续记录生成器当时的状态和任务进度。
如果刚回来,先做检查点第 1 题。算出读档后的 6 和重新开始时的 0,就可以接着看多进程子流。
下一章 从 NumPy 到 PyTorch。