深度学习基础：感知机

什么是感知机？

感知机 (Perceptron) 是 Frank Rosenblatt 于 1958 年提出的一种二分类线性模型，是人工神经网络的最小单元。它的核心思想异常简单：感知机接收若干输入，给每个输入分配一个权重，加权求和后加上偏置，再通过一个激活函数得到分类结果。

感知机是机器学习历史上第一个能从数据中自动学习的人工神经元模型：它把每个样本看成一个向量，用一条直线（高维空间里叫超平面）把两类数据分开——直线怎么放不是人设计的，而是模型自己在训练中”学”出来的。

虽然结构简单，但感知机是连接主义 (Connectionism) 的开山之作——它把”学习”具象化为调整权重的过程，直接点燃了后来深度学习革命的火种。

一段跌宕起伏的历史

1958 年 Rosenblatt 在康奈尔航空实验室用硬件实现了感知机 Mark I，能识别简单图像，纽约时报当时报道说”它能走路、说话、写字、繁殖后代”——当然这非常夸张，但反映了当时人们的狂热。1969 年 Minsky 和 Papert 在《Perceptrons》一书中证明了感知机无法解决 XOR 问题，直接导致整个领域 10 年寒冬。

生物神经元 vs 人工神经元

感知机的灵感来源于生物神经元。理解这种类比有助于建立直观感受：

感知机是什么：一个用直线分类的机器

感知机的全部逻辑只有三步：把输入加权求和，加上偏置，再过一道阶跃函数，输出 +1 或 -1。（这里输出的是±1，而不是0/1，很容易让初学感知机时感到困惑。两种约定都存在，都不是错的：±1 是经典感知机（Rosenblatt 原始论文、Novikoff 收敛定理、Minsky & Papert《Perceptrons》一书）的标准约定；0/1 则常见于 McCulloch-Pitts 神经元、逻辑门实现和多层感知机的表述。）

输入与权重

• 定义：每个样本 $\mathbf{x} = (x_1, x_2, \ldots, x_n)$ 是一个 $n$ 维特征向量，每个特征 $x_i$ 配一个权重 $w_i$。
• 特点：权重刻画”这个特征对分类有多重要”——权重越大，该特征对决策的影响越大；权重为负，说明该特征把样本往负类方向推。
• 注意：权重初始为 0 或很小的随机数，全部靠训练自动调整，人不需要设计任何分类规则。

加权求和与偏置

• 定义：模型先把特征与权重做内积，再加上偏置 $b$，得到净输入

$$z = \mathbf{w} \cdot \mathbf{x} + b = \sum_{i=1}^{n} w_i x_i + b$$

• 特点：偏置的作用是让决策边界可以离开原点平移——没有它，直线永远只能过原点，能解决的问题少一大半。
• 注意：$z$ 的几何含义是”样本点到决策超平面的带符号距离”：符号决定它被判成哪一类，绝对值决定它离边界有多远。

激活函数

• 定义：阶跃函数 $\operatorname{sign}(z)$ 把净输入映射成二分类输出：$z > 0$ 输出 $+1$，否则输出 $-1$：

$$\hat{y} = \operatorname{sign}(z) = \begin{cases} +1, & z > 0 \\ -1, & z \le 0 \end{cases}$$

• 特点：这是感知机”硬分类”的来源——输出只有两个值，没有中间地带。
• 注意：正因为 $\operatorname{sign}$ 不可导，感知机没法用普通梯度下降，只能用下一节介绍的”误分类驱动”更新规则。

决策边界

• 定义：所有满足 $\mathbf{w} \cdot \mathbf{x} + b = 0$ 的点构成一个超平面，把特征空间切成两半。
• 特点：一侧 $\mathbf{w} \cdot \mathbf{x} + b > 0$ 输出 $+1$，另一侧输出 $-1$。
• 注意：感知机训练的本质，就是在学这个超平面的方向（$\mathbf{w}$）和位置（$b$）。

数学模型与几何直觉

形式化定义

对于输入向量$\mathbf{x} = (x_1, x_2, \ldots, x_n)^T$和权重向量$\mathbf{w} = (w_1, w_2, \ldots, w_n)^T$ ，感知机计算：

$$z = \mathbf{w}^T \mathbf{x} + b = \sum_{i=1}^{n} w_i x_i + b$$

$$y = f(z) = \begin{cases} +1 & \text{if } z > 0 \\ -1 & \text{if } z \le 0 \end{cases}$$

其中b是偏置 (bias)，f是激活函数（这里默认是符号函数 sign）。

几何直觉：超平面

方程$\mathbf{w}^T \mathbf{x} + b = 0$在n维空间中定义了一个超平面 (Hyperplane)。超平面把空间分成两部分：

• 正侧 (Positive side)：$\mathbf{w}^T \mathbf{x} + b > 0$，预测为+1
• 负侧 (Negative side)：$\mathbf{w}^T \mathbf{x} + b < 0$，预测为-1

感知机的学习目标就是找到一组w,b ，使训练样本被正确分到超平面两侧。 2决定超平面的方向， b决定位置。

训练前后：决策边界如何变化

激活函数：从阶跃到 ReLU

激活函数决定神经元的输出形式。感知机使用的阶跃函数不可导，限制了其在梯度下降框架下的使用，因此现代网络都改用平滑可导的激活函数：

为什么 ReLU 更受欢迎?Sigmoid/Tanh 在两端梯度接近 0，导致梯度消失；ReLU 在正区间梯度恒为 1，计算高效且收敛更快，是 AlexNet 之后几乎所有深度网络的默认选择。

感知机是如何进行学习的？

感知机的训练规则简单到一句话：每遇到一个被分错的样本，就把权重往”正确方向”掰一步。这一节把这句话拆成损失、更新规则和收敛保证三部分。

损失函数：误分类点到超平面的距离

感知机不追求复杂的损失曲面。它把损失定义为所有误分类点到超平面的总距离：

$$L(\mathbf{w}, b) = -\sum_{i \in M} y_i\,(\mathbf{w} \cdot \mathbf{x}_i + b)$$

其中 $M$ 是误分类样本的集合，$y_i \in \{+1, -1\}$ 是真实标签。直觉上，误分类点的 $y_i(\mathbf{w} \cdot \mathbf{x}_i + b)$ 是负数（标签和预测方向相反），取负号后损失为正；样本离边界越远、错得越离谱，损失越大。当没有误分类点时损失为 0，训练结束。

更新规则：向正确方向掰权重

对损失函数求梯度，就得到极简的更新规则：每看到一个误分类样本 $(\mathbf{x}_i, y_i)$，就执行

$$\mathbf{w} \leftarrow \mathbf{w} + \eta\, y_i \mathbf{x}_i, \qquad b \leftarrow b + \eta\, y_i$$

其中 $\eta$ 是学习率（常用 0.1）。几何直觉：如果真实标签是 $+1$ 却被判成 $-1$，说明 $\mathbf{w} \cdot \mathbf{x}_i$ 太小，加上 $\eta \mathbf{x}_i$ 后下次净输入会变大，更容易判对；反之亦然。注意：只有误分类的样本才会触发更新，分对的样本不会产生任何动作——这是感知机训练”抓住错误不放”的由来。

收敛定理：线性可分就一定能学会

Novikoff 在 1962 年证明：只要数据线性可分，上述更新规则在有限步内一定收敛到把数据全部分对的超平面。大白话就是：学不会的唯一原因是数据本身分不开，不是算法不行。这是感知机最有价值的理论保证——不少后来的模型都没有这么干净的结论。

重要限制

• 该定理只保证收敛，不保证找到”最好的”超平面（无数解都可以分开数据）
• 如果数据不可分，算法会永远震荡——这也是感知机被冷落的重要原因
• 实际使用时常设置n_epochs 上限 + 平均权重 (voted perceptron、averaged perceptron) 来缓解

致命缺陷：XOR 问题

XOR 的四个点无论用哪条直线切，总有一个点被分错。这正是单层感知机的天花板，也是 Minsky 与 Papert 在 1969 年用数学严格证明的结论。

为什么单层感知机搞不定 XOR？

XOR（异或）的真值表是：

• 0 XOR 0 = 0
• 0 XOR 1 = 1
• 1 XOR 0 = 1
• 1 XOR 1 = 0

把这四个点画在坐标轴上（(0,0)、(1,1) 是蓝色类0；(0,1)、(1,0) 是红色类），你会发现：你永远无法用一条直线把红色和蓝色分开。这就是经典的“线性不可分”问题。因为单层感知机只能画直线，所以它在数学上被证明无法解决 XOR。这也是 1969 年神经网络陷入寒冬的导火索。

感知机只擅长”一条线就能分开”的问题，且输出生硬、不耐噪声。它的局限至少有以下五条：

• 只能线性可分：XOR 这类问题直接失效，必须引入多层结构或核技巧才能解决。
• 输出没有概率：只有 $+1 / -1$，无法表达”有 80% 把握”这类置信度，难以直接用于排序或风险控制。
• 对噪声敏感：训练集里一个异常点就会让权重大幅摆动，收敛后仍可能震荡不停。
• 解不唯一：线性可分时收敛到的超平面不唯一，取决于初始化和样本顺序，泛化能力没有保证。
• 历史包袱：1969 年 Minsky & Papert 的《Perceptrons》证明了单层感知机能力有限，直接导致第一波神经网络研究陷入低谷，直到 1980 年代反向传播与多层感知机出现才翻身。

破局：多层感知机 (MLP)

关键想法

既然一条直线分不开，那就先把数据”变形”，再画直线——这就是多层感知机的核心思想：

• 隐藏层把原始输入映射到新空间 (特征变换 / 表示学习)
• 输出层在新空间里画一个超平面
• 两层叠加等价于在原始空间中画一条曲线

解决 XOR

你可以把 MLP 理解为“带隐藏层的升级版神经元网络”。

• 单层感知机：只有输入层和输出层，本质上是一条直线（线性分类器）。它只能处理像“AND（与）”或“OR（或）”这样能一刀切开的问题。
• 多层感知机：在输入和输出之间插入了隐藏层，并且隐藏层的神经元配备了非线性激活函数（如 ReLU、Sigmoid、Tanh）。

核心公式：输出=激活函数(权重2×激活函数(权重1×输入+偏置1)+偏置2)

有了隐藏层和非线性激活，MLP 就不再只能画直线，而是能扭曲空间，画出任意复杂的曲线。

MLP 是如何巧妙破解 XOR 的？

MLP 解决 XOR 的关键在于“升维变换”。它不直接尝试在原始平面分类，而是先把平面“折叠”成三维空间，再切一刀。

我们以一个包含 3 个神经元的隐藏层为例，手算推演一下（使用 ReLU 激活函数，负数归零）：

步骤一：空间扭曲（隐藏层）

隐藏层把输入$(x_1,x_2)$映射成两个新的特征 $(h_1,h_2)$：

• $h_1=ReLU(x_1+x_2-1.5)$（用来检测“是否两个都是 1”）
• $h_2=ReLU(x_1-x_2+0.5)$和$h_3=ReLU(x_2-x_1+0.5$（用来检测“是否只有一个为1”）

步骤二：线性分割（输出层）

经过变换后，原来的四个点被映射到了新的特征空间。此时，输出层只需要用一条直线（或一个超平面）把新空间的点分开即可。

最直观的几何解释（S型曲线）

你不需要理解复杂的数学公式，只需要想象：MLP 的隐藏层把原始的二维平面“折叠”了一下。原本在对角线上的两个点 (0,0) 和 (1,1) 被压到了低处，而另外两个点 (0,1) 和 (1,0) 被翘到了高处。这时，输出层只需要在高低之间平切一刀，问题就迎刃而解了。

现实意义：XOR 问题虽然简单，但它代表了所有“非线性关系”。MLP 能解决 XOR，意味着它理论上可以拟合任何复杂的函数（万能近似定理），这也是它能做图像识别、自然语言处理的基础。

为什么今天还要学感知机？

感知机虽然简单到”只有一个神经元”，但它把”自动学习参数”这件事讲透了，是理解一切现代模型的起点。具体有四个价值点：

• 最小的可解释分类器：全部参数只有 $\mathbf{w}$ 和 $b$，学完能直接读出”每个特征往哪个方向、以多大力度投票”，决策过程完全透明。
• 有严格的收敛保证：线性可分数据上有限步内必然收敛，这是入门阶段难得一见”有数学证明”的算法。
• 神经网络的地基：把多个感知机堆成多层、把阶跃函数换成可导的非线性激活函数，就是多层感知机（MLP）——深度学习一切网络的原型。
• 逻辑回归和 SVM 的近亲：三者都在学同一个超平面，区别只在输出形式与损失函数，学会感知机再学它们会非常快。

要素速查矩阵

下表把感知机的五个核心要素与”是什么、作用、常见实现”对照起来，方便回头速查：

与逻辑回归、线性 SVM 的关系

感知机学习算法 (Python 实现)

感知机原始形式实现

import numpy as np

class Perceptron:
    """
    单层感知机分类器 (原始形式)
    仅适用于二分类线性可分问题，标签需为 +1 和 -1
    """
    def __init__(self, learning_rate=0.1, max_iter=1000):
        self.lr = learning_rate      # 学习率 η
        self.max_iter = max_iter      # 最大迭代轮数（防止死循环）
        self.w = None                 # 权重向量
        self.b = None                 # 偏置项
        self.errors_ = []             # 记录每轮分类错误的次数，用于观察收敛情况

    def fit(self, X, y):
        """
        训练感知机
        X: shape (n_samples, n_features)
        y: shape (n_samples,)，取值必须为 +1 或 -1
        """
        n_samples, n_features = X.shape
        # 初始化权重和偏置为 0
        self.w = np.zeros(n_features)
        self.b = 0

        # 确保标签是 +1 和 -1（若输入是 0/1 可做转换，这里要求调用前自行处理）
        unique_labels = np.unique(y)
        if not np.array_equal(np.sort(unique_labels), [-1, 1]):
            raise ValueError("标签必须为 +1 和 -1，请转换标签（如将 0 改为 -1）")

        # 迭代训练
        for epoch in range(self.max_iter):
            error_count = 0
            # 遍历每个样本（感知机按样本逐个更新，非批量梯度下降）
            for xi, target in zip(X, y):
                # 计算当前输出: sign(w·x + b)
                linear_output = np.dot(xi, self.w) + self.b
                # 误分类条件: y * (w·x + b) <= 0
                if target * linear_output <= 0:
                    # 权重更新: w = w + η * y_i * x_i
                    self.w += self.lr * target * xi
                    # 偏置更新: b = b + η * y_i
                    self.b += self.lr * target
                    error_count += 1
            
            # 记录本轮错误次数
            self.errors_.append(error_count)
            
            # 如果没有误分类点，说明已完全线性可分，提前终止
            if error_count == 0:
                print(f"感知机在第 {epoch+1} 轮迭代后收敛。")
                break
        else:
            # 如果 for 循环正常结束（未 break），说明达到最大迭代次数仍未收敛
            print(f"警告：达到最大迭代次数 {self.max_iter}，数据可能线性不可分。")

    def predict(self, X):
        """预测样本标签"""
        if self.w is None:
            raise RuntimeError("请先调用 fit 方法训练模型")
        linear_output = np.dot(X, self.w) + self.b
        # np.sign: 正数返回 1，负数返回 -1，零返回 0
        return np.sign(linear_output)

    def score(self, X, y):
        """计算准确率"""
        predictions = self.predict(X)
        return np.mean(predictions == y)

测试用例 1：线性可分的 AND（与）问题

# 准备数据 (特征需保留原始 0/1 也可以，这里为了对称性用 -1/1)
# 注意：感知机对特征缩放不敏感，这里直接用 0/1 也可以跑通，但我们用标准 -1/1 展示
X_and = np.array([[-1, -1], [-1, 1], [1, -1], [1, 1]])
# 标签: AND 逻辑, 只有 (1,1) 为正类 (+1)
y_and = np.array([-1, -1, -1, 1]) 

# 训练
p_and = Perceptron(learning_rate=0.1, max_iter=100)
p_and.fit(X_and, y_and)

# 预测并打印结果
print("=== AND 问题测试 (线性可分) ===")
print(f"权重 w: {p_and.w}, 偏置 b: {p_and.b}")
print(f"预测结果: {p_and.predict(X_and)}")
print(f"真实标签: {y_and}")
print(f"准确率: {p_and.score(X_and, y_and) * 100}%")
print(f"每轮错误次数记录: {p_and.errors_}\n")

测试用例 2：线性不可分的 XOR（异或）问题

X_xor = np.array([[-1, -1], [-1, 1], [1, -1], [1, 1]])
# 标签: XOR 逻辑
y_xor = np.array([-1, 1, 1, -1]) 

# 训练（增大迭代次数，看它如何挣扎）
p_xor = Perceptron(learning_rate=0.1, max_iter=100)
p_xor.fit(X_xor, y_xor)

print("=== XOR 问题测试 (线性不可分) ===")
print(f"最终权重 w: {p_xor.w}, 偏置 b: {p_xor.b}")
print(f"预测结果: {p_xor.predict(X_xor)}")
print(f"真实标签: {y_xor}")
print(f"准确率: {p_xor.score(X_xor, y_xor) * 100}%")
print(f"每轮错误次数记录 (前20轮): {p_xor.errors_[:20]}... (共 {len(p_xor.errors_)} 轮)")

从零实现MLP（NumPy 版）

我们设计一个 2 → 4 → 1 的网络结构（输入2个特征，隐藏层4个神经元，输出1个神经元）。

• 隐藏层激活函数：ReLU（引入非线性，解决 XOR 的关键）。
• 输出层激活函数：Sigmoid（将输出映射到 0~1，视为概率）。
• 损失函数：均方误差（MSE）。

import numpy as np

class MLP:
    def __init__(self, input_size, hidden_size, output_size, lr=0.1):
        self.lr = lr
        # 使用 He 初始化（Xavier 变体），让梯度更稳定，不要用全零
        self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2. / input_size)
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(2. / hidden_size)
        self.b2 = np.zeros((1, output_size))

    # ---------- 激活函数及其导数 ----------
    def _sigmoid(self, x):
        return 1 / (1 + np.exp(-np.clip(x, -250, 250)))  # 防止溢出

    def _sigmoid_deriv(self, x):
        # 注意：这里传入的是 sigmoid 的输出值 a，而不是原始 z
        return x * (1 - x)

    def _relu(self, x):
        return np.maximum(0, x)

    def _relu_deriv(self, x):
        # 这里传入的是原始 z，大于 0 导数为 1，否则为 0
        return (x > 0).astype(float)

    # ---------- 前向传播 ----------
    def forward(self, X):
        # 输入层 -> 隐藏层
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self._relu(self.z1)
        # 隐藏层 -> 输出层
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self._sigmoid(self.z2)  # 最终预测值 (0~1)
        return self.a2

    # ---------- 反向传播 (核心) ----------
    def backward(self, X, y, output):
        m = X.shape[0]  # 样本数量

        # 损失对输出层的梯度 (MSE 导数: output - y)
        d_loss = output - y

        # --- 输出层反向传播 ---
        # d_z2 = d_loss * sigmoid'(a2)，注意 a2 是 sigmoid 输出
        d_z2 = d_loss * self._sigmoid_deriv(output)
        # 更新 W2 和 b2 (加上了除以 m 取平均，使梯度更稳定)
        dW2 = np.dot(self.a1.T, d_z2) / m
        db2 = np.sum(d_z2, axis=0, keepdims=True) / m

        # --- 隐藏层反向传播 ---
        # 误差从输出层传回隐藏层
        d_a1 = np.dot(d_z2, self.W2.T)
        # d_z1 = d_a1 * relu'(z1)
        d_z1 = d_a1 * self._relu_deriv(self.z1)
        # 更新 W1 和 b1
        dW1 = np.dot(X.T, d_z1) / m
        db1 = np.sum(d_z1, axis=0, keepdims=True) / m

        # 梯度下降更新参数
        self.W2 -= self.lr * dW2
        self.b2 -= self.lr * db2
        self.W1 -= self.lr * dW1
        self.b1 -= self.lr * db1

    # ---------- 训练函数 ----------
    def train(self, X, y, epochs=10000, print_loss=True):
        for epoch in range(epochs):
            output = self.forward(X)
            self.backward(X, y, output)
            if print_loss and epoch % 2000 == 0:
                loss = np.mean((output - y) ** 2)
                print(f"Epoch {epoch}, Loss: {loss:.6f}")

    # ---------- 预测 ----------
    def predict(self, X, threshold=0.5):
        output = self.forward(X)
        return (output >= threshold).astype(int)

测试 XOR 问题

# 准备数据 (0/1 特征，标签为 0 或 1)
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])  # XOR 真值表

# 实例化并训练
mlp = MLP(input_size=2, hidden_size=4, output_size=1, lr=0.5)
mlp.train(X, y, epochs=10000, print_loss=True)

# 输出预测结果
print("\n=== 预测结果 ===")
preds = mlp.predict(X)
for i, (x, pred) in enumerate(zip(X, preds)):
    print(f"输入: {x} -> 预测: {pred[0]} (真实: {y[i][0]})")

# 查看隐藏层学到了什么（可选）
print(f"\n最终损失: {np.mean((mlp.forward(X) - y) ** 2):.8f}")