很多人学 PyTorch，一上来就背 API。结果代码能跑，报错不会查，性能不会调，模型为什么能训练也说不清。

这一章先解决一个问题：PyTorch 不是“一个深度学习库”，它是一整套把数据、模型、梯度、GPU 和工程训练串起来的系统。

一、PyTorch 本质是什么

PyTorch 官方文档把它描述为“面向 GPU 和 CPU 的优化张量库”。这句话很短，但信息量很大。

张量库，说明它的核心数据结构是 Tensor。优化，说明它不是普通数组，而是面向高性能计算设计。GPU 和 CPU，说明它可以把同一套代码跑在不同设备上。

再往深处看，PyTorch 不只是做矩阵运算。它还提供自动求导、神经网络模块、优化器、数据加载、分布式训练、模型编译和部署导出能力。

一句话：PyTorch = 会跑 GPU 的 Tensor + 自动求导引擎 + 神经网络积木 + 训练工程生态。

如果用开发者语言描述，PyTorch 大概是下面这条链路：

数据先变成 Tensor。Tensor 进入 nn.Module。前向传播得到预测值。Loss 计算误差。Autograd 反向计算梯度。Optimizer 根据梯度更新参数。GPU 后端负责把计算跑快。

这就是 PyTorch 最小闭环。后面的所有复杂能力，几乎都是围绕这个闭环扩展出来的。

二、为什么 PyTorch 学起来顺手

PyTorch 最早打动开发者的地方，不是“大而全”，而是“像写普通 Python”。

你写一个 if，它就执行一个 if。你写一个 for，它就循环。你在 forward 里打断点，它真的能断在那里。模型结构可以按输入动态变化，调试体验接近普通业务代码。

这背后对应的是动态图机制。动态图不是先把整张图定义好再执行，而是每一次前向传播时，一边执行，一边记录计算过程。

这就是 PyTorch 和很多传统静态图框架的最大体感差异。

静态图更像“先画施工图，再统一施工”。动态图更像“边走边修路，每一步都能看清”。

研究阶段，模型经常改。今天加一层，明天改一个分支，后天换一种损失函数。动态图让这些改动变得轻。

工程阶段，动态图也不是不能优化。PyTorch 2.x 之后，torch.compile 会尝试捕获 Python 执行过程中的图，再交给编译后端做优化。也就是说，PyTorch 走了一条很现实的路：先保持好写，再尽量变快。

三、PyTorch 的四层理解法

不要一开始就被海量 API 淹没。理解 PyTorch，可以分成四层。

第 1 层：Tensor 层

Tensor 是 PyTorch 的血液。输入数据是 Tensor，模型参数是 Tensor，梯度也是 Tensor。

它像 NumPy 数组，但多了几个关键能力：可以放到 GPU 上；可以记录梯度；可以参与深度学习计算图。

import torch

x = torch.randn(2, 3) # CPU Tensor

w = torch.randn(3, 4)

y = x @ w # 矩阵乘法

print(y.shape) # torch.Size([2, 4])

这个例子很简单。可一旦 x 和 w 放到 CUDA 设备上，底层计算就不再是 Python 慢慢算，而是交给 GPU 内核执行。

第 2 层：Autograd 层

Autograd 是训练的发动机。它负责记住前向计算发生了什么，然后在 backward 时倒着走一遍，把梯度算出来。

官方教程明确说，torch.autograd 是 PyTorch 的自动微分引擎，驱动神经网络训练。它支持对计算图自动计算梯度。

x = torch.tensor(2.0, requires_grad=True)

y = x * x + 3 * x

y.backward()

print(x.grad) # dy/dx = 2x + 3，x=2，所以梯度是 7

这里没有手写求导公式。PyTorch 会记录 x * x 和 3 * x 这些操作，最后自动反向求梯度。

训练模型的本质：不是模型“自己会学习”，而是 Autograd 先算梯度，Optimizer 再改参数。

第 3 层：nn.Module 层

nn.Module 是模型的骨架。你写的 CNN、RNN、Transformer，本质上都是一个 Module。

官方教程里也强调，神经网络由一层层模块组成，所有 PyTorch 模型都应该继承 nn.Module。Module 可以嵌套 Module，所以复杂模型天然形成树形结构。

from torch import nn

class Net(nn.Module):

def __init__(self):

super().__init__()

self.fc = nn.Linear(10, 2)

def forward(self, x):

return self.fc(x)

很多人只记住了 __init__ 里写层，forward 里写计算。真正关键的是：为什么 self.fc = nn.Linear(10, 2) 之后，PyTorch 就能自动找到参数？

答案在源码里。Module 内部维护了 _modules、_parameters、_buffers 等字典。子模块、参数、状态张量会被登记进去。后面调用 parameters、state_dict、to(cuda)、train、eval 时，PyTorch 都能沿着这棵树递归处理。

第 4 层：Backend 层

PyTorch 的上层写起来像 Python，但真正跑得快，是因为底层不是纯 Python。

它有 C++ 核心、ATen 张量库、Dispatcher 分发机制，以及 CPU、CUDA、MPS、XPU 等设备后端。

你写一行 torch.add(x, y)，底层会根据 x 和 y 的设备、数据类型、算子类型，找到合适的实现。CPU Tensor 走 CPU Kernel。CUDA Tensor 走 CUDA Kernel。

四、从源码视角看 PyTorch 的整体架构

如果只从使用层看，PyTorch 是 torch、nn、optim、DataLoader 这些模块。

如果从源码层看，它更像一个分层系统。Python 只是门面，C++ 和设备后端才是高性能执行层。

第一层是用户代码。你写 model(x)、loss.backward()、optimizer.step()。

第二层是 Python API。torch.Tensor、torch.nn、torch.autograd、torch.optim 都在这一层暴露给你。

第三层是分发层 Dispatcher。它决定这个算子应该交给哪个后端执行。

第四层是 ATen / C++ Core。这里承载了大量张量运算、内存管理和算子实现。

第五层是设备后端。CPU、CUDA、MPS、XPU、ROCm 等分别提供不同硬件上的执行能力。

第六层是硬件本身。GPU Kernel、CPU 指令、cuDNN、NCCL 等在这里真正消耗算力。

PyTorch 的设计取向很清楚：上层保持 Python 友好，下层尽量接近硬件性能。

五、训练闭环：PyTorch 最重要的一张图

学 PyTorch，不要先陷入复杂模型。先看一轮训练。

一轮训练一般分六步：

• DataLoader 取出一个 batch。

• model(x) 执行前向传播，得到预测值。

• loss_fn 计算预测值和真实标签之间的误差。

• optimizer.zero_grad() 清空上一轮残留梯度。

• loss.backward() 触发 Autograd，反向计算梯度。

• optimizer.step() 根据梯度更新参数。

这就是所有 PyTorch 训练代码的骨架。无论你训练的是图像分类模型、文本分类模型，还是大模型微调，本质都绕不开这个闭环。

for x, y in dataloader:

pred = model(x) # 1. 前向传播

loss = loss_fn(pred, y) # 2. 计算损失

optimizer.zero_grad() # 3. 清空梯度

loss.backward() # 4. 反向传播

optimizer.step() # 5. 更新参数

这段代码不要死记。你要记住它背后的分工：

model 负责算预测。loss 负责衡量错多少。autograd 负责算梯度。optimizer 负责改参数。DataLoader 负责稳定供数据。

六、PyTorch 为什么能成为主流

PyTorch 不是靠单点能力胜出，而是几个特性叠在一起，形成了很强的开发体验。

1. 写法自然，像普通 Python

这让研究人员可以快速试模型，让工程师可以用熟悉的方式调试问题。

2. 动态图适合快速迭代

模型结构、输入长度、控制流都可以灵活变化。复杂模型不用为了框架限制绕来绕去。

3. Autograd 把求导变成基础设施

以前你要手推梯度。现在只要用可微 Tensor 组织计算，反向传播由引擎完成。

4. nn.Module 让复杂模型有组织

没有 Module，复杂模型会变成一堆散乱函数和张量。Module 把层、参数、状态、保存、加载、迁移设备统一管理起来。

5. 生态完整，能从研究走到生产

训练阶段有 Dataset、DataLoader、optim、AMP、distributed。优化阶段有 profiler、torch.compile。部署阶段有 torch.export、ONNX 等方案。

这就是为什么 PyTorch 既能被学生拿来入门，也能被大模型团队拿来做训练、微调、推理和部署。

七、源码重点：不要把 PyTorch 看成黑盒

第一章不展开所有源码，但要先建立源码阅读方向。

后续读源码，先抓三条主线。

主线一：Tensor 怎么表示数据；主线二：Autograd 怎么记录和反传；主线三：Module 怎么注册和管理参数。

源码里最值得先看的，不是某个复杂模型，而是基础机制。

torch.Tensor：看张量的设备、dtype、shape、stride、storage。理解数据怎么存。

torch.autograd：看 grad_fn、Function、Node、Engine。理解梯度怎么流。

torch.nn.Module：看 _parameters、_modules、_buffers。理解模型怎么被管理。

Dispatcher / ATen：看算子如何从 Python 调到底层内核。理解为什么它快。

这也是本专栏后面“源码级讲解”的路线：不只告诉你 API 怎么用，还会告诉你为什么这么设计。

八、总结

记住 5 句话。

✓ PyTorch 的核心数据结构是 Tensor。

✓ 训练能跑起来，靠的是 Autograd 自动求导。

✓ 模型能被组织起来，靠的是 nn.Module 的注册机制。

✓ 速度能上去，靠的是底层 C++ / ATen / 设备后端。

✓ PyTorch 好用，是因为它把 Python 友好性和底层高性能结合在了一起。

下一章，我们开始进入第一个硬核组件：Tensor。你会看到 Tensor 不只是数组，它背后还有 dtype、device、stride、storage 和内存布局。