PyTorch入门实战：从张量、自动求导到完整训练循环

我最早碰深度学习那阵子，用的还是静态图框架。模型写完之后要先“编译”再执行，中间过程跟黑盒一样，你想打印某个层的输出看一眼，都得先搞清楚算子注册到了哪一步。那种感觉怎么说呢，有点像蒙眼开车，撞了护栏才知道方向偏了。后来切到PyTorch写训练脚本，第一次在forward函数里随手print一个张量的shape，我就知道回不去了——这才是人写代码的方式。

这篇文章就是给准备入门深度学习的读者准备的。我会从框架选型讲到张量机制，从自动求导讲到完整跑通一个图像分类模型，再把训练循环里那些文档不会明说的细节和坑都翻出来。内容尽量说人话，代码可以直接复制去跑，适合刚看完理论、想动手敲第一行PyTorch代码的同学，也适合已经跑过Demo但总在奇怪报错上卡住的人。

1. 为什么我现在会劝新手直接上PyTorch

1.1 动态计算图带来的调试自由度

早年主流框架是静态图思路：你先定义一张完整的计算图，把输入输出、层与层之间的连接全部声明好，然后整个模型被“编译”成一个固定的执行流程，再往里面喂数据。这个设计在部署上有优势，但对做研究、调模型的人来说非常不友好——你没法在模型跑到一半的时候停下来看看某个中间结果，因为图是预先建好的，除非你专门写一堆调试代码去“抓”某个节点的输出。

PyTorch走的是另一条路：动态计算图。它不预先构建全局结构，而是每次前向传播的时候“现场”把计算图搭出来，跑完就释放。这意味着你在forward函数里写什么，它就是什么——打印、断点、if判断、for循环，所有Python原生操作都可以直接用。调试一个模型跟调试普通Python函数没有区别，这一条就足以让大多数新手和研究者倒戈。

1.2 生态成熟度与学习性价比

除了调试体验，PyTorch的生态也是我推荐它的重要原因。现在学术界开源的模型实现，十个里有八个是PyTorch写的；你想找一个预训练模型来迁移学习，主流模型库几乎都能直接加载。配套的工具链也很齐全：数据加载、分布式训练、模型可视化、部署转换，官方和社区都有成熟的方案。对新手来说，这意味着你遇到的所有问题几乎都能搜到现成答案，不至于卡在一个冷门报错上怀疑人生。

当然不是说静态图框架一无是处，它在某些工业落地场景下确实有优势。但如果你正处于入门阶段，目标是快速理解深度学习原理、把模型跑起来、验证你的想法，那么PyTorch的学习曲线绝对是最平滑的。先学会用PyTorch把事情跑通，以后再谈部署优化，这个顺序不会错。

2. 装环境与第一行代码：张量到底是什么

2.1 环境准备里最容易忽略的两个细节

安装PyTorch本身不复杂，官方站会给出适配你本机环境的安装命令，比如用pip安装CPU版还是GPU版。这里有两个细节我建议新手留意：

第一个是Python版本。别为省事去装系统自带的古老Python，建议装稍微新一点的稳定版本，很多第三方组件对老版本的支持会逐渐消失，没必要给自己埋坑。

第二个是虚拟环境。我见过太多同学全局装了一堆套件，版本互相打架，最后只能重装系统。老老实实给项目建一个独立环境，虽然多敲两行命令，但后面能省出大量排查依赖冲突的时间。

安装完之后，终端里敲一下验证代码，确认框架能正常导入即可。如果你有独立显卡并且安装了GPU版驱动，可以再检查一下CUDA是否可见，后续训练能明显提速。

2.2 用生活类比理解张量

很多教程上来就抛概念：张量就是一个多维数组。这么说没错，但我想换个角度帮你建立直觉。你可以把张量理解成“带编号的大型集装箱”：一维张量就是一条队列，二维张量是一张表格，三维张量是一叠表格摞在一起，四维以上你直接想象成仓库里的一排货架，每层每列都能精确索引到。

PyTorch里的torch.Tensor就是这种数据结构，但它比普通数组多了两个关键能力：一是可以放到显卡上做大规模并行计算，二是可以记录自身的计算历史，为后面的自动求导服务。对一个刚入门的人来说，你要记住的就三件事：张量怎么创建、怎么改形状、怎么搬到设备上。

创建张量最基本的写法是这样的：

import torch # 直接通过列表创建 x = torch.tensor([1.0, 2.0, 3.0]) print(x.dtype, x.shape, x.device) # torch.float32 torch.Size([3]) cpu # 全零 / 全一 / 随机初始化 zeros = torch.zeros(2, 3) ones = torch.ones(2, 3) randn = torch.randn(2, 3) # 标准正态分布

改形状是高频操作，最常用的是view和reshape，两者都可以改变张量维度，只是view要求改动前后元素总数一致且内存连续。reshape更宽容一点，它会在必要时复制数据。实际写代码时，我用reshape更多，省得在报错边缘来回试探。

2.3 设备与运算：数据到底在哪块“地盘”上

深度学习绕不开设备问题。最简单的理解：CPU像一个大而全的仓库，什么都能干但速度一般；显卡像一条专门的高速公路，适合处理大批量并行运算，但数据要先“运上去”才能跑。

在PyTorch里，搬运张量的方法就是.to(device)：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") x = torch.randn(3, 3).to(device)

注意一个高频踩坑点：如果x在显卡上，你直接x.numpy()会报错。必须先把数据搬回CPU，再用.detach()切断梯度追踪，才能转成NumPy数组。这个顺序很多人记不住，写成x.cpu().detach().numpy()就对了。

运算本身不复杂，加减乘除、矩阵乘法、拼接拆分，都能直接用算符或函数完成。我建议新手花半小时把常用运算过一遍，后面写模型时会反复用到。

3. autograd自动求导：PyTorch的发动机舱

3.1 手动算梯度早就过时了

在自动求导出现之前，你要自己实现反向传播，把一个复合函数的梯度逐层手动推导出来，再写成代码。一旦网络深一点，链式法则展开就是一大片数学公式，人肉推导既慢又容易错。

PyTorch的autograd机制把这个过程完全自动化了。它的核心思路是：在每一次前向计算过程中，框架会记下张量之间经历了哪些操作，形成一个临时的计算关系网。当你调用backward()时，框架沿着这张网从输出端向输入端逐层回传梯度，每个参与计算的张量都会得到一个.grad属性，存放它相对于最终结果的梯度。

3.2 一个最小例子看懂梯度回传

看个最简单的例子：

import torch x = torch.tensor(3.0, requires_grad=True) y = x ** 2 + 2 * x + 1 y.backward() print(x.grad) # tensor(8.)

从数学角度，y对x的导数是2x+2，代入x=3得到8。这个结果和框架给出的梯度完全一致。关键在于requires_grad=True这一句，它告诉框架：这个张量是“待求导”的，你要记录对它做的所有操作。正常情况下，输入数据、模型参数里需要更新的部分都要开启梯度追踪；而像标签、常量这类不需要求导的，保持默认False即可。

3.3 三个常用模式：no_grad / enable_grad / inference_mode

梯度记录不是免费的，它要额外存储计算历史，占用内存、降低速度。所以在不需要梯度的场景里，我们要手动关掉它。

最常见的场景是验证和推理。模型已经训练好了，你只想让数据过一遍前向过程、看看预测结果，这时候再记录计算图纯属浪费。写法是：

with torch.no_grad(): logits = model(x)

还有一个inference_mode，从名字就能看出是专门为纯推理设计的，比no_grad更激进一些，效率也更高。如果你只是跑验证集做评估，用前者就够了；如果是做线上推理或者大规模跑预测，可以试试后者。

另外提一句，模型参数默认是requires_grad=True的，因为我们要通过反向传播更新它们。但如果你想在训练过程中冻结某层（比如迁移学习里锁定骨干网络），把对应参数的requires_grad置为False就可以了，这样优化器也不会更新它们。

4. 用nn.Module攒一个能跑通的图像分类模型

4.1 一个模块就是一个“积木块”

nn.Module是PyTorch里组织模型的基础单元。你可以把它理解成一个积木块：块里面既包含参数（比如卷积核权重、偏置），也包含前向计算逻辑。小模块可以拼成大模块，大模块再拼成完整网络，层层嵌套，非常符合人脑的组织方式。

自定义模型的标准写法是两步：在__init__里定义层，在forward里用这些层完成计算。注意不要在forward里临时创建新层（除非你有特殊设计），因为只有注册进__init__的子模块才会被框架自动管理参数、自动搬到GPU上。

4.2 手写一个精简卷积网络

以手写数字识别这类经典任务为例，我来写一个能直接跑的卷积网络。输入是单通道的灰度图，尺寸可以按28×28来理解（这类公开数据集通常都是这个量级）：

import torch import torch.nn as nn class SimpleCNN(nn.Module): def __init__(self, num_classes=10): super().__init__() self.features = nn.Sequential( nn.Conv2d(1, 32, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(2), nn.Conv2d(32, 64, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(2), ) self.classifier = nn.Sequential( nn.Flatten(), nn.Linear(64 * 7 * 7, 128), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(128, num_classes), ) def forward(self, x): x = self.features(x) x = self.classifier(x) return x

这个网络很简单：两个卷积块提取特征，两次下采样把尺寸缩小，最后展平接全连接层输出分类分数。这里我重点说两个容易算错的地方。

第一个是卷积后的尺寸变化。如果输入是28×28，第一层卷积padding=1保持尺寸不变，池化后变成14×14；第二次卷积仍然保持尺寸，池化后变成7×7。所以展平之前是64通道×7×7，全连接层第一个维度就是6477。这个数值是你自己推导出来的，不是凭空取的。

第二个是Dropout。我在分类器里放了它来抑制过拟合，但注意它只在训练阶段生效。如果你忘了切换模型的train/eval模式，就会出现在验证集上结果飘忽不定的问题。这一点我后面专门展开讲。

4.3 Dataset和DataLoader：把数据变成“流水线”

训练模型不能一次性把全部数据丢进显卡，内存扛不住，也没必要。正确做法是做成一个可以按序号取样本的数据集，再用加载器按批次、按顺序地取数据。

Dataset类需要实现两个方法：__len__返回样本总数，__getitem__根据索引返回一组（输入, 标签）。DataLoader负责在这之上做批量打包、随机打乱、多进程预取等工作。核心代码长这样：

from torch.utils.data import Dataset, DataLoader class SimpleDataset(Dataset): def __init__(self, x_data, y_labels): self.x_data = x_data self.labels = y_labels def __len__(self): return len(self.x_data) def __getitem__(self, idx): return self.x_data[idx], self.labels[idx] train_loader = DataLoader(train_set, batch_size=64, shuffle=True, num_workers=2) test_loader = DataLoader(test_set, batch_size=128, shuffle=False)

在Windows上num_workers如果设大于0，有概率触发子进程相关的报错，业界通用做法是设成0或者把相关代码包进脚本入口，别在交互式环境里开多进程预取。宁可慢一点，也别卡在一个诡异问题上。

5. 训练循环里那些文档不会告诉你的细节

5.1 经典三行代码的固定顺序

每个训练batch里几乎都是固定的四步：清零梯度、前向计算、反向传播、更新参数。代码长这样：

for epoch in range(epochs): model.train() total_loss = 0 for x, y in train_loader: x, y = x.to(device), y.to(device) optimizer.zero_grad() # 第一步：清零上一次的梯度 logits = model(x) # 第二步：前向传播 loss = criterion(logits, y) # 计算损失 loss.backward() # 第三步：反向传播，算出梯度 optimizer.step() # 第四步：更新参数 total_loss += loss.item()

我见过至少三个新手把optimizer.zero_grad()写成了loss.backward()之后，结果训练曲线上下乱跳，准确率完全上不去。原因很简单：PyTorch里的梯度是“累加”的，不清零的话，本次batch的梯度会跟上次的加在一起，参数更新的方向就完全错了。这个顺序没有任何商量的余地，一定要刻在肌肉记忆里。

loss.item()用于取出Python数值，方便记录日志。注意这里取的是标量值，不会参与计算图追踪。如果你把张量直接存进列表，内存会一直持有计算图引用，训练几百轮后内存直接爆掉，这类问题排查起来非常隐蔽。

5.2 train()和eval()：两个字就能毁掉你的验证集

PyTorch的模型有train和eval两种状态。调用model.train()时，Dropout会随机屏蔽神经元，BatchNorm会使用当前batch的统计量；调用model.eval()时，Dropout失效，BatchNorm改用训练阶段积累的全局统计量。

很多新手把这两个模式混着用：训练完了直接在同一个模式下跑验证，结果验证准确率一会高一会低，还以为模型没收敛。其实不是模型的问题，是Dropout在验证阶段还在“随机丢东西”，所以你每次跑出来的结果都不一样。

正确做法是：训练阶段在遍历数据前调用model.train()，验证阶段切换到model.eval()，并且配合torch.no_grad()关闭梯度追踪。这两条配合起来，验证结果才是稳定可靠的。

5.3 选损失函数、学习率和batch size的朴素原则

分类任务一般用交叉熵损失，在PyTorch里是nn.CrossEntropyLoss。有一件事容易混淆：这个损失函数内部已经把softmax做了，所以模型最后一层直接输出原始分数（logits）就行，不要在模型里再加softmax，否则会重复计算。如果你只是想看每个类别的概率，那就在推理阶段对logits做softmax。

学习率是训练里最需要盯住的超参数。设太大，损失会发疯一样乱跳，甚至直接变NaN；设太小，损失半天降不下来。我的习惯是先试1e-3这个量级，观察前几个batch的损失下降趋势，再逐步调整。如果模型大、数据多，可以做学习率衰减，让训练后期更平稳。

batch size的选择受显存限制，同时也影响训练稳定性。太大的batch会导致梯度方向过于“平滑”，有时反而需要配合更高的学习率。小batch噪声大，但有时候泛化性能意外地好。这块没有金科玉律，都是试出来的。我个人经验是，先从32或64开始，能跑通再往下调优。

5.4 训练过程中应该盯住哪些信号

训练不是把代码跑完就结束。我建议每轮结束时输出三个数字：训练损失、验证损失、验证准确率。你会发现一些典型现象：

• 训练损失下降，验证损失也在下降：正常，继续跑。
• 训练损失下降，验证损失先降后升：过拟合信号，考虑加正则、Dropout或数据增强。
• 训练损失和验证损失都下不去：可能是学习率不对，或者模型容量不足。
• 损失出现NaN：大概率是学习率过大，也可能是输入数据里有异常值。

养成盯这些指标的习惯后，你对模型状态的判断会准很多，这也是所谓“手感”的来源。

6. 高频报错和模型保存加载：提前帮你排雷

6.1 我踩过最狠的四个坑

下面这几个报错，每个我都亲眼目睹过无数次，也自己踩过。整理成表格给你：

还有一个隐形坑：如果你用了BatchNorm但训练和验证时batch size特别小，比如只有一个样本，那么BatchNorm会直接报错或产生极不稳定的统计量。这类问题在视频、长文本这样的变长数据上尤其常见，解决办法是调整batch size或改用其他归一化方式。

6.2 模型的保存与加载姿势

训练完了，模型要落盘。PyTorch里最推荐的做法是只保存权重，不保存整个模型对象：

# 保存 torch.save(model.state_dict(), "model_weights.pth") # 加载 model = SimpleCNN(num_classes=10) model.load_state_dict(torch.load("model_weights.pth", map_location="cpu"))

第一次加载state_dict时，你要先手动创建好一个结构完全一致的模型实例，再往里填权重。这个设计初看麻烦，但它保证了不同机器、不同环境之间加载的兼容性，也避免把一堆不稳定的代码对象序列化进文件里。

torch.load的map_location参数很常用：原模型是在GPU上训练的，你现在只有CPU，加载时指定map_location='cpu'就能正常读到权重，省去手动搬运的麻烦。如果是GPU迁移，也可以传对应设备名。

6.3 从训练到推理，还有一段路

训练一个模型只是开始，真正要把它用起来，还要做推理部署。这一步对新手来说可以晚点再研究，但我先给你打个底。

一个尽量简洁的推理流程是：模型加载权重后切到eval模式，对输入做和训练时一致的预处理，然后在no_grad或inference_mode下跑前向，最后把输出概率映射到类别。这里最关键的一点是预处理必须和训练完全一致——很多人训练时用归一化、尺寸缩放，推理时忘了做，结果模型输出莫名其妙的概率分布，还以为模型坏了，其实只是数据没对齐。

如果后续要做服务化部署，可以考虑把模型导出成开放的标准化格式，或者配合推理引擎做加速。这部分属于进阶内容，我不展开，但你提前知道“训练环境≠生产环境”这件事，未来会少走很多弯路。

我个人最后再分享一个小经验：入门阶段千万别纠结在那些花哨的高级API上，把张量、自动求导、训练循环这三件事玩明白，你就已经掌握了九成的日常开发能力。至于分布式训练、混合精度、模型量化这些，都是在基础扎实之后水到渠成的事。先把第一个模型老老实实跑起来，比看一百篇教程都管用。