PyTorch梯度调试入门：从线性回归看反向传播与训练稳定性

简介：这是一本面向深度学习初学者的PyTorch系统入门指南，专为零基础但具备基本编程能力的学习者设计，解决从理论理解到工程实践的关键断层问题。全书以“Step-by-Step”为特色，覆盖神经网络基础、PyTorch环境搭建与张量操作、图像分类与NLP实战项目、迁移学习、GANs及注意力机制等进阶内容，并配有大量可运行代码示例与清晰原理图解，帮助读者边学边练、扎实掌握建模全流程。资源为单文件PDF格式，共1个33.58MB高清电子书（v1.1.1版，2022年2月更新），内容结构完整，含序言、6大核心章节及附录参考资源，便于按需精读或系统通学。目前已有216人下载学习，适合高校学生、转行AI的开发者及希望夯实PyTorch工程能力的初级算法工程师作为首本深度学习实践手册使用。

1. 别急着写model.train()——先搞懂梯度怎么“走错路”，这份 PyTorch 入门方案才真正立得住

你是不是也这样：照着教程敲完import torch、定义nn.Linear、调optimizer.step()，模型跑起来了，但 loss 曲线像心电图，验证集准确率卡在 62% 死活上不去？调试时 print 出来的grad是 nan，weight突然暴涨到1e8，重启 kernel 都救不回来……这不是玄学，是梯度下降的每一步都没被“看见”。《Deep Learning with PyTorch Step-by-Step》最硬核的地方，不是教你怎么堆模型，而是用可视觉化、可打断、可单步追踪的完整训练流，把“反向传播”从黑匣子变成一张能画在白板上的路径图。它专为两类人设计：一类是毕设/课设卡在“能跑但调不好”的学生——你需要的不是 API 手册，而是一套从数据生成→参数初始化→前向计算→loss 可视化→梯度检查→学习率试探→收敛诊断的闭环验证链；另一类是想带新人的工程师——你得有一份能让实习生自己 debug、自己改 learning rate、自己看 grad norm 的教学材料，而不是每次都要蹲在工位旁手把手点鼠标。这本书 v1.1.1（2022 年终版）把 PyTorch 最容易被忽略的底层机制——autograd的触发时机、no_grad的作用域边界、zero_grad()被漏掉的后果、state_dict里到底存了什么——全拆开揉碎，塞进一个线性回归的极简场景里反复锤炼。它不讲 Transformer，不炫 GAN，就死磕“让一个 y = wx + b 真正学会拟合”，因为所有深度模型的崩塌，都始于第一步梯度没算对。

1.1 这不是教材，是 PyTorch 的“训练过程显微镜”

很多初学者误以为 PyTorch 上手快，是因为它“动态图好理解”。但真实情况是：动态图反而更难 debug——你没法像 TensorFlow 1.x 那样静态画出整个计算图再查节点；你得在运行时实时捕获张量状态、梯度流向、参数更新轨迹。这本书的 Chapter 0 就干了一件事：用纯 NumPy 手写梯度下降，再用 PyTorch 重实现，最后把两者的每一步——从w, b初始化值、到y_pred计算、到mse_loss公式展开、到∂L/∂w手动推导、再到.backward()后w.grad的数值——全部对齐打印。它甚至用 Matplotlib 画出了 loss surface 的三维曲面，让你亲眼看到：为什么 learning rate=0.01 时参数在谷底缓慢爬行，而 lr=0.1 时直接跳过最优解，lr=0.3 时直接飞出画布。这种“所见即所得”的训练过程可视化，不是炫技，而是建立直觉的刚需。当你在毕设里遇到 ResNet 训练震荡，第一反应不该是换 optimizer，而是打开 TensorBoard 看grad_norm是否爆炸、weight分布是否偏移、lrscheduler 是否在正确 epoch 触发——这些能力，全在这本书前两章的线性回归 demo 里埋好了伏笔。

1.2 为什么选“线性回归”作为唯一入口？这是刻意为之的“降维打击”

有人问：都 2022 年了，还讲线性回归？这太简单了吧！恰恰相反——越简单的任务，越能暴露框架的本质缺陷。图像分类可以靠数据增强和预训练模型硬扛，NLP 任务可以靠 BERT 微调绕过底层细节，但线性回归不行：它没有非线性激活函数缓冲，没有 batch norm 稳定分布，没有 dropout 防止过拟合。它的 loss 就是干净的(y - (wx+b))²，梯度就是干净的-2x(y - (wx+b))。一旦这里出问题，100% 是你对 PyTorch 的理解有断层。书中 Chapter 1 把这个任务拆成 5 个原子步骤（Step 0–5），每个步骤都强制你手动实现、手动验证、手动对比 NumPy 版本。比如 Step 3 “Compute the Gradients”：它不直接告诉你loss.backward()，而是先让你用 NumPy 算出理论梯度值，再用 PyTorch.backward()得到w.grad，最后assert np.allclose(w.grad.numpy(), expected_grad)。这种“数学公式 ↔ 代码输出 ↔ 数值校验”的三重锚定，才是工程级落地的起点。你毕设答辩时被问“你的 loss 为什么下降这么慢”，你能答“我检查了 grad norm 在 1e-3 量级，learning rate 设为 1e-2 是合理的”，而不是支吾“可能数据有问题……”。

1.3 它解决的不是“会不会”，而是“敢不敢”——敢改源码、敢删一行、敢关 autograd

很多学生交毕设代码，是把 GitHub 上 clone 的项目改改路径、换换数据集，全程不敢动 model 定义里的nn.Sequential，不敢碰optimizer.zero_grad()的位置，更不敢在forward里加一句print(x.shape)——怕一动就报错，怕一错就找不到原因。这本书的“敢”，来自它构建的可逆操作链：每个 notebook 都提供reset_parameters()函数，每次实验前一键恢复初始状态；每个梯度计算后都有torch.norm(w.grad)检查；每个optimizer.step()前都print(f"Before update: w={w.item():.4f}")，之后再print(f"After update: w={w.item():.4f}")。它甚至专门用一节讲no_grad()的两种写法：上下文管理器with torch.no_grad():vs 装饰器@torch.no_grad()，并演示如果在 validation loop 里漏掉no_grad，GPU memory 会怎样指数级增长。这种对“副作用”的极致敏感，不是为了考试，而是为了让你在真实项目里——比如调试一个自定义 loss function 时——能立刻判断：是 forward 逻辑错了？还是 backward 没注册？还是 gradient 被其他 branch 意外清空？这种“敢”的底气，比写出 10 个 SOTA 模型更重要。

2. 总体架构设计：五步原子训练流与三层 PyTorch 抽象的职责划分

这本书的骨架非常清晰：它把一次完整的模型训练，强行拆解为Step 0 → Step 1 → Step 2 → Step 3 → Step 4 → Step 5的线性流程，并为每一步匹配 PyTorch 中对应的核心抽象层。这不是为了教学方便而硬分，而是因为 PyTorch 的设计哲学本身就是“显式优于隐式”——它拒绝把数据加载、设备迁移、梯度计算、参数更新打包成一个fit()黑盒，而是让你亲手把每个齿轮装上去。这种设计对初学者看似繁琐，但对工程交付却是救命稻草：当你的毕设模型在服务器上跑崩，你能精准定位是 Step 2（loss 计算）的 tensor device 不一致，还是 Step 4（参数更新）的optimizer没绑定到当前 GPU 上。下面我们就按这五步流，结合 PyTorch 的三层抽象（Tensor 层、Autograd 层、Module/Optimizer 层），逐层说明设计意图与落地要点。

2.1 Step 0：随机初始化——为什么torch.randn(1)比torch.zeros(1)更危险？

初始化不是随便给个数就行。书中 Chapter 0 的 Synthetic Data Generation 部分明确指出：若用w = torch.zeros(1)初始化，而真实权重是w_true = 2.5，那么∂L/∂w = -2x(y - (0*x+b))在初始时刻恒为 0（因为y_pred = b，若b也初始化为 0，则y_pred=0，loss 对w的梯度为 0），模型根本无法启动。这就是为什么必须用torch.randn(1)或torch.normal(0, 0.01)——引入微小扰动打破对称性。但randn也有坑：标准差太大（如torch.randn(1) * 10）会导致初始y_pred远离真实y，loss 巨大，梯度爆炸。书中给出的安全初始化模式是：

# 推荐：按输入维度缩放，符合 He 初始化思想（虽线性回归不严格需要，但养成习惯） w = torch.randn(1) * 0.1 # 标准差 0.1，足够小又非零 b = torch.randn(1) * 0.1 w.requires_grad_(True) b.requires_grad_(True)

提示：requires_grad_(True)是关键！很多初学者只写w = torch.tensor([1.0])，忘了加这一句，导致.backward()后w.grad为None。PyTorch 不会自动推断你需要梯度——你必须显式声明。

这个步骤的设计价值在于：它把“参数可学习性”这个抽象概念，具象为一个布尔标志requires_grad和一个内存地址（.grad属性）。你在毕设中如果发现模型完全不训练，第一件事就是print(param.requires_grad)和print(param.grad)，而不是盲目调 learning rate。

2.2 Step 1 & Step 2：前向计算与 Loss 构建——Tensor 的 device 一致性是隐形地雷

Step 1（Compute Model’s Predictions）和 Step 2（Compute the Loss）表面看只是两行代码：

y_pred = w * x + b # Step 1 loss = torch.mean((y_pred - y) ** 2) # Step 2, MSE

但背后藏着 PyTorch 最常翻车的 device 问题。假设你用x = torch.randn(100)（默认 CPU），但w, b是在 CUDA 上创建的：

w = torch.randn(1, device='cuda') b = torch.randn(1, device='cuda') # x 仍在 CPU，执行 y_pred = w * x + b 会报错：Expected all tensors to be on the same device

书中在 “Loading Data, Devices, and CUDA” 小节强调：device 绑定必须发生在数据进入计算图之前。正确做法是统一迁移：

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') x = x.to(device) y = y.to(device) w = w.to(device) b = b.to(device)

更进一步，书中推荐使用torch.set_default_device(device)（PyTorch 2.0+）或封装to_device()函数，避免每一行都.to(device)。这个设计点直接对应毕设部署痛点：你本地用 CPU 跑通了，一上服务器（有 GPU）就报 device error，根源往往就在这里。另外，loss 构建必须用torch.mean而非np.mean，因为只有 PyTorch 的mean才能参与 autograd 图。书中特意对比了loss_numpy = np.mean((y_pred.numpy() - y.numpy())**2)——它得到标量，但彻底脱离计算图，.backward()会静默失败。

2.3 Step 3：梯度计算——backward()的触发条件与retain_graph的血泪经验

loss.backward()看似简单，实则是 PyTorch 最易误解的 API。书中 Chapter 1 的 “Autograd” 小节用整整三页解释其行为：

• 它只对loss标量（scalar）有效；若loss是向量（如loss = (y_pred - y) ** 2），需先loss.sum().backward()或loss.mean().backward()。
• 它默认释放计算图（retain_graph=False），所以同一个 loss 不能调两次.backward()。常见错误：

loss.backward() # 第一次，正常 loss.backward() # 第二次，报错：Trying to backward through the graph a second time...

解决方案？要么重新计算 loss，要么显式loss.backward(retain_graph=True)。但后者会占用更多内存——书中提醒：仅在需要多次 backward（如 GAN 的 generator/discriminator 交替更新）时才用，否则是资源浪费。

更隐蔽的坑是：backward()只计算loss对requires_grad=True的叶子节点的梯度。如果你写了：

w = torch.randn(1, requires_grad=True) z = w * 2 loss = z ** 2 loss.backward() print(w.grad) # 输出 8.0，正确 print(z.grad) # 输出 None！因为 z 不是叶子节点

这个设计强制你思考：哪些变量是你要优化的参数（叶子节点），哪些是中间结果（非叶子）。毕设中若自定义 layer，忘记在__init__里把self.weight = nn.Parameter(torch.randn(...))（自动requires_grad=True），而用了self.weight = torch.randn(...)，就会出现grad=None的静默失败。

2.4 Step 4：参数更新——optimizer.step()与zero_grad()的不可分割性

很多人以为optimizer.step()就是“更新参数”，其实它是两步的组合：

1. 用optimizer内部存储的梯度（p.grad）计算更新量（如 SGD 就是p -= lr * p.grad）；
2. 但梯度不会自动清零！

这是初学者最大误区。书中用一个经典反例演示：

# epoch 1 loss1.backward() # w.grad = g1 optimizer.step() # w = w - lr*g1 # epoch 2 loss2.backward() # w.grad = g1 + g2 ← 错！应该是 g2 optimizer.step() # w = w - lr*(g1+g2) ← 累积错误梯度！

所以optimizer.zero_grad()不是可选项，是必选项，且必须放在每个 batch 的loss.backward()之前：

for epoch in range(num_epochs): for x_batch, y_batch in dataloader: optimizer.zero_grad() # 关键！清空上一轮梯度 y_pred = model(x_batch) loss = criterion(y_pred, y_batch) loss.backward() # 计算本轮梯度 optimizer.step() # 应用本轮梯度

书中甚至建议：在zero_grad()后加一句assert w.grad is None or torch.allclose(w.grad, torch.zeros_like(w.grad))，作为防御性编程。这个习惯，能帮你省下 80% 的“模型不收敛”排查时间。

2.5 Step 5：循环迭代——train()/eval()模式切换与no_grad()的精确作用域

Step 5 “Rinse and Repeat!” 表面是循环，实则涉及模型状态管理。书中强调：model.train()和model.eval()不是装饰，而是开关：

• model.train()：启用 dropout、batch norm 的 training mode（计算 running mean/var）；
• model.eval()：禁用 dropout、batch norm 切换到 eval mode（使用 running statistics）。

但更关键的是torch.no_grad()——它关闭 autograd 引擎，节省显存、加速推理。书中明确指出其作用域必须精确：

model.eval() with torch.no_grad(): # 必须用 with，确保退出时自动恢复 val_loss = 0 for x_val, y_val in val_loader: y_val_pred = model(x_val) # 不计算梯度！ val_loss += criterion(y_val_pred, y_val) model.train() # 切回训练模式

错误写法：

model.eval() torch.no_grad() # ❌ 这只是个函数，不生效！必须用 with 或装饰器 y_val_pred = model(x_val) # 依然计算梯度，显存爆满

这个设计点直击毕设性能瓶颈：你可能训练时显存够用，但 validation 时 OOM，就是因为漏了with torch.no_grad():。

3. 核心模块实现：从裸张量到nn.Module的渐进式封装策略

这本书最值得借鉴的，是它展示了一条平滑的抽象升级路径：从 Chapter 0 的纯张量（w,b）手写，到 Chapter 1 的nn.Parameter封装，再到nn.Module类定义，最后到nn.Sequential组合。它不鼓励初学者一上来就写class MyModel(nn.Module)，而是让你先体会“为什么需要封装”。这种渐进式设计，完美适配课程设计/毕设的交付节奏：第一周交手写梯度下降代码，第二周交Parameter版，第三周交Module版，第四周加DataLoader和TensorBoard——每一步都有明确产出、可测试、可答辩。

3.1 从torch.tensor到nn.Parameter：可学习参数的“身份证”

裸张量w = torch.randn(1)要参与优化，必须满足两个条件：requires_grad=True，且被optimizer显式传入。但这样管理 10 个参数就很痛苦。nn.Parameter就是 PyTorch 给参数发的“身份证”——它继承自torch.Tensor，但自动设置requires_grad=True，且能被nn.Module自动识别为可学习参数。书中 Chapter 1 的 “Creating Parameters” 小节给出标准写法：

class LinearRegressionModel: def __init__(self): self.w = nn.Parameter(torch.randn(1) * 0.1) # 自动 requires_grad=True self.b = nn.Parameter(torch.randn(1) * 0.1) def forward(self, x): return self.w * x + self.b # 使用时，optimizer 直接传入 model.parameters() model = LinearRegressionModel() optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # 自动收集 w, b

注意：nn.Parameter必须在__init__中定义，不能在forward中创建，否则model.parameters()找不到它。

这个模块的价值在于：它把“参数管理”从手动列表（[w, b]）升级为自动发现（model.parameters()），为后续扩展（如加 regularization）打下基础。你毕设答辩时，导师问“你怎么管理模型参数？”，你可以指着model.parameters()说：“PyTorch 通过nn.Parameter标记和Module的parameters()方法自动维护，确保 optimizer 总能获取到所有待优化变量。”

3.2nn.Module封装：forward是契约，__init__是蓝图

nn.Module是 PyTorch 的核心契约。书中强调：__init__定义结构，forward定义计算。任何违反此契约的写法都会导致灾难。例如，错误地在forward中定义新参数：

class BadModel(nn.Module): def forward(self, x): # ❌ 大忌！每次 forward 都新建参数，无法优化 self.w = nn.Parameter(torch.randn(1)) return self.w * x

正确写法必须在__init__中完成所有参数声明：

class LinearModel(nn.Module): def __init__(self, input_dim, output_dim): super().__init__() # 结构定义：这里声明所有 Parameter 和 Submodule self.weight = nn.Parameter(torch.randn(input_dim, output_dim) * 0.1) self.bias = nn.Parameter(torch.randn(output_dim) * 0.1) def forward(self, x): # 计算定义：只做 tensor 运算，不创建新 Parameter return x @ self.weight + self.bias

书中还演示了如何利用Module的state_dict()进行模型持久化：

# 训练后保存 torch.save(model.state_dict(), 'linear_model.pth') # 加载时，必须先实例化 model，再 load_state_dict model = LinearModel(1, 1) model.load_state_dict(torch.load('linear_model.pth'))

state_dict是一个OrderedDict，key 是参数名（如'weight','bias'），value 是 tensor。它不保存模型结构，只保存参数值——这意味着你必须保证加载时的model类型和保存时完全一致。这个细节，是毕设模型复现的关键。

3.3Sequential与Layers：组合式建模的工业级实践

当任务变复杂（如多层感知机 MLP），手写forward就容易出错。nn.Sequential是 PyTorch 提供的“乐高式”组合工具。书中 Chapter 1 的 “Sequential Models” 小节给出标准范式：

model = nn.Sequential( nn.Linear(1, 10), # 输入1维，输出10维 nn.ReLU(), # 激活函数 nn.Linear(10, 1) # 输出1维 )

Sequential的优势在于：它自动将各层的forward串成一条流水线，且model.parameters()会递归收集所有子层的参数。但要注意陷阱：Sequential要求每层的输出维度匹配下一层的输入维度。书中用一个反例说明：

# ❌ 错误：第一层输出 5 维，第二层期望输入 10 维 model = nn.Sequential( nn.Linear(1, 5), nn.Linear(10, 1) # 运行时报错：mat1 dim 1 must match mat2 dim 0 )

解决方案是显式检查维度，或用nn.Sequential的命名版本（nn.Sequential(OrderedDict([...]))）便于 debug。这个模块设计教会你：工业级代码不是写得越短越好，而是写得越可验证越好。你毕设中若用Sequential搭 CNN，务必在forward前加print(x.shape)，确认每层输入输出 shape 匹配。

3.4DataLoader与Dataset：数据管道的标准化接口

Chapter 1 的 “Data Preparation” 小节指出：手写for i in range(len(x)):做 mini-batch 是反模式。torch.utils.data.DataLoader提供了标准化的数据管道。书中给出最小可行实现：

from torch.utils.data import Dataset, DataLoader class SimpleDataset(Dataset): def __init__(self, x_data, y_data): self.x_data = x_data self.y_data = y_data def __len__(self): return len(self.x_data) def __getitem__(self, idx): return self.x_data[idx], self.y_data[idx] # 创建 DataLoader dataset = SimpleDataset(x_train, y_train) dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

关键点：

• Dataset.__getitem__返回单个样本（tensor），DataLoader自动批处理；
• shuffle=True仅对训练集开启，验证集应shuffle=False以保证评估稳定；
• num_workers>0可加速数据加载，但 Windows 下需if __name__ == '__main__':保护。

这个设计让毕设代码具备生产环境兼容性：你只需替换SimpleDataset为自己的图像/文本 dataset，其余训练循环完全复用。

3.5TensorBoard集成：可视化不是锦上添花，是调试刚需

书中 “Setup Guide” 明确要求安装tensorboard，并在 Chapter 1 的 “Putting It All Together” 中集成。这不是为了好看，而是为了量化观察。一个典型的训练日志记录：

from torch.utils.tensorboard import SummaryWriter writer = SummaryWriter('runs/linear_regression') for epoch in range(num_epochs): # ... training loop ... writer.add_scalar('Loss/train', loss.item(), epoch) writer.add_scalar('GradNorm/w', torch.norm(w.grad).item(), epoch) writer.add_scalar('Weight/w', w.item(), epoch) writer.close()

然后终端运行tensorboard --logdir=runs。这个动作带来的改变是质的：你不再靠肉眼盯 console 输出的 loss 数字，而是看曲线是否平滑、GradNorm是否在1e-2 ~ 1e-1合理区间、Weight是否稳定收敛。毕设答辩时，导师问“你怎么知道模型收敛了？”，你可以直接打开 TensorBoard 页面，指给他看 loss 曲线的 plateau 和 grad norm 的衰减趋势——这是比任何文字描述都硬核的证据。

4. 关键避坑指南：PyTorch 初学者最常踩的 5 个“静默杀手”

PyTorch 的错误往往不报红，而是给你一个“看起来正常但结果错误”的输出。这些“静默杀手”最消耗调试时间，也是毕设延期的主因。这本书的实战价值，很大程度上体现在它把这些坑提前挖出来、标好警示牌。以下是基于书中案例和我带项目的真实经验，总结的 5 个最高频、最致命的避坑点，每条都按“现象 → 原因 → 解决”结构给出可立即执行的方案。

4.1 现象：loss下降，但val_acc不升反降，且val_loss持续震荡

原因：model.eval()和torch.no_grad()未同时启用，导致 validation 时仍在计算梯度并更新 batch norm 的 running stats，污染了模型状态。
解决：强制在 validation loop 前后添加状态检查：

model.eval() print(f"Model training mode: {model.training}") # 应为 False with torch.no_grad(): print(f"Inside no_grad: {torch.is_grad_enabled()}") # 应为 False # validation code here model.train() # 立即切回训练模式

提示：model.training是布尔属性，torch.is_grad_enabled()是全局梯度开关。两者必须同时为False才安全。

4.2 现象：loss为nan或inf，且w.grad也为nan

原因：数据中存在inf或nan值，在计算loss = (y_pred - y)**2时传播；或 learning rate 过大，导致w更新后溢出（如w = 1e8），后续计算w*x直接inf。
解决：在数据加载后、训练前插入数据清洗和梯度监控：

# 数据清洗 assert not torch.isnan(x).any(), "x contains nan" assert not torch.isinf(x).any(), "x contains inf" assert not torch.isnan(y).any(), "y contains nan" # 梯度监控（放在 optimizer.step() 后） if torch.isnan(w.grad).any() or torch.isinf(w.grad).any(): print(f"Gradient explosion at epoch {epoch}!") # 可选择跳过本次更新，或降低 lr optimizer.zero_grad() continue

4.3 现象：loss缓慢下降，但w和b的值几乎不变（如w从0.1234变为0.1235）

原因：optimizer未正确绑定到model.parameters()，或parameters()返回空列表（如w是普通 tensor 而非nn.Parameter）。
解决：在训练前打印参数信息，形成“参数审计”习惯：

print("Model parameters:") for name, param in model.named_parameters(): print(f"{name}: {param.shape}, requires_grad={param.requires_grad}") print(f"Optimizer param groups: {len(optimizer.param_groups)}") print(f"First group params: {len(optimizer.param_groups[0]['params'])}")

如果named_parameters()为空，或requires_grad=False，立刻检查nn.Parameter声明位置。

4.4 现象：loss曲线在某个 epoch 突然飙升（如从0.01跳到1000），然后又回落

原因：optimizer.zero_grad()被漏掉，导致梯度累积；或DataLoader的shuffle=True在 validation 时误用，导致 batch 内数据分布突变。
解决：用torch.autograd.detect_anomaly()开启异常检测（仅调试用，会降低速度）：

with torch.autograd.detect_anomaly(): loss.backward() # 若某步计算导致 nan/inf，会在此处报错并显示 stack trace

同时，严格区分 train/val dataloader 的shuffle参数：

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False) # 关键！

4.5 现象：本地 CPU 运行正常，但服务器 GPU 上报CUDA out of memory

原因：torch.no_grad()未覆盖整个 validation loop，或model.eval()后仍有 dropout/batch norm 的 training mode 残留，导致显存持续增长。
解决：使用torch.cuda.memory_summary()定位显存大户：

model.eval() with torch.no_grad(): for x, y in val_loader: x, y = x.cuda(), y.cuda() y_pred = model(x) loss = criterion(y_pred, y) break # 只跑一个 batch 查看显存 print(torch.cuda.memory_summary()) # 查看哪部分占显存最多

通常问题出在y_pred或loss的中间变量未被及时释放。解决方案是显式del y_pred, loss，或确保with torch.no_grad():作用域足够大。

5. 毕设/课设验收与答辩：用“可验证性”代替“能跑就行”

毕设或课设的终极目标，不是“代码能跑出一个数字”，而是让评审老师能独立验证你的工作。这本书的每一个章节、每一个 notebook，都在践行这个理念：它不提供黑盒 API，而是提供可打断、可打印、可对比的中间状态。我把这套思路提炼为三个验收维度，它们直接对应答辩时老师最可能问的问题。你不需要背答案，只需要在代码里埋好这些“验证钩子”，答辩时现场打开 Jupyter 就能演示。

5.1 维度一：数学可追溯性——证明你的 loss 公式和梯度推导是正确的

老师可能会问：“你这个 loss 是怎么定义的？它的梯度公式是什么？” 如果你只回答“我用nn.MSELoss()”，那就输了。正确做法是：在 notebook 里单独开辟一节，用 LaTeX 写出数学公式，并用代码验证数值一致性。

# 数学公式：L = 1/n * Σ(y_i - (w*x_i + b))^2 # 梯度：∂L/∂w = -2/n * Σ(x_i * (y_i - (w*x_i + b))) # ∂L/∂b = -2/n * Σ(y_i - (w*x_i + b)) # 数值验证 w_val, b_val = 1.5, 0.8 y_pred_manual = w_val * x_train + b_val loss_manual = torch.mean((y_pred_manual - y_train) ** 2) # PyTorch 计算 w_t = torch.tensor([w_val], requires_grad=True) b_t = torch.tensor([b_val], requires_grad=True) y_pred_t = w_t * x_train + b_t loss_t = torch.mean((y_pred_t - y_train) ** 2) loss_t.backward() print(f"Manual loss: {loss_manual.item():.6f}") print(f"PyTorch loss: {loss_t.item():.6f}") print(f"Manual dL/dw: {-2/len(x_train) * ((y_train - y_pred_manual) * x_train).sum().item():.6f}") print(f"PyTorch dL/dw: {w_t.grad.item():.6f}") # 输出应完全一致

这个验证节，就是你答辩时的“后悔药”。老师质疑 loss 实现，你直接运行这段，数字对上了，质疑自然消失。

5.2 维度二：硬件可复现性——证明你的结果不依赖特定 GPU 或 driver 版本

深度学习实验常被诟病“不可复现”。这本书的 Setup Guide 要求明确 Python、PyTorch、CUDA 版本（v1.1.1 对应 PyTorch 1.10+），并提供 Google Colab/Binder 链接。你在毕设中必须做同样事：

1. 固定随机种子（书中 Chapter 0 的 Spoilers 小节强调）：

import random import numpy as np import torch def set_seed(seed=42): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) if torch.cuda.is_available(): torch.cuda.manual_seed(seed) torch.cuda.manual_seed_all(seed) # multi-GPU torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False set_seed(42) # 在训练前调用

2. 记录环境（生成environment.yml）：

conda env export > environment.yml # 或 pip list --format=freeze > requirements.txt

答辩时，老师说“我在自己机器上跑不出来”，你递上environment.yml和set_seed()代码，就是最强回应。

5.3 维度三：过程可审计性——用 TensorBoard 日志证明你的训练是健康的

不要只交一个最终acc=92.5%的截图。交一份完整的runs/文件夹（或 TensorBoard 的events.out.tfevents.*文件），里面包含：

• Loss/train和Loss/val曲

本文还有配套的精品资源，点击获取