深度学习基础

这一课你将能做到

1. 用 PyTorch 的 autograd 理解「自动求导」——反向传播不再是一个黑名词
2. 用 TensorDataset + DataLoader 把数据切成批次，喂进神经网络
3. 用 nn.Sequential 搭一个三层 MLP，跑通「zero_grad → 前向 → 反向 → 更新」训练四步曲
4. 用 state_dict 保存和加载模型权重

为什么要学

前面的逻辑回归、决策树都属于「浅层模型」，特征要靠人设计。深度学习的核心优势是自己学特征：题目文本、用户行为序列这类复杂信号，人工提特征提不动，让神经网络逐层抽象。

PyTorch 是当前学术界和工业界的主流框架，API 像原生 Python 一样直白。本课不追求训练出 SOTA 模型，只求你亲手跑通一次完整的训练循环，理解每一步在做什么。

先建立图像

一个神经元：  输出 = ReLU(w₁x₁ + w₂x₂ + b)

三层 MLP（本课结构）：
输入(3维) → Linear(3→16) → ReLU → Linear(16→8) → ReLU → Linear(8→1) → logits

训练循环四步曲（背下来）：
opt.zero_grad()   # 清空上一批的梯度
loss = 前向        # 算预测和损失
loss.backward()   # 反向传播算所有参数的梯度
opt.step()        # 按梯度更新参数

跟着做

步骤 1：autograd——自动求导 5 行看懂

import torch

x = torch.tensor(2.0, requires_grad=True)
y = 2 * x ** 2        # y = 2x²
y.backward()          # 反向传播
print(y.item(), x.grad.item())   # 8.0 8.0 —— 导数 4x 在 x=2 处等于 8

backward() 沿计算图用链式法则自动算出梯度。训练百万参数的模型时，人手算不现实，这就是框架存在的意义。

步骤 2：构造做题数据并分批

import numpy as np
from torch.utils.data import TensorDataset, DataLoader

rng = np.random.default_rng(42)
n = 500
accuracy = rng.uniform(0.1, 0.95, n).round(3)
attempts = (rng.uniform(1, 9, n) + (0.6 - accuracy) * 5).round(1)
seconds  = (260 - 180 * accuracy + rng.normal(0, 20, n)).round(0)
mastery  = (accuracy > 0.5) & (attempts > 3)

X = torch.tensor(np.column_stack([accuracy, attempts, seconds]),
                 dtype=torch.float32)
y = torch.tensor(mastery.astype(np.float32)).unsqueeze(1)

loader = DataLoader(TensorDataset(X, y), batch_size=64, shuffle=True)

batch_size=64：每次用 64 条记录估一次梯度。小批量比全量更省内存，噪声还能帮模型跳出局部最优。

步骤 3：搭建 MLP 并训练

import torch.nn as nn

model = nn.Sequential(
    nn.Linear(3, 16), nn.ReLU(),
    nn.Linear(16, 8), nn.ReLU(),
    nn.Linear(8, 1),            # 输出 logits，不接 Sigmoid
)
loss_fn = nn.BCEWithLogitsLoss()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(30):
    total = 0.0
    for xb, yb in loader:
        opt.zero_grad()                    # ① 清梯度
        loss = loss_fn(model(xb), yb)      # ② 前向
        loss.backward()                    # ③ 反向
        opt.step()                         # ④ 更新
        total += loss.item()
    if (epoch + 1) % 10 == 0:
        print(f"epoch {epoch+1:2d}  平均 loss={total/len(loader):.4f}")