如果让你给一台机器讲清楚“两个输入都为 1 时才输出 1”这件事，你会怎么教？我第一次看感知机训练过程手算拆解时，最直观的感受是：它真的不靠任何聪明的规划，就是一遍一遍拿样本试，错了就改，改完再试，几轮之后居然真的能把逻辑与这条规则学出来。后来我把同样的过程用代码写了一遍，才彻底理解为什么说感知机是神经网络的基础，也理解了什么叫“错误驱动”。
这篇文章适合两类人：一类是刚接触机器学习、觉得感知机公式太抽象的人；另一类是已经会调库但从来没自己逐行算过权重更新的同学。我会用一个最简单的二分类例子（逻辑与 AND），先手工把每一轮权重变化算得明明白白，再给出可运行的 Python 代码，最后把我在训练过程中踩过的坑一并整理出来。读完你至少能做到：不看任何框架，只凭一条更新规则，徒手推出一枚能用的感知机。
1. 感知机要解决的到底是什么问题
1.1 一个公式加一条阶跃函数，模型就能做二分类
感知机是个非常古老的模型，但它的结构在今天看起来依然不过时：一个线性加权求和，接一个非线性阈值判断。它处理的问题是二分类——给你一个 n 维输入向量 x = (x1, x2, ..., xn)，输出一个标签 y，y 只有两种取值，我这里统一用 {0, 1}。
决策过程分两步。第一步，把输入特征做加权求和，再加上一个偏置：
z = w1 * x1 + w2 * x2 + ... + wn * xn + b
第二步，把 z 扔进阶跃函数，也叫阈值函数：
y_hat = 1 如果 z > 0，否则 y_hat = 0
这里有个小细节：z 恰好等于 0 时，我归为负类。不同教材在边界约定上略有差异，但只要初始化一致，最终结论基本不受影响。
经常有人把 w 叫权重，把 b 叫偏置。权重决定每条特征对结果的影响方向和大小，偏置相当于一个平移量，决定决策边界离原点有多远。拿生活里的例子类比：权重像是给不同科目考试分数分配的“重要程度”，偏置则是及格线的位置。
1.2 训练规则只有一句话：错了才改
感知机训练过程和咱们熟悉的梯度下降不太一样。梯度下降像“沿着山坡往低处走”，依赖目标函数光滑可导；而感知机用的阶跃函数处处不平滑，它的梯度要么为 0，要么不存在。
那它靠什么学？答案是错误驱动。训练时把所有样本依次喂进来，每喂一个样本，先算出预测值 y_hat，再和真实标签 y 比对：
delta = y - y_hat
如果 delta 为 0，说明预测正确，什么都不用改。如果 delta 不为 0，说明预测错了，就更新权重和偏置：
w_i = w_i + lr * delta * x_i b = b + lr * delta
这里 lr 是学习率。你可以仔细品一下这个公式：当一个正类样本（真实 y = 1）被预测成 0 时，delta = 1，权重会往“把 z 推大”的方向走；当一个负类样本（真实 y = 0）被预测成 1 时，delta = -1，权重会往“把 z 推小”的方向走。所以更新是自洽的，每次更新都在尝试修正刚才那个错误。
从几何上看，更新就是在旋转权重向量的方向、平移决策边界的位置。感知机没有“损失函数曲线平滑下降”这种叙事，它的训练过程更像是不同样本在轮流“掰”一条直线，直到所有样本都被分对。
1.3 为什么大家都拿逻辑与当入门案例
任何一个训练过程，如果输入特征很多、数据量很大，手算就会淹没在计算量里，完全看不清本质。所以我选了一个只有两个特征、四个样本的经典例子：逻辑与（AND）。
真值表非常清晰：输入 x1 和 x2，输出 y。
- (0, 0) -> 0
- (0, 1) -> 0
- (1, 0) -> 0
- (1, 1) -> 1
这组数据画在二维平面上，前三个点聚在原点方向，第四个点在右上方，完全可以用一条直线把它们分开，所以它是线性可分的。线性可分是感知机能收敛的前提。后面我会专门讲，如果数据线性不可分会发生什么。
2. 手算全过程：逻辑与的感知机训练示例
2.1 开局约定：零权重、学习率为 1、固定样本顺序
手算前先把参数约定好：
- 权重初始值：w1 = 0，w2 = 0
- 偏置初始值：b = 0
- 学习率：lr = 1
- 样本顺序：固定为 (0,0)、(0,1)、(1,0)、(1,1)，每个样本喂一遍算一轮；一轮内四个样本全部预测正确才停。
为什么初始权重设 0？因为在线性可分数据上，感知机没有局部最优的困扰，零初始化最简单。为什么学习率设 1？这是感知机最常用的取值，理由我放到第四部分单独展开，这里先直接用。
顺便提一下标签体系。很多教科书会把负类标成 -1、正类标成 +1，然后用 sign(z) 做预测。我用 {0, 1} 标签纯属为了手算更直观，更新规则同样可用，只是 delta 的取值范围依然是 -1、0、1，本质没有变化。
2.2 第 1 轮：权重第一次从零开始增长
刚开始权重全是 0，模型就是一个“什么都不懂”的靶子。
先喂 (0,0)，真实标签 0：
z = 0 * 0 + 0 * 0 + 0 = 0
因为 z = 0 不满足大于 0，所以 y_hat = 0。预测正确，w 和 b 保持不动。
再喂 (0,1)，真实标签 0：
z = 0 * 0 + 0 * 1 + 0 = 0，y_hat = 0。正确，不动。
继续喂 (1,0)，真实标签 0：
z = 0 * 1 + 0 * 0 + 0 = 0，y_hat = 0。正确，不动。
最后一组 (1,1)，真实标签 1：
z = 0 * 1 + 0 * 1 + 0 = 0，y_hat = 0。
问题来了：真实标签是 1，预测却是 0，分类错了。delta = 1 - 0 = 1，于是更新：
w1 = 0 + 1 * 1 * 1 = 1
w2 = 0 + 1 * 1 * 1 = 1
b = 0 + 1 * 1 = 1
第一轮结束，权重从 (0,0,0) 变成 (1,1,1)。
这里有个容易被忽略的点：零权重模型的输出永远为 0，因为它算出来的 z 恒为 0，所以前三个样本“预测正确”其实是靠蒙的。真正促使模型开始学习的，是第四个样本带来的第一次错误更新。可见感知机的起点是“全负”，然后逐步被正类样本纠正过来。
2.3 第 2 轮：权重开始震荡，错误数不降反升
第二轮开始前，权重是 w1 = 1，w2 = 1，b = 1。挨个看。
样本 (0,0)，真实 0：
z = 1 * 0 + 1 * 0 + 1 = 1，y_hat = 1。预测错误！delta = 0 - 1 = -1，更新：
w1 = 1 + (-1) * 0 = 1
w2 = 1 + (-1) * 0 = 1
b = 1 + (-1) = 0
更新后 (1,1,0)。
样本 (0,1)，真实 0：
z = 1 * 0 + 1 * 1 + 0 = 1，y_hat = 1。预测错误！delta = 0 - 1 = -1，更新：
w1 = 1 + (-1) * 0 = 1
w2 = 1 + (-1) * 1 = 0
b = 0 + (-1) = -1
更新后 (1,0,-1)。
样本 (1,0)，真实 0：
z = 1 * 1 + 0 * 0 + (-1) = 0，y_hat = 0。正确。
样本 (1,1)，真实 1：
z = 1 * 1 + 0 * 1 + (-1) = 0，y_hat = 0。预测错误！delta = 1 - 0 = 1，更新：
w1 = 1 + 1 * 1 = 2
w2 = 0 + 1 * 1 = 1
b = -1 + 1 = 0
更新后 (2,1,0)。
第二轮结束，把四个样本整理成一张表。
| 样本 | z 值 | y_hat | 是否更新 | 更新后 (w1, w2, b) |
|---|---|---|---|---|
| (0,0) | 1 | 1 | 是 | (1, 1, 0) |
| (0,1) | 1 | 1 | 是 | (1, 0, -1) |
| (1,0) | 0 | 0 | 否 | (1, 0, -1) |
| (1,1) | 0 | 0 | 是 | (2, 1, 0) |
你有没有发现，第 2 轮一开始，权重就把第一轮学到的方向“退让”了一点：b 从 1 降到 0，w2 从 1 降到 0。这不是坏事，感知机的更新本来就不是一条笔直的下坡路，而是不断被不同样本纠正的之字形路径。我当时第一次手算到这里还挺惊讶：为什么模型会“越改越回去”？因为负类样本在把决策边界往下压，正类样本又在把它往上抬，两边拉扯是正常状态。
2.4 第 3 轮到第 5 轮：三个错误样本把参数推向临界
从第 3 轮开始，如果每一轮都列一张大表会显得比较啰嗦，我改用每轮记录“在哪些样本上发生了更新、更新后参数变成多少”的方式。
第 3 轮：
- (0,0) 正确，不更新。
- (0,1) 错误，delta = -1，更新后 (2, 0, -1)。
- (1,0) 错误，delta = -1，更新后 (1, 0, -2)。
- (1,1) 错误，delta = 1，更新后 (2, 1, -1)。
第 3 轮结束时参数为 (2, 1, -1)。
第 4 轮：
- (0,0) 正确。
- (0,1) 正确。
- (1,0) 错误，delta = -1，更新后 (1, 1, -2)。
- (1,1) 错误，delta = 1，更新后 (2, 2, -1)。
第 4 轮结束时参数为 (2, 2, -1)。
第 5 轮：
- (0,0) 正确。
- (0,1) 错误，delta = -1，更新后 (2, 1, -2)。
- (1,0) 正确。
- (1,1) 正确。
第 5 轮结束时参数为 (2, 1, -2)。
你看这个过程中权重的变化不是单调的：w1 在 1 和 2 之间震荡，w2 在 0、1、2 之间来回跳，b 从正数一路被压到 -2。这正是感知机训练的典型形态——没有平滑的损失曲线，只有“某个样本把它往右拽一下、另一个样本把它往左拽一下”的博弈结果。
我建议你手算时也把每一轮的参数变化像上面这样记下来，过一会儿你就能发现：某一次更新看似让这个样本对了，但可能让另一个样本错了；可是整体趋势上，决策边界在慢慢逼近正确位置。
2.5 第 6 轮：一轮零错误，宣布收敛
第 6 轮用 (2,1,-2) 把四个样本再完整过一遍：
- (0,0)：z = 0 + 0 - 2 = -2，y_hat = 0，正确。
- (0,1)：z = 0 + 1 - 2 = -1，y_hat = 0，正确。
- (1,0)：z = 2 + 0 - 2 = 0，y_hat = 0，正确。
- (1,1)：z = 2 + 1 - 2 = 1，y_hat = 1，正确。
四个样本全部正确，训练结束。最终参数 w = (2,1)，b = -2。
这组参数对应一条决策直线：2 * x1 + x2 - 2 = 0，也就是 x2 = -2 * x1 + 2。把四个样本点画在坐标系里，这条线恰好把 (1,1) 这个点划到一侧，把其他三个点划到另一侧。
值得多说一句：感知机收敛后，答案并不唯一。只要能把数据分开，任何一条直线都行。换个初始化、换个样本顺序，你可能得到 w = (1,1)、b = -1.5 这样的参数，也同样正确。所以不要纠结“为什么非得是这个权重”，重点是理解更新规则如何驱动参数走向可分状态。
3. 代码实现：从手算到可运行的 Python 脚本
3.1 纯 Python 版感知机：每个变量都能对上手算
我建议第一步先别急着上框架，用纯 Python 写一个能跑的最小版本，方便和手算逐行对齐。这个版本不用 numpy，每个变量都能打印出来验证。
class Perceptron: def __init__(self, n_features, lr=1.0, max_epochs=100): self.lr = lr self.max_epochs = max_epochs self.w = [0.0] * n_features self.b = 0.0 self.errors_per_epoch = [] def predict(self, x): z = self.b for i in range(len(x)): z += self.w[i] * x[i] return 1 if z > 0 else 0 def fit(self, X, y): for epoch in range(1, self.max_epochs + 1): errors = 0 for xi, yi in zip(X, y): y_hat = self.predict(xi) delta = yi - y_hat if delta != 0: for i in range(len(xi)): self.w[i] += self.lr * delta * xi[i] self.b += self.lr * delta errors += 1 self.errors_per_epoch.append(errors) print(f"第 {epoch} 轮错误数: {errors}") if errors == 0: print(f"第 {epoch} 轮收敛") break return self这个类做了三件事：初始化权重、预测、训练。最核心的是 fit 方法里的 if delta != 0 判断，它体现了“错了才改”的原则。注意我提前把 y_hat 存了下来，避免计算两次 predict。
3.2 运行结果解读：与手算逐项对照
用逻辑与数据来测试：
X = [[0, 0], [0, 1], [1, 0], [1, 1]] y = [0, 0, 0, 1] p = Perceptron(n_features=2, lr=1.0) p.fit(X, y) print("最终权重:", p.w, "偏置:", p.b) print("每轮错误数:", p.errors_per_epoch)实际运行输出如下：
第 1 轮错误数: 1 第 2 轮错误数: 3 第 3 轮错误数: 3 第 4 轮错误数: 2 第 5 轮错误数: 1 第 6 轮错误数: 0 第 6 轮收敛 最终权重: [2.0, 1.0] 偏置: -2.0 每轮错误数: [1, 3, 3, 2, 1, 0]和手算完全一致。注意看错误数曲线：1、3、3、2、1、0，它不是一路下降的。第 2 轮错误数反而从 1 涨到 3，这是正常现象，因为权重被新样本拽偏之后，之前对的样本可能又错了。
3.3 numpy 版：把向量运算压缩成三行
学会最小实现后，可以换一个 numpy 版本，代码更短，更接近实际项目里的写法。
import numpy as np class PerceptronNP: def __init__(self, n_features, lr=1.0, max_epochs=100): self.lr = lr self.max_epochs = max_epochs self.w = np.zeros(n_features) self.b = 0.0 def predict(self, x): return 1 if np.dot(self.w, x) + self.b > 0 else 0 def fit(self, X, y): for epoch in range(1, self.max_epochs + 1): error_count = 0 for xi, yi in zip(X, y): y_hat = self.predict(xi) delta = yi - y_hat if delta != 0: self.w += self.lr * delta * np.array(xi) self.b += self.lr * delta error_count += 1 if error_count == 0: return epoch return None这里唯一要注意的是：计算 delta 时，先把 y_hat 存下来再用。有些新手会写 if self.predict(xi) != yi 然后在更新时又调用一次 predict，这样预测函数执行了两遍，虽然结果一样，但代码可读性差，也容易引入隐藏 bug。
3.4 可视化决策边界：直线怎么画出来的
数学推演和代码输出都证明了同一件事，如果还想更直观，可以画个图。用 matplotlib 画四个样本点，再画出直线 2 * x1 + x2 = 2。
import matplotlib.pyplot as plt import numpy as np points = [(0, 0), (0, 1), (1, 0), (1, 1)] labels = [0, 0, 0, 1] colors = ['red' if l == 1 else 'blue' for l in labels] xs = [p[0] for p in points] ys = [p[1] for p in points] plt.scatter(xs, ys, c=colors) x_vals = np.linspace(-0.5, 1.5, 100) y_vals = -2 * x_vals + 2 plt.plot(x_vals, y_vals, 'k--') plt.xlabel('x1') plt.ylabel('x2') plt.title('AND 数据集与感知机决策边界') plt.axis('equal') plt.grid(True) plt.show()画出图来，红点 (1,1) 在直线上方，蓝点都在直线下方，分隔效果一目了然。如果换一组权重，直线的斜率或截距会变，但只要数据可分，它总能找到这样一条线。
3.5 手算与代码结果对照表
| 项目 | 手算 | 代码 |
|---|---|---|
| w1 | 2 | 2.0 |
| w2 | 1 | 1.0 |
| b | -2 | -2.0 |
| 收敛轮次 | 第 6 轮 | 第 6 轮 |
到这里，手算和代码已经互相验证完毕。接下来聊聊训练过程中那些不亲眼见到就很难避开的坑。
4. 训练感知机时最容易踩的坑
4.1 学习率为什么直接设 1 就好
说真的，对单层感知机来说，学习率不是一个需要反复调的超参数。理由很简单：感知机更新规则里的 delta 只有 -1、0、1 三种取值，学习率只是整体缩放每次更新的幅度。只要 lr 大于 0，样本是否被纠正的方向不会变，变的只是被纠正的幅度大小。
如果你把 lr 设成 10，手算过程会立刻变得剧烈震荡，错误数涨得更厉害；设成 0.1，权重每次只挪一点点，可能要更多轮才能收敛。不过在线性可分数据上，任意正学习率最终都会收敛，这是感知机收敛定理保证的。所以实践中最省事的做法就是 lr = 1，不用调。
这里面的直觉是：感知机更新不涉及“步长太大会越过最优点”的问题，因为它没有连续的目标函数曲面，每一步要么把一个样本纠对，要么没纠对。你不需要像调梯度下降的学习率那样小心翼翼。
4.2 样本顺序不同，为什么结果可能不一样
我前面说过，同样的数据、同样的初始化，只要把样本顺序打乱，手算出来的中间权重序列就会完全不同，甚至收敛轮次也会变。原因在于感知机是逐样本更新，后面样本的更新会覆盖前面样本的影响。
如果你在复现时发现收敛轮次和我写的不一样，先别慌，大概率只是样本顺序或边界约定不同。我自己把样本顺序换成 (0,0)、(1,1)、(0,1)、(1,0) 之后，第二轮就碰到完全不同的状态。这说明感知机的训练轨迹对顺序敏感，但最终的可分结果不敏感。
实验时想复现结果，最好固定随机种子，或者像我一样固定样本顺序。如果模型不收敛，不要一上来就怀疑代码，先检查数据是不是不可分。
4.3 线性不可分时，训练会永远停不下来
单层感知机最大的软肋，写在它的名字里：它只能处理线性可分数据。经典反例是异或（XOR）：四个样本两两交错，无论怎么画直线，都不可能把 0 和 1 分开。
拿生活打比方，就像一张纸上散落了两种颜色的点，同类点分布在斜对角，你要用一把直尺把它们分开，挪来挪去总会误伤一个。感知机的更新规则会在几组样本之间来回震荡，错误数始终不会降到 0，训练自然停不下来。
所以碰到感知机训练迟迟不收敛，第一反应不是调学习率，而是检查数据是否线性可分。可以在最大轮数内打印错误数，如果它一直维持在一个较高水平震荡，大概率就是数据本身不可分。这时需要的是多层网络和非线性激活函数，而不是更长的训练时间。
4.4 快速排查表：现象、原因与处理方案
| 现象 | 可能原因 | 排查/处理 |
|---|---|---|
| 训练永远不收敛 | 数据线性不可分，或特征、标签喂错 | 画出样本分布看是否线性可分；检查数据预处理 |
| 错误数先升后降 | 感知机正常训练现象 | 不要用单轮错误数判断好坏，看最终是否收敛 |
| z = 0 时样本被判错 | 边界约定不一致 | 统一使用 y_hat = 1 if z > 0 else 0 |
| 权重和手算不一致 | 样本顺序或学习率不同 | 感知机的解不唯一，数据可分即可 |
| 加了偏置 b 还是分不开 | 数据本身线性不可分 | 换多层模型，或先用线性可分数据验证代码 |
| 权重更新后错误数反而暴增 | 可能初始权重太大或 lr 过大 | 初始化权重为 0，lr 设为 1 重新验证 |
4.5 一点实操心得
我自己的体会是，理解感知机最好的方式就是拿一支笔，盯着一张小表格算三轮以上。第一次算会很容易漏掉“delta = 0 时不更新”这个条件，因为你觉得反正权重没变，好像没关系；但漏掉判断会导致错误数统计不准确，影响收敛判断。
还有一个容易被忽略的细节是偏置 b 的更新。很多人算权重算得勤快，偏置却忘记跟着 delta 一起动。实际上 b 的更新规则和权重几乎一样，只是它的输入恒为 1，所以每发生一次错误，b 就要加上 lr * delta。没有 b，决策边界只能穿过原点，逻辑与这种边界不过原点的任务根本学不出来。
代码调试时，我习惯在 fit 循环里每轮打印一次全部权重和偏置，而不是只在结束后打印。这样一旦某一步和手算对不上，能立刻定位是在哪个样本的更新时跑偏的。
5. 从感知机往后看：理解神经网络的关键跳板
5.1 单层感知机的天花板：XOR 与线性不可分
前面用逻辑与举例是线性可分数据里最简单的代表。但单层感知机能干的事也就到此为止了。一旦数据像 XOR 那样需要非线性分割，单层感知机就束手无策。这个事实曾经给早期神经网络研究泼过一盆冷水，直到后来人们引入隐藏层和非线性激活函数，多层感知机才重新把表达能力打开。
现在的深度学习模型动辄几百万参数，但根基仍然是“线性加权求和 + 非线性激活函数 + 误差反向传播”。感知机让我理解到，哪怕是最简单的模型，也有自己清晰的归纳偏好和边界。在盲目堆参数之前，先把基础模型的脾气摸透，后面调试复杂模型会少走很多弯路。
5.2 错误驱动到梯度下降：视角的转换
如果只把感知机当分类器，你可能会觉得它有点“过时”。换个角度看，感知机的错误驱动更新，本质上是最小化分类错误数的随机梯度下降的一种特例。区别在于感知机用的是 0-1 损失，阶跃函数的梯度要么不存在，要么为 0，所以更新规则更像“错则修正”的硬性规则，而不是“按梯度方向挪一小步”。
当我后来学逻辑回归、softmax 和反向传播时，发现只要把阶跃函数换成可导的 sigmoid 或 softmax，再把“错误驱动”换成“梯度下降”，整个训练过程就平滑多了。此时再回头看感知机的更新公式，会觉得它像一束光，把神经网络训练的底层逻辑照得清清楚楚。
5.3 两个练手任务，把知识变成本能
如果你想确认自己真学会了，我建议做两个练习。
第一个练习：换个样本顺序，手算逻辑与的感知机训练，看看最终权重是否和本文不同，但依然能把数据分开。这个练习能帮你理解“解不唯一”和“样本顺序敏感”。
第二个练习：用代码实现一个判别函数，判断数据集是否线性可分，然后拿 XOR 数据集试试，观察感知机的错误数是否一直在震荡。这个练习能帮你建立“线性可分”和“收敛性”之间的直觉。
这两个练习做完，感知机就不只是你背下来的公式，而是一条你亲手验证过的规律。
实际上我每次回顾感知机的训练过程，都会觉得它把“学习”这个词的朴素版本演得很生动。没有复杂的数学，没有精巧的工程，就是一个简单的规则被反复应用，最后涌现出有用的边界。如果你也照着上面的步骤手算过一遍，再跑一遍代码，你应该会同意：感知机不难，但它是理解后续一切模型的好起点。就算现在主流框架里已经很少单独用感知机解决实际问题，我还是建议每个人都亲手推一次它——那笔账算完，你会对权重更新、错误驱动和收敛条件产生远比读十篇教程更深的肌肉记忆。
