pytorch api文档：torch.manual_seed()设置随机种子-马育民老师

# 介绍

`torch.manual_seed()` 是 PyTorch 中用于设置**CPU 端随机数生成器（RNG）种子**的函数。

简单来说：

- 随机数生成器默认是“随机”的（每次运行代码生成的随机数都不同）；
- 设置种子后，随机数生成器会按照固定的算法生成可预测的随机数序列，**保证多次运行代码时，随机相关的操作（如创建随机张量、模型初始化、数据洗牌等）结果完全一致**；
- 这个函数只影响 CPU 端的随机数，如果使用 GPU，还需要额外设置 `torch.cuda.manual_seed()` 或 `torch.cuda.manual_seed_all()`。

### 应用场景

设置种子后，随机操作的结果固定，这在 **实验复现**、**调试** 时非常有用；但在 **实际训练** 模型时（尤其是最终部署前），通常会关闭固定种子，以引入更多随机性提升模型泛化能力。

# 语法格式

```python
torch.manual_seed(seed)
```

**参数：**

- `seed`：整数（int），随机数种子值（可以是任意整数，比如 0、42、12345 等）。

**返回值**：返回 `torch.Generator` 对象（随机数生成器），一般不需要关注这个返回值。

# 相关随机函数

`torch.manual_seed()` 最直接的作用对象是 PyTorch 中所有生成随机张量的函数，固定种子后这些函数的输出会完全可复现。

| 函数/操作                | 功能                          | 搭配示例                                                                 |
|--------------------------|-------------------------------|--------------------------------------------------------------------------|
| `torch.rand()`           | 生成 [0,1) 均匀分布随机张量   | `torch.manual_seed(42); torch.rand(2,2)` → 输出固定                      |
| `torch.randn()`          | 生成标准正态分布随机张量      | `torch.manual_seed(42); torch.randn(2,2)` → 输出固定                     |
| `torch.randint()`        | 生成整数随机张量              | `torch.manual_seed(42); torch.randint(0, 10, (2,2))` → 输出固定          |
| `torch.randperm()`       | 生成随机排列的整数张量        | `torch.manual_seed(42); torch.randperm(5)` → 输出固定                   |
| `torch.empty().uniform_()` | 填充均匀分布随机值          | `torch.manual_seed(42); torch.empty(2,2).uniform_(0,1)` → 输出固定       |

### 例子：不设置种子 → 随机结果不可复现
```python
import torch

# 第一次生成随机张量
print("不设置种子 - 第一次运行：")
print(torch.rand(2, 2))  # 随机值，每次运行不同
# 输出示例：
# tensor([[0.4139, 0.6139],
#         [0.4322, 0.6486]])

# 第二次生成随机张量（和第一次结果不同）
print("\n不设置种子 - 第二次运行：")
print(torch.rand(2, 2))
# 输出示例（和上面不同）：
# tensor([[0.5349, 0.6603],
#         [0.5862, 0.8832]])
```

### 例子：设置种子 → 随机结果可复现
```python
import torch

# 设置 CPU 随机种子为 42
torch.manual_seed(42)

# 第一次生成随机张量
print("设置种子 42 - 第一次运行：")
print(torch.rand(2, 2))
# 固定输出：
# tensor([[0.8823, 0.9150],
#         [0.3829, 0.9593]])

# 重置种子后，第二次生成的结果和第一次完全一致
torch.manual_seed(42)
print("\n设置种子 42 - 第二次运行：")
print(torch.rand(2, 2))
# 固定输出（和第一次完全相同）：
# tensor([[0.8823, 0.9150],
#         [0.3829, 0.9593]])
```

# GPU 场景下的种子设置
如果使用 GPU，仅设置 `torch.manual_seed()` 不够，必须搭配 CUDA 种子函数，否则 GPU 上的随机操作仍不可复现。

| CUDA 种子函数            | 作用                          | 搭配示例                                                                 |
|--------------------------|-------------------------------|--------------------------------------------------------------------------|
| `torch.cuda.manual_seed()` | 为单个 GPU 设置随机种子      | `torch.manual_seed(42); torch.cuda.manual_seed(42)`                     |
| `torch.cuda.manual_seed_all()` | 为所有 GPU 设置随机种子    | `torch.manual_seed(42); torch.cuda.manual_seed_all(42)`                 |

### 示例：固定 GPU 随机操作
```python
import torch

seed = 42
torch.manual_seed(seed)  # CPU 种子
if torch.cuda.is_available():
    torch.cuda.manual_seed_all(seed)  # 所有 GPU 种子

# GPU 上生成随机张量（结果固定）
if torch.cuda.is_available():
    print("GPU 上的 torch.rand(2,2)：")
    print(torch.rand(2, 2).cuda())
    # 固定输出：tensor([[0.8823, 0.9150], [0.3829, 0.9593]], device='cuda:0')
```

# 模型参数初始化

PyTorch 中模型层（如 `nn.Linear`、`nn.Conv2d`、`nn.Embedding`）的参数默认是随机初始化的，固定种子后，每次运行模型的初始参数完全一致，保证实验可复现。

### 示例：固定模型参数初始化结果
```python
import torch
import torch.nn as nn

# 设置种子（必须在模型定义前执行）
torch.manual_seed(42)

# 定义简单模型
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(3, 2)  # 随机初始化权重
        self.embedding = nn.Embedding(10, 4)  # 随机初始化嵌入向量

# 创建模型（每次运行，初始参数都相同）
model = SimpleModel()

# 打印线性层的权重（固定值）
print("nn.Linear 初始权重：")
print(model.linear.weight)
# 固定输出：
# Parameter containing:
# tensor([[ 0.4414,  0.4792, -0.1353],
#         [-0.4074, -0.2251,  0.3219]], requires_grad=True)
```

# 数据层面的随机操作

训练模型时，数据层面的随机操作（如随机洗牌、随机裁剪、随机翻转）也需要固定种子，否则即使模型参数初始化固定，数据输入顺序/形态不同，结果也无法复现。

| 操作类型                | 搭配方式                                                                 |
|-------------------------|--------------------------------------------------------------------------|
| `DataLoader` 随机洗牌   | 设置 `DataLoader` 的 `generator` 参数为固定种子的生成器                  |
| 图像随机变换（`torchvision.transforms`） | 需同时设置 Python 内置 `random`、NumPy 和 PyTorch 的种子               |

### 示例：固定 DataLoader 随机洗牌结果
```python
import torch
from torch.utils.data import DataLoader, TensorDataset

# 全量设置种子（保证数据操作可复现）
seed = 42
torch.manual_seed(seed)
import random
random.seed(seed)
import numpy as np
np.random.seed(seed)

# 构造示例数据
data = torch.randn(10, 3)
labels = torch.randint(0, 2, (10,))
dataset = TensorDataset(data, labels)

# 创建 DataLoader（设置 generator 保证洗牌可复现）
generator = torch.Generator().manual_seed(seed)
dataloader = DataLoader(
    dataset,
    batch_size=2,
    shuffle=True,  # 随机洗牌
    generator=generator  # 绑定固定种子的生成器
)

# 打印第一批数据（每次运行结果相同）
print("DataLoader 第一批数据标签：")
for batch_data, batch_labels in dataloader:
    print(batch_labels)
    break  # 只看第一批
# 固定输出：tensor([1, 0])
```

# 注意

1. **执行时机**：种子需要在**所有随机操作之前**设置，否则前面的随机操作仍会是不可预测的。

# 总结

1. `torch.manual_seed(seed)` 的核心作用是**固定 CPU 端随机数生成器的种子**，让随机操作的结果可复现。搭配**所有生成随机数的 PyTorch 函数**（`rand()`/`randn()`/`randint()` 等），保证随机张量可复现；
2. GPU 场景需额外使用 `torch.cuda.manual_seed()`/`torch.cuda.manual_seed_all()`；
3. 全流程可复现需同时设置 P
4. 可搭配**模型参数初始化**（`nn.Linear`/`nn.Embedding` 等），保证模型初始状态一致；
5. 可搭配**数据处理的随机操作**（`DataLoader` 洗牌、图像增强），且要同时设置 Python/NumPy 种子；ython、NumPy、PyTorch 的种子，且种子要在随机操作前设置。

原文出处：http://malaoshi.top/show_1GW2b3yc5S6M.html