🏠 总目录📚 本教程 10 · 随机数种子与可复现 ← →

NUMPY / 10 · 10 · 随机数、种子与可复现

四个任务都在随机抽样,为什么抽到同一段?

想让四个任务各自抽一串数,下次重跑又能对上。先分清从哪里开始、现在走到哪里,以及每个任务用哪一串。

学完后,你能预测什么时候会重复抽样,给任务分配各自的随机数序列(子流),并从保存的位置接着抽。

一个根种子,四个任务起点 根种子 42 派生四个子节点。任务 0 到 3 分别使用位置 0 到 3 的子节点。 根种子 42 位置 0任务 0 位置 1任务 1 位置 2任务 2 位置 3任务 3 重跑时,按任务编号找回起点
先看根,再沿分支找到任务。换一个工作进程执行任务 2,仍然把位置 2 分给它。

读前准备。先跟着本章手算取余。到洗牌时会用到 第 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。

种子取 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)就是代码调用这套功能的入口。

比特生成器(BitGenerator)保存内部状态,生成由 0 和 1 组成的原始随机数据。
随机数生成器(Generator)按抽样请求把原始数据变成样本,例如五个整数。后文用变量 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 的整数。运行前先预测三种做法的差别。

  1. 全部重置成 42。比较四个任务的首个输出。
  2. 不指定种子。启动两轮进程池,观察结果是否重放。
  3. 从同一个根种子派生四个起点。比较两轮里同一个任务的结果。下一节展开派生步骤。

把代码保存为 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)把根种子与子节点在派生树里的位置混合,产生用来初始化生成器的数据。

根种子 42
ss = np.random.SeedSequence(42)

↓ children = ss.spawn(4) 派生四个子节点

  1. 任务 0
    位置 (0,)
    首抽 4974
  2. 任务 1
    位置 (1,)
    首抽 746
  3. 任务 2
    位置 (2,)
    首抽 7031
  4. 任务 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 时默认有放回,同一编号可以再次抽中。

放回抽样(sampling with replacement)

订单 0 抽完放回,可继续抽到 0。例如依次得到 [0, 1, 1]。Bootstrap(自助抽样)利用有放回抽样构造样本。

不放回抽样(sampling without replacement)

订单 0 抽完移出候选。只有两笔订单时,第三次没有可选的订单,choice(2, 3, replace=False) 会报 ValueError。

连续数值怎样分布。把可能抽到的数放到横轴上。图里,同样宽的两段在均匀分布下机会相同,在正态分布下越靠近中心通常越容易抽到。这里对照的是分布形状。

均匀分布和标准正态分布的形状 均匀分布在 0 到 1 的区间内密度恒定。标准正态分布以 0 为中心,密度向两边降低。 均匀分布 区间内密度相同 01 标准正态分布 中心附近密度更高 −303
示意图。横轴是可能抽到的值,纵向高度表示相对密度。正态曲线仍向两端延伸。

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 列
00123
14567
2891011
整列移动,三行共用下标顺序 2、0、1、3
行第 0 列第 1 列第 2 列第 3 列
02013
16457
2108911
逐行洗牌,每行分别抽排列
行第 0 列第 1 列第 2 列第 3 列
02013
17654
2911810

一维例子里,两种方法都得到 [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]。

按同一组下标移动订单耗时和标签
新位置来源下标耗时(分钟)标签
02150
1080
21231
33301
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
  1. 生成并记录。一次 rng.random(100) 生成 100 个值。json.dumps 将此时的状态字典转为 JSON(JavaScript Object Notation)文本,存进变量 checkpoint。
  2. 接着抽。让原对象再抽 3 个值,留作参照。
  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 题检查子流、抽样和洗牌,最后两题检查恢复和评估。

  1. 教学模型的第三步得到 4。存下 4 后读档,第四步是多少?用种子 2 重开又是多少?
  2. 同样传入 42,遗留和现代整数抽样示例为什么各自能重放,却得出不同的数组?
  3. 只调用 np.random.seed(42),能否控制后面的 default_rng()?两个函数共享同一个 rng 时,额外抽样会怎样?
  4. 在第三节的遗留实验中先取走哪个整数?随后的三个数是什么?
  5. 四个任务都主动重置同样的种子,为什么在 spawn 下也会重复?如果省去重置,能凭四个值不同就确认独立吗?
  6. 同一个 ss 执行 spawn(3) 后再 spawn(1),最后一个孩子的位置是什么?怎样让任务换到另一个 worker 执行时仍抽到同一组数?
  7. 将 integers(0, 10) 改成 integers(0, 10, endpoint=True),候选范围变在哪里?若有两个候选,choice 哪种设置能抽三次?
  8. 二维数组中,permutation(m, axis=1)、permuted(m, axis=1) 与 shuffle(m, axis=1) 怎样搬列?哪一个就地改动原数组?
  9. 用下标 [2, 0, 1, 3] 打乱订单,若只移动 X,23 分钟会对应哪个错误标签?
  10. 训练第 30 轮结束后想继续抽数,为什么只存种子不够?
  11. 同一组种子下,新旧模型的指标差为 +0.3、−0.1、+0.1 个百分点。平均差是多少?每次都改善了吗?
👀 答案
  1. 第四步是 (3 × 4 + 1) mod 7 = 13 mod 7 = 6,因为 13 = 1 × 7 + 6。重开则从 2 算起,第一步输出 0。
  2. 在相同的版本、环境、比特生成器和调用条件下,各自重放。示例的遗留接口基于 MT19937,现代接口默认用 PCG64,两条生成与采样路径给出不同结果。
  3. 模块级 seed 只重置遗留共享状态。default_rng() 从系统取随机输入。两个函数共享同一对象时,先执行的抽样会推进状态,影响后续结果。
  4. 先取走 51,接着得到 [92 14 71]。这里两处调用抽的是同一范围的整数。
  5. 子进程重新启动后,任务代码仍会把状态重置到同一个起点。省去重置后,观察到的不同值也无法证明独立,尤其还要考虑 fork 可能继承状态。
  6. 最后一个位置是 (3,)。保存逻辑任务到子节点的映射,换进程时给它同一子节点,并保持抽样配置和顺序。
  7. 右端点 10 加入候选,整数范围变为 0 到 10。两个候选允许有放回抽三次。无放回最多抽两次。
  8. permutation 和 shuffle 用同一排列移动整列,其中 shuffle 就地修改。permuted 对每一行分别抽排列,默认返回新数组。
  9. 23 分钟被移到新位置 2,原标签序列在位置 2 是 0。用同一个 idx 同时索引 X 和 y 会得到正确标签 1。
  10. 种子用于初始化。续跑要存下当时的比特生成器状态,用匹配的类型恢复。完整训练还要恢复数据读取位置等其他进度。
  11. 三次差值相加为 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。

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

即使两边都叫随机数,NumPy 与 PyTorch 也没有同一份生成器状态。跨库前逐一核对语义。