深度学习基础：回归、Loss、梯度与 Softmax

传统程序是「人写规则」，机器学习是「机器从数据里学规则」。

判断一张图是不是猫：

• 传统程序：人写 if-else——耳朵尖？毛多？眼睛圆？→ 猫。规则写不完，也写不准。
• 机器学习：给机器几万张标注好的图片，让模型自己调整参数，最后得到一个函数 $f(x;\theta)$，输入图片输出「是猫的概率」。

所谓「训练模型」，本质就是找到一组好的参数 $\theta$。

回归就是「预测一个连续数字」。例如根据房子的面积、房间数、房龄预测房价。最简单的假设是：这些因素对房价的影响是线性叠加的。

import torch, torch.nn as nn

model = nn.Linear(3, 1)          # 3 个输入特征 → 1 个输出
x = torch.tensor([[120.0, 3.0, 5.0]])   # [batch=1, d_in=3]
y_hat = model(x)                  # [1, 1]
print(y_hat)

模型猜完必须有人告诉它「错了多少」。这个评分函数就是 Loss（损失）。回归任务里最常用的是均方误差 MSE：把每个样本的误差平方后求平均。

对单个样本 $L = (\hat y - y)^2$，$\hat y = wx + b$：

直觉：预测误差 $(\hat y - y)$ 越大，梯度越大，参数被修正得越多；输入 $x$ 越大，说明这个特征「责任越大」，对应权重被修正得越多。

想象你在山上（Loss 是海拔），目标是走到谷底。你站在某个位置 $w$，梯度 $\frac{\partial L}{\partial w}$ 告诉你「往哪个方向走 Loss 会变大」。所以你往反方向走一小步：

$\eta$ 是步长，也就是学习率（learning rate）。走一步、看一眼坡度、再走一步——这就是梯度下降。

optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

for x, y in dataloader:          # 一轮一轮拿 batch
    y_hat = model(x)             # ① 前向传播
    loss = loss_fn(y_hat, y)     # ② 算损失
    optimizer.zero_grad()        # ③ 清空上一轮的梯度
    loss.backward()              # ④ 反向传播：算每个参数的梯度
    optimizer.step()             # ⑤ 梯度下降：更新参数

训练数据太多，一次全部拿来算梯度既慢又费显存。所以把数据切成小批（batch），一批一批地学。学完所有批次叫一个 epoch。

前向传播：把输入一层层算到输出，再算 Loss。 反向传播：从 Loss 出发往回问——「每个参数，你对这个错误负多少责任？」用链式法则把责任一层层分下去。

import torch

x = torch.tensor(2.0)
y = torch.tensor(5.0)
w = torch.tensor(1.0, requires_grad=True)   # 需要求导

z = w * x          # 前向
L = (z - y) ** 2

L.backward()       # 反向：自动算所有梯度
print(w.grad)      # tensor(-12.)  ← 与手算一致

回归输出一个数字；分类要输出「每个类别的概率」。模型先给出每个类别的原始分数（logits），Softmax 把这些分数变成和为 1 的概率分布。

直接算 $e^{1000}$ 会溢出。实际实现会先减去最大值：

数学上等价（分子分母同乘 $e^{-\max(z)}$），但数值上安全——最大指数变成 $e^0 = 1$。

def softmax(z):
    z = z - z.max(dim=-1, keepdim=True).values   # 数值稳定
    e = torch.exp(z)
    return e / e.sum(dim=-1, keepdim=True)

假设 vocabulary $|V| = 100000$，每生成一个 token：

然后从中选下一个 token。所以 GPT 的最后一层就是一个 $d_{model} \to |V|$ 的线性层（LM Head）+ Softmax。

模型给正确答案的概率越高，损失越小；给得越低，损失越大。交叉熵就是用 $-\log p_{\text{正确类别}}$ 来度量这件事。

import torch.nn.functional as F

logits = model(x)                 # [B, V] 未归一化分数
target = y                        # [B] 正确类别索引
loss = F.cross_entropy(logits, target)   # 内部自动做 log_softmax + NLL

# 注意：F.cross_entropy 接收的是 logits，不是 softmax 后的概率！
# 传入概率会得到错误结果（双重 softmax）。

这个公式是分类学习「本质」的数学表达：抬高正确类别，压低错误类别。梯度直接等于「预测概率 − 真实标签」。

一层线性变换只能画直线/平面。要拟合曲线、识别复杂模式，必须引入非线性。做法是：线性变换 → 激活函数 → 线性变换……堆叠成多层感知机（MLP）。

mlp = nn.Sequential(
    nn.Linear(4, 8),
    nn.ReLU(),            # 非线性！
    nn.Linear(8, 3),
)
x = torch.randn(16, 4)    # batch=16, d_in=4
y = mlp(x)                # [16, 3]

激活函数就是「非线性开关」。早期用 Sigmoid/Tanh，现代深层网络几乎都用 ReLU 及其变体（GELU、SiLU），因为 Sigmoid 系在深层网络里会导致梯度消失。

import torch, torch.nn.functional as F
x = torch.linspace(-5, 5, 1000)
for name, fn in [("sigmoid", torch.sigmoid), ("tanh", torch.tanh), ("relu", F.relu), ("silu", F.silu)]:
    y = fn(x)   # 画出来对比形状