从线性模型到神经网络

平面上有四个点：两个对角上的点属于一类，另外两个属于另一类。一条直线分不开它们。把更多线性层接起来也没用，因为它们仍能合成一个线性变换。下面从这个 XOR 例子看起：加入非线性以后，隐藏层怎样把原来分不开的点重新表示。

先看结构：隐藏层学特征，线性头读出

先看一种常见的分类网络：隐藏层学习特征，线性分类头读出结果。二分类时再接 sigmoid，就像在学到的特征上做逻辑回归。这是理解本章的入口，不是所有神经网络都必须采用的输出结构。

这一页从最小二乘推到反向传播，每一步都给出公式和一份不依赖框架的 Python 实现。

线性回归：决策边界只能是超平面

$$\hat{y} = \mathbf{w}^\top \mathbf{x} + b = \sum_{i=1}^{n} w_i x_i + b, \qquad \mathbf{x}, \mathbf{w} \in \mathbb{R}^n$$

配平方损失 $\mathcal{L} = \frac{1}{2}\sum_k (y_k - \hat y_k)^2$，把偏置吸收进 $\mathbf{w}$（给 $\mathbf{x}$ 补一维常数 1）。当 $X$ 列满秩时，令梯度为零可以解出：

$$\nabla_{\mathbf{w}}\mathcal{L} = X^\top(X\mathbf{w} - \mathbf{y}) = 0 \;\Longrightarrow\; \hat{\mathbf{w}} = (X^\top X)^{-1} X^\top \mathbf{y}$$

如果特征线性相关，$X^\top X$ 可能不可逆，可以用伪逆求最小范数解。实际代码通常用 QR / SVD 最小二乘求解器，不显式计算逆矩阵。

拿它做分类的话，判定面是

$$\{\mathbf{x} : \mathbf{w}^\top \mathbf{x} + b = 0\}$$

一个超平面（hyperplane）。二维是直线，三维是平面。这是线性模型能画出的唯一形状。

加入交互项后还算线性吗？

这里容易绕晕，因为「线性」有两个意思。

$$\hat{y} = w_1 x_1 + w_2 x_2 + w_3 \underbrace{x_1 x_2}_{\text{交互项}} + b$$

• 对参数线性：$\hat y$ 是 $\mathbf{w}$ 的线性函数，所以统计课仍叫它 linear regression，上面那个闭式解照用。
• 对输入线性：不是了。令 $\hat y = 0$ 解出来的不是直线，是双曲线。

发生了什么？你其实手动构造了一个特征映射（feature map）

$$\phi(x_1, x_2) = (x_1,\; x_2,\; x_1 x_2)$$

把二维的点映射到三维，在三维里用一个超平面分割，投影回原平面就成了曲线。$x^2$ 项给你抛物线，$x_1^2 + x_2^2$ 给你圆。polynomial regression、kernel SVM 都遵循这个思路：先确定一个 $\phi$，再使用线性边界。

问题是 $\phi$ 得你自己猜。

Sigmoid 改变输出形式，不增加表达能力

先算同一个线性分数，再压成概率：

$$z = \mathbf{w}^\top \mathbf{x} + b, \qquad \sigma(z) = \frac{1}{1 + e^{-z}}$$

决策边界（decision boundary）还是超平面：$\sigma(z) = 0.5 \iff z = 0 \iff \mathbf{w}^\top\mathbf{x} + b = 0$。sigmoid 单调，动不了那个面的形状，只是把「离面多远」翻译成概率。

那 sigmoid 到底解决什么

一个优化问题。假设不加 sigmoid，直接拿分数配 MSE 拟合 0/1 标签。有个点 $\mathbf{w}^\top\mathbf{x} = 100$，标签是 1，已经分对得不能再对——但残差是 99，梯度巨大，它会拼命把决策面往自己这边拉。已经分对的点在主导训练。

换成 sigmoid + 交叉熵（cross-entropy）：

$$\mathcal{L} = -\big[\, y \log \sigma(z) + (1-y)\log(1 - \sigma(z)) \,\big]$$

推一遍梯度。先记住 sigmoid 的一个漂亮性质：

$$\sigma'(z) = \sigma(z)\big(1 - \sigma(z)\big)$$

代入链式法则，令 $s = \sigma(z)$：

$$\frac{\partial \mathcal{L}}{\partial s} = -\frac{y}{s} + \frac{1-y}{1-s} = \frac{s - y}{s(1-s)}$$

$$\frac{\partial \mathcal{L}}{\partial z} = \frac{\partial \mathcal{L}}{\partial s}\cdot \sigma'(z) = \frac{s-y}{s(1-s)} \cdot s(1-s) = \boxed{\;s - y\;}$$

分母被 $\sigma'$ 完全约掉，只剩预测减真值：

$$\nabla_{\mathbf{w}} \mathcal{L} = (\sigma(z) - y)\,\mathbf{x}, \qquad \frac{\partial \mathcal{L}}{\partial b} = \sigma(z) - y$$

这就是二分类里常用 sigmoid 配交叉熵的一个原因：

• 分对的远点 $\sigma(100) \approx 1$，$s - y \approx 0$ —— 自动闭嘴。
• 分错的点 $\sigma(-10) \approx 0$ 而 $y=1$，$s - y \approx -1$ —— 梯度饱和不了，优化器专心处理它。

如果 sigmoid 后面改接 MSE，梯度会多出一个 $\sigma'(z)$ 因子，在饱和区趋近 0，分错的点反而很难更新。对这里的线性 logistic regression，交叉熵关于参数是凸的，但不自动保证唯一或有限的最优解：特征共线可能带来多解；完全可分的数据上，无正则的参数还可能越长越大。换成多层网络后，也不能沿用这个凸性结论。

$\sigma'$ 在 $z=0$ 处最大（$0.25$），两端趋近 $0$——这正是梯度消失（vanishing gradient）的来源，也是后来隐藏层多改用 ReLU 的主要原因之一。

Python：从零写一遍

只用 numpy，梯度是上面推出来的那一行。

import numpy as np

def sigmoid(values):
    values = np.asarray(values, dtype=float)
    return np.exp(-np.logaddexp(0.0, -values))

def fit_logistic(X, y, lr=0.1, steps=2000):
    """X: (N, d)   y: (N,) in {0, 1}"""
    w = np.zeros(X.shape[1])
    b = 0.0
    for _ in range(steps):
        s = sigmoid(X @ w + b)          # (N,)
        err = s - y                     # 就是 dL/dz —— 全部推导浓缩成这一行
        w -= lr * (X.T @ err) / len(y)
        b -= lr * err.mean()
    return w, b

四个常见函数：看起来都在“变数值”，角色完全不同

$$ \boxed{ \begin{aligned} \text{Sigmoid}&:\text{独立的软开关或二分类概率}\\ \text{Softmax}&:\text{在多个选项之间分配总量为 1 的概率}\\ \text{ReLU}&:\text{给隐藏层引入分段线性非线性}\\ \text{Tanh}&:\text{产生带正负方向的有界状态} \end{aligned}} $$

最重要的分类不是“输出长什么样”，而是元素是否竞争。Sigmoid、ReLU、Tanh 对每个元素独立计算；Softmax 的每个输出都依赖整条输入向量，增大一个 logit 会改变其他类别的相对概率。

Sigmoid 与 Softmax：独立标签还是互斥选择

把四者放回模型

LSTM gates                 → Sigmoid：每个通道通过多少
LSTM candidate / RNN state → Tanh：写入带正负方向的值
Transformer attention      → row-wise Softmax：在 key 之间分配注意力
LM head                    → vocabulary Softmax：下一个 token 的分布
Vanilla Transformer FFN    → ReLU；现代模型多用 GELU / SiLU / SwiGLU

一句话记忆：Sigmoid 像独立阀门，Softmax 像在候选（candidate）项之间分票，ReLU 像截断负半轴，Tanh 像把带方向的状态压进 $(-1,1)$。

神经网络真正多做的事：把 $\phi$ 学出来

$$\mathbf{h} = \phi(W_1 \mathbf{x} + \mathbf{b}_1), \qquad \hat{y} = \sigma(\mathbf{w}_2^\top \mathbf{h} + b_2)$$

其中 $W_1 \in \mathbb{R}^{m \times n}$，$\mathbf{h} \in \mathbb{R}^m$，$\phi$ 是逐元素的激活函数（activation function）。第二行就是逻辑回归，只不过输入从 $\mathbf{x}$ 换成了 $\mathbf{h}$。

$\phi$ 不能省。 去掉它：

$$W_2(W_1\mathbf{x}) = (W_2 W_1)\mathbf{x} = W'\mathbf{x}$$

线性映射的复合还是线性映射。堆多少层都一样，整个网络塌回逻辑回归。

反向传播就是链式法则

沿用上面的结论 $\delta_2 \equiv \partial\mathcal{L}/\partial z_2 = \hat y - y$，往回推一层：

$$\frac{\partial \mathcal{L}}{\partial \mathbf{w}_2} = \delta_2\, \mathbf{h}, \qquad \frac{\partial \mathcal{L}}{\partial b_2} = \delta_2$$

$$\boldsymbol{\delta}_1 = \underbrace{(\delta_2\, \mathbf{w}_2)}_{\text{误差传回来}} \odot \underbrace{\phi'(\mathbf{z}_1)}_{\text{过激活的门}}, \qquad \frac{\partial \mathcal{L}}{\partial W_1} = \boldsymbol{\delta}_1 \mathbf{x}^\top$$

$\odot$ 是逐元素乘。对 ReLU，$\phi'(z) = \mathbb{1}[z > 0]$——梯度要么原样通过，要么被完全掐断。这就是全部。

def init(n_in, n_hidden, seed=0):
    rng = np.random.default_rng(seed)
    return {"W1": rng.normal(0, np.sqrt(2 / n_in), (n_hidden, n_in)),  # He 初始化
            "b1": np.zeros(n_hidden),
            "w2": rng.normal(0, np.sqrt(2 / n_hidden), n_hidden),
            "b2": 0.0}

def step(p, X, y, lr=0.05):
    N = len(y)
    z1 = X @ p["W1"].T + p["b1"]        # (N, m)   前向
    h = np.maximum(z1, 0)              # ReLU
    z2 = h @ p["w2"] + p["b2"]         # (N,)
    yhat = sigmoid(z2)

    d2 = (yhat - y) / N                            # (N,)     反向：还是那一行
    gw2, gb2 = h.T @ d2, d2.sum()
    d1 = np.outer(d2, p["w2"]) * (z1 > 0)          # (N, m)   过 ReLU 的门
    gW1, gb1 = d1.T @ X, d1.sum(0)

    for k, g in (("W1", gW1), ("b1", gb1), ("w2", gw2), ("b2", gb2)):
        p[k] = p[k] - lr * g
    loss = -np.mean(y * np.log(yhat + 1e-9) + (1 - y) * np.log(1 - yhat + 1e-9))
    return loss, ((z2 > 0) == y).mean()

完整可运行版本在 code/why_nonlinear.py（PyTorch）和 code/make_figures.py（生成本页所有图）。

用 XOR 验证表达能力

四团高斯点，对角同类。没有任何直线能分开——这就是 1969 年 Minsky & Papert 用来说明感知机做不到什么的例子。

三个模型，同样的数据和训练配置：

B 和 C 是同一个架构、同样 33 个参数，只差一个 ReLU。 B 的两个权重矩阵乘起来是 $(1,8)\times(8,2) = (1,2)$，一行而已，和 A 的形式完全相同——所以它和 3 参数的逻辑回归一样弱。

50% 不是没训好。对称 XOR 上，交叉熵的最优解就是权重全为 0：每个点都预测 0.5，损失停在 $\ln 2 \approx 0.693$，按 0.5 切分的准确率也就是 50%。就算换个目标直接追求准确率，一条直线最好的分法也只是把其中一团单独切出来，做到 75%，仍有一整团分错。

隐藏层在几何上做了什么

把输入空间的方格网推过隐藏层，看它被揉成什么样：

（画图用的是 2 个隐藏单元的版本，因为二维才画得出来。）ReLU 沿一条折痕把平面对折，两类点落到了同一条直线的两侧——输出层依然只是逻辑回归，只是长在了这个新坐标系上。

一张表：从线性模型到 Transformer

Transformer 的最后一层也是线性分类器

$$\mathbf{h} = \text{TransformerBlocks}\big(\text{Embed}(\mathbf{x})\big), \qquad \text{logits} = W_{\text{head}}\, \mathbf{h}$$

$$p(\text{token}_i) = \text{softmax}(\text{logits})_i = \frac{e^{z_i}}{\sum_j e^{z_j}}$$

softmax 是 sigmoid 在多类上的推广（两类时二者等价）。而且那个漂亮的性质原样保留：配交叉熵时

$$\frac{\partial \mathcal{L}}{\partial z_i} = p_i - y_i$$

还是预测减真值。lm_head 就是那个线性分类器，类别数换成 vocab_size。可以这样理解底下几十层的作用：把表示空间一步步弯折，直到「下一个 token 是什么」能被一个线性头读出来。

最终都是 function approximator 吗？

广义上是。监督学习模型都在一个参数化的函数族里，寻找一个函数 $f_\theta$，去逼近未知的真实映射 $f^*$，或真实的条件分布 $p^*$：

$$ \theta^*=\arg\min_\theta \frac{1}{N}\sum_{i=1}^{N}\ell\big(f_\theta(x_i),y_i\big). $$

这里最容易混淆的是：“整个模型是 approximator”不等于“整个模型是 linear approximator”。

所以 polynomial regression 很有代表性：加入 $x^2$ 后，它对 $x$ 已经不是线性的，但仍然对参数线性（linear in parameters）。神经网络再向前一步，连 basis / feature map $\phi$ 也一起从数据中学习。

对 Transformer 也一样：最后的 lm_head 是线性的，但

$$ x_{<t}\longmapsto \mathbf{h}_t\longmapsto \operatorname{softmax}(W_{\text{head}}\mathbf{h}_t) $$

这条完整映射包含 attention、Softmax、MLP activation 和多层组合，所以整体是一个高度非线性的 conditional-distribution approximator。真正决定它是否有用的，不只是“能不能逼近”，还包括 inductive bias、data、objective、optimization 与 evaluation。

能表示，不等于能学到，更不等于能泛化

用折线逼近 $f(x)=x^2$。区间 $[a,b]$ 上的端点连线是 $s(x)=(a+b)x-ab$，所以

$$s(x)-x^2=(x-a)(b-x)\leq (b-a)^2/4.$$

在 $[0,1]$ 上均匀分成 $M$ 段，最大误差是 $1/(4M^2)$：4 段为 0.015625，10 段为 0.0025。折线也可以写成初始直线加上各拐点的斜率变化：

$$s(x)=b_0+a_0x+\sum_j c_j\operatorname{ReLU}(x-t_j).$$

$t_j$ 是拐点，$c_j$ 是斜率增量。这就给出了一个 ReLU 表示，但还没证明训练会找到它。

def square_interpolant(value, segments):
    if type(segments) is not int or segments < 1 or not 0 <= value <= 1:
        raise ValueError("Expected x in [0, 1] and a positive segment count")
    index = min(int(value * segments), segments - 1)
    left, right = index / segments, (index + 1) / segments
    return (left + right) * value - left * right

for segments in (4, 10):
    errors = [
        square_interpolant((index + 0.5) / segments, segments)
        - ((index + 0.5) / segments) ** 2
        for index in range(segments)
    ]
    assert abs(max(errors) - 1 / (4 * segments ** 2)) < 1e-12

再看数据够不够：如果只观察 $x=0,1$，$x^2$ 与 $x^2+10x(1-x)$ 在训练点上完全相同，中间却差很多。零训练误差无法判断哪个正确。需要更多数据、合理的先验或约束，而不是只扩大网络。

前面的经验损失最小化是在样本上选参数，不等于已经找到了真实规律。带噪声时，平方损失的总体最优预测在适当条件下是 $\mathbb E[Y\mid X=x]$，也不是逐次猜对所有随机波动。

什么时候先试更简单的方法？

这不是按数据类型选模型的死规则。公平比较要用相同切分、可比的调参预算，以及只在训练集拟合的预处理。时间序列随机打散不能证明未来泛化；同一个人的多条记录可能需要分组切分。结论应是“在这些数据和约束下更合适”，不是“函数族更强就一定赢”。

自检

继续阅读

• Transformer 架构 —— 那个 $\phi$ 具体长什么样
• Post-Training —— 训练完之后还怎么改它
• 表征与记忆 —— $\mathbf{h}$ 里该留下什么

快速学习：从 linear readout 到 learned feature map

参考论文

• Learning representations by back-propagating errors — Rumelhart, Hinton & Williams, 1986
• Multilayer feedforward networks are universal approximators — Hornik et al., 1989
• Delving Deep into Rectifiers — He 初始化与 ReLU