LeCun纽约大学深度学习课：EBM、自监督与Notebook复现

这是一门被很多人收藏、但真正跟完的人并不多的课。纽约大学 2021 年春季的 Deep Learning 课程，英文原声，配套讲义和 Notebook 齐全，视频播放量已经到 63 万+（以页面实际显示为准）。主讲阵容里最受关注的是 Yann LeCun——2018 年图灵奖得主、纽约大学 Silver Professor、Meta 首席 AI 科学家，他在课程中后段系统讲了能量基础模型（Energy-Based Model，EBM）和自监督学习这条主线。

之所以值得单独写一篇“怎么用”的文章，是因为这类课程资源最大的坑不在内容质量，而在学习方式。63 万播放量背后，大概率有相当一部分人停在前两讲。它不像一个开箱即用的工具，双击就能看到结果；它更像一套需要自己搭环境、自己跑代码、自己推导公式的训练体系。内容硬、密度高、没有中文配音，直接从头顺着看，很容易在第三讲之后掉队。

这篇文章不谈“深度学习有多重要”这种空话，只解决几个具体问题：这门课的 2021 版到底讲了什么、哪些章节必须先看、配套 Notebook 怎么在本地跑起来、跑不动的时候是显存问题还是版本问题、以及如何用一套最小实验流程把“看懂了”变成“写出来了”。文中给出的代码是通用模板，需要按你实际使用的 PyTorch 版本和课程仓库内容调整，但结构和验证思路可以直接抄。

适合两类读者：一是已经有 Python 基础、用过 PyTorch 或者至少写过 numpy，想把深度学习从“会调包”补到“知道为什么这么设计”的人；二是冲着 LeCun 的 EBM 和自监督内容来的研究生、算法工程师，想搞明白 JEPA 那套思路的源头在哪里。如果你的目标是三天内做出一个能演示的 AI 应用，这门课不是最优解。

1. 纽约大学深度学习课程核心信息速览

先把规格摆出来，判断要不要投入时间。下面这些信息全部来自课程本身的公开设定，具体细节以你能访问到的课程页面和官方仓库为准。

有一点必须提前说清楚：这门课的价值不在“跑通某个模型”，而在“建立一套分析问题的语言”。比如它讲正则化，不是罗列 L1、L2 的公式，而是从能量面、从隐变量的角度解释为什么模型会记住训练集。这种视角上的差异，是做工程和做研究之间的分水岭，也是它比一般入门课难啃的原因。

2. 适用人群判断与使用边界

先把“不适合”讲在前面，能省下不少时间。这门课不适合完全没有编程经验的人，因为中段开始大量出现 Notebook 里的张量操作和梯度推导，看不懂 backward() 在干什么，后面的内容会变成天书。也不适合只想学提示词工程、想快速做出产品原型的读者，课程几乎不涉及应用层封装、部署、推理加速这些工程话题，你想找的是另一类资料。

它最适合三类人。第一类是写过一两年深度学习代码、但总觉得“知其然不知其所以然”的工程师，比如能训 ResNet 但说不清为什么对比学习需要负样本、为什么 VAE 的 KL 项会带来模糊。第二类是要读论文的研究生，课程里对 EBM、自监督、隐变量模型的统一视角，能把散落在各篇论文里的概念串成一条线。第三类是面试准备阶段的人，反向传播手推、优化器行为、正则化本质这几个高频考点，这门课讲得比大部分面经扎实。

再讲使用边界，这部分容易被忽略。课程视频、讲义和 Notebook 是有版权的教学材料，仓库里通常会有明确的 LICENSE 说明，能不能用于企业内训、能不能二次分发、能不能剪辑后上传到别的平台，都要以官方许可为准，不要默认“能看就能传”。个人学习、做笔记、写读后感、把代码用于自己的实验，一般没问题；但把整套资料打包做成付费课程、或者把视频搬运到自己的账号下引流，就越线了。

另外提醒一点：课程里的示例数据集多是 MNIST、CIFAR 这类公开数据，拿来练手没问题。但如果后续你想把课上的方法用到人脸、医疗影像、语音克隆这类涉及个人信息的场景，数据来源的授权、隐私保护、以及所在行业对算法应用的合规要求，必须提前确认，不要拿“学术实验”当挡箭牌直接上生产。

3. 学习环境与代码环境准备

环境分两块，观看环境和代码环境要分开准备，否则很容易变成“打开 Notebook 就开始折腾依赖，视频一集没看”。

观看环境建议这样配：播放器支持 1.25 到 1.5 倍速，遇到推导环节降到 1 倍；左边播放器右边 Markdown 编辑器，形成“看一段、记一段、跑一段”的节奏。笔记不要记为逐字稿，记三样东西就够了——这一讲要解决的问题、关键公式的物理含义、以及一个自己想到的反例。第三样最值钱，它决定了你是被动接收还是主动思考。

代码环境不要追求最新版本。这门课 2021 年录制，配套 Notebook 里的写法可能用了当时较新的 PyTorch API，盲目装最新版反而可能报参数弃用的警告或错误。稳妥做法是单独建一个 conda 环境，先装一个与你能找到的 Notebook 兼容的版本，跑通之后再考虑升级。

bash复制# 创建独立环境，避免污染主环境；Python 版本按 Notebook 实际需求调整
conda create -n nyu-dl python=3.10 -y
conda activate nyu-dl

# 安装 PyTorch，严格按 pytorch.org 上对应 CUDA 版本的官方命令安装
# 下面只是示例，不要照抄 CUDA 版本号
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

# Notebook 与常用工具
pip install jupyterlab numpy matplotlib scikit-learn pyyaml tqdm

装完必须验证，不要跳过这一步。写一个三行的检查脚本：torch.__version__ 看版本、torch.cuda.is_available() 看能不能用上显卡、torch.cuda.get_device_name(0) 看设备名。如果第二项是 False，说明驱动或 CUDA 版本不匹配，这时候去跑 Notebook 只会得到一堆莫名其妙的报错，先解决环境再谈学习。

硬件方面，观看阶段零门槛。跑代码阶段，课程里的大部分小实验在 CPU 上也能跑完，只是慢；真正需要显卡的是需要训练卷积网络、跑对比学习负采样、或者做图像生成的练习。从经验判断，4GB 到 6GB 显存的卡足够应付课程级别的实验，具体占用需要以你实际跑的模型和 batch size 为准，没法给一个准确数字——任何声称“这门课固定占用 X G 显存”的说法都不靠谱，因为占用取决于你自己写的代码。

4. 课程资料获取与本地目录整理

资料到手之后，第一件事不是打开视频，是建目录。这一步花十分钟，后面能省十小时。课程资料一般包括：课程网站（讲次安排、阅读材料）、讲义 PDF、Notebook 代码、以及视频本身。把这四类东西按用途分开存，别全丢在下载文件夹里。

bash复制# 建议的本地目录结构，路径按自己习惯调整
nyu-dl-2021/
├── video/            # 本地视频，仅个人学习使用
├── slides/           # 官方讲义 PDF，按讲次命名
├── notebooks/        # 官方 Notebook，保持原始文件名以便对照
├── notes/            # 自己的 Markdown 笔记，一篇对应一讲
├── code/             # 自己复现的脚本，不要改官方 Notebook
└── runs/             # 实验输出，按实验名建子目录

这里有个细节很重要：官方 Notebook 一律不要改动，要改就复制一份到 code/ 目录再动手。原因很实际——你改完之后报错，就分不清是课程代码本身有问题还是你改坏了；而且后续想回头对照原始实现时，改过的版本已经失去参考价值。这个习惯在做任何开源项目复现时都适用。

笔记的命名建议带讲次编号和关键词，比如 05-ebm-intro.md，方便日后检索。另一个实用技巧是给每篇笔记加一个固定的头部模板：这一讲的核心问题、我卡住的三个点、我跑通的代码路径。三个月后回看，最有用的是“卡住的点”那一栏，因为那往往就是你知识体系里的真实漏洞。

5. 分阶段跟课路线与每阶段验证方法

按顺序硬啃是最低效的方式。这门课的内容编排有明显的层次，分成三个阶段推进，每个阶段配一个可验证的产出，效果会好很多。

5.1 第一阶段：基础篇，重点是把反向传播手推一遍

课程开头从深度学习概览讲起，紧接着就是梯度下降和反向传播。这一段千万不要开倍速，也不要觉得“我早就会了”就跳过。LeCun 讲这部分时会把计算图、链式法则、参数更新放在一个统一框架里，这个框架在后面的能量模型章节会反复用到。很多人在中后段听不懂，根源就在这里的框架没建立起来。

这一阶段的验证方式很明确：拿一张纸，不看任何资料，手推一个两层网络的梯度，包括损失对权重、对偏置的偏导，然后把结果和你用 PyTorch 跑出来的梯度对比。PyTorch 提供了 torch.autograd.gradcheck，可以用数值梯度验证解析梯度是否正确。能对上，说明你真懂了；对不上，回去重看那一讲。

5.2 第二阶段：实战篇，把 Notebook 跑通并改一个参数

紧接着是 PyTorch 与计算图的实战内容，然后是优化方法、正则化这些训练层面的东西。这一阶段的目标不是“看完”，而是“跑通并改动”。跑通只是确认环境没问题，改动才是学习发生的时刻。

具体做法：每个 Notebook 至少改三处，一是 batch size，二是学习率，三是网络宽度或层数。改完观察三件事——训练损失下降的曲线形状变没变、验证集准确率有没有掉、显存占用涨了多少。这三个观察连起来，你对“超参数”的理解就会从抽象名词变成具体的因果链。这一步花的时间会比你想象的长，但收益也最大。

5.3 第三阶段：核心篇，EBM 与自监督是重点

课程中后段是精华，围绕能量基础模型和自监督学习展开，涉及对比方法、正则化隐变量、稀疏编码、PCA 与字典学习，后面还有 GAN、VAE、图卷积网络和 Transformer。这部分内容密度最高，也最能体现这门课和其他入门课的区别。

理解 EBM 的关键是抓住一个统一视角：模型不再直接输出概率，而是给每个输入配置打一个“能量分”，能量低的配置是模型认为合理的。训练就是压低真实样本的能量、抬高对比样本的能量，推理就是从低能量区域里采样。这个框架一旦建立，你会发现分类、回归、生成、甚至某些自监督任务都能塞进同一个模子里。

这一阶段的验证方式：自己动手实现一个二维玩具数据集上的能量模型，用朗之万动力学采样，然后画图看能量面。如果采样点能收敛到数据分布附近，说明你理解了对比散度在做什么；如果采样点乱跑，八成是步长或噪声尺度没调好，这个过程本身就是最好的学习。

6. 配套代码运行与最小实验验证

环境好了、路线清了，接下来是最实际的部分：代码怎么跑。课程 Notebook 一般按讲次组织，直接 jupyter lab 打开即可，但建议先在终端里逐个用 nbconvert 跑一遍，确认没有隐藏的执行顺序依赖。

bash复制# 进入 notebooks 目录后批量执行，检查是否有跑不通的单元
jupyter nbconvert --to notebook --execute \
  --ExecutePreprocessor.timeout=600 \
  --output-dir ../runs/nbcheck \
  notebooks/*.ipynb

如果有 Notebook 报错，先别急着改代码，按这个顺序排查：是不是缺依赖包（看报错里有没有 ModuleNotFoundError）、是不是数据集没下载成功（检查数据目录和网络）、是不是 API 版本变了（看弃用警告）。这三类占了报错的绝大多数。

6.1 跑通一个最小训练循环

在碰官方 Notebook 之前，先自己写一个 30 行的最小训练循环，把“数据加载、前向、损失、反向、更新”这条链路走一遍。这个循环后面可以反复复用，也是判断环境是否正常的基准。

python复制import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device:", device)

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,)),
])
train_set = datasets.MNIST(root="./data", train=True, download=True, transform=transform)
train_loader = DataLoader(train_set, batch_size=64, shuffle=True, num_workers=2)

model = nn.Sequential(
    nn.Flatten(),
    nn.Linear(28 * 28, 128), nn.ReLU(),
    nn.Linear(128, 10),
).to(device)

opt = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
loss_fn = nn.CrossEntropyLoss()

for epoch in range(3):
    total = 0.0
    for x, y in train_loader:
        x, y = x.to(device), y.to(device)
        opt.zero_grad()
        loss = loss_fn(model(x), y)
        loss.backward()
        opt.step()
        total += loss.item() * x.size(0)
    print(f"epoch {epoch} loss {total / len(train_set):.4f}")
    if device.type == "cuda":
        print("peak mem MB:", round(torch.cuda.max_memory_allocated() / 1024 ** 2, 1))

预期结果是三个 epoch 后平均损失降到 0.3 以下。如果损失不降反升，先查学习率是不是太大，再查数据标签有没有对齐。这段代码跑通，说明你的环境、数据、显卡三者都是好的，可以放心去看官方 Notebook 了。

6.2 复现一个能量模型的对比损失

EBM 是课程的重点，值得单独写一遍。下面是一个二维玩具版本的骨架，重点看损失函数的结构：正样本压能量、负样本抬能量，用一个 margin 防止负样本能量被推得过高。

python复制import torch
from torch import nn

class EnergyNet(nn.Module):
    def __init__(self, dim=2, hidden=64):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(dim, hidden), nn.Softplus(),
            nn.Linear(hidden, hidden), nn.Softplus(),
            nn.Linear(hidden, 1),
        )

    def forward(self, x):
        return self.net(x).squeeze(-1)  # 能量值，越小表示模型越认可

def langevin_sample(model, x0, steps=60, step_size=0.1, noise=0.05):
    """从高能量区域往低能量区域走，加噪声避免卡在局部极小"""
    x = x0.clone().detach().requires_grad_(True)
    for _ in range(steps):
        energy = model(x).sum()
        grad, = torch.autograd.grad(energy, x)
        x = (x - step_size * grad + noise * torch.randn_like(x)).detach()
        x.requires_grad_(True)
    return x.detach()

def contrastive_loss(model, real, margin=1.0):
    fake = langevin_sample(model, torch.randn_like(real))
    e_pos = model(real)
    e_neg = model(fake)
    return (e_pos + torch.clamp(margin - e_neg, min=0)).mean()

判断成功的标准很直观：把采样得到的点画在二维平面上，看它们是不是聚到真实数据所在的分布附近。如果采样点四散飞开，通常是 step_size 太大；如果采样点几乎不动，是 step_size 太小或者 noise 太低。这个过程调参调到怀疑人生是正常的，课程里讲的理论和实际调参之间的落差，就在这里。

6.3 批量实验与配置管理

跟课过程中你会反复改参数，手工记录必然混乱。用一个 YAML 管配置，一个脚本管循环，实验结果自然可复现。

yaml复制# configs/ebm_toy_baseline.yaml
experiment: ebm_toy_baseline
seed: 42
device: cuda
batch_size: 64
epochs: 20
optimizer:
  name: adam
  lr: 0.001
langevin:
  steps: 60
  step_size: 0.1
  noise: 0.05
output_dir: ./runs/ebm_toy_baseline

bash复制# 批量跑多个配置，失败的记录下来，别让一个报错中断整批
mkdir -p logs
for cfg in configs/*.yaml; do
  name=$(basename "$cfg" .yaml)
  python train.py --config "$cfg" > "logs/${name}.log" 2>&1 \
    || echo "failed: $name" >> logs/failed.txt
done

这套东西课程本身没有提供，但只要你打算认真复现，早晚得写。它带来的最大好处是：两周后你看到一个好结果，能立刻知道当时用的是哪组参数，而不是对着文件夹发呆。

6.4 把课程实验封装成接口

课程不提供任何 API 服务，所以这一节是可选的扩展。如果你想把训练好的模型接到自己的小工具里验证效果，用 FastAPI 包一层是最省事的做法。下面的模板需要按你自己的模型输入输出改。

python复制from fastapi import FastAPI
from pydantic import BaseModel
import torch

app = FastAPI()

# 这里换成你自己训练保存的权重
model = torch.nn.Linear(2, 1)
model.load_state_dict(torch.load("runs/ebm_toy_baseline/model.pt", map_location="cpu"))
model.eval()

class ScoreRequest(BaseModel):
    vector: list[float]

@app.post("/score")
def score(req: ScoreRequest):
    with torch.no_grad():
        x = torch.tensor([req.vector], dtype=torch.float32)
        energy = model(x).item()
    return {"energy": energy}

启动后访问 /docs 就能看到自动生成的接口文档，用 curl 打一发试试。注意两点：一是这类自建服务只适合本地或内网验证，不要直接暴露到公网；二是输入维度要做校验，否则传错长度会直接抛异常。这跟合规也有关系——任何对外提供的模型服务，都要考虑输入内容是否合法、是否涉及个人信息，这属于设计阶段就该想清楚的问题。

7. 显存占用与性能观察方法

这一节的内容课程不会教，但直接决定你能不能顺畅跟完。观察显存最直接的办法是开一个终端跑 watch -n 1 nvidia-smi，边训练边看占用曲线。更精确的做法是代码里埋点。

python复制import torch

def report_memory(tag=""):
    if torch.cuda.is_available():
        alloc = torch.cuda.memory_allocated() / 1024 ** 2
        peak = torch.cuda.max_memory_allocated() / 1024 ** 2
        print(f"[{tag}] 当前 {alloc:.1f} MB / 峰值 {peak:.1f} MB")

# 训练循环里每个 epoch 末尾调用一次，同时记得在合适位置重置峰值
# torch.cuda.reset_peak_memory_stats()

影响占用的变量就那么几个，搞清因果关系比死记数字有用。batch size 翻倍，激活值占用大致翻倍；模型宽度翻倍，参数量和激活值都涨；输入分辨率翻倍，卷积层的激活值涨得比参数快得多；混合精度训练能把激活值占用压下来，但对小模型收益不明显。这些规律比“某模型占多少 G”更有普适价值，因为后者换个显卡、换个驱动就又变了。

CPU 和 GPU 的差异也值得说一句。课程里的小实验在 CPU 上跑，可能从几秒变成几分钟，但结果是一致的；好处是没有显存限制，可以随便把 batch size 调大做对比实验。所以如果你手上只有一台轻薄本，完全不影响学这门课，只是复现大一点的实验时要更有耐心。真正的门槛从来不是硬件，而是能不能坚持把公式推完、把代码跑通。

另外提一个容易踩的坑：Jupyter 里反复执行同一个单元，显存是不会自动释放的，变量一直被引用着。跑一段时间后出现 OOM，先重启内核，而不是加内存。长期批量跑实验时，建议用脚本而不是 Notebook，进程结束自动回收，省心得多。

8. 常见问题与排查方法

跟课过程中遇到的问题，八成集中在下面这几类。按表格先定位，再往下看具体说明。

单独说两个最容易误判的问题。第一，“损失不下降”很多时候不是模型的问题，是数据没归一化或者标签错位，尤其是你自己从 CSV 读数据的时候，ToTensor 之后的取值范围要确认。第二，“显存不够”经常是 Jupyter 内核没重启造成的假象，实际占用远低于报错时显示的值，先重启内核再判断，能省下大量无谓的调参时间。

还有一个心态层面的问题值得提：听不懂某一讲是正常的。这门课有大量研究生级别的推导，第一遍没跟上不代表你不适合，而是说明你需要回头补那块前置知识。正确做法是标记下来继续往后看，第二遍再回来补——顺序推进带来的整体感，比死磕单点更有价值。

9. 学习效率与最佳实践

跟完这门课的人给出的经验高度一致：产出倒逼输入。意思是不要只做“看视频、记笔记”这两件事，一定要有一个外部产出——博客、代码仓库、或者一个小组分享。因为只有当你试图把 EBM 讲给别人听的时候，才会发现自己其实没搞懂采样那一步在做什么。

具体建议几条。第一，第一遍只求建立全局图景，不追求每个公式都推通，第二遍再挑重点章节深挖，尤其是 EBM 和自监督那几讲，这两块值得看三遍。第二，笔记里公式必须自己敲一遍，不要截图，敲的过程会强迫你注意每一个下标。第三，代码不要照抄，看完关掉原文件自己写一遍，写不出来说明没懂。第四，笔记和代码都放进版本管理，半年后回头看提交记录，能清楚看到自己的学习轨迹。

工程习惯上也有几条能迁移的经验：数据集、代码、实验结果分目录管理，任何一次实验都能从配置复原；随机种子固定并写进配置，保证结果可复现；批量实验加日志和失败重试，别让一个报错毁掉一整晚；跑长任务前先用小样本验证流程通不通，再放大。这些习惯不是课程教的，但恰恰是区分“学过”和“会用”的地方。

合规层面再强调一次。课程资料用于个人学习、写读书笔记、做技术分享都没问题，但引用讲义和代码时要标注来源，不要把别人的整理成果当成自己的原创发布。如果你把课程里的方法用到真实业务数据上，尤其是涉及用户行为、图像、语音的数据，数据授权、隐私保护、算法备案这些前置条件必须先过一遍，技术能力不等于使用许可。

10. 值不值得跟：先验证这三件事

如果只记一句话：这门课最值得投入的不是那些公式，而是 LeCun 那套把分类、生成、自监督统一到能量视角下的思维方式。这套思维在 2022 年之后的联合嵌入预测架构相关工作里被反复使用，先在这里打好底子，后面读那些论文会顺畅得多。

第一次上手建议先验证三件事，能全部走通再决定要不要投入八周。第一件，把环境搭好，跑通一个最小训练循环，确认显卡和依赖都是好的。第二件，手推一遍两层网络的反向传播，用 gradcheck 验证结果，这一步决定你后面能不能真正看懂课程。第三件，打开任意一个官方 Notebook，改三个参数，记录损失曲线的变化，这一步决定你是“看视频的人”还是“做实验的人”。

最容易踩的坑有三个。一是直接跳到 EBM 章节，前面的计算图和梯度框架没建立，后面全是符号。二是只看不写，视频看得很爽，合上电脑什么都不会。三是倍速开到 2 倍，这类推导型内容超过 1.5 倍速基本等于没看。避开这三条，跟完的概率会高很多。

后续可以往外扩的方向也很清楚：把课程里的 EBM 骨架扩到真实数据集上，试试对比方法在高维输入下的表现；顺着自监督这条线去读联合嵌入预测架构的论文，看它和课程里的正则化隐变量模型有什么继承关系；或者干脆把课程实验整理成一个自己的小仓库，配上复现说明，这本身就是一份很有说服力的技术材料。这门课的价值不在于你看完了 63 万播放量里的一个，而在于你从里面带走了什么能自己复用的东西。