提交 39c76d6d authored 作者: zhangqianwei's avatar zhangqianwei

ljy_完成模块二-PyTorch基础(第二版)

上级 79f5f9db
# 模块二 PyTorch 基础 # 模块二 PyTorch 基础
> **本模块导读**:本模块面向刚开始接触深度学习工程实践的实习生,目标不是先把概念背下来,而是先把 PyTorch 最常用的基础能力练到能独立上手。包含 4 个章节,从 Tensor 操作开始,到自动求导、`nn.Module`,最后进入训练循环。学完本模块,你应该能读懂一段基础训练代码,也能自己从零写出一个最小可运行模型。 > **本模块导读**:本模块面向刚开始接触深度学习工程实践的实习生,目标不是先死记概念,而是先把 PyTorch 最常用的一套基础能力练到能独立上手。内容从 Tensor 操作开始,逐步过渡到自动求导、`nn.Module` 和训练循环。学完之后,你应该能读懂一段基础训练代码,也能自己从零写出一个最小可运行模型。
> >
> **章节列表**: > **章节列表**:
> - 2.1 Tensor 操作 > - 2.1 Tensor 操作
> - 2.2 自动求导 > - 2.2 自动求导
> - 2.3 `nn.Module` > - 2.3 `nn.Module`
> - **2.4 训练循环** ← 本文档当前章节(★5 重点) > - 2.4 训练循环
> >
> **阅读建议**:建议边看边跑代码,尤其是 `2.4` 这章,不要只看不敲。训练循环一旦理解透,前面三章会更容易串起来。 > **学习建议**:本模块最好的阅读方式不是“从头读到尾”,而是“边读边跑”。尤其是 `2.1` 和 `2.4`,建议一边修改输入张量、一边看输出变化,这样理解会快很多。
---
## 本模块学习目标
完成本模块后,你应当至少具备下面这些能力:
- 能创建、查看、切片、变形和迁移 Tensor。
- 能解释 `requires_grad`、`backward()`、`grad`、`no_grad()`、`detach()` 的区别。
- 能自己写一个最小的 `nn.Module` 模型,并知道怎么保存、加载、切换模式。
- 能写出一个可运行的完整训练循环,并定位梯度清零、`NaN` 等常见错误。
---
## 2.1 Tensor 操作
> Tensor 是 PyTorch 里最基础的数据结构。你可以把它理解成“会参与深度学习计算的数组”,后面所有模型、梯度、参数更新,最终都绕不开 Tensor。
>
> 📖 预计阅读时长:30 分钟 ⏱️ 实战建议:把每个小节的张量都自己打印一遍,尤其注意 `shape` 和 `device`
### 📋 本章知识点速览
| 编号 | 知识点 | 难度 | 一句话概括 |
| --- | --- | --- | --- |
| 2.1.1 | 张量创建 | ★★☆☆☆ | 先学会把数据放进 PyTorch |
| 2.1.2 | 张量属性 | ★★☆☆☆ | 搞清张量的形状、类型和所在设备 |
| 2.1.3 | 张量运算 | ★★★☆☆ | 会做逐元素运算和矩阵乘法 |
| 2.1.4 | 索引与切片 | ★★★☆☆ | 能从张量里准确拿到你想要的部分 |
| 2.1.5 | 形状变换 | ★★★★☆ | 理解 `reshape`、`view`、`transpose` 的区别 |
| 2.1.6 | 张量与 NumPy 互转 | ★★★☆☆ | 知道 PyTorch 和 NumPy 怎么互通 |
| 2.1.7 | GPU 迁移 | ★★★★☆ | 会把张量和模型迁移到同一设备上 |
| 2.1.8 | 广播机制 | ★★★★☆ | 理解“维度不同但还能计算”是怎么发生的 |
---
### 2.1.0 章节导读:先建立 Tensor 的主线认知
如果把 PyTorch 学习过程比作搭积木,那么 Tensor 就是最底层的那块地基。
```text
创建 Tensor
->
看 shape / dtype / device
->
做加减乘除 / 矩阵乘法
->
切片取局部数据
->
reshape / transpose 调整结构
->
与 NumPy 互转
->
迁移到 GPU
->
在广播机制下完成更灵活的计算
```
你后面看到的输入、标签、权重、梯度,本质上几乎都是 Tensor。
---
### 2.1.1 张量创建
> 用 1-2 句话说清:张量创建解决的是“怎样把数据交给 PyTorch”。你不先会创建 Tensor,后面的模型、损失函数和训练循环都没有输入可用。
## 什么是这个知识点?
### 一句话定义
张量创建,就是把 Python 数据、规则生成的数据或随机数据转成 PyTorch 能直接计算的 Tensor。
### 为什么重要
因为训练数据、模型参数、标签、梯度,最后都要落在 Tensor 上。创建 Tensor 是后面一切操作的起点。
### 生活类比
就像做菜前先把食材放到案板上。没有食材,后面的切、炒、炖都无从谈起。
## 举个例子
### 输入是什么
- 一个 Python 列表
- 一个固定形状
- 一个需要随机初始化的形状
### 输出是什么
- 普通 Tensor
- 全 0 Tensor
- 全 1 Tensor
- 随机初始化 Tensor
### 代码演示
```python
import torch
x = torch.tensor([[1, 2], [3, 4]], dtype=torch.float32)
zeros = torch.zeros((2, 3))
ones = torch.ones((2, 3))
randn = torch.randn((2, 3))
print(x)
print(zeros)
print(ones)
print(randn.shape)
```
## 正解 vs 错误
- 正解:需要浮点计算时,主动指定 `dtype=torch.float32`。
- 错误:把需要参与神经网络计算的数据默认写成整数 Tensor。
- 错误表现:后面一接线性层、损失函数或梯度计算,容易出现类型不匹配。
---
### 2.1.2 张量属性
> 用 1-2 句话说清:张量属性解决的是“这个 Tensor 现在长什么样、是什么类型、在什么设备上”。这是排查报错时第一批要看的信息。
## 什么是这个知识点?
### 一句话定义
张量属性主要指 `shape`、`dtype`、`device` 这三类最关键的状态信息。
### 为什么重要
很多 PyTorch 错误并不是“你不会写代码”,而是 Tensor 的形状、类型或设备不匹配。
## 举个例子
### 输入是什么
一个普通张量:
```python
import torch
x = torch.randn(3, 4)
print(x.shape)
print(x.dtype)
print(x.device)
```
### 输出是什么
- `shape`:张量的维度结构
- `dtype`:张量元素类型
- `device`:张量所在设备,例如 `cpu` 或 `cuda:0`
## 正解 vs 错误
- 正解:报错时先看 `shape / dtype / device`。
- 错误:只盯着报错最后一行,不检查 Tensor 自身状态。
- 错误表现:明明代码看起来“差不多”,但就是跑不通。
---
### 2.1.3 张量运算
> 用 1-2 句话说清:张量运算解决的是“Tensor 怎么参与数学计算”。新手最容易混淆的是逐元素乘法 `*` 和矩阵乘法 `@`。
## 什么是这个知识点?
### 一句话定义
张量运算包括逐元素加减乘除,以及更符合线性代数语义的矩阵乘法。
### 为什么重要
神经网络里的线性层、注意力分数、本质上都建立在张量运算之上。
## 举个例子
### 代码演示
```python
import torch
a = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
b = torch.tensor([[10.0, 20.0], [30.0, 40.0]])
print(a + b)
print(a * b)
print(a @ b)
```
### `*` 和 `@` 的区别
| 写法 | 含义 | 结果特点 |
| --- | --- | --- |
| `a * b` | 逐元素相乘 | 每个位置自己乘自己 |
| `a @ b` | 矩阵乘法 | 需要维度满足矩阵乘法规则 |
## 正解 vs 错误
- 正解:做线性代数意义上的“乘法”时优先想 `@` 或 `torch.matmul`。
- 错误:把矩阵乘法误写成 `*`。
- 错误表现:有时不会报错,但算出来的结果完全不是你想要的。
---
### 2.1.4 索引与切片
> 用 1-2 句话说清:索引与切片解决的是“如何从 Tensor 里精确拿数据”。训练里取某一列特征、某一批样本、本质上都是这个操作。
## 什么是这个知识点?
### 一句话定义
索引是取单个位置,切片是取一段连续区域。
### 为什么重要
训练里经常要按行取样本、按列取特征、按范围取局部数据。如果索引和切片不熟,最容易出现“取出来了,但不是自己以为的那块数据”。
## 举个例子
### 输入是什么
一个 `2 x 3` 的二维张量。
### 输出是什么
- 第一行
- 第二列
- 前两列组成的子张量
### 代码演示
```python
import torch
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(x[0]) # 第一行
print(x[:, 1]) # 第二列
print(x[:, :2]) # 前两列
```
## 正解 vs 错误
- 正解:先想清楚“按行取”还是“按列取”。
- 错误:把 `x[0]`、`x[:, 0]`、`x[0, :]` 混着写。
- 错误表现:维度对不上,或者拿到的不是你想要的样本/特征。
---
### 2.1.5 形状变换(`reshape / view / transpose`)
> 用 1-2 句话说清:形状变换解决的是“数据本身不变,但组织方式要变”。这在图片、batch、序列建模里非常常见。
## 什么是这个知识点?
### 一句话定义
`reshape` 和 `view` 更偏向“重新排布形状”,`transpose` 更偏向“交换维度顺序”。
### 为什么重要
模型层与层之间经常要求固定输入形状,如果不会变形,就很难把数据喂进模型。
## 举个例子
### 输入是什么
一个形状为 `[2, 3]` 的二维张量。
### 输出是什么
- `reshape(3, 2)` 后的新形状
- `transpose(0, 1)` 后的维度交换结果
### 代码演示
```python
import torch
x = torch.arange(1, 7).reshape(2, 3)
print(x)
print(x.reshape(3, 2))
print(x.transpose(0, 1))
```
### `reshape / view / transpose` 对比
| 操作 | 主要作用 | 更像什么 |
| --- | --- | --- |
| `reshape` | 改整体外形 | 把 2 行 3 列重新摆成 3 行 2 列 |
| `view` | 改整体外形 | 和 `reshape` 类似,但更依赖底层内存连续性 |
| `transpose` | 交换某两个维度 | 把“行”和“列”互换 |
## 正解 vs 错误
- 正解:想“换外形”时先用 `reshape`,想“交换维度”时用 `transpose`。
- 错误:把 `transpose` 当成任意 reshape 工具。
- 错误表现:维度数量没错,但数据语义已经乱了。
---
### 2.1.6 张量与 NumPy 互转
> 用 1-2 句话说清:互转解决的是“PyTorch 和 NumPy 怎么配合用”。很多数据预处理、传统数值计算代码仍然大量使用 NumPy。
## 什么是这个知识点?
### 一句话定义
PyTorch Tensor 和 NumPy 数组可以互相转换,方便你在两个生态之间切换。
## 举个例子
### 输入是什么
一个 NumPy 数组,以及一个由它转换得到的 Tensor。
### 输出是什么
- `torch.from_numpy(arr)` 得到的 Tensor
- `x.numpy()` 转回去后的 NumPy 数组
### 代码演示
```python
import numpy as np
import torch
arr = np.array([[1, 2], [3, 4]], dtype=np.float32)
x = torch.from_numpy(arr)
y = x.numpy()
print(type(x), x.dtype)
print(type(y), y.dtype)
```
## 正解 vs 错误
- 正解:进入模型训练前,最终把数据落到 Tensor。
- 错误:以为 NumPy 数组能直接替代所有 Tensor 场景。
- 错误表现:后面一接 `.to(device)`、`backward()` 就不对了。
---
### 2.1.7 GPU 迁移(`.to('cuda')`)
> 用 1-2 句话说清:GPU 迁移解决的是“怎么让张量和模型在更快的设备上运行”。重点不是死记 `.cuda()`,而是记住“模型和数据必须在同一设备”。
## 什么是这个知识点?
### 一句话定义
GPU 迁移就是把 Tensor 或模型从 CPU 移动到 CUDA 设备上执行计算。
### 为什么重要
一旦模型或数据量大起来,GPU 往往比 CPU 快很多。但前提是相关对象在同一设备上。
## 举个例子
```python
import torch
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.randn(2, 3).to(device)
print(x.device)
```
### 模型和数据一起迁移
```python
import torch
import torch.nn as nn
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = nn.Linear(3, 1).to(device)
inputs = torch.randn(4, 3).to(device)
outputs = model(inputs)
print(outputs.device)
```
## 正解 vs 错误
- 正解:模型和输入一起 `.to(device)`。
- 错误:只迁移模型,不迁移数据;或者只迁移数据,不迁移模型。
- 错误表现:报错提示张量不在同一设备上。
---
### 2.1.8 广播机制
> 用 1-2 句话说清:广播机制解决的是“维度不完全一样时,为什么还能做运算”。这是 PyTorch 里非常常见但也很容易误用的能力。
## 什么是这个知识点?
### 一句话定义
广播机制会在维度兼容时,自动“扩展”较小张量,使它能够与较大张量逐元素运算。
### 生活类比
像给一个班里的每个人都发同一张通知。你没有真的把通知复制 40 次,但逻辑上等价于“每个人都有一份”。
## 举个例子
### 输入是什么
一个形状为 `[2, 3]` 的二维张量,和一个形状为 `[3]` 的一维张量。
### 输出是什么
较小张量按广播规则“扩展”后,与较大张量逐元素相加的结果。
### 代码演示
```python
import torch
x = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
bias = torch.tensor([10.0, 20.0, 30.0])
print(x + bias)
```
## 正解 vs 错误
- 正解:知道广播是“维度兼容下的自动扩展”。
- 错误:以为任何形状都能自动相加。
- 错误表现:维度不兼容时报 shape 错误,或者虽然能算但语义不对。
---
## 实战代码
下面这段代码把 `2.1` 的常见操作串起来,适合你读完后直接跑一遍。
```python
import torch
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.arange(1, 7, dtype=torch.float32).reshape(2, 3)
y = torch.ones((2, 3), dtype=torch.float32)
print("x =", x)
print("shape =", x.shape, "dtype =", x.dtype, "device =", x.device)
print("x + y =", x + y)
print("x[:, 1] =", x[:, 1])
print("reshape ->", x.reshape(3, 2))
print("transpose ->", x.transpose(0, 1))
print("broadcast ->", x + torch.tensor([10.0, 20.0, 30.0]))
print("to(device) ->", x.to(device).device)
```
## 常见问题
**Q:为什么我的张量明明数字对了,模型还是报错?**
A:先检查 `shape`、`dtype`、`device`。这三个字段是排查 Tensor 问题的第一入口。
**Q:什么时候用 `*`,什么时候用 `@`?**
A:做逐元素计算用 `*`,做矩阵乘法用 `@`。
**Q:为什么 `.to('cuda')` 之后还是报错?**
A:通常不是 `.to()` 失效,而是模型和数据没有同时迁移到同一个设备。
## 验收标准
☐ 能独立创建常见 Tensor
☐ 能解释 `shape / dtype / device` 分别表示什么
☐ 能区分 `*` 和 `@`
☐ 能写出 GPU 迁移示例
☐ 能解释广播机制为什么会生效
## 官方来源
- https://pytorch.org/docs/stable/tensors.html
- https://pytorch.org/docs/stable/generated/torch.reshape.html
- https://pytorch.org/docs/stable/notes/cuda.html
## 参考文献
[1] PyTorch Documentation, Tensors
[2] PyTorch Documentation, CUDA semantics
---
## 2.2 自动求导
> 自动求导是 PyTorch 真正“会学习”的核心能力。模型之所以能不断更新参数,本质上靠的就是计算图和梯度。
>
> 📖 预计阅读时长:25 分钟 ⏱️ 实战建议:把 `requires_grad`、`no_grad()`、`detach()` 放在一起对比看
### 📋 本章知识点速览
| 编号 | 知识点 | 难度 | 一句话概括 |
| --- | --- | --- | --- |
| 2.2.1 | `requires_grad` 设置 | ★★★☆☆ | 决定这个张量是否需要记录梯度 |
| 2.2.2 | `backward()` 反向传播 | ★★★★☆ | 根据损失往回算梯度 |
| 2.2.3 | `grad` 属性读取 | ★★★☆☆ | 查看参数到底学到了什么更新方向 |
| 2.2.4 | `no_grad()` 上下文 | ★★★★☆ | 在不需要训练时关闭梯度记录 |
| 2.2.5 | `detach()` 断开计算图 | ★★★★☆ | 从当前计算图中分离张量 |
---
### 2.2.1 `requires_grad` 设置
> 用 1-2 句话说清:`requires_grad` 决定 PyTorch 要不要跟踪这个张量后续的计算过程。要训练的参数通常需要它,纯展示或推理数据通常不需要。
## 什么是这个知识点?
### 一句话定义
`requires_grad=True` 表示这个张量需要参与梯度计算。
## 举个例子
```python
import torch
x = torch.tensor([2.0], requires_grad=True)
y = x ** 2
print(x.requires_grad)
print(y.requires_grad)
```
## 正解 vs 错误
- 正解:模型参数默认需要梯度;普通记录值不一定需要。
- 错误:所有张量都默认开梯度。
- 错误表现:内存开销变大,推理速度变慢,还更难排查图结构问题。
---
### 2.2.2 `backward()` 反向传播
> 用 1-2 句话说清:`backward()` 的作用是从结果往回推,每个需要梯度的张量会得到自己的导数信息。
## 什么是这个知识点?
### 一句话定义
`backward()` 会沿着计算图反向传播,计算每个叶子节点的梯度。
## 举个例子
```python
import torch
x = torch.tensor([2.0], requires_grad=True)
y = x ** 2 + 3 * x
y.backward()
print(x.grad) # dy/dx = 2x + 3 -> 7
```
## 正解 vs 错误
- 正解:先有标量损失,再做 `loss.backward()`。
- 错误:对一堆中间值随便 `backward()`,但自己都不清楚想求谁的梯度。
- 错误表现:梯度含义模糊,后面也不知道该怎么更新参数。
---
### 2.2.3 `grad` 属性读取
> 用 1-2 句话说清:`grad` 是“梯度真正落地的地方”。如果你想确认参数有没有被正确更新方向影响,第一眼就看它。
## 什么是这个知识点?
### 一句话定义
`tensor.grad` 保存的是该张量相对于目标值的梯度。
## 举个例子
```python
import torch
w = torch.tensor([1.0], requires_grad=True)
loss = (w - 5) ** 2
loss.backward()
print(w.grad)
```
## 正解 vs 错误
- 正解:把 `grad` 看成“该往哪个方向改参数”的证据。
- 错误:以为 `grad` 自己会自动清零。
- 错误表现:多次 `backward()` 后梯度累加,结果越来越怪。
---
### 2.2.4 `no_grad()` 上下文
> 用 1-2 句话说清:`no_grad()` 解决的是“什么时候我只想算结果,不想留下梯度记录”。验证和推理阶段非常常用。
## 什么是这个知识点?
### 一句话定义
`torch.no_grad()` 会临时关闭自动求导记录。
## 举个例子
```python
import torch
x = torch.tensor([2.0], requires_grad=True)
with torch.no_grad():
y = x * 3
print(y.requires_grad)
```
## 正解 vs 错误
- 正解:验证、推理阶段用 `with torch.no_grad():`。
- 错误:评估模型时忘记关闭梯度记录。
- 错误表现:显存浪费、速度变慢,但结果你又根本不会拿去反向传播。
---
### 2.2.5 `detach()` 断开计算图
> 用 1-2 句话说清:`detach()` 解决的是“我想保留当前值,但不想再继续沿着这条计算路径求梯度”。它常用于日志记录、中间结果处理或某些更复杂的训练技巧。
## 什么是这个知识点?
### 一句话定义
`detach()` 会返回一个与原张量共享数值、但不再参与原计算图梯度传播的新张量。
## 举个例子
```python
import torch
x = torch.tensor([2.0], requires_grad=True)
y = x * 3
z = y.detach()
print(y.requires_grad)
print(z.requires_grad)
```
### `requires_grad` / `no_grad()` / `detach()` 对比
| 概念 | 控制范围 | 常见用途 |
| --- | --- | --- |
| `requires_grad` | 张量级别 | 决定某个张量是否参与梯度 |
| `no_grad()` | 代码块级别 | 验证、推理、临时关闭梯度 |
| `detach()` | 某个结果张量 | 从当前计算图中摘出来继续用 |
## 正解 vs 错误
- 正解:需要“保留值但断梯度”时使用 `detach()`。
- 错误:把 `detach()` 和 `no_grad()` 完全等同起来。
- 错误表现:代码能写出来,但你其实不理解计算图到底在哪断了。
---
## 实战代码
```python
import torch
x = torch.tensor([2.0], requires_grad=True)
w = torch.tensor([3.0], requires_grad=True)
y = x * w
loss = (y - 10) ** 2
loss.backward()
print("x.grad =", x.grad)
print("w.grad =", w.grad)
with torch.no_grad():
pred = x * w
print("pred.requires_grad =", pred.requires_grad)
detached = y.detach()
print("detached.requires_grad =", detached.requires_grad)
```
## 常见问题
**Q:为什么 `grad` 一开始是 `None`?**
A:因为你还没有执行 `backward()`,梯度还没被计算出来。
**Q:为什么验证阶段经常配合 `no_grad()`?**
A:因为验证只关心结果,不需要反向传播,关掉梯度记录更省内存也更快。
**Q:`detach()` 和复制一个张量是一回事吗?**
A:不是。`detach()` 的重点不是“复制值”,而是“切断它和原计算图的梯度关系”。
## 验收标准
☐ 能解释 `requires_grad=True` 的含义
☐ 能写出 `loss.backward()` 的最小示例
☐ 能看懂 `grad` 里存的是什么
☐ 能区分 `no_grad()` 和 `detach()` 的用途
## 官方来源
- https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html
- https://pytorch.org/docs/stable/generated/torch.Tensor.detach.html
## 参考文献
[1] PyTorch Tutorials, Autograd
[2] PyTorch Documentation, `torch.Tensor.detach`
---
## 2.3 `nn.Module`
> 如果说 Tensor 是数据,自动求导是学习机制,那么 `nn.Module` 就是“把模型组织起来的骨架”。你之后写的大多数网络,都会以它为基础。
>
> 📖 预计阅读时长:30 分钟 ⏱️ 实战建议:边看边把 `forward()` 想成“模型收到输入后真正做的事情”
### 📋 本章知识点速览
| 编号 | 知识点 | 难度 | 一句话概括 |
| --- | --- | --- | --- |
| 2.3.1 | 自定义模型 | ★★★☆☆ | 继承 `nn.Module` 开始搭模型 |
| 2.3.2 | `__init__` 与 `forward` | ★★★☆☆ | 一个负责定义层,一个负责定义计算过程 |
| 2.3.3 | 模型参数 | ★★★★☆ | 用 `parameters()` 把可训练参数交给优化器 |
| 2.3.4 | 模型保存与加载 | ★★★★☆ | 学会保留训练成果 |
| 2.3.5 | `.train()` / `.eval()` | ★★★★☆ | 区分训练模式和推理模式 |
---
### 2.3.1 自定义模型(继承 `nn.Module`)
> 用 1-2 句话说清:自定义模型解决的是“如何把一堆层组织成一个可以直接调用的整体”。在 PyTorch 里,模型本质上就是一个类。
## 什么是这个知识点?
### 一句话定义
自定义模型通常通过继承 `torch.nn.Module` 来完成。
## 举个例子
```python
import torch
import torch.nn as nn
class SimpleRegressor(nn.Module):
def __init__(self) -> None:
super().__init__()
self.linear = nn.Linear(1, 1)
def forward(self, x: torch.Tensor) -> torch.Tensor:
return self.linear(x)
```
## 正解 vs 错误
- 正解:模型定义成类,层作为成员变量挂在 `self` 上。
- 错误:把层写在函数临时变量里,或者不继承 `nn.Module`。
- 错误表现:参数无法被框架自动注册,优化器拿不到。
---
### 2.3.2 `__init__` 与 `forward`
> 用 1-2 句话说清:`__init__` 负责“准备模型里有什么层”,`forward` 负责“数据进来后怎么流动”。这两个角色一定要分清。
## 什么是这个知识点?
### 一句话定义
`__init__` 定义结构,`forward` 定义计算路径。
## 举个例子
```python
import torch
import torch.nn as nn
class TwoLayerNet(nn.Module):
def __init__(self) -> None:
super().__init__()
self.fc1 = nn.Linear(4, 8)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(8, 2)
def forward(self, x: torch.Tensor) -> torch.Tensor:
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x
```
## 正解 vs 错误
- 正解:在 `__init__` 里定义层,在 `forward` 里按顺序调用。
- 错误:在 `forward` 里临时新建层。
- 错误表现:每次前向传播都像新模型,训练不到稳定参数。
---
### 2.3.3 模型参数(`parameters()`)
> 用 1-2 句话说清:优化器之所以知道该更新谁,靠的就是 `model.parameters()`。如果参数没被注册进去,模型就算“看起来在训练”,其实也学不到东西。
## 什么是这个知识点?
### 一句话定义
`parameters()` 会返回模型里所有可训练参数。
## 举个例子
```python
import torch.nn as nn
model = nn.Linear(3, 1)
for name, param in model.named_parameters():
print(name, param.shape)
```
## 正解 vs 错误
- 正解:把 `model.parameters()` 传给优化器。
- 错误:自己随手造一个张量,结果没有挂进模块参数体系。
- 错误表现:`optimizer.step()` 执行了,但模型效果几乎不变。
---
### 2.3.4 模型保存与加载
> 用 1-2 句话说清:保存与加载解决的是“训练成果怎么留下来”。教程阶段最值得先掌握的是 `state_dict()` 这条主线。
## 什么是这个知识点?
### 一句话定义
PyTorch 常见做法是保存模型参数字典,再在需要时加载回来。
## 举个例子
```python
import torch
import torch.nn as nn
model = nn.Linear(2, 1)
torch.save(model.state_dict(), "simple_model.pt")
loaded_model = nn.Linear(2, 1)
loaded_model.load_state_dict(torch.load("simple_model.pt"))
```
## 正解 vs 错误
- 正解:优先学会 `state_dict()` 的保存和加载。
- 错误:不了解保存格式,就直接把各种对象混着存。
- 错误表现:后面换环境、换代码版本时很难恢复。
---
### 2.3.5 `.train()` / `.eval()` 模式
> 用 1-2 句话说清:训练模式和评估模式不是“写着好看”,而是会影响某些层的真实行为,比如 `Dropout`、`BatchNorm`。
## 什么是这个知识点?
### 一句话定义
`.train()` 用于训练阶段,`.eval()` 用于评估或推理阶段。
## 举个例子
```python
import torch
import torch.nn as nn
model = nn.Sequential(
nn.Linear(4, 4),
nn.Dropout(p=0.5),
)
model.train()
print("training mode:", model.training)
model.eval()
print("eval mode:", model.training)
```
## 正解 vs 错误
- 正解:训练前 `model.train()`,验证/推理前 `model.eval()`。
- 错误:全程不切模式。
- 错误表现:推理结果不稳定,或者验证表现和训练逻辑混在一起。
---
## 原理深入
`nn.Module` 可以理解成一个“可递归管理子层和参数的容器”:
```text
nn.Module
->
在 __init__ 中注册子层
->
在 forward 中定义数据流
->
parameters() 收集所有可训练参数
->
optimizer 根据这些参数更新模型
->
训练循环把模型真正跑起来
```
这也是为什么 `2.3` 学完之后,下一步自然就会进入 `2.4 训练循环`。因为光有模型壳子还不够,必须把它放进“数据 -> 预测 -> 损失 -> 反向传播 -> 更新”的完整闭环里。
## 实战代码
```python
import os
import torch
import torch.nn as nn
class MiniNet(nn.Module):
def __init__(self) -> None:
super().__init__()
self.net = nn.Sequential(
nn.Linear(2, 4),
nn.ReLU(),
nn.Linear(4, 1),
)
def forward(self, x: torch.Tensor) -> torch.Tensor:
return self.net(x)
model = MiniNet()
sample = torch.tensor([[1.0, 2.0]])
print(model(sample))
save_path = "/tmp/mininet_state_dict.pt"
torch.save(model.state_dict(), save_path)
restored = MiniNet()
restored.load_state_dict(torch.load(save_path))
restored.eval()
print(restored(sample))
if os.path.exists(save_path):
os.remove(save_path)
```
## 常见问题
**Q:为什么 `forward()` 里不要临时新建层?**
A:因为那样每次前向传播都可能重新创建参数,优化器也无法稳定更新这些参数。
**Q:为什么保存时经常推荐 `state_dict()`?**
A:因为它更清晰、更通用,也更符合 PyTorch 的主流保存加载方式。
**Q:`.eval()` 会不会改变参数值?**
A:不会。它改变的是某些层的行为模式,不是直接改参数。
## 验收标准
☐ 能独立写出一个继承 `nn.Module` 的最小模型
☐ 能解释 `__init__` 和 `forward` 的职责
☐ 能把 `model.parameters()` 交给优化器
☐ 能写出模型保存与加载示例
☐ 能区分 `.train()` 和 `.eval()`
## 官方来源
- https://pytorch.org/docs/stable/generated/torch.nn.Module.html
- https://pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html
- https://pytorch.org/tutorials/beginner/saving_loading_models.html
## 参考文献
[1] PyTorch Documentation, `torch.nn.Module`
[2] PyTorch Tutorials, Build the Neural Network
[3] PyTorch Tutorials, Saving and Loading Models
--- ---
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论