一、卡住它的那四行

异或问题的全部内容就是四行：

二、加一层就能做，但要碰运气

加上隐层之后：

三、三次浪潮

把时间线摊开：

四、这段历史该记住什么

第一，表达力和可训练性是两件事。 两个隐单元就能表达异或，但训练不出来；八个隐单元能训练出来，虽然用不上那么多。 一个模型「理论上能做」和「实际上能做」之间隔着一整个优化问题。 第二，被否定的往往是当时的训练手段，不是想法本身。 1969 年的结论「单层感知器做不了异或」没错，但被推广成「神经网络没前途」就错了。 这类误推在技术史上反复发生。 第三，很多「新技术」其实是老想法等到了配套条件。 反向传播的数学早在 1970 年代就有，卷积网络的雏形在 1980 年代末就出现了， 真正爆发是在数据和算力跟上之后。

五、动手 Demo：发展历程：一个异或问题，困了神经网络十几年

这段代码先证明没有隐层时异或怎么做都不行，再逐个数隐层个数、每个数跑八个随机种子， 看有几次能训练成功。 重点看两处。第二段「八个种子最好的也只到 0.50」；第三段那张表——隐层 2 个只有 1/8，8 个才 8/8。

# -*- coding: utf-8 -*-
import numpy as np


def init_mlp(sizes, seed=0):
    """He 初始化：每层权重的标准差取 sqrt(2 / 输入个数)。"""
    rg = np.random.default_rng(seed)
    W, b = [], []
    for i in range(len(sizes) - 1):
        W.append(rg.normal(0.0, np.sqrt(2.0 / sizes[i]), (sizes[i], sizes[i + 1])))
        b.append(np.zeros(sizes[i + 1]))
    return {"W": W, "b": b}


def forward(p, X, keep=False):
    Z, A = [], [X]
    h = X
    n = len(p["W"])
    for i in range(n):
        z = h @ p["W"][i] + p["b"][i]
        Z.append(z)
        h = z if i == n - 1 else np.maximum(z, 0.0)
        A.append(h)
    return (A, Z) if keep else h


def softmax(S):
    S = S - S.max(axis=1, keepdims=True)
    E = np.exp(S)
    return E / E.sum(axis=1, keepdims=True)


def backward(p, X, T):
    A, Z = forward(p, X, keep=True)
    n = len(p["W"])
    d = (softmax(A[-1]) - T) / len(X)
    gW = [None] * n
    gb = [None] * n
    for i in range(n - 1, -1, -1):
        gW[i] = A[i].T @ d
        gb[i] = d.sum(axis=0)
        if i > 0:
            d = (d @ p["W"][i].T) * (Z[i - 1] > 0.0)
    return {"W": gW, "b": gb}


def train(p, X, T, lr=0.5, epochs=3000, seed=0):
    """四个样本，全批量，所以不需要打乱。"""
    for _ in range(epochs):
        g = backward(p, X, T)
        for i in range(len(p["W"])):
            p["W"][i] -= lr * g["W"][i]
            p["b"][i] -= lr * g["b"][i]
    return p


def acc(p, X, y):
    return float(np.mean(np.argmax(forward(p, X), axis=1) == y))


# 异或：两个输入相同时输出 0，不同时输出 1
X = np.array([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
y = np.array([0, 1, 1, 0])
T = np.zeros((4, 2))
T[np.arange(4), y] = 1.0

print('[1] 一个只有四个样本的问题，却困了神经网络十多年')
print('  输入两个 0 或 1，相同输出 0，不同输出 1')
print('  这四个点画在平面上，两类的对角线交叉，一条直线切不开')
print('')

print('[2] 没有隐层：无论怎么训练都不行')
best = 0.0
for s in range(8):
    p = train(init_mlp([2, 2], seed=s), X, T, lr=0.5, epochs=3000)
    best = max(best, acc(p, X, y))
print('  八个随机种子，最好的那个也只到 %.2f' % best)
print('  原因不是优化没做好，是它压根没有能表达异或的结构')
print('')

print('[3] 加上隐层：能做了，但不是每次都成功')
print('  隐层个数   八个种子里全对的次数   八次的准确率')
for h in (2, 3, 4, 8):
    vals = []
    for s in range(8):
        p = train(init_mlp([2, h, 2], seed=s), X, T, lr=0.5, epochs=3000)
        vals.append(acc(p, X, y))
    print('  %4d       %d / 8                %s'
          % (h, sum(1 for v in vals if v == 1.0), '  '.join('%.2f' % v for v in vals)))

print('')
print('[4] 这就是历史上那段低谷的技术原因')
print('  1969 年明斯基指出单层感知器连异或都做不了，研究冷了十几年')
print('  1986 年反向传播让多层网络可以训练，才重新热起来')
print('  2006 年深层网络找到可行的初始化与预训练办法，深度学习才算立住')
print('  三次起伏，卡的都是同一件事：能不能又多一层')

实跑输出：

--------------------------------------------------------------------
发展历程：一个异或问题，困了神经网络十几年
--------------------------------------------------------------------
[1] 一个只有四个样本的问题，却困了神经网络十多年
  输入两个 0 或 1，相同输出 0，不同输出 1
  这四个点画在平面上，两类的对角线交叉，一条直线切不开

[2] 没有隐层：无论怎么训练都不行
  八个随机种子，最好的那个也只到 0.50
  原因不是优化没做好，是它压根没有能表达异或的结构

[3] 加上隐层：能做了，但不是每次都成功
  隐层个数   八个种子里全对的次数   八次的准确率
     2       1 / 8                0.50  0.75  0.50  0.50  0.75  0.75  1.00  0.75
     3       6 / 8                1.00  1.00  1.00  1.00  1.00  0.75  1.00  0.75
     4       5 / 8                1.00  1.00  0.75  0.75  1.00  0.75  1.00  1.00
     8       8 / 8                1.00  1.00  1.00  1.00  1.00  1.00  1.00  1.00

[4] 这就是历史上那段低谷的技术原因
  1969 年明斯基指出单层感知器连异或都做不了，研究冷了十几年
  1986 年反向传播让多层网络可以训练，才重新热起来
  2006 年深层网络找到可行的初始化与预训练办法，深度学习才算立住
  三次起伏，卡的都是同一件事：能不能又多一层

第一段那句「一条直线切不开」是整个故事的起点。 异或是线性不可分的最小例子，只有四个点，却足够说明问题。 第二段的 0.50 要强调它是「上限」而不是「没调好」。 换学习率、换轮数、换种子，都突破不了——因为模型只会画直线。 这是「模型族不够」和「优化不够」的区别，两者要分清。 第三段那张表最有信息量的是第一行。 隐层 2 个：理论上够，实际上八次只成一次。 这个反差就是 1970 年代的真实处境——不是不知道要加层，是加层之后训不出来。 第三段最后一行 8/8 也不该读成「8 个隐单元比 2 个好」。 它说的是：参数多了，损失曲面上通往低处的路也多了，随机初始化的运气成分被平均掉了。 这在今天叫「过参数化有利于优化」，是个仍在研究的话题。 代码里 train 用的是全批量（四个样本一次算完），没有打乱。 因为样本只有四个，批量大小和学习率的搭配要单独特调——这也是小数据集的麻烦之处。

30 秒实验

1. 把 init_mlp 的初始化标准差从 sqrt(2 / fan_in) 改成 0.01，重跑。 隐层 8 个那一行也会掉下来。 初始化太小，信号一层层缩水，梯度传不回去——这就是后来「初始化方法」成为一门学问的原因。
2. 把 train 的 lr 从 0.5 改成 5.0，重跑。会出现准确率乱跳甚至变成 0.50 的情况。 学习率太大，更新一步就跨过了谷底。 这个旋钮在第 2.9 节会专门讲。
3. 把隐层个数扫到 16、32，重跑。八个种子的成功率不会一直涨，会在某个点饱和。 异或只有四个样本，容量过剩之后没有额外好处。

常见误区

1. 「1969 年明斯基证明了神经网络不行」。 他证明的是「单层感知器表达不了异或」，这个结论完全正确。 被误传成「神经网络不行」，是后人的过度推广。 多层网络从来都能表达异或，只是当时训练不出来。
2. 「理论上能表达，就一定能训练出来」。 实测隐层 2 个（理论够用）八次只成功一次。 表达力是「存在一组参数能做到」，可训练性是「梯度下降能不能找到那组参数」。 两件事之间隔着一整个优化问题。
3. 「深度学习是 2012 年突然出现的」。 反向传播 1986 年就普及了，卷积网络的雏形在 1980 年代末就有。 2012 年爆发是因为数据（ImageNet）、算力（GPU）、方法（ReLU、Dropout）三样同时到位。
4. 「历史只是故事，对动手没帮助」。 这段历史里的每个卡点，今天都还在：梯度消失、初始化、学习率、过拟合。 知道它们曾经怎么卡住人，比记住年份有用得多。

历史讲完了，回到一个更实际的问题： 既然传统机器学习也能做分类，为什么非要这么多层？ 答案不在「精度高一点」，而在「谁来设计特征」这件事上。 下一节用同一份图像数据把两种做法摆在一起比。

• ☐ （本节完，下一节 1.3 为什么是深度学习）

相关笔记

• 深度学习与机器学习
• 为什么是深度学习
• 本书结构
• 📗 图解深度学习 · 索引