Skip to content
项目
群组
代码片段
帮助
当前项目
正在载入...
登录 / 注册
切换导航面板
S
studyweb
项目
项目
详情
活动
周期分析
仓库
仓库
文件
提交
分支
标签
贡献者
图表
比较
统计图
议题
0
议题
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
CI / CD
CI / CD
流水线
作业
日程
统计图
Wiki
Wiki
代码片段
代码片段
成员
成员
折叠边栏
关闭边栏
活动
图像
聊天
创建新问题
作业
提交
问题看板
Open sidebar
project
studyweb
Commits
39c76d6d
提交
39c76d6d
authored
7月 07, 2026
作者:
zhangqianwei
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
ljy_完成模块二-PyTorch基础(第二版)
上级
79f5f9db
隐藏空白字符变更
内嵌
并排
正在显示
1 个修改的文件
包含
1008 行增加
和
3 行删除
+1008
-3
模块二-PyTorch基础.md
docs/PyTorch基础/模块二-PyTorch基础.md
+1008
-3
没有找到文件。
docs/PyTorch基础/模块二-PyTorch基础.md
浏览文件 @
39c76d6d
# 模块二 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
人
到此讨论。请谨慎行事。
请先完成此评论的编辑!
取消
请
注册
或者
登录
后发表评论