提交 3f3cf23b authored 作者: zhangqianwei's avatar zhangqianwei

ljy_完成模块二-PyTorch基础、模块五-LLM-API调用(第一版)

上级 93315742
# 模块五 LLM + API 调用
> **本模块导读**:本模块面向需要真正把大模型接进应用里的实习生,目标不是停留在“听懂概念”,而是学会怎么通过 API 让模型工作起来。包含 4 个章节,从 Prompt Engineering 到 OpenAI API 调用、流式输出,再到 Function Calling。学完本模块,你应该能独立完成一次基础模型调用,并理解多轮对话和工具调用的完整链路。
>
> **章节列表**:
> - 5.1 Prompt Engineering
> - **5.2 OpenAI API 调用** ← 本文档当前章节(★5 重点)
> - 5.3 流式输出
> - 5.4 Function Calling
>
> **阅读建议**:先把 `5.2` 里的调用链路跑通,再去看 `5.3` 和 `5.4`。基础调用如果没吃透,后面的流式和工具调用会像“会背词但不会说话”。
---
## 5.2 OpenAI API 调用
> OpenAI API 调用这章的目标,不是让你背几个参数名,而是让你清楚“请求是怎么发出去的、上下文是怎么组织的、结果是怎么取回来的、报错时该从哪里查”。真正做业务接入时,这些能力比“会复制一段示例代码”更重要。
>
> 📖 预计阅读时长:40 分钟 ⏱️ 实战建议:先完成环境变量配置,再依次跑通单轮调用和多轮对话示例
### 📋 本章知识点速览
| 编号 | 知识点 | 难度 | 一句话概括 |
| --- | --- | --- | --- |
| 5.2.1 | API Key 配置 | ★★☆☆☆ | 先让程序拥有调用模型的权限 |
| 5.2.2 | 基本调用(Chat Completions) | ★★★★☆ | 先跑通一轮最小请求 |
| 5.2.3 | `messages` 格式 | ★★★★☆ | 上下文是怎么组织起来的 |
| 5.2.4 | Token 计算 | ★★★★☆ | 为什么一次请求会产生成本 |
| 5.2.5 | 错误处理 | ★★★★★ | 让调用代码在真实环境里能稳定工作 |
| 5.2.6 | 多轮对话 | ★★★★★ | 模型为什么“记得住上文” |
| 5.2.7 | 成本优化 | ★★★★☆ | 让功能能上线,而不是账单先炸掉 |
---
### 5.2.0 章节导读:先跑通一次“最小可用调用”
> 如果你是第一次接 OpenAI API,先不要急着理解所有参数。先把“环境变量配置 -> 创建客户端 -> 发请求 -> 读取返回内容”这条链跑通。
#### 这章最重要的 4 件事
```text
1. 知道 API Key 放在哪里
2. 知道最小调用代码怎么写
3. 知道 messages 是怎么组织上下文的
4. 知道常见报错该怎么处理
```
#### 一张图看懂一次 API 调用
```text
┌─────────────────────────────┐
│ 本地 Python 代码 │
│ 负责组织请求和处理返回结果 │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ 读取 OPENAI_API_KEY │
│ 提供调用模型所需的身份凭证 │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ 创建 OpenAI 客户端 │
│ client = OpenAI(...) │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ 组织请求体 │
│ messages + model + params │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ 发送请求到模型服务 │
│ chat.completions.create(...)│
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ 拿到 response │
│ choices / usage / metadata │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ 提取文本 / 记录 usage │
│ 处理异常 / 拼接多轮上下文 │
└─────────────────────────────┘
关键产物:
- `messages`:模型看到的完整上下文
- `response.choices[0].message.content`:最终回答文本
- `response.usage`:本次请求的 token 消耗
```
> 🎯 **目标**:读完这章后,你应该能独立完成一次基础对话调用,能写多轮 `messages`,也知道真实项目里怎么补错误处理。
> **说明**:本章以教学示例为主,重点是帮助你理解 API 调用链路、参数组织方式和返回结果读取方式。实际运行这些示例时,需要先在本机配置有效的 `OPENAI_API_KEY`。
---
### 5.2.1 API Key 配置
> 用 1-2 句话说清:OpenAI API 不是匿名调用的,程序必须先拿到凭证。这个凭证通常就是 `OPENAI_API_KEY` 环境变量。
---
## 什么是这个知识点?
### 一句话定义
API Key 是调用 OpenAI API 的身份凭证,最常见做法是把它放进环境变量 `OPENAI_API_KEY`。
### 为什么重要
没有 Key,请求发不出去;Key 泄露了,别人可以直接拿你的额度去调用模型。
### 生活类比
API Key 就像公司门禁卡。没有卡进不去,乱丢卡则可能被别人冒用。
---
## 举个例子
### 输入是什么
在终端里配置环境变量。
### 输出是什么
Python 程序能够读取到 `OPENAI_API_KEY`。
### 代码演示
```bash
# macOS / Linux
export OPENAI_API_KEY="sk-xxxxxxxxxxxxxxxx"
# 查看是否设置成功
echo "$OPENAI_API_KEY"
```
```python
import os
api_key = os.getenv("OPENAI_API_KEY")
print(bool(api_key)) # True 表示读取成功
```
#### 正解 vs 错误
- 正解:把 API Key 放在环境变量里,由代码在运行时读取。
- 错误:把 Key 直接写死在脚本、笔记或仓库里。
- 错误表现:代码暂时能跑,但一旦泄露就是安全事故,后面也不方便切换不同环境。
---
### 5.2.2 基本调用(Chat Completions)
> 用 1-2 句话说清:最小 API 调用只需要三件事:客户端、模型名、输入消息。先把这一轮跑通,再去谈多轮对话、流式输出和 Function Calling。
---
## 什么是这个知识点?
### 一句话定义
基本调用就是通过 SDK 向模型发送一个请求,并从返回结果里取出模型生成的内容。
### 为什么重要
如果单轮调用都没跑通,后面的多轮对话、流式输出、工具调用都无从谈起。
### 生活类比
这就像第一次给客服打电话,先确认“电话能打通、对方会回话”,然后才谈复杂业务流程。
---
## 举个例子
### 输入是什么
- 环境变量中的 `OPENAI_API_KEY`
- 模型名,例如 `gpt-4.1-mini`
- 一组 `messages`
### 输出是什么
模型返回的一段文本,例如:
```text
张量可以理解为多维数组,是 PyTorch 里最基础的数据结构。
```
### 代码演示
```python
import os
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
response = client.chat.completions.create(
model="gpt-4.1-mini",
messages=[
{"role": "system", "content": "你是一名耐心的 AI 助教。"},
{"role": "user", "content": "请用一句话解释什么是张量。"},
],
)
print(response.choices[0].message.content)
```
#### 正解 vs 错误
- 正解:明确客户端、模型名、`messages` 和返回内容读取路径。
- 错误:只会复制示例,不知道结果该从哪里取。
- 错误表现:一旦返回结构稍微变化,或者你要加参数时,就很容易改崩。
> 注意:模型返回内容会因模型版本、提示词、上下文不同而变化。上面的输出只是示例,不会每次完全一样。
---
### 5.2.3 `messages` 格式
> 用 1-2 句话说清:在 Chat Completions 里,对话上下文不是靠“自动记忆”,而是靠你把历史消息一条一条放进 `messages` 列表里。
---
## 什么是这个知识点?
### 一句话定义
`messages` 是一个按时间顺序排列的消息列表,每条消息通常包含 `role` 和 `content`。
### 为什么重要
模型能不能“接得上话”,关键不在于它记不记得,而在于你有没有把历史上下文正确地带回去。
### 生活类比
你去找一个从没见过聊天记录的人复盘对话,必须把前文一条条给他看;否则他不知道你们刚才聊到了哪里。
---
## 举个例子
### 输入是什么
一组带角色的消息:
```python
messages = [
{"role": "system", "content": "你是一名耐心的 AI 助教。"},
{"role": "user", "content": "什么是损失函数?"},
{"role": "assistant", "content": "损失函数用来衡量模型预测值和真实值之间的差距。"},
{"role": "user", "content": "那它和准确率有什么区别?"},
]
```
### 输出是什么
模型会基于整个上下文回答最后一个问题,而不是只看最后一条 user 消息。
### 代码演示
```python
messages = [
{"role": "system", "content": "你是一名耐心的 AI 助教。"},
{"role": "user", "content": "什么是损失函数?"},
{"role": "assistant", "content": "损失函数用来衡量模型预测值和真实值之间的差距。"},
{"role": "user", "content": "那它和准确率有什么区别?"},
]
```
#### 正解 vs 错误
- 正解:把 `system`、`user`、`assistant` 按时间顺序组织进同一个 `messages` 列表。
- 错误:只保留最后一句用户输入,觉得模型会“自动记住”前文。
- 错误表现:模型像失忆一样接不上话,经常出现答非所问。
#### 常见角色说明
| 角色 | 作用 |
| --- | --- |
| `system` | 设定助手身份、风格、边界 |
| `user` | 用户当前提出的问题 |
| `assistant` | 模型上一轮给出的回答 |
---
### 5.2.4 Token 计算
> 用 1-2 句话说清:一次 API 调用不是按“字数”收费,而通常和输入输出消耗的 token 相关。上下文越长、输出越长,成本一般越高。
---
## 什么是这个知识点?
### 一句话定义
token 可以理解为模型处理文本时使用的基本计量单位,API 返回里通常也会带 usage 信息。
### 为什么重要
如果你完全不关注 token,最常见的后果不是“代码报错”,而是“功能跑起来了,但成本不可控”。
### 生活类比
像打出租车时按里程计费。走得越远,费用越高;上下文越长,token 通常越多。
---
## 举个例子
### 输入是什么
一次普通 API 请求。
### 输出是什么
返回结果中常见会带 usage 信息,例如:
```text
prompt_tokens=32
completion_tokens=18
total_tokens=50
```
### 代码演示
```python
response = client.chat.completions.create(
model="gpt-4.1-mini",
messages=[
{"role": "system", "content": "你是一名耐心的 AI 助教。"},
{"role": "user", "content": "请解释一下什么是反向传播。"},
],
)
print(response.usage.prompt_tokens)
print(response.usage.completion_tokens)
print(response.usage.total_tokens)
```
#### 正解 vs 错误
- 正解:通过 `response.usage` 看输入、输出和总 token 消耗。
- 错误:只看功能有没有跑通,从来不看 usage。
- 错误表现:开发阶段觉得“能用就行”,上线后才发现上下文越堆越长,成本完全失控。
---
### 5.2.5 错误处理
> 用 1-2 句话说清:真实业务里不能假设“每次请求都成功”。错误处理不是锦上添花,而是把示例代码升级成可用代码的关键步骤。
---
## 什么是这个知识点?
### 一句话定义
错误处理就是在请求失败、认证失败、限流、参数错误等情况下,给出可诊断、可恢复或可追踪的处理逻辑。
### 为什么重要
没有错误处理的 API 代码,通常只能在“本地理想环境”里跑;一旦遇到网络波动、Key 配错、限流,就直接崩。
### 生活类比
就像出差前不仅要买票,还得准备“晚点怎么办、身份证忘带怎么办、酒店满房怎么办”的备用方案。
---
## 举个例子
### 输入是什么
- 没配置 API Key
- 请求参数错误
- 网络连接失败
### 输出是什么
程序不会直接一脸空白地崩掉,而是输出更可理解的错误信息。
### 代码演示
```python
import os
from openai import OpenAI, APIConnectionError, AuthenticationError, BadRequestError, RateLimitError
def ask_once(question: str) -> None:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise RuntimeError("未检测到 OPENAI_API_KEY,请先配置环境变量。")
client = OpenAI(api_key=api_key)
try:
response = client.chat.completions.create(
model="gpt-4.1-mini",
messages=[
{"role": "system", "content": "你是一名耐心的 AI 助教。"},
{"role": "user", "content": question},
],
)
print(response.choices[0].message.content)
except AuthenticationError:
print("认证失败:请检查 API Key 是否正确。")
except RateLimitError:
print("请求过快:请稍后重试,或降低并发量。")
except BadRequestError as exc:
print(f"请求参数错误:{exc}")
except APIConnectionError:
print("网络连接失败:请检查网络或稍后重试。")
```
#### 正解 vs 错误
- 正解:至少区分认证失败、限流、参数错误和网络错误这几类常见异常。
- 错误:默认所有请求都会成功,出错时只让程序直接抛 traceback。
- 错误表现:一旦放进真实服务环境,问题很难排查,用户也拿不到可理解的提示。
---
### 5.2.6 多轮对话
> 用 1-2 句话说清:多轮对话的本质不是“模型自己记住了”,而是你把上文一并发回去。上下文管理写得好不好,直接决定聊天产品体验。
---
## 什么是这个知识点?
### 一句话定义
多轮对话就是在新请求里保留前面几轮 `user` 和 `assistant` 消息,让模型基于完整上下文继续回答。
### 为什么重要
如果你每次只发最后一句问题,模型就会像“失忆”一样答非所问。
### 生活类比
像接力聊天。你不能只把最后一句“那它为什么会这样?”丢给一个不看前文的人。
---
## 举个例子
### 输入是什么
一段逐轮累积的 `messages`:
```python
messages = [
{"role": "system", "content": "你是一名耐心的 AI 助教。"},
{"role": "user", "content": "什么是训练循环?"},
]
```
### 输出是什么
模型在第二轮、第三轮还能接着前面的上下文继续回答。
### 代码演示
```python
import os
from openai import OpenAI
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
messages = [
{"role": "system", "content": "你是一名耐心的 AI 助教。"},
{"role": "user", "content": "什么是训练循环?"},
]
response = client.chat.completions.create(
model="gpt-4.1-mini",
messages=messages,
)
assistant_reply = response.choices[0].message.content
print("assistant:", assistant_reply)
messages.append({"role": "assistant", "content": assistant_reply})
messages.append({"role": "user", "content": "那为什么每个 batch 都要 zero_grad?"})
response = client.chat.completions.create(
model="gpt-4.1-mini",
messages=messages,
)
print("assistant:", response.choices[0].message.content)
```
#### 正解 vs 错误
- 正解:每轮都把上一轮的 `assistant` 回复追加回 `messages`,再加上新的用户问题。
- 错误:第二轮只发一句“那为什么会这样?”之类的跟进提问。
- 错误表现:模型不知道“这样”指什么,回答会明显跑偏。
---
### 5.2.7 成本优化
> 用 1-2 句话说清:API 能跑通只是第一步,能不能长期稳定地上线,还取决于成本是否可控。很多项目不是被技术卡住,而是被账单卡住。
---
## 什么是这个知识点?
### 一句话定义
成本优化就是在满足效果要求的前提下,通过控制模型选择、上下文长度和输出长度等手段,降低单次请求和整体调用成本。
### 为什么重要
开发阶段一两次调用看不出问题,但一旦放进循环、批量处理或者真实用户场景里,成本会被迅速放大。
### 生活类比
像点外卖,不是每顿都必须点最贵套餐;适合的份量和配置,长期看最重要。
---
## 举个例子
### 输入是什么
一个不断追加历史消息的聊天程序。
### 输出是什么
通过裁剪历史记录、选择合适模型、压缩系统提示词,让单次请求 token 更低。
### 代码演示
```python
def keep_recent_messages(messages: list[dict], max_rounds: int = 3) -> list[dict]:
system_message = messages[:1]
recent_history = messages[1:][-2 * max_rounds :]
return system_message + recent_history
```
#### 正解 vs 错误
- 正解:保留系统消息,再按轮数裁剪最近历史,控制上下文长度。
- 错误:无上限地把所有历史消息一直往后堆。
- 错误表现:单次请求越来越重,响应变慢,token 和成本越来越难控制。
#### 3 条最常用的成本优化建议
1. 不要无上限保留全部历史消息,定期裁剪上下文。
2. 在满足效果的前提下,优先选择更轻量的模型。
3. 系统提示词写清楚即可,不要堆很多重复约束。
---
## 正解 vs 错误
| 场景 | 正解 ✅ | 错误 ❌ | 错误表现 |
| --- | --- | --- | --- |
| Key 管理 | 用环境变量保存 API Key | 把 Key 直接硬编码进仓库 | 泄露凭证,存在安全风险 |
| 基础调用 | 明确模型名、messages、结果读取路径 | 只复制一段代码,不知道返回结构 | 一换接口或字段就不会改 |
| 多轮对话 | 把历史消息一并带回 | 每次只发最后一句用户输入 | 模型像“失忆”一样接不上话 |
| 错误处理 | 捕获认证、限流、网络异常 | 默认所有请求都会成功 | 程序在真实环境里容易直接崩掉 |
| 成本控制 | 关注 usage、裁剪上下文 | 上下文无限堆积 | token 飙升,成本不可控 |
**错误示例 1:把 API Key 写死在代码里**
```python
client = OpenAI(api_key="sk-1234567890")
```
这种写法最大的问题不是“不优雅”,而是**高风险泄露**。一旦代码被提交到仓库,别人就可能直接使用你的额度。
**错误示例 2:多轮对话不回传历史**
```python
response = client.chat.completions.create(
model="gpt-4.1-mini",
messages=[
{"role": "user", "content": "那为什么它会这样?"},
],
)
```
这种情况下,模型根本不知道“它”指的是什么,很容易答偏。
---
## 原理深入
### 核心逻辑
一次标准调用至少包括四步:
```text
1. 准备凭证
2. 组织请求体
3. 发送请求
4. 读取结果并处理异常
```
### 为什么 `messages` 能实现上下文
因为服务端不会神奇地“自动记住你上一轮在说什么”,真正起作用的是你把上下文重新放进了这次请求中。换句话说,**多轮对话的本质是“上下文重放”**。
### 一个最小心智模型
```text
system: 你是谁,要遵守什么规则
user: 我现在问了什么
assistant: 你上一轮怎么回答的
--------------------------------
把这些一起发给模型
--------------------------------
模型基于完整上下文继续回答
```
---
## 实战代码
下面这段示例把环境变量、单轮调用、usage 读取和多轮对话都串起来了。你可以先把它当成完整模板来理解调用流程;如果后续需要真实运行,再补上官方 SDK 和有效的 `OPENAI_API_KEY` 即可。
```python
import os
from openai import OpenAI, APIConnectionError, AuthenticationError, BadRequestError, RateLimitError
def main() -> None:
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
raise RuntimeError("请先设置 OPENAI_API_KEY 环境变量。")
client = OpenAI(api_key=api_key)
messages = [
{"role": "system", "content": "你是一名耐心的 AI 助教。"},
{"role": "user", "content": "请用两句话解释什么是训练循环。"},
]
try:
response = client.chat.completions.create(
model="gpt-4.1-mini",
messages=messages,
)
answer = response.choices[0].message.content
print("assistant:", answer)
print("usage:", response.usage)
messages.append({"role": "assistant", "content": answer})
messages.append({"role": "user", "content": "那为什么每个 batch 都要 zero_grad?"})
follow_up = client.chat.completions.create(
model="gpt-4.1-mini",
messages=messages,
)
print("assistant:", follow_up.choices[0].message.content)
except AuthenticationError:
print("认证失败:请检查 API Key。")
except RateLimitError:
print("请求过快:请稍后重试。")
except BadRequestError as exc:
print(f"请求参数错误:{exc}")
except APIConnectionError:
print("网络连接失败:请检查网络连接。")
if __name__ == "__main__":
main()
```
---
## 常见问题
**Q:为什么一定要用环境变量保存 API Key?**
A:因为这是最常见、也最安全的基础做法。把 Key 写进代码或提交到仓库,会带来非常现实的泄露风险。
**Q:为什么我第二轮提问时,模型像没看过上一轮内容?**
A:因为你没有把上一轮的 `assistant` 回复和之前的 `user` 消息一起放回 `messages`。模型不是自动记忆,而是依赖你重传上下文。
**Q:为什么我能拿到回答,却不知道这次花了多少 token?**
A:因为你还没看 `response.usage`。这个字段通常能帮助你快速判断输入、输出和总 token 消耗。
**Q:为什么明明代码没问题,还是请求失败?**
A:真实环境里最常见的是三类问题:Key 没配对、网络不通、请求太快被限流。所以调用代码里一定要有错误处理,而不是默认所有请求都成功。
**Q:为什么这章先讲 Chat Completions,不先讲更复杂的工具调用?**
A:因为工具调用建立在“基础请求已经能稳定跑通”的前提上。`5.4 Function Calling` 会在这章的基础上继续展开。
---
## 验收标准
```text
☐ 能正确配置 OPENAI_API_KEY 环境变量
☐ 能写出一次最小 Chat Completions 调用
☐ 能解释 messages 中 system / user / assistant 的作用
☐ 能通过 response.usage 查看 token 消耗
☐ 能写出带基础错误处理的 API 调用代码
☐ 能实现最小多轮对话
```
## 官方来源
- OpenAI API Quickstart: [https://developers.openai.com/api/docs/quickstart](https://developers.openai.com/api/docs/quickstart)
- OpenAI Text Generation Guide: [https://platform.openai.com/docs/guides/text-generation](https://platform.openai.com/docs/guides/text-generation)
- OpenAI Token Counting Guide: [https://developers.openai.com/api/docs/guides/token-counting](https://developers.openai.com/api/docs/guides/token-counting)
- OpenAI Chat Completions API 参考: [https://platform.openai.com/docs/api-reference/chat](https://platform.openai.com/docs/api-reference/chat)
- OpenAI Developer Docs 首页: [https://developers.openai.com/api](https://developers.openai.com/api)
## 参考文献
[1] OpenAI Developer Documentation, accessed on 2026-07-07.
# 模块二 PyTorch 基础
> **本模块导读**:本模块面向刚开始接触深度学习工程实践的实习生,目标不是先把概念背下来,而是先把 PyTorch 最常用的基础能力练到能独立上手。包含 4 个章节,从 Tensor 操作开始,到自动求导、`nn.Module`,最后进入训练循环。学完本模块,你应该能读懂一段基础训练代码,也能自己从零写出一个最小可运行模型。
>
> **章节列表**:
> - 2.1 Tensor 操作
> - 2.2 自动求导
> - 2.3 `nn.Module`
> - **2.4 训练循环** ← 本文档当前章节(★5 重点)
>
> **阅读建议**:建议边看边跑代码,尤其是 `2.4` 这章,不要只看不敲。训练循环一旦理解透,前面三章会更容易串起来。
---
## 2.4 训练循环
> 训练循环是 PyTorch 入门里最像“发动机”的部分。模型到底能不能学到东西,不取决于你写没写 `nn.Linear`,而取决于你有没有把“取数据、做预测、算误差、反向传播、更新参数”这一整套流程写对。
>
> 📖 预计阅读时长:35 分钟 ⏱️ 实战建议:把整章代码完整跑一遍,再尝试自己删掉一两行看看会发生什么
### 📋 本章知识点速览
| 编号 | 知识点 | 难度 | 一句话概括 |
| --- | --- | --- | --- |
| 2.4.1 | 数据加载(`Dataset` / `DataLoader`) | ★★★☆ | 把样本按批次喂给模型 |
| 2.4.2 | 前向传播 | ★★★☆ | 让模型先按当前参数做一次预测 |
| 2.4.3 | 损失计算 | ★★★☆ | 判断预测值离真实答案有多远 |
| 2.4.4 | 反向传播与参数更新 | ★★★★☆ | 让模型知道自己哪里错了,并真的改参数 |
| 2.4.5 | 完整训练循环 | ★★★★★ | 把前面几步串成一段真正能训练的代码 |
| 2.4.6 | 常见错误(梯度清零 / NaN) | ★★★★★ | 新手最容易写错、最值得先避坑的地方 |
---
### 2.4.0 章节导读:先记住训练循环只有 5 步
> 如果你现在只想先抓主线,先把这 5 步记住:`取数据 -> 前向传播 -> 计算损失 -> 反向传播 -> 更新参数`。
#### 一句话先理解训练循环
训练循环本质上就是让模型不断“做题、对答案、改错、再做题”的过程。
#### 用生活类比理解
把模型想象成一个刚开始刷题的同学:
```text
拿到题目(输入数据)
->
写出答案(模型预测)
->
对照标准答案(计算损失)
->
找到错因(反向传播)
->
修正做题习惯(更新参数)
->
下一轮继续刷题
```
#### 一张图看懂完整流程
```text
┌─────────────────────────────┐
│ Dataset / DataLoader │
│ 负责提供一个 batch 的数据 │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ features, targets │
│ 输入: 特征张量 + 真实标签 │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ model(features) │
│ 前向传播,得到 predictions │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ loss_fn(predictions, │
│ targets) │
│ 计算预测值和真实值的差距 │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ optimizer.zero_grad() │
│ 先清空上一轮残留梯度 │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ loss.backward() │
│ 反向传播,计算每个参数的梯度 │
└──────────────┬──────────────┘
│
v
┌─────────────────────────────┐
│ optimizer.step() │
│ 用梯度更新模型参数 │
└──────────────┬──────────────┘
│
v
进入下一个 batch
关键产物:
- `predictions`:模型当前这次“猜出来的答案”
- `loss`:模型这次猜错了多少
- `grad`:参数应该往哪个方向改
```
> 🎯 **目标**:读完这章后,你应该不只是“知道训练循环是什么”,而是能自己写出一段最小训练代码,并且知道每一步为什么不能少。
---
### 2.4.1 数据加载(`Dataset` / `DataLoader`)
> 用 1-2 句话说清:训练不是一次喂完整个数据集,而是通常一批一批地喂。`Dataset` 负责“数据长什么样”,`DataLoader` 负责“怎么一批一批拿出来”。
---
## 什么是这个知识点?
### 一句话定义
`Dataset` 定义“如何按索引取样本”,`DataLoader` 定义“如何把这些样本按 batch 组织并迭代出来”。
### 为什么重要
如果没有这两个组件,你就得自己手动切片、手动打乱、手动分 batch。样本一多,代码会又乱又容易出错。
### 生活类比
`Dataset` 像一本题库,`DataLoader` 像老师发卷子的方式。题库告诉你“第 3 题是什么”,老师决定“这次先发 4 道题,下一次再发 4 道题”。
---
## 举个例子
### 输入是什么
我们先做一个最小回归任务,让模型学习下面这条规律:
```text
y = 2x + 1
```
输入样本和标签会像这样:
```text
x: [[1.0], [2.0], [3.0], [4.0], ...]
y: [[3.0], [5.0], [7.0], [9.0], ...]
```
### 输出是什么
`DataLoader` 每次返回一个 batch,例如:
```text
features.shape = [4, 1]
targets.shape = [4, 1]
```
### 代码演示
```python
import torch
from torch.utils.data import Dataset, DataLoader
class ToyRegressionDataset(Dataset):
def __init__(self) -> None:
self.x = torch.arange(1, 21, dtype=torch.float32).unsqueeze(1)
self.y = 2 * self.x + 1
def __len__(self) -> int:
return len(self.x)
def __getitem__(self, index: int) -> tuple[torch.Tensor, torch.Tensor]:
return self.x[index], self.y[index]
dataset = ToyRegressionDataset()
dataloader = DataLoader(dataset, batch_size=4, shuffle=True)
features, targets = next(iter(dataloader))
print(features.shape) # torch.Size([4, 1])
print(targets.shape) # torch.Size([4, 1])
```
#### 正解 vs 错误
- 正解:用 `Dataset` 管理单条样本,用 `DataLoader` 负责 batch、shuffle 和迭代。
- 错误:手动在训练循环里自己切列表、自己拼 batch。
- 错误表现:代码很快变乱,batch shape 容易不一致,后面一接模型就容易报错。
---
### 2.4.2 前向传播
> 用 1-2 句话说清:前向传播就是“模型先按当前参数猜一次答案”。这一步不会修改参数,只会产出预测值。
---
## 什么是这个知识点?
### 一句话定义
前向传播就是把输入数据送进模型,经过层与层之间的计算,得到预测结果。
### 为什么重要
如果没有前向传播,就没有预测值;没有预测值,就没法计算损失,更谈不上训练。
### 生活类比
你做一道题时,先根据自己当前掌握的知识写出一个答案,这一步就是前向传播。
---
## 举个例子
### 输入是什么
一个 batch 的特征张量,例如:
```text
[[1.0], [2.0], [3.0], [4.0]]
```
### 输出是什么
模型当前给出的预测值,例如:
```text
[[2.17], [3.86], [5.55], [7.24]]
```
### 代码演示
```python
import torch
from torch import nn
model = nn.Linear(1, 1)
batch_x = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
predictions = model(batch_x)
print(predictions.shape) # torch.Size([4, 1])
print(predictions)
```
#### 正解 vs 错误
- 正解:把一个 batch 的输入直接送进 `model(features)`,把输出理解成“当前参数下的预测值”。
- 错误:把前向传播和参数更新混在一起,以为 `forward` 自己就会“学习”。
- 错误表现:明明写了模型调用,但 loss 不会下降,因为你根本还没开始反向传播和更新参数。
---
### 2.4.3 损失计算
> 用 1-2 句话说清:损失函数回答的是“你这次猜得离标准答案有多远”。loss 越小,通常说明当前预测越接近真实值。
---
## 什么是这个知识点?
### 一句话定义
损失函数把“预测值”和“真实值”之间的差距压缩成一个数值,这个数值就是 loss。
### 为什么重要
模型不会自己知道“做得好不好”,loss 就是它的成绩单。训练时,优化器就是围着这个成绩单来改参数的。
### 生活类比
你做完题后对答案,错得越多,扣分越多。loss 就像扣分后的总分数。
---
## 举个例子
### 输入是什么
- 预测值:`predictions`
- 真实值:`targets`
### 输出是什么
一个标量 loss,比如:
```text
loss = 12.38
```
### 代码演示
```python
import torch
from torch import nn
loss_fn = nn.MSELoss()
predictions = torch.tensor([[2.0], [4.0], [6.0]])
targets = torch.tensor([[3.0], [5.0], [7.0]])
loss = loss_fn(predictions, targets)
print(loss.item()) # 1.0
```
#### 正解 vs 错误
- 正解:保证 `predictions` 和 `targets` 的 shape 对齐,再送进损失函数。
- 错误:只看数值能不能算出来,不检查张量 shape。
- 错误表现:轻则报维度错误,重则“能跑但 loss 没意义”,后面训练方向全偏。
---
### 2.4.4 反向传播与参数更新
> 用 1-2 句话说清:反向传播负责算出“每个参数该怎么改”,优化器更新负责“真的把参数改掉”。这两步连起来,模型才会越来越会做题。
---
## 什么是这个知识点?
### 一句话定义
`loss.backward()` 用来计算梯度,`optimizer.step()` 用来根据梯度更新参数。
### 为什么重要
只有算出梯度并更新参数,模型才会从“这次错了”变成“下次争取别再这样错”。
### 生活类比
反向传播像老师指出“你是哪里想错了”,参数更新像你真的改掉了做题习惯。
---
## 举个例子
### 输入是什么
- 模型参数
- 当前 batch 的 loss
### 输出是什么
模型参数会发生变化,下一次前向传播得到的预测值通常也会变化。
### 代码演示
```python
import torch
from torch import nn
model = nn.Linear(1, 1)
loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.001)
batch_x = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
batch_y = torch.tensor([[3.0], [5.0], [7.0], [9.0]])
predictions = model(batch_x)
loss = loss_fn(predictions, batch_y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
```
#### 正解 vs 错误
- 正解:按 `zero_grad -> backward -> step` 的顺序更新参数。
- 错误:漏掉 `zero_grad()`,或者把 `step()` 写在 `backward()` 前面。
- 错误表现:梯度累积、参数更新异常、训练结果忽大忽小。
---
### 2.4.5 完整训练循环
> 用 1-2 句话说清:真正训练模型时,不是只做一次 forward/backward,而是要对很多个 batch、很多轮 epoch 重复执行整套流程。完整训练循环就是把这些步骤可靠地串起来。
---
## 什么是这个知识点?
### 一句话定义
完整训练循环就是在多个 epoch 中,不断从 `DataLoader` 取 batch,执行前向传播、损失计算、反向传播和参数更新。
### 为什么重要
单独会写 `nn.Linear` 没有用,真正的工程代码几乎都会落到训练循环里。你能不能独立训练一个模型,关键就在这。
### 生活类比
不是只刷一题就提高,而是反复刷题、反复改错,过很多轮之后才逐渐学会。
---
## 举个例子
### 输入是什么
- 数据集:满足 `y = 2x + 1` 的样本
- 模型:`nn.Linear(1, 1)`
- 损失函数:`nn.MSELoss()`
- 优化器:`torch.optim.SGD`
### 输出是什么
- 每个 epoch 的平均 loss 逐步下降
- 训练后模型对 `x = 10` 的预测值接近 `21`
### 代码演示
```python
import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader
class ToyRegressionDataset(Dataset):
def __init__(self) -> None:
self.x = torch.arange(1, 21, dtype=torch.float32).unsqueeze(1)
self.y = 2 * self.x + 1
def __len__(self) -> int:
return len(self.x)
def __getitem__(self, index: int) -> tuple[torch.Tensor, torch.Tensor]:
return self.x[index], self.y[index]
dataset = ToyRegressionDataset()
dataloader = DataLoader(dataset, batch_size=4, shuffle=True)
model = nn.Linear(1, 1)
loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.001)
epochs = 200
for epoch in range(1, epochs + 1):
epoch_loss = 0.0
for features, targets in dataloader:
optimizer.zero_grad()
predictions = model(features)
loss = loss_fn(predictions, targets)
loss.backward()
optimizer.step()
epoch_loss += loss.item() * len(features)
epoch_loss /= len(dataset)
if epoch in {1, 50, 100, 150, 200}:
print(f"epoch={epoch:03d} loss={epoch_loss:.6f}")
test_x = torch.tensor([[10.0]])
test_y = model(test_x)
print(f"x=10.0 -> predicted y={test_y.item():.4f}")
```
#### 正解 vs 错误
- 正解:每个 batch 都完整走一遍 `forward -> loss -> backward -> step`,每个 epoch 再汇总一次平均 loss。
- 错误:只写单次 forward/backward,就把它当成“完整训练”。
- 错误表现:代码看起来像训练循环,实际上只跑了一步,模型几乎学不到东西。
---
### 2.4.6 常见错误(梯度清零 / NaN)
> 用 1-2 句话说清:训练循环最让新手崩溃的,不是不会写,而是“代码能跑,但结果不对”。这一小节专门帮你识别两类最常见、也最容易踩中的坑:忘记清零梯度,以及 loss 变成 `NaN`。
---
## 什么是这个知识点?
### 一句话定义
训练循环常见错误,指的是那些不会立刻让程序崩掉、但会让训练结果悄悄失真的问题。
### 为什么重要
这类错误比语法错误更难发现。语法错了程序会马上停;训练逻辑错了,程序可能能一直跑,但模型根本学不会。
### 生活类比
就像你每次做题都在改错本上叠加旧错误,或者每次都把分数算炸了。表面上你一直在“认真学习”,实际上方法已经偏了。
---
## 举个例子
### 输入是什么
- 一个漏掉 `optimizer.zero_grad()` 的训练循环
- 一个学习率设置过大的优化器
### 输出是什么
- 梯度会不断累积
- loss 会剧烈波动,严重时直接变成 `NaN`
### 代码演示
```python
for features, targets in dataloader:
predictions = model(features)
loss = loss_fn(predictions, targets)
loss.backward()
optimizer.step()
```
上面这段代码少了 `optimizer.zero_grad()`。它能跑,但会把上一个 batch 的梯度也一起带进来。
```python
optimizer = torch.optim.SGD(model.parameters(), lr=10.0)
```
上面这段代码的问题是学习率太大,参数会被一步推得过猛,loss 很容易爆炸。
#### 正解 vs 错误
- 正解:每个 batch 开头先清梯度,并用一个保守学习率起步,比如 `0.001`。
- 错误:觉得“前一个 batch 的梯度留着也没事”,或者一上来把学习率设得很大。
- 错误表现:loss 不降反升、数值忽大忽小、训练几轮后直接打印出 `nan`。
---
## 正解 vs 错误
| 场景 | 正解 ✅ | 错误 ❌ | 错误表现 |
| --- | --- | --- | --- |
| 梯度清零 | 每个 batch 先 `optimizer.zero_grad()` | 漏掉清零步骤 | 梯度累积,loss 波动奇怪,训练结果不稳定 |
| 反向传播顺序 | `loss.backward()` 后再 `optimizer.step()` | 先 `step()` 再 `backward()` | 参数更新基于旧梯度甚至没梯度 |
| 模型训练模式 | 训练前调用 `model.train()` | 忘记设置训练模式 | 带 Dropout / BatchNorm 的模型行为异常 |
| 学习率设置 | 从较小学习率开始,比如 `0.001` | 学习率过大,比如 `10.0` | loss 爆炸,甚至出现 `NaN` |
| 损失函数输入 | 预测值和标签 shape 对齐 | shape 不一致强行计算 | 报错或 silent bug,loss 不可信 |
**错误示例 1:忘记清零梯度**
```python
for features, targets in dataloader:
predictions = model(features)
loss = loss_fn(predictions, targets)
loss.backward()
optimizer.step()
```
这段代码的问题不是“不能跑”,而是**能跑但会悄悄累积旧梯度**,属于最危险的一类新手错误。
**错误示例 2:学习率太大**
```python
optimizer = torch.optim.SGD(model.parameters(), lr=10.0)
```
这类错误的常见表现是 loss 忽大忽小,或者训练几步之后直接变成:
```text
loss = nan
```
---
## 原理深入
### 核心逻辑
训练循环里真正的“学习”发生在这两行:
```python
loss.backward()
optimizer.step()
```
第一行负责算梯度,第二行负责用梯度更新参数。前面的 `forward` 和 `loss` 更像是在告诉模型“你这次错了多少”,后面的这两步才是在执行“怎么改”。
### 一个最小心智模型
```text
参数 w, b
|
v
模型先做预测
|
v
拿预测值和真实值做比较
|
v
loss 告诉你这次差多少
|
v
backward 告诉你 w, b 该往哪个方向改
|
v
step 真正把 w, b 改一点
```
### 为什么是“循环”
因为一次更新通常只会把参数往正确方向推近一点点。模型不是一口气学会的,而是通过很多个 batch、很多轮 epoch 逐步逼近正确答案。
---
## 实战代码
下面这段是可以直接运行的最小完整示例。它把本章所有核心步骤都串起来了:
```python
import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader
class ToyRegressionDataset(Dataset):
def __init__(self) -> None:
self.x = torch.arange(1, 21, dtype=torch.float32).unsqueeze(1)
self.y = 2 * self.x + 1
def __len__(self) -> int:
return len(self.x)
def __getitem__(self, index: int) -> tuple[torch.Tensor, torch.Tensor]:
return self.x[index], self.y[index]
def train() -> None:
dataset = ToyRegressionDataset()
dataloader = DataLoader(dataset, batch_size=4, shuffle=True)
model = nn.Linear(1, 1)
loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.001)
model.train()
for epoch in range(1, 201):
epoch_loss = 0.0
for features, targets in dataloader:
optimizer.zero_grad()
predictions = model(features)
loss = loss_fn(predictions, targets)
loss.backward()
optimizer.step()
epoch_loss += loss.item() * len(features)
epoch_loss /= len(dataset)
if epoch in {1, 50, 100, 150, 200}:
print(f"epoch={epoch:03d} loss={epoch_loss:.6f}")
test_x = torch.tensor([[10.0]])
predicted = model(test_x).item()
print(f"x=10.0 -> predicted y={predicted:.4f}")
if __name__ == "__main__":
train()
```
---
## 常见问题
**Q:为什么每个 batch 都要 `optimizer.zero_grad()`?**
A:因为 PyTorch 默认会把新梯度累加到旧梯度上。如果你不手动清零,当前 batch 的梯度里会混进上一个 batch 的信息,训练结果就会失真。
**Q:为什么 loss 一开始很大,是不是代码写错了?**
A:不一定。模型刚初始化时参数通常是随机的,预测很差很正常。重点不是“初始 loss 大不大”,而是训练几轮之后有没有明显下降趋势。
**Q:为什么 loss 变成 `NaN` 了?**
A:最常见的原因有三个:学习率过大、输入数据里本身有异常值、某一步计算出现数值不稳定。新手排查时优先先把学习率调小。
**Q:`Dataset` 和 `DataLoader` 到底谁负责什么?**
A:`Dataset` 负责“单条样本如何获取”,`DataLoader` 负责“如何批量、迭代、打乱、并行加载样本”。
**Q:为什么训练循环里 usually 用 `for epoch in ...` 还要再套一层 `for batch in dataloader`?**
A:外层 epoch 表示“整份数据学几轮”,内层 batch 表示“这一轮里一小批一小批地学”。这是深度学习里最常见的双层循环结构。
---
## 验收标准
```text
☐ 能解释 Dataset、DataLoader、model、loss_fn、optimizer 各自负责什么
☐ 能独立写出 zero_grad -> forward -> loss -> backward -> step 的完整顺序
☐ 能写出一个最小可运行训练循环
☐ 能解释为什么要按 batch 训练,而不是一次性把所有数据都塞进去
☐ 能排查“忘记清零梯度”和“loss 变 NaN”这两类常见错误
```
## 官方来源
- PyTorch Tutorials - Datasets & DataLoaders: [https://docs.pytorch.org/tutorials/beginner/basics/data_tutorial.html](https://docs.pytorch.org/tutorials/beginner/basics/data_tutorial.html)
- PyTorch Tutorials - Build the Neural Network: [https://docs.pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html](https://docs.pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html)
- PyTorch Tutorials - Optimizing Model Parameters: [https://docs.pytorch.org/tutorials/beginner/basics/optimization_tutorial.html](https://docs.pytorch.org/tutorials/beginner/basics/optimization_tutorial.html)
- PyTorch 文档 - `torch.utils.data.DataLoader`: [https://pytorch.org/docs/stable/data.html](https://pytorch.org/docs/stable/data.html)
- PyTorch 文档 - `torch.optim.SGD`: [https://pytorch.org/docs/stable/generated/torch.optim.SGD.html](https://pytorch.org/docs/stable/generated/torch.optim.SGD.html)
## 参考文献
[1] Paszke, A., et al. *PyTorch: An Imperative Style, High-Performance Deep Learning Library*. NeurIPS, 2019.
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论