1. 从一个具体例子切入：为什么需要理解PyTorch的运作方式
很多刚接触深度学习的开发者，在跑通第一个Demo之后，会陷入一种“能跑但说不清”的状态。模型训练起来了，损失也在下降，但一旦需要修改网络结构、自定义损失函数，或者排查梯度消失的问题，就无从下手。这个现象非常普遍，根源在于对框架的底层运作逻辑缺乏一个具象的认知。
PyTorch的核心设计哲学可以用一句话概括：让张量像NumPy数组一样好用，同时自动帮你算梯度。这句话听起来简单，但它背后涉及三个关键机制——张量计算、自动微分和动态计算图。如果只是照着教程搭一个分类器，这三个机制你一个都不会真正理解。
我打算用一个完整的、可复现的例子来拆解这些机制。这个例子不追求模型精度，而是追求每一步都能看到数据在框架内部是怎么流动的。具体来说，我们会手动实现一个线性回归，从数据构造、前向传播、损失计算、反向传播到参数更新，全部用PyTorch的基础API完成，不借助nn.Linear这类封装好的模块。这样做的好处是，你能清楚地看到requires_grad、backward()、grad这些概念在实际代码中到底扮演什么角色。
这个内容适合两类人：一类是刚学完Python和NumPy、准备进入深度学习领域的初学者；另一类是用过PyTorch但只会调库、想搞清楚底层原理的开发者。不管你属于哪一类，跟着把代码敲一遍，再对照文中的解释，你对PyTorch的理解会从“会用”提升到“知道为什么这样用”。
提示：本文所有代码基于PyTorch 2.x版本编写，CPU环境即可运行，不需要GPU。如果你用的是更早的版本，大部分API仍然兼容，但个别行为可能有差异，建议对照官方文档确认。
2. 张量：PyTorch里一切数据的载体
2.1 张量和NumPy数组的本质区别
如果你用过NumPy，第一次看到torch.tensor的时候可能会觉得这就是换了个名字的数组。从数据存储的角度看，确实如此——它们都是多维数组，都支持切片、广播、矩阵乘法。但有一个关键区别决定了PyTorch能做的事情远超NumPy：PyTorch的张量可以记录计算历史，并自动计算梯度。
这个区别通过一个属性来控制：requires_grad。当你创建一个张量时，默认requires_grad=False，此时它就是一个普通的数值容器，和NumPy数组没有本质区别。但一旦你把它设为True，PyTorch就会开始追踪所有基于这个张量的运算，构建一张计算图，为后续的反向传播做准备。
import torch # 普通张量，不追踪梯度 x = torch.tensor([1.0, 2.0, 3.0]) print(x.requires_grad) # False # 开启梯度追踪 w = torch.tensor([2.0], requires_grad=True) print(w.requires_grad) # True这里有一个容易踩的坑：只有浮点类型的张量才能开启梯度追踪。如果你写torch.tensor([1, 2, 3], requires_grad=True)，会直接报错，因为整数张量不支持梯度计算。这个限制的原因是梯度本身是连续的浮点值，整数张量无法表示。我在早期就因为这个报错排查了半天，后来养成习惯，创建需要梯度的张量时一律显式指定dtype=torch.float32。
2.2 张量的创建方式与内存布局
PyTorch提供了多种创建张量的方式，不同方式在内存布局和使用场景上有细微差别。直接从Python列表创建（torch.tensor）会复制数据，而从NumPy数组转换（torch.from_numpy）则共享内存。这意味着如果你修改了原始NumPy数组，对应的张量也会跟着变，反之亦然。
import numpy as np arr = np.array([1.0, 2.0, 3.0]) t_shared = torch.from_numpy(arr) arr[0] = 100.0 print(t_shared) # tensor([100., 2., 3.])这个共享内存的特性在数据预处理阶段非常有用，可以避免不必要的内存拷贝。但也要小心，如果你不希望原始数据被意外修改，就应该用torch.tensor或者.clone()来创建副本。
另外，torch.zeros、torch.ones、torch.randn这些工厂函数在初始化参数时用得最多。它们默认创建的是浮点张量，可以直接开启梯度追踪。在实际项目中，我通常会用torch.randn配合一个较小的缩放因子来初始化权重，而不是直接用默认的标准正态分布，这样可以避免训练初期的梯度爆炸问题。
2.3 张量运算与计算图的构建
当你对开启了requires_grad的张量做运算时，PyTorch会在后台默默构建一张计算图。这张图的每个节点是一个张量，每条边是一个运算操作。比如下面这段代码：
w = torch.tensor([2.0], requires_grad=True) b = torch.tensor([1.0], requires_grad=True) x = torch.tensor([3.0]) y = w * x + by的计算过程会被记录为：y = add(mul(w, x), b)。当你调用y.backward()时，PyTorch会沿着这张图反向遍历，用链式法则计算每个叶子节点的梯度。叶子节点就是那些由用户直接创建、requires_grad=True且不是运算结果的张量，在这里就是w和b。
理解这一点很重要，因为它解释了为什么中间张量的梯度默认不会被保留。只有叶子节点的.grad属性会被填充，非叶子节点的梯度在反向传播完成后就被释放了（除非你调用retain_grad()）。这个设计是为了节省内存，因为大多数情况下我们只关心模型参数的梯度。
3. 自动微分：PyTorch最核心的机制
3.1 前向传播与计算图的动态构建
PyTorch采用动态计算图，这意味着计算图是在每次前向传播时实时构建的。这和早期TensorFlow的静态图模式有本质区别。动态图的好处是你可以用普通的Python控制流（if、for、while）来构建模型，调试起来就像写普通Python代码一样直观。
用一个线性回归的例子来说明。假设我们有三个样本，每个样本一个特征：
# 数据准备 x_data = torch.tensor([[1.0], [2.0], [3.0]]) y_data = torch.tensor([[2.0], [4.0], [6.0]]) # 参数初始化 w = torch.tensor([[0.5]], requires_grad=True) b = torch.tensor([0.0], requires_grad=True) # 前向传播 y_pred = x_data @ w + b loss = ((y_pred - y_data) ** 2).mean()每一步运算都在扩展计算图。x_data @ w产生一个中间张量，加上b又产生一个，减去y_data再产生一个，平方、求均值，最终得到标量loss。这张图从loss出发，反向追溯到w和b，路径非常清晰。
3.2 反向传播：backward()到底做了什么
调用loss.backward()之后，PyTorch会做以下几件事：
- 从
loss这个标量开始，初始化其梯度为1.0（因为d(loss)/d(loss) = 1）。 - 沿着计算图反向遍历，对每个运算应用链式法则，计算该运算输出对输入的偏导数。
- 将梯度累积到叶子节点的
.grad属性上。
对于上面的例子，loss = mean((xw + b - y)^2)，对w的偏导数是2 * mean((xw + b - y) * x)，对b的偏导数是2 * mean(xw + b - y)。你可以手动算一遍，然后和代码输出的.grad对比，验证理解是否正确。
loss.backward() print(w.grad) # tensor([[-13.3333]]) print(b.grad) # tensor([-5.3333])这里有一个非常重要的细节：梯度是累积的，不是替换的。如果你连续调用两次backward()而没有清零梯度，第二次的梯度会加到第一次的结果上。这就是为什么训练循环里必须写optimizer.zero_grad()或者手动把.grad置零。我见过不少初学者因为漏了这一步，导致模型完全不收敛，排查半天才发现是梯度累积的问题。
3.3 梯度清零的正确姿势与常见误区
手动清零梯度有两种写法：
# 写法一：直接置零 w.grad.zero_() b.grad.zero_() # 写法二：用optimizer统一清零 optimizer.zero_grad()推荐用第二种，因为当参数很多的时候，逐个清零容易遗漏。另外要注意，在第一次调用backward()之前，.grad属性是None，直接调用w.grad.zero_()会报错。所以如果你手动清零，需要先判断if w.grad is not None。
还有一个容易忽略的点：torch.no_grad()上下文管理器。在评估模型或者只需要前向传播的时候，应该用with torch.no_grad():包裹代码，这样PyTorch不会构建计算图，可以显著节省内存和计算时间。我在做推理部署的时候，如果忘了加这个，显存占用会高出30%以上。
4. 手动实现一个完整的训练循环
4.1 从零搭建线性回归的训练流程
现在把前面讲的所有知识点串起来，写一个完整的训练循环。这个循环不依赖nn.Module和optim.SGD，全部手动实现，目的是让你看清每一步在做什么。
import torch # 1. 准备数据 x_data = torch.tensor([[1.0], [2.0], [3.0], [4.0]]) y_data = torch.tensor([[3.0], [5.0], [7.0], [9.0]]) # 2. 初始化参数 w = torch.tensor([[0.1]], requires_grad=True) b = torch.tensor([0.0], requires_grad=True) # 3. 设置超参数 lr = 0.01 epochs = 1000 # 4. 训练循环 for epoch in range(epochs): # 前向传播 y_pred = x_data @ w + b loss = ((y_pred - y_data) ** 2).mean() # 反向传播 loss.backward() # 手动更新参数（注意：更新时不需要梯度追踪） with torch.no_grad(): w -= lr * w.grad b -= lr * b.grad # 清零梯度 w.grad.zero_() b.grad.zero_() if epoch % 100 == 0: print(f"Epoch {epoch}, Loss: {loss.item():.4f}") print(f"最终参数: w={w.item():.4f}, b={b.item():.4f}")这段代码有几个值得注意的地方。第一，参数更新必须在torch.no_grad()下进行，否则w -= lr * w.grad这个操作本身会被记录到计算图里，导致下次反向传播时出错。第二，loss.item()用于从标量张量中取出Python数值，避免在打印时保留计算图引用。第三，学习率设为0.01是因为数据量小、问题简单，实际项目中需要根据情况调整。
4.2 训练过程中的常见异常与排查思路
即使这么简单的代码，新手也可能遇到几个典型问题。我把自己踩过的坑列出来，方便你对照排查。
问题一：Loss变成NaN。最常见的原因是学习率太大，导致参数更新步长过大，损失函数发散。解决办法是把学习率调小一个数量级试试。另一个可能的原因是数据没有归一化，特征值范围差异太大，导致梯度计算时数值不稳定。
问题二：Loss不下降。如果Loss一直卡在初始值附近，首先检查梯度是否为零。可以在backward()之后打印w.grad看看。如果梯度确实是零，可能是计算图断了——比如在某个地方用了.detach()或者.item()，导致梯度无法回传。另一个常见原因是忘了清零梯度，导致梯度累积后方向混乱。
问题三：参数更新后没有变化。检查是否在更新时用了with torch.no_grad()。如果没有用，PyTorch会报错“a leaf Variable that requires grad is being used in an in-place operation”。这个报错信息其实已经提示了原因，但初学者往往看不懂。
注意：手动更新参数时，一定要用
with torch.no_grad()包裹，或者用.data属性来操作。但.data的方式不推荐，因为它绕过了版本检查，可能导致难以发现的bug。
4.3 用optimizer简化参数更新
手动更新参数虽然直观，但实际项目中参数动辄百万千万，不可能逐个手写。PyTorch的optim模块提供了各种优化器，用法非常统一：
optimizer = torch.optim.SGD([w, b], lr=0.01) for epoch in range(epochs): y_pred = x_data @ w + b loss = ((y_pred - y_data) ** 2).mean() optimizer.zero_grad() # 清零梯度 loss.backward() # 反向传播 optimizer.step() # 更新参数三行代码替代了之前的手动操作，而且optimizer.step()内部自动处理了no_grad的问题。optimizer.zero_grad()也比手动清零更可靠，它会遍历所有传入的参数，把.grad置零或设为None。
这里有一个性能上的小技巧：zero_grad(set_to_none=True)比默认的zero_grad()稍微快一点，因为它把梯度设为None而不是零张量，减少了内存写入操作。在大型模型训练中，这个差异会累积成可观的时间节省。
5. 从手动实现过渡到nn.Module
5.1 nn.Module封装了什么
当你理解了手动实现的全过程，再看nn.Module就会觉得理所当然。它主要做了三件事：把参数管理起来（parameters()方法）、定义了前向传播的接口（forward()方法）、提供了训练和评估模式的切换（train()和eval()）。
用nn.Module重写上面的线性回归：
import torch.nn as nn class LinearRegression(nn.Module): def __init__(self): super().__init__() self.linear = nn.Linear(1, 1) def forward(self, x): return self.linear(x) model = LinearRegression() optimizer = torch.optim.SGD(model.parameters(), lr=0.01) for epoch in range(epochs): y_pred = model(x_data) loss = ((y_pred - y_data) ** 2).mean() optimizer.zero_grad() loss.backward() optimizer.step()model.parameters()会自动收集所有子模块的参数，不需要手动传入[w, b]。nn.Linear(1, 1)内部已经做好了权重初始化，比手动设w = torch.tensor([[0.1]], requires_grad=True)更规范。
5.2 自定义层和损失函数的编写要点
实际项目中，你经常需要自定义层或损失函数。自定义层的关键是继承nn.Module并在__init__中定义参数，在forward中定义计算逻辑。参数必须用nn.Parameter包装，这样才会被parameters()收集到。
class MyLinear(nn.Module): def __init__(self, in_features, out_features): super().__init__() self.weight = nn.Parameter(torch.randn(in_features, out_features)) self.bias = nn.Parameter(torch.zeros(out_features)) def forward(self, x): return x @ self.weight + self.bias自定义损失函数则更简单，通常直接写一个函数就行，不需要继承任何类。只要输入是张量、输出是标量，并且计算过程可导，就可以直接调用backward()。
def my_mse_loss(y_pred, y_true): return ((y_pred - y_true) ** 2).mean()这里有一个经验之谈：自定义损失函数时，尽量避免使用不可导的操作，比如round()、argmax()（除非用在不需要梯度的分支上）。如果确实需要，可以用torch.no_grad()把不可导的部分隔离开，或者用直通估计器（straight-through estimator）等技巧来处理。
5.3 训练模式与评估模式的差异
model.train()和model.eval()的区别在简单模型上体现不出来，但一旦涉及Dropout和BatchNorm，就至关重要。Dropout在训练时随机置零部分神经元，在评估时则使用全部神经元并按比例缩放。BatchNorm在训练时用当前batch的统计量，在评估时用全局统计量。
如果你忘了切换模式，最典型的症状是：训练时Loss正常下降，但评估时结果波动很大，或者验证集准确率远低于训练集。我遇到过好几次这种情况，排查半天才发现是忘了写model.eval()。所以养成习惯：每次评估之前先调model.eval()，评估完再调model.train()回到训练模式。
6. 动态图机制带来的调试优势
6.1 用pdb断点调试PyTorch代码
动态图最大的好处是可以用标准的Python调试工具。你可以在forward函数里直接打pdb.set_trace()，然后逐行检查张量的形状、数值和梯度。这在静态图框架里是很难做到的，因为静态图在运行前就已经编译好了，你无法在构建阶段插入断点。
import pdb class DebugModel(nn.Module): def forward(self, x): pdb.set_trace() y = self.linear(x) return y进入断点后，你可以用x.shape查看形状，用x.mean()查看均值，用x.requires_grad确认梯度追踪是否开启。这些信息在排查“形状不匹配”“梯度为None”等问题时非常有用。
6.2 打印中间张量梯度的技巧
有时候你需要查看非叶子节点的梯度，比如某个中间层的输出。默认情况下这些梯度在反向传播后就被释放了。解决办法是调用retain_grad()：
x = torch.tensor([1.0, 2.0], requires_grad=True) y = x * 2 y.retain_grad() # 保留y的梯度 z = y.sum() z.backward() print(y.grad) # tensor([1., 1.])这个技巧在调试梯度消失或梯度爆炸时特别有用。你可以逐层打印梯度范数，定位到具体是哪一层的梯度出了问题。
6.3 常见形状错误的定位方法
形状不匹配是PyTorch新手最常见的错误之一。报错信息通常是“The size of tensor a (X) must match the size of tensor b (Y) at non-singleton dimension Z”。看到这个报错，第一步是打印所有相关张量的.shape，然后对照广播规则检查。
我自己的习惯是在forward函数的关键步骤后面加一行print(f"after op X: {tensor.shape}")，跑一次小批量数据，确认每一步的形状都符合预期。确认无误后再把这些打印语句删掉或注释掉。虽然看起来笨，但比盲目猜测高效得多。
7. 几个容易被忽略但很重要的细节
7.1 in-place操作对梯度的影响
PyTorch里很多操作有in-place版本，比如add_()、mul_()、relu_()。这些操作直接修改原张量，不创建新对象，可以节省内存。但在需要梯度的计算中，in-place操作可能导致问题，因为它会覆盖反向传播所需的值。
x = torch.tensor([1.0, 2.0], requires_grad=True) y = x * 2 y.add_(1) # in-place操作 z = y.sum() z.backward() # 可能报错或得到错误梯度PyTorch的自动微分系统会检测到这种冲突并抛出错误，提示你某个变量被in-place修改了。解决办法是改用非in-place版本：y = y + 1。虽然多了一次内存分配，但保证了梯度的正确性。
7.2 设备管理：CPU与GPU之间的数据搬运
如果你的机器有GPU，需要把模型和数据都搬到GPU上。常见错误是模型在GPU上但数据在CPU上，或者反过来，导致“Expected all tensors to be on the same device”的报错。
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = model.to(device) x_data = x_data.to(device) y_data = y_data.to(device)注意model.to(device)是in-place操作，会直接修改模型；而x_data.to(device)返回一个新的张量，需要重新赋值。这个不一致性经常让人困惑，记住“模型原地改，数据要赋值”就行了。
7.3 随机种子与结果复现
深度学习实验的复现性是个大问题。PyTorch的随机数生成器、NumPy的随机数生成器、Python内置的random模块，三者互相独立。要完全复现一次实验，需要同时设置三个种子：
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_all(seed)即便如此，某些CUDA操作仍然是非确定性的，比如atomicAdd。如果对复现性要求极高，还需要设置torch.use_deterministic_algorithms(True)，但这会牺牲一些性能。我的建议是：日常开发中设置种子就够了，只有在提交论文或做严格对比实验时才需要开启完全确定性模式。
8. 从这个小例子延伸出去的学习路径
把上面这个线性回归的例子彻底吃透之后，你会发现PyTorch的其他内容都是在这个基础上的自然延伸。卷积层不过是把矩阵乘法换成了卷积运算，循环网络不过是把一次前向传播变成了多次循环，Transformer不过是加了注意力机制。底层的自动微分、计算图、梯度更新逻辑，完全一样。
我个人的学习路径是这样的：先用纯手动的方式实现一遍线性回归和逻辑回归，确保对backward()和grad的理解没有偏差；然后过渡到nn.Module和optim，学会用封装好的组件；接着找一个简单的卷积网络（比如LeNet）手动实现一遍前向传播，理解卷积和池化的计算过程；最后再去看Transformer的实现，这时候你会发现大部分代码都是在做张量形状变换，核心的梯度计算部分反而很简单。
如果你现在处于第一阶段，建议不要急着去看复杂的模型。把线性回归的代码改一改，试试不同的学习率、不同的初始化方式、不同的损失函数，观察Loss曲线的变化。这种“控制变量”的实验方式，比看十篇教程都管用。我在最初学习的时候，光是调整学习率就花了一整天，但那一整天让我对梯度下降的理解深刻了很多，后面再学其他优化器就水到渠成。
最后分享一个我常用的调试技巧：当你怀疑梯度计算有问题时，可以用torch.autograd.gradcheck来验证。它通过数值微分的方式计算梯度，和你用backward()得到的梯度对比，如果误差在容忍范围内，说明梯度计算是正确的。这个工具在实现自定义层的时候特别有用，能帮你快速定位到数学推导中的错误。
