Python随机种子设置全攻略：从NumPy到PyTorch的实战避坑指南

你是否曾经遇到过这样的场景：你和同事运行同一份代码，甚至你自己在不同时间运行同一份代码，得到的模型训练结果却大相径庭？损失曲线飘忽不定，最终准确率相差好几个百分点，让你怀疑人生。或者，你在调试一个棘手的bug时，因为每次运行程序的行为都略有不同，导致问题难以复现和定位。如果你在深度学习或数据科学领域工作过，这种“随机性”带来的困扰，大概率是家常便饭。

问题的核心，往往不在于算法本身，而在于我们未能有效地控制程序中的“随机源”。在Python的生态里，从数据预处理、模型初始化到训练过程中的数据采样，随机性无处不在。NumPy、PyTorch、TensorFlow，甚至Python内置的random模块，都有自己独立的随机数生成器。如果不对它们进行妥善的“驯服”，实验的可复现性就无从谈起。

设置随机种子，正是我们给这些“随机源”戴上缰绳的关键操作。但这件事远不止在代码开头写几行seed=42那么简单。不同的库、不同的硬件环境（尤其是GPU）、甚至不同的库版本，都可能让看似简单的种子设置失效。这篇文章，我将结合自己多次“踩坑”的经验，为你梳理一份从原理到实战，覆盖NumPy和PyTorch两大核心库的随机种子设置全指南。我们不仅要知其然，更要知其所以然，并彻底解决那些“设置了种子但结果仍不一致”的典型困惑。

1. 理解伪随机：随机种子背后的数学引擎

在深入代码之前，我们必须先打破一个迷思：计算机生成的随机数，几乎都是“伪随机数”。它们并非真正的随机，而是由一个确定的数学公式（伪随机数生成器，PRNG）计算出来的。这个公式需要一个初始值来启动整个计算序列，这个初始值，就是随机种子。

你可以把PRNG想象成一个非常非常长的、预先写好的数字列表。随机种子，就是决定你从这份列表的哪个位置开始读取的“页码”。只要种子相同，你读到的数字序列就完全相同。这就是可复现性的基石。

import random

# 设置种子
random.seed(42)
print("第一次序列:", [random.randint(1, 100) for _ in range(3)])

# 重置种子到相同值
random.seed(42)
print("第二次序列:", [random.randint(1, 100) for _ in range(3)])

# 不重置种子，继续生成
print("继续生成:", [random.randint(1, 100) for _ in range(3)])

运行上述代码，你会发现前两次输出完全一致，而第三次输出则不同。这是因为前两次我们都从序列的“同一页”开始读，而第三次则是接着第二次读完的地方继续往下读。

关键点：设置一次种子，只能保证从该点开始生成的序列是确定的。一旦程序中的其他部分（可能来自不同模块）消耗了随机数，而没有重置种子，整个系统的状态就会“漂移”。因此，完整的控制需要覆盖所有可能产生随机性的源头。

2. NumPy随机种子的精细控制

NumPy是科学计算的基石，其随机数生成器被广泛用于数据洗牌、初始化等操作。控制NumPy的随机性，是第一步。

2.1 基础设置与常见陷阱

最基本的操作是np.random.seed()。但这里有个细节：从NumPy 1.17版本开始，官方推荐使用更灵活的随机状态生成器（Generator）API，而非旧的全局状态方法。不过，为了兼容性和理解原理，我们先从经典的开始。

import numpy as np

# 经典方法：设置全局种子
np.random.seed(2024)
arr1 = np.random.rand(3)
print("arr1:", arr1)

# 再次调用，会继续消耗全局随机数流
arr2 = np.random.rand(3)
print("arr2:", arr2) # 与arr1不同

# 重置全局种子，序列从头开始
np.random.seed(2024)
arr3 = np.random.rand(3)
print("arr3:", arr3) # 与arr1完全相同

陷阱一：多线程/进程环境。在并行计算中，每个线程或进程可能会干扰全局的随机状态，导致不确定性。此时，需要为每个进程创建独立的随机数生成器实例。

陷阱二：第三方库的干扰。许多库内部会使用NumPy生成随机数，它们可能在你不知情的情况下消耗了全局随机数流。一个保险的做法是，在你需要确定性的关键操作之前，重新设置种子。

2.2 现代推荐：使用Generator和SeedSequence

NumPy的新API提供了更好的封装和更可靠的随机性来源。

from numpy.random import Generator, PCG64, SeedSequence

# 创建一个带种子的生成器
seed = 777
rg = Generator(PCG64(seed))

# 使用这个生成器产生随机数
print("使用Generator:", rg.random(3))

# 即使其他代码使用了np.random，也不会影响rg的序列
np.random.seed(999)
print("使用Generator again:", rg.random(3)) # 输出与上次连续，不受影响

# SeedSequence 用于派生多个独立的随机流，非常适合并行任务
ss = SeedSequence(12345)
child_seeds = ss.spawn(4) # 生成4个子种子
generators = [Generator(PCG64(s)) for s in child_seeds]
# 现在你有4个互不干扰的随机数生成器，可用于4个并行任务

使用Generator对象将随机状态封装起来，是避免全局状态污染的最佳实践。下表对比了新旧两种方式：

特性	旧式 np.random.* / np.random.seed()	新式 numpy.random.Generator
状态范围	全局，易被意外修改	实例化对象内，隔离性好
算法	默认为MT19937（梅森旋转算法）	可配置（如PCG64、Philox），通常更快、统计特性更好
并行安全	不安全，全局状态是竞争源	安全，每个对象独立
官方推荐	已不推荐，为兼容性保留	推荐用于新项目

提示：在新项目中，请坚持使用numpy.random.Generator。如果你的代码库很庞大，迁移需要时间，至少要在关键的可复现性实验部分使用它。

3. PyTorch随机种子的全面掌控

进入深度学习领域，PyTorch的随机性控制更为复杂，因为它涉及CPU、GPU以及底层CUDA库的行为。

3.1 基础设置：CPU与GPU

PyTorch将CPU和GPU的随机数生成器分开管理。

import torch
import numpy as np

def set_deterministic(seed):
    # 1. 设置Python内置随机种子
    import random
    random.seed(seed)

    # 2. 设置NumPy随机种子
    np.random.seed(seed)

    # 3. 设置PyTorch CPU随机种子
    torch.manual_seed(seed)

    # 4. 设置PyTorch GPU随机种子（所有GPU）
    if torch.cuda.is_available():
        torch.cuda.manual_seed(seed)
        torch.cuda.manual_seed_all(seed) # 如果使用多GPU

# 调用函数
set_deterministic(42)

看起来很简单，对吧？但如果你只做了这些，在GPU上跑复杂模型时，很可能还是会得到不一致的结果。因为你还缺了关键的两步。

3.2 深度控制：cuDNN的确定性与Benchmark模式

这是很多开发者栽跟头的地方。PyTorch在GPU上执行卷积等操作时，会调用NVIDIA的cuDNN库。cuDNN为了追求极致性能，默认会使用非确定性算法，并且会开启benchmark模式来自动寻找最快的算法实现。

• 非确定性算法：即使输入相同，每次运行也可能因底层并行计算线程的细微调度差异而产生不同的浮点结果（通常在小数点后多位，但足以影响模型训练）。
• Benchmark模式：torch.backends.cudnn.benchmark = True 时，PyTorch会在第一次遇到新的输入尺寸时，对多种卷积算法进行基准测试，然后选择最快的一个。如果网络输入尺寸是固定的，这能加速训练。但如果输入尺寸变化，每次都会触发新的基准测试，反而更慢，并且由于算法选择可能不同，也会引入不确定性。

因此，为了绝对的确定性，你需要：

def set_full_deterministic(seed):
    set_deterministic(seed) # 调用上面的基础设置函数

    # 关键配置：强制使用确定性算法，关闭benchmark
    if torch.cuda.is_available():
        torch.backends.cudnn.deterministic = True
        torch.backends.cudnn.benchmark = False
        # 一个更严格的设置，但可能影响性能
        # os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'  # 或 ':16:8'
        # torch.use_deterministic_algorithms(True) # PyTorch 1.8+

注意：设置 torch.backends.cudnn.deterministic = True 可能会带来性能下降，因为确定性算法可能不是最快的。通常只在调试、验证实验或发布需要严格复现的结果时开启。正式训练为了速度可以关闭。

3.3 实战中的复杂情况与排查清单

即使你设置了以上所有，有时结果仍会波动。请按以下清单排查：

1. 数据加载的随机性：DataLoader使用了worker进程。你需要为每个worker设置不同的初始种子，以避免所有worker产生相同的随机序列。

   def worker_init_fn(worker_id):
       worker_seed = torch.initial_seed() % 2**32 + worker_id
       np.random.seed(worker_seed)
       random.seed(worker_seed)
   
   dataloader = DataLoader(dataset, batch_size=32, num_workers=4,
                           worker_init_fn=worker_init_fn, pin_memory=True)
   

2. Dropout层：Dropout本身就是随机丢弃神经元，但其随机源受PyTorch的随机种子控制。只要种子设置正确，它的行为就是确定的。

3. torch.nn.init 操作：模型权重初始化。确保在设置完所有随机种子之后，再创建和初始化模型。

4. 集合操作或torch.topk等：某些操作在GPU上由于并行归约，可能存在非确定性。PyTorch 1.8+ 的 torch.use_deterministic_algorithms(True) 可以强制使用确定性变体，但支持的操作有限。

5. 浮点运算的非结合性：(a+b)+c 与 a+(b+c) 在浮点数计算中可能结果不同，GPU并行计算时求和顺序不确定。这是硬件层面的根本限制，完全消除极其困难，通常其影响微乎其微。

一个完整的、可复现的训练脚本开头应该是这样的：

import random
import numpy as np
import torch
import os

def set_all_seeds(seed):
    random.seed(seed)
    os.environ['PYTHONHASHSEED'] = str(seed) # 禁止哈希随机化
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)
        torch.backends.cudnn.deterministic = True # 可能影响速度
        torch.backends.cudnn.benchmark = False

SEED = 42
set_all_seeds(SEED)

# 然后再定义模型、数据加载器等

4. 跨库协作与随机状态管理

真实的项目往往混合使用多个库。你需要一个统一的策略来管理所有随机源。

策略一：主种子派生。指定一个“主种子”，然后用它派生所有其他库所需的种子或生成器。这能保证整个实验由一个种子完全控制。

master_seed = 123456

# 派生一系列种子
import hashlib
def derive_seed(base, label):
    # 使用哈希函数从主种子和标签派生新种子
    h = hashlib.sha256(f"{base}_{label}".encode()).digest()
    return int.from_bytes(h[:4], 'little') # 取前4字节作为整数种子

seed_numpy = derive_seed(master_seed, "numpy")
seed_pytorch = derive_seed(master_seed, "pytorch")
seed_random = derive_seed(master_seed, "python_random")

# 分别设置
random.seed(seed_random)
np.random.seed(seed_numpy)
torch.manual_seed(seed_pytorch)

策略二：随机状态快照与恢复。在关键代码段前后，保存和恢复随机状态。这对于调试特别有用。

import random
import numpy as np
import torch

def get_random_state():
    """获取当前所有随机状态"""
    state = {
        'python': random.getstate(),
        'numpy': np.random.get_state(),
        'torch_cpu': torch.get_rng_state(),
    }
    if torch.cuda.is_available():
        state['torch_gpu'] = torch.cuda.get_rng_state_all() # 所有GPU
    return state

def set_random_state(state):
    """恢复随机状态"""
    random.setstate(state['python'])
    np.random.set_state(state['numpy'])
    torch.set_rng_state(state['torch_cpu'])
    if torch.cuda.is_available() and 'torch_gpu' in state:
        torch.cuda.set_rng_state_all(state['torch_gpu'])

# 用法示例
checkpoint_state = get_random_state()
# ... 执行一些操作
set_random_state(checkpoint_state) # 恢复到之前的状态

策略三：依赖隔离。尽可能让你代码的随机性依赖于你显式传递的随机数生成器对象，而不是全局状态。这是最健壮的设计模式。

def process_data(data, rng_np):
    """处理数据，使用传入的NumPy Generator"""
    indices = rng_np.permutation(len(data)) # 洗牌
    return data[indices]

# 在主程序中创建并传递生成器
rng = np.random.default_rng(seed=42)
processed = process_data(my_dataset, rng)

5. 高级话题：随机性与模型性能

最后，我们聊聊一个更深入的问题：固定随机种子，是否会让模型性能变差？答案是否定的。一个好的模型，其性能不应该对随机初始化的微小变化过于敏感。如果换一个种子，模型性能就剧烈波动，那可能说明：

• 模型训练不稳定：学习率可能太高，或者优化器选择不当。
• 数据量太小或噪声太大：模型容易过拟合到随机噪声。
• 模型架构存在缺陷：例如梯度流动不畅。

因此，固定种子是评估模型鲁棒性和实验严谨性的必要手段。在论文实验或生产系统部署前的评估中，你应该用多个不同的种子（例如5到10个）运行实验，报告其均值和标准差，而不是一个“幸运”的种子结果。这能更真实地反映算法的性能。

我自己的习惯是，在项目初期调试和复现问题时，使用固定的种子（比如42）。当进入正式的实验评估阶段，我会写一个循环，用一组预定义的种子（如 [42, 123, 456, 789, 1024]）重复训练，最后分析统计结果。这样既能保证调试时的确定性，又能得到可靠的性能估计。