1. 开场：学了理论但不会写代码？我也踩过这坑

2019年我入坑深度学习，跟着吴恩达Coursera专项课刷完了全部视频，笔记记了三大本。然后我打开Kaggle，准备用PyTorch训练一个图片分类器——结果卡在DataLoader怎么用、nn.Module该继承什么方法、损失函数为什么是负数。那种“理论全会，动手全废”的感觉，干过活的都懂。

后来我又花了三个月，试了Fast.ai、李沐的《动手学深度学习》、Karpathy的CS231n笔记，才真正打通从理论到PyTorch的链条。今天把这几门课掰开了讲，给出我验证过的学习路线，附上可复现的代码和性能基准。

2. 问题：课程千千万，哪门能真正带你上手？

市面上主流深度学习课程分为三类：

• 理论派：吴恩达Coursera、Stanford CS231n（视频版）、三蓝一棕等。数学推导扎实，但代码示例偏TF1/Keras，PyTorch实战弱。
• 工程派：Fast.ai Practical Deep Learning。课程设计是“先说结果，再讲原理”，直接教你用预训练模型、调参。对新手友好，但理论基础不扎实容易变成调包侠。
• 综合派：李沐《动手学深度学习》（PyTorch版）、Karpathy的Neural Networks from Scratch。代码从零实现，数学与代码一一对应。

2.1 四门经典课程对比

我的结论：入门首选李沐《动手学深度学习》（PyTorch版），每一章都有代码、有数学、有练习。接着用Fast.ai补工程技巧，最后用Karpathy的课程把训练技巧补全。

3. 我的方案：三步走学习路线 + 可复现代码

3.1 第一步：李沐《动手学深度学习》(PyTorch版）

这门课是异步的——每个概念都配Jupyter Notebook。我从第3章（线性回归）开始上手，第5章卷积神经网络直接跑CIFAR-10。下面是我基于官方示例改写的训练脚本，加了TensorBoard监控，可以直接运行。

代码1：conda环境配置 (bash)

#!/bin/bash
# 使用conda创建独立环境，避免包冲突
conda create -n d2l pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia -y
conda activate d2l
pip install matplotlib tensorboard pandas scikit-learn
pip install d2l==1.0.3  # 对应《动手学深度学习》PyTorch版

代码2：训练一个简单的CNN于CIFAR-10（python）

# train_cifar10.py
# 基于d2l库，增加TensorBoard日志
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torch.utils.tensorboard import SummaryWriter
import time

# 1. 数据加载
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225])
])
train_data = datasets.CIFAR10(root='./data', train=True, transform=transform, download=True)
test_data = datasets.CIFAR10(root='./data', train=False, transform=transforms.ToTensor())

train_loader = DataLoader(train_data, batch_size=64, shuffle=True, num_workers=4, pin_memory=True)
test_loader = DataLoader(test_data, batch_size=256, shuffle=False, num_workers=2)

# 2. 定义模型（最简单的LeNet变体）
class LeNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(16*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool1(torch.relu(self.conv1(x)))
        x = self.pool2(torch.relu(self.conv2(x)))
        x = x.view(-1, 16*5*5)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = LeNet().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

writer = SummaryWriter(log_dir='runs/cifar10_lenet')
epochs = 50
global_step = 0

for epoch in range(epochs):
    model.train()
    running_loss = 0.0
    start_time = time.time()
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        global_step += 1
        writer.add_scalar('Loss/train_batch', loss.item(), global_step)
    epoch_loss = running_loss / len(train_loader)
    writer.add_scalar('Loss/train_epoch', epoch_loss, epoch)
    scheduler.step()

    # 测试精度
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in test_loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    acc = 100 * correct / total
    writer.add_scalar('Accuracy/test', acc, epoch)
    elapsed = time.time() - start_time
    print(f'Epoch {epoch+1:2d}/{epochs} | Loss: {epoch_loss:.4f} | Test Acc: {acc:.2f}% | Time: {elapsed:.1f}s')
writer.close()
print('Training finished.')

代码3：训练配置的JSON文件

将超参数分离出来，方便多组实验对比。

{
  "batch_size": 64,
  "lr": 0.01,
  "momentum": 0.9,
  "epochs": 50,
  "weight_decay": 0.0001,
  "step_size": 30,
  "gamma": 0.1,
  "data_root": "./data",
  "log_dir": "runs/cifar10_lenet"
}

# 使用示例
import json
with open('config.json','r') as f:
    config = json.load(f)
batch_size = config['batch_size']

代码4：基于YAML的数据加载配置（使用Hydra风格）

# config.yaml
data:
  dataset: CIFAR10
  root: ./data
  num_workers: 4
  pin_memory: true
  normalization:
    mean: [0.485, 0.456, 0.406]
    std: [0.229, 0.224, 0.225]

train:
  epochs: 50
  batch_size: 64
  shuffle: true
  augment: true

model:
  type: LeNet
  num_classes: 10

optimizer:
  name: SGD
  lr: 0.01
  momentum: 0.9
  weight_decay: 0.0001

# 用PyYAML加载
import yaml
with open('config.yaml','r') as f:
    cfg = yaml.safe_load(f)
print(cfg['data']['normalization'])

3.2 第二步：Fast.ai 2022补工程技巧

学习重点：迁移学习、逐渐解冻、对比学习。Fast.ai的API封装强大，但建议先手工实现一次，再用高层API。

• 课程核心：learner.fine_tune() 做什么？先冻结backbone，训练头部；再解冻全部，低学习率微调。
• 推荐章节：Lesson 1-7 （图像分类、分割、文本分类）。

3.3 第三步：Karpathy的CS231n + Neural Networks from Scratch

Karpathy的两个项目必须看：

• Neural Networks from Scratch：用纯numpy实现两层神经网络（反向传播手写），理解梯度流。
• CS231n课程笔记：特别是“训练技巧”部分（学习率衰减、Batch Normalization、Dropout、数据增强）。

我花了一周时间手动实现了一个纯numpy的CNN前向+反向，之后对PyTorch的自动求导理解直接上了一个台阶。

4. 效果数据：同一模型，不同课程组合带来的准确率和训练速度差异

我在一张RTX 3060（12GB）上，用上面LeNet训练CIFAR-10，对比了三种学习路径的效果（只做课程学习，不做超参优化）：

结论：仅靠理论课程，准确率比系统学习路径低近30个百分点。而且95%的坑都出在数据加载、过拟合、学习率这三个地方。

5. 避坑指南（我实际踩过的5个坑）

坑1：PyTorch版本与CUDA不匹配

我曾经在Ubuntu20.04上装了cuda11.3的pytorch1.10，结果训练时显存泄漏（batch_size=64，显存占用逐渐到8G然后OOM）。后来发现是pytorch1.10与cuda11.3的某个补丁不兼容。解决方案：用conda安装pytorch时指定cuda版本，比如：pytorch-cuda=11.8（对应CUDA 11.8）。

坑2：DataLoader的num_workers设置过多

同事将num_workers设为16（服务器48核），结果数据加载比GPU计算还慢，因为进程间通信开销。经验值：num_workers = 4 * GPU数量，且pin_memory=True。在单卡上设4~8足矣。

坑3：学习率选择不当导致Loss爆炸

新手常犯：直接使用Adam默认lr=1e-3，对于小网络（如LeNet）会梯度爆炸。我用了lr=0.01的SGD，反而收敛更快。原则：先试1e-3，观察Loss第一个epoch后是否下降；若Loss NaN，立即调低10倍。

坑4：没有用学习率调度器

初期训练Loss下降很快，后期震荡不收敛。加入StepLR（每30epoch降为0.1倍）后测试准确率从67%提升到74%。建议优先使用CosineAnnealingLR。

坑5：忘记对验证集做相同的预处理

我在测试时直接用全TO tensor + 归一化，但验证集没有加入RandomHorizontalFlip，结果验证准确率虚高。正确做法：验证集只做toTensor和Normalize，不要加数据增强。

6. 总结：从菜鸟到能训练模型的推荐书单

1. 第1周：李沐《动手学深度学习》前三章（线性回归、Softmax、MLP），配合官方Notebook跑一遍。
2. 第2-3周：CNN+RNN章节，跑上面代码。
3. 第4周：Fast.ai Lesson 1-3，重点理解fine_tune。
4. 第5周：读Karpathy的CS231n笔记“训练神经网络”部分，手工实现numpy两层网络。
5. 第6周：用PyTorch复现一个Kaggle分类比赛（如猫狗分类），完整走一遍数据加载、训练、验证、保存模型、推理。

以上路线，每天2-3小时，一个月后你能独立调出一个70%+的模型。别贪多，动手是唯一的捷径。