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