Yann LeCun深度学习公开课：PyTorch训练循环与代码复现实战

很多人收藏夹里躺着几十门公开课，最后真正学完的却不到一门。纽约大学这门由 Yann LeCun 主讲的深度学习课程，过去几年在中文技术社区反复被推荐，2021 年这一版因为配套资料完整、代码量适中，被认为是比较适合自学的版本之一。后来社区出现了中文配音加资料整理的分发形式，语言门槛确实降下来了，但一个更现实的问题随之暴露：配音只解决了"听得懂"，没有解决"学得会"。看完视频依然写不出训练循环、调不动 loss、不知道该改哪一层，这才是大多数人的真实卡点。

这篇文章不打算复述课程简介，而是把重点放在一个更工程化的角度：如何把这门课从"看过的视频"转成"跑得通、调得动、讲得清"的能力。具体会拆开讲清楚四件事——这门课的知识地图和它在深度学习体系里的位置、学习前必须补齐的前置条件、用 PyTorch 落地的完整代码路径、以及最容易踩坑的那些细节。如果你正在犹豫要不要入这门课，或者已经看了一半却发现代码跑不起来，下面这些内容应该能帮你少绕几圈。

需要先说明一个判断：这门课的价值不在于它覆盖了多少模型，而在于它反复追问"这个设计为什么成立"。这种讲法对初学者不算友好，但对已经会用框架、概念却一直模模糊糊的人，收益非常明显。所以本文的读者画像很明确：有 Python 基础、能看懂矩阵运算、想真正理解神经网络内部机制，而不是只想调包跑个分类任务。

1. 先说结论：这门课适合谁，不适合谁

在讨论怎么学之前，得先把"要不要学"这个问题回答掉。公开课的沉没成本往往不是时间，而是学到第三周才发现方向不对，然后整段放弃。所以先给出一组判断标准，比后面任何操作步骤都重要。

比较适合的三类人。 第一类是有一定 Python 和 NumPy 基础、想系统入门深度学习的开发者。这类人最大的问题是知识碎片化，看过无数篇讲反向传播的文章，但从来没有把"损失函数—梯度—参数更新"这条链完整走通过一遍，这门课能把这个链条讲到底层。第二类是已经在业务里用过 PyTorch 或 TensorFlow、但遇到模型不收敛只能靠搜博客试参数的人，课程里对优化、正则化、网络结构的讨论，能解释清楚很多"玄学调参"背后的机制。第三类是想往研究方向走、需要理解能量模型和自监督学习思路的人，主讲人在这一方向上长期的公开主张，是这门课区别于普通教学课的重要特征。

不太适合的三类人。 完全没有编程经验的人，直接上这门课会非常痛苦，因为课程材料大量使用 Notebook 和框架代码，缺了编程基础连示例都读不下来。只想快速做出业务效果的人也不用勉强，调包解决分类、检测、推荐这些常规需求，市面上有更短的学习路径。还有一类是把"看完视频"当作目标的人，这门课的配套练习和代码复现才是重点，光看讲解的收获会打不少折扣。

一个更实际的判断方式。 不妨先随便找一个公开的深度学习训练脚本，试着读懂它的数据加载、前向传播、损失计算、反向传播、参数更新这五段逻辑。如果这五段里你能说清至少三段在干什么，这门课可以直接开始；如果只能看懂个大概，建议先花一到两周补齐 NumPy 和 PyTorch 基础，再回来投入，效率会高很多。这个自测成本很低，但能省下大量无效学习时间。

关于中文配音版本，这里要提一句：它确实降低了语言门槛，但二次加工内容的使用应当尊重原作者的授权和原始发布渠道的规则，学习时建议以官方公开的讲义、代码仓库和原始视频为准，配音版本作为辅助理解的手段更合适。毕竟技术术语的翻译常常有偏差，遇到关键概念还是建议回到原始表述去核对。

2. 课程的知识地图：从 LeNet 到能量模型

要高效使用一门课，得先知道它的骨架。这门课的讲述逻辑并不是按"模型清单"平铺，而是沿着一条主线推进：先建立"学习就是优化"的基本框架，再逐步引入更强的假设。

起点是线性模型与梯度下降。 任何深度学习的讲法都绕不开这条线：用一个线性函数拟合数据，用损失函数衡量偏差，用梯度下降更新参数。看起来简单，但这里埋着后面所有内容的基础——为什么用交叉熵而不是均方误差、为什么学习率太大会震荡、为什么需要批量而非全量。这门课在这部分的处理比较扎实，值得慢下来。

接着是反向传播与自动微分。 这是整门课的技术枢纽。手推一遍链式法则，和真正理解计算图上的梯度回传，是两件不同的事。很多人在这一步只是"记住了公式"，等到自己改网络结构时就不知道梯度会怎么流。课程里对计算图和自动微分的讲解，是理解后续所有框架行为的前提。

然后是卷积网络这条主线。 主讲人本人是卷积网络早期工作的推动者之一，LeNet 系列在手写数字识别上的实践是这段历史的起点。课程对卷积的讲解不止于"权值共享降参数"，而是会回到图像的局部性和平移不变性这些先验假设上。理解了先验，才知道为什么在有些任务上卷积好用、在另一些任务上不如注意力机制。

后半程会进入更偏研究的视角。 包括序列建模、注意力机制，以及能量模型（Energy-Based Model）和自监督学习的思路。这部分是这门课比较有辨识度的地方。传统教学往往把分类当作终点，而能量模型的视角把"预测"重新表述为"给各个配置打一个能量分数，学习的目标是让正确配置的能量更低"。这个视角不是必需的业务技能，但它能帮你重新理解很多模型之间的内在联系。

一条建议的取舍路线。 如果时间有限，前四分之三的内容（基础框架、反向传播、卷积网络、优化与正则）是必须吃透的，这些直接对应日常工程能力。后半程的能量模型与自监督部分，可以先建立概念印象，等实际遇到相关问题时再回头精读。不必追求一次贯通，公开课的价值很大一部分在于它可以被反复查阅。

3. 环境准备：把"看课"变成"能跑"

这一节是分水岭。环境和代码跑不起来，后面所有内容都只是纸上谈兵。这里不写死具体版本号，因为不同时间点的依赖生态变化很快，只给出稳定可用的配置思路和验证方式。

3.1 基础环境与依赖

推荐使用 conda 或 venv 做环境隔离，不要装在系统 Python 里。深度学习项目依赖多、版本敏感，隔离能避免大量"昨天还能跑今天报错"的问题。

bash复制# 创建并激活独立环境（Python 版本请按实际项目要求选择，3.9 至 3.11 区间通常兼容性较好）
conda create -n dl-nyu python=3.10 -y
conda activate dl-nyu

# 安装 PyTorch，CPU 与 CUDA 版本请根据本机显卡情况到官方安装页面选择对应命令
# 下面这条是 CPU 版本的通用写法，仅用于验证流程是否跑通
pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu

# 常用辅助库
pip install numpy matplotlib jupyterlab tqdm

安装完成后必须做一次验证，不要凭"没报错"就认为装好了。

bash复制# 文件路径：scripts/check_env.py 或直接在 python 交互式环境中执行
python -c "import torch, torchvision; print('torch:', torch.__version__); print('cuda available:', torch.cuda.is_available())"

预期输出会打印出 torch 版本号，以及 cuda available 为 True 或 False。如果本机有 NVIDIA 显卡但这里返回 False，说明装的不是 CUDA 版本，或者驱动与运行时版本不匹配，需要回到官方安装页面重新选择命令。这个检查值得每次都做，因为很多"训练特别慢"的问题，根源就是一路在 CPU 上跑。

3.2 硬件与时间预算

CPU 也能完成课程前期的小规模实验，比如在 MNIST 上训练一个简单卷积网络，几分钟到十几分钟就能跑完一轮完整训练。但到了稍大的数据集或更深的网络，CPU 的时间成本会迅速变得不可接受。如果没有本地显卡，可以考虑使用云端的 Notebook 环境，按小时计费对学习场景更划算。

还有一个常被忽略的准备工作：把课程配套的 Notebook 和数据集提前下载到本地，而不是每次打开都重新拉取。数据下载失败是学习初期最常见的中断原因之一，尤其在网络条件不稳定的情况下。提前准备好，能把注意力留在内容本身。

4. 核心概念拆解：张量、自动微分与反向传播

课程里这三个概念是连在一起讲的，但很多人学完之后依然分不清它们的边界。这里用工程视角重新梳理一遍，重点放在"出问题时该往哪看"。

张量不是多维数组的同义词。 从数据结构角度看它确实是多维数组，但在框架里它多了两个关键属性：设备位置和是否需要梯度。设备位置决定了它在 CPU 还是 GPU 上，跨设备运算会直接报错；requires_grad 决定了它是否参与梯度计算。新手最常犯的错误是把 NumPy 数组直接喂给模型，或者把需要梯度的张量 .item() 之后又拿去反传，这两类问题在报错信息里都不算直观。

自动微分解决的是"手推梯度"的工程负担。 没有自动微分的年代，每改一次网络结构就要重新推导一遍梯度公式，出错概率极高。框架的做法是把前向计算过程记录成一张计算图，反向传播时沿着图自动应用链式法则。理解这一点之后，很多行为就变得可解释了：为什么每次迭代前必须清零梯度、为什么 torch.no_grad() 能显著省显存、为什么原地操作有时会破坏计算图。

反向传播的本质是复用中间结果。 如果对每一层都独立计算梯度，计算量会呈指数级增长。反向传播的关键在于，它利用前向过程中保存的中间激活值，从输出层往回逐层求导，把复杂度拉回到和层数线性相关。这个"用空间换时间"的取舍，直接导致了训练时显存占用远高于推理——因为训练要保留中间结果，推理不需要。

把三者串起来的判断方法。 训练不收敛时，先看梯度有没有正常回传，再看学习率是否合适，最后才怀疑网络结构。这个顺序很重要，因为大部分问题出在前两步。一个很实用的调试手段是打印各层梯度的范数，如果某些层梯度接近零或者爆炸到很大，问题定位就非常明确了。

5. 完整示例一：从零写一个最小训练循环

概念讲完，接下来必须有能跑的代码。第一个示例刻意做得小：一个一维非线性回归任务，不涉及数据加载，专门用来把"前向—损失—反向—更新"这四步走通。这个例子跑通之后，再去看真实的图像分类脚本，理解成本会低很多。

python复制# 文件路径：examples/01_autograd_regression.py
import torch

# 固定随机种子，保证每次运行结果可复现
torch.manual_seed(42)

# 构造一个简单的一维非线性回归任务：y = sin(x) + 小噪声
x = torch.linspace(-3.0, 3.0, 200).unsqueeze(1)   # 形状 [200, 1]
y = torch.sin(x) + 0.05 * torch.randn_like(x)     # 形状 [200, 1]

# 三层小网络：1 -> 16 -> 16 -> 1
model = torch.nn.Sequential(
    torch.nn.Linear(1, 16),
    torch.nn.Tanh(),
    torch.nn.Linear(16, 16),
    torch.nn.Tanh(),
    torch.nn.Linear(16, 1),
)

loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)

for epoch in range(2000):
    pred = model(x)                 # 前向传播
    loss = loss_fn(pred, y)         # 计算损失

    optimizer.zero_grad()           # 清空上一轮累积的梯度
    loss.backward()                 # 反向传播，计算各参数梯度
    optimizer.step()                # 按梯度更新参数

    if (epoch + 1) % 200 == 0:
        print(f"epoch={epoch + 1:4d}  loss={loss.item():.6f}")

这段代码里最值得注意的不是模型结构，而是那三行固定动作的顺序：zero_grad()、backward()、step()。顺序错了或者漏了任何一行，训练都会以非常隐蔽的方式失败——漏 zero_grad() 会导致梯度不断累加，loss 可能剧烈震荡；只调 backward() 不调 step()，参数永远不会更新，loss 会卡在一个值上不动。这两类问题是初学者最常见的排查对象。

运行方式和预期结果如下：

bash复制python examples/01_autograd_regression.py

正常情况下，loss 会从初始的较大值持续下降，到 2000 轮时通常能降到比较小的量级。具体数值受随机种子和初始化影响，不必强求某个精确值，关键看趋势是否单调下降。如果 loss 在几百轮之后就停滞，可以先把学习率调小一个数量级再试，1e-2 对 Adam 偏大，1e-3 往往更稳。

6. 完整示例二：卷积网络与工程化训练脚本

小例子跑通之后，应该立刻进入真实场景，否则学到的只是玩具。第二个示例是一个结构完整的图像分类训练脚本，包含数据加载、模型定义、训练循环、验证评估和权重保存。这个脚本的骨架可以直接复用到大部分中小规模分类任务上。

python复制# 文件路径：examples/02_mnist_cnn.py
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms


def build_model(num_classes: int = 10) -> nn.Module:
    """两层卷积 + 全连接的小型分类网络。"""
    return nn.Sequential(
        nn.Conv2d(1, 32, kernel_size=3, padding=1),
        nn.BatchNorm2d(32),
        nn.ReLU(inplace=True),
        nn.MaxPool2d(2),                       # 28 -> 14
        nn.Conv2d(32, 64, kernel_size=3, padding=1),
        nn.BatchNorm2d(64),
        nn.ReLU(inplace=True),
        nn.MaxPool2d(2),                       # 14 -> 7
        nn.Flatten(),
        nn.Linear(64 * 7 * 7, 128),
        nn.ReLU(inplace=True),
        nn.Dropout(0.3),
        nn.Linear(128, num_classes),
    )


def build_loaders(batch_size: int = 64) -> tuple:
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,)),
    ])
    train_set = datasets.MNIST(root="./data", train=True, download=True, transform=transform)
    test_set = datasets.MNIST(root="./data", train=False, download=True, transform=transform)

    train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=2)
    test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False, num_workers=2)
    return train_loader, test_loader


def evaluate(model: nn.Module, loader: DataLoader, device: torch.device) -> float:
    model.eval()
    correct, total = 0, 0
    with torch.no_grad():
        for images, labels in loader:
            images, labels = images.to(device), labels.to(device)
            logits = model(images)
            preds = logits.argmax(dim=1)
            correct += (preds == labels).sum().item()
            total += labels.size(0)
    return correct / total


def train(epochs: int = 3, lr: float = 1e-3, batch_size: int = 64) -> None:
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"device = {device}")

    train_loader, test_loader = build_loaders(batch_size)
    model = build_model().to(device)
    loss_fn = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)

    for epoch in range(1, epochs + 1):
        model.train()
        running_loss, seen = 0.0, 0
        for step, (images, labels) in enumerate(train_loader, start=1):
            images, labels = images.to(device, non_blocking=True), labels.to(device, non_blocking=True)

            logits = model(images)
            loss = loss_fn(logits, labels)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            running_loss += loss.item() * images.size(0)
            seen += images.size(0)

            if step % 200 == 0:
                print(f"epoch={epoch} step={step} avg_loss={running_loss / seen:.4f}")

        acc = evaluate(model, test_loader, device)
        print(f"epoch={epoch} train_loss={running_loss / seen:.4f} test_acc={acc:.4f}")

    torch.save(model.state_dict(), "mnist_cnn.pt")
    print("model saved to mnist_cnn.pt")


if __name__ == "__main__":
    train()

这个脚本里有几处设计是需要解释的，否则复制过去也不知道为什么这么写。model.train() 和 model.eval() 的切换不是可选项，它直接决定了 BatchNorm 和 Dropout 的行为：训练时要统计批内均值和方差、要随机丢弃，推理时要使用滑动统计量、不做丢弃。忘记切换是"训练准确率很好、测试效果很差"这类问题的常见成因之一。

torch.no_grad() 包住评估过程同样重要。推理不需要计算图，关掉之后显存占用和耗时都会明显下降。至于 non_blocking=True，只在数据和模型都在 GPU 且使用了锁页内存时才有明显收益，属于锦上添花的优化，先保证逻辑正确更重要。

运行命令和验证方式：

bash复制python examples/02_mnist_cnn.py

数据集会在首次运行时自动下载到 ./data 目录。如果下载卡住，可以手动下载后放到对应目录，或者把 download 参数改为 False 并自行准备数据。训练完成后会输出每轮的训练损失和测试准确率，并在当前目录生成 mnist_cnn.pt 权重文件。

7. 运行结果与效果验证

脚本能跑完不等于结果正确。这一节讲怎么判断"跑对了"。很多人看到 loss 在下降就认为模型训练成功，其实还有若干种情况会让指标看起来正常但模型实际不可用。

第一步看 loss 曲线形态。 正常的训练损失应当整体下降，前期下降快、后期趋于平缓，允许小幅抖动。如果 loss 一开始就几乎不动，通常指向学习率过小或梯度没有正确回传；如果 loss 出现大幅震荡甚至变成 nan，多半是学习率过大、输入没有归一化，或者网络里出现了数值不稳定的操作。

第二步看训练集与测试集的差距。 两个指标都高，说明模型容量和训练流程基本没问题；训练高测试低，是典型的过拟合，可以从数据增强、正则化、降低模型复杂度三个方向调整；两个都低，说明欠拟合，优先考虑加大模型容量或延长训练。这个判断比单纯盯一个数字有用得多。

第三步做一次人工抽样检查。 从测试集里随机取十几张图，打印模型预测的类别和真实标签，肉眼看一遍。这个过程能发现一些指标无法反映的问题，比如标签映射错位——所有预测都偏移一位时，整体准确率可能依然不低，但模型实际是错的。这类错误在自定义数据集上尤其常见。

第四步验证权重能否正确加载。 保存完模型后，重新加载一遍并再评估一次，确认两次结果一致。这一步能提前发现保存和加载时的结构不匹配问题，比等到线上部署时才暴露要好得多。

python复制# 文件路径：examples/03_verify_checkpoint.py
import torch
from examples.cnn_model import build_model, evaluate, build_loaders
from torch import nn

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = build_model().to(device)
state = torch.load("mnist_cnn.pt", map_location=device)
model.load_state_dict(state)

_, test_loader = build_loaders(batch_size=128)
loss_fn = nn.CrossEntropyLoss()
print("reloaded test_acc =", evaluate(model, test_loader, device))

如果加载时报参数名不匹配，基本可以断定模型结构在保存之后被改动过，或者保存的是整个模型对象而非 state_dict。前者需要重新训练，后者建议统一改成只存权重字典，兼容性更好。

8. 常见问题与排查思路

学习过程中遇到的问题高度集中，多数可以归类到下面这几种。把它们整理成表，遇到时按顺序排查，比盲目搜索效率高得多。

除了表格里的通用问题，还有一类情况容易被忽略：代码没问题但结果就是不如预期。这时候要回头确认任务定义本身是否合理。比如用准确率评估严重不平衡的数据集，模型全预测多数类也能得到很高的数字，看起来训练成功，实际毫无价值。遇到这种反常的好结果，先怀疑评估指标，再怀疑数据。

另一个高频坑是数据预处理不一致。训练时做了标准化，推理时忘了做，模型在线上表现会莫名其妙地变差。工程上比较稳妥的做法是把预处理逻辑封装成一个可复用的模块，训练和推理共用同一份代码，从结构上杜绝这类不一致。

9. 最佳实践与学习节奏建议

最后聊点方法论层面的东西。公开课的学习效果差异，很大程度上不取决于智力，而取决于有没有一套可执行的学习流程。

每个主题都走一遍"复现再改动"的闭环。 单纯跟着敲一遍代码的收益很低，因为那是被动执行。更有效的方式是：先独立复现课程里的示例，跑通之后至少改三个地方——换一个激活函数、改一下网络深度、调整一次学习率，然后观察结果变化并写下解释。这个改动过程才是真正把知识变成经验的地方。改动最好有记录，哪怕只是一个简单的文本笔记，写清楚改了什么、结果如何、为什么。

笔记要按问题组织，而不是按章节。 按视频顺序记笔记，复习时基本用不上。更实用的做法是围绕问题建索引，比如"为什么这个模型不收敛""什么样的场景适合用卷积而不是全连接"，每个问题下面挂课程里的对应位置、自己的实验记录和结论。这样积累下来，笔记会变成可检索的经验库，而不是一堆抄写的定义。

时间分配建议。 假设一周能投入六到八小时，比较合理的切分是：看讲解两小时、动手复现三小时、整理笔记和验证结论一到两小时。很多人把大部分时间花在看视频上，感觉进度很快，但真正形成能力的是后面两段。宁可看得慢一些，也要保证每个核心主题都跑通过代码。

关于算力和数据受限的情况。 如果没有显卡，完全可以用小规模数据完成大部分概念验证，MNIST 这类数据集在 CPU 上训练也并不慢。真正需要大算力的部分是在理解清楚原理之后，那时候再去考虑租用云端资源。不要在还没搞清楚反向传播的时候就去纠结显卡型号，这是很常见的本末倒置。

工程习惯从学习阶段就要建立。 固定随机种子、把配置抽成参数、保存训练日志、区分训练和评估模式，这些习惯在学习时养成，比工作后再纠正成本低得多。尤其是日志，训练过程中打印的信息最好能落到文件里，事后复盘时你会感谢当时多写的这几行。

最后提醒一点版权与合规。 二次加工的中文配音和资料，使用时应尊重原始发布者的授权范围，优先通过官方公开渠道获取讲义和代码。学习资源的价值来自持续维护，支持正规渠道也是让这类材料能长期存在的前提。

回到最开始的那个判断：这门课真正稀缺的不是知识点，而是把"为什么这样设计"讲透的耐心。中文配音解决了语言，代码环境解决了可运行性，但剩下的那部分——反复实验、记录、纠错、形成自己的理解——没有任何外部条件可以替代。如果你打算开始，最实际的起步方式不是从头看第一集，而是先把第 5 节那个最小训练循环在本地跑通，看到 loss 真的降下来，再回头去看理论讲解，顺序反过来往往会顺很多。