从零手写前馈神经网络：Numpy实现XOR异或分类全解析

XOR异或问题，几乎是我见过最适合用来理解前馈神经网络和反向传播的小实验了。网上教程一抓一大把，但真到自己动手写代码时，很多人会卡在同一个地方：单层感知机学不了XOR，换成两层网络又不知道权重怎么初始化、激活函数选哪个、损失函数为什么一直不降。这篇文章我打算把整个“前馈神经网络求解XOR”的链路完整梳理一遍，从为什么单层网络不行，到2层网络的结构设计、数学原理、Numpy手写实现、超参数调试，再到常见问题的排查，全部展开讲。对刚接触深度学习的读者来说，把这个项目吃透，等于亲手把神经网络最核心的那层“窗户纸”捅破了。

我会尽量少讲空泛的概念，多放能直接跑起来的代码和踩坑经验。即使你之前只写过Python、没碰过任何深度学习框架，跟着这篇文章一步步走，也能从零搭出一个能正确分类XOR的小网络。

1. 项目概述：一个看似简单却能卡住无数新手的分类任务

1.1 XOR到底是什么

XOR全称是 exclusive OR，也就是“异或”。它接收两个二进制输入（0或1），当两个输入不同时输出1，相同时输出0。真值表非常简单：

听起来是不是很简单？就是四个样本，分两类。但麻烦的地方在于，这四个点在二维平面上的位置很特殊：两个输出1的点（0,1）和（1,0）位于一条对角线上，两个输出0的点（0,0）和（1,1）位于另一条对角线上。你想用一条直线把它们分开，是永远做不到的。这个问题后来成了神经网络历史上一个著名的反例，也是深度学习入门绕不开的“Hello World”。

1.2 单层感知机为什么搞不定它

在神经网络里，一个最简单的单层感知机，本质就是学一条直线。输出可以写成 y = w1 * x1 + w2 * x2 + b，然后过一个阶跃函数或者Sigmoid函数。它能做的只是在平面上找一条直线，把两类点分开。可XOR问题的四个点是“对角分布”的，比如（0,0）和（1,1）是一类，（0,1）和（1,0）是另一类，不管怎么画直线，总会有一两个点被分错。

上世纪60年代，Minsky和Papert在《感知机》这本书里就明确指出了一个点：单层感知机连XOR都学不了。这个结论当时给神经网络研究浇了一盆冷水，直接导致相关研究进入低谷。今天我们再回头看，这个问题的本质是“线性不可分”。要解决它，不能靠一条直线，而需要把原始特征空间做一次非线性变换，让原本纠缠在一起的数据在新的空间里变得线性可分。

1.3 为什么用前馈神经网络，适合谁参考

前馈神经网络（Feedforward Neural Network）之所以能解决XOR，关键在于它加入了至少一层隐藏层，并且在隐藏层使用了非线性激活函数。网络会把输入先映射到一个新的特征空间，比如把二维坐标变成隐藏层神经元上的激活值，然后在输出层再做一次线性分类。整个过程不需要我们手工设计特征，网络自己就能通过反向传播学到合适的映射关系。

这个小项目特别适合这几类人：刚开始学深度学习、对反向传播只知道公式但没动手推导过的初学者；准备面试机器学习岗位、想用一个经典例子把神经网络原理讲清楚的人；以及那些已经会用TensorFlow或者PyTorch搭模型，但从未手写过梯度下降细节的开发者。我认为，哪怕你已经会用框架了，也值得用Numpy手写一次这个项目，因为手写一遍之后，你对“模型到底在更新什么参数”“梯度是怎么流回去的”会有完全不同的理解。

2. 网络设计与核心原理分析

2.1 网络结构怎么选：2-2-1还是2-4-1

针对XOR问题，可以使用一个最简单的两层前馈神经网络，也就是“输入层2个节点、隐藏层若干节点、输出层1个节点”。最常用的结构是2-2-1，即隐藏层放2个神经元。它一共有多少个可训练参数？

• 输入层到隐藏层：W1 是 2x2 的矩阵，b1 是 2 个偏置，共 4+2=6 个参数。
• 隐藏层到输出层：W2 是 2x1 的矩阵，b2 是 1 个偏置，共 2+1=3 个参数。
• 合计9个参数。

这个规模非常小，特别适合用来手动推导和观察训练过程。当然，你也可以把隐藏层改成4个神经元，变成2-4-1结构，参数数量变成 2x4+4+4x1+1=17个。理论上隐藏层神经元更多，网络容量更大，XOR这种小问题会更容易收敛。但隐藏层神经元太多也会带来一个新问题：模型容量过剩，训练时容易进入一些比较奇怪的局部最优解，反而可能导致输出不稳定。我个人的建议是先用2-2-1把核心原理跑通，再去尝试2-4-1对比效果。

2.2 激活函数怎么选：Sigmoid、Tanh还是ReLU

XOR问题里最关键的设计决策就是隐藏层的激活函数。因为如果隐藏层用线性激活函数，整个网络叠加起来还是线性的，那和单层感知机没有本质区别。所以必须引入非线性。选哪种非线性其实有讲究：

• Sigmoid：输出范围0到1，处处可导，是经典选择。但它的导数最大值只有0.25，在反向传播中连续相乘后梯度很容易变小，收敛速度偏慢。
• Tanh：输出范围-1到1，均值为0，梯度最大值是1，收敛速度通常比Sigmoid快，是这个小项目里我非常推荐的选择。
• ReLU：在正区间梯度恒为1，计算简单。但它有个“神经元死亡”的问题：如果某个神经元输出进入负区间，梯度就变成0，后续再也无法更新。在XOR这类小规模任务里，ReLU偶尔也能跑通，但稳定性不如Tanh。

输出层我通常会选Sigmoid，因为我们要输出一个0到1之间的概率，用它来表示分类信心非常自然。你也可以直接用Tanh，然后认为输出大于0就算类别1，但那样损失函数和概率解释都会绕一点。

2.3 损失函数和优化器怎么搭配

二分类问题最常用的损失函数是交叉熵（BCE）。输出层如果是Sigmoid，配合交叉熵损失，反向传播出来的梯度形式非常简洁，几乎没有“梯度饱和”问题。这里我顺便解释一下为什么不用均方误差（MSE）：Sigmoid加MSE会让输出接近0或1的时候导数变得很小，训练后期会出现梯度消失，收敛很慢。交叉熵在这种组合下能够保证输出错误越大梯度越大，学习效率明显更高。

优化器这里不需要太复杂，直接用最朴素的梯度下降（Batch Gradient Descent）就行。因为整个数据集只有4个样本，一次迭代完全可以把全部样本都看一遍，然后求平均梯度更新一次。这样便于观察每一次迭代的损失变化。如果你用随机梯度下降（SGD）一次只看一个样本，反而会因为样本之间梯度方向差异过大，出现损失上下震荡的情况。

2.4 前向传播和反向传播的计算过程

前向传播很好理解。输入 x，经过第一层线性变换 z1 = x * W1 + b1，然后通过非线性激活函数 a1 = tanh(z1)。接着再做二次线性变换 z2 = a1 * W2 + b2，最后经过Sigmoid得到预测值 y_pred。整个过程就是数据的逐层传递。

反向传播稍微绕一点，但核心就是高数里的链式法则。我们已知损失函数 L 对输出 y_pred 的梯度，然后逐层向前计算损失对每一层参数的偏导。对于输出层的 Sigmoid 加 BCE 的结构，有个非常著名且好用的结论：损失对 z2 的梯度等于 y_pred - y_true。就是说，预测值和真实值之间的差，直接就是输出层线性输出的梯度方向。得到这个之后，再把它往隐藏层传：先对 W2 求梯度，再把梯度从输出层神经元传到隐藏层神经元的激活输出 a1，最后乘以 tanh 的导数（1 - a1^2），就得到了隐藏层的误差信号。整个过程看着公式多，但落到代码里就是矩阵乘法和逐元素乘法。

3. 从零开始用Numpy实现前馈神经网络

3.1 准备数据集

XOR的数据集只有4个样本，不需要任何预处理。

import numpy as np X = np.array([ [0, 0], [0, 1], [1, 0], [1, 1] ], dtype=np.float64) y = np.array([[0], [1], [1], [0]], dtype=np.float64)

这里我特意把 y 的维度保持成 (4, 1)，因为后面做矩阵运算时，每个列向量对齐会省掉很多麻烦。很多初学者喜欢把 y 写成 (4,) 的一维数组，然后训练时控制台不断报维度不匹配的错。所以从一开始就养成“每个样本一行、每个输出一列”的习惯比较好。

3.2 权重初始化关键点

权重初始化在XOR问题里非常重要。如果你把所有权重初始化为0，那么所有隐藏层神经元收到完全相同的梯度，无论训练多久，两个隐藏神经元的输出都会完全一样，这叫做“对称性问题”，网络实际上退化成只有一个神经元在学，根本学不会XOR。

我的初始化方法是：权重在 [-1, 1] 之间均匀随机分布，偏置初始化为0。XOR问题的输入范围很小，所以权重范围不用设太大。如果你用别的范围，比如 [0, 1] 的正值，可能也能跑通，但收敛速度会有差别。为了让结果可复现，我会固定一个随机种子，比如 np.random.seed(42)。

np.random.seed(42) hidden_size = 2 input_size = 2 output_size = 1 W1 = np.random.uniform(-1, 1, (input_size, hidden_size)) b1 = np.zeros((1, hidden_size)) W2 = np.random.uniform(-1, 1, (hidden_size, output_size)) b2 = np.zeros((1, output_size))

3.3 前向传播与损失计算

前向传播的代码比较直白，每一步都对应前面讲过的公式。我会把每一层的中间变量都保存下来，因为反向传播时要用。

def sigmoid(x): return 1.0 / (1.0 + np.exp(-x)) def tanh(x): return np.tanh(x) def forward(X, W1, b1, W2, b2): z1 = X.dot(W1) + b1 a1 = tanh(z1) z2 = a1.dot(W2) + b2 a2 = sigmoid(z2) return z1, a1, z2, a2

计算损失时，为了数值稳定，我不会直接用 log(y_pred) 这种形式，而是给 y_pred 加一个极小值 eps 防止取对数时出现无穷大。这是实际写代码时一个容易被忽略的细节。

def compute_loss(y_true, y_pred): eps = 1e-8 return -np.mean( y_true * np.log(y_pred + eps) + (1 - y_true) * np.log(1 - y_pred + eps) )

3.4 反向传播与参数更新

反向传播是手写版本里最容易出错的环节。我先把2000行的推导浓缩成几行代码，但每一行都和前面第2.4节的公式对应。如果你第一次写，建议对照公式逐行看。

def backward(X, y_true, a1, a2, W2): m = X.shape[0] # 输出层梯度：BCE + Sigmoid 化简为 y_pred - y_true dz2 = a2 - y_true dW2 = a1.T.dot(dz2) / m db2 = np.sum(dz2, axis=0, keepdims=True) / m # 隐藏层梯度 da1 = dz2.dot(W2.T) dz1 = da1 * (1 - a1 ** 2) # tanh 的导数 dW1 = X.T.dot(dz1) / m db1 = np.sum(dz1, axis=0, keepdims=True) / m return dW1, db1, dW2, db2

注意这里所有梯度都除以了样本数 m，得到的是平均梯度。因为数据集只有4个样本，平均梯度更稳定。参数更新时，我用的学习率是1.0。看到这里你可能会觉得1.0太大了，但在全量梯度下降、数据集只有4条的情况下，这个学习率综合看其实挺合适。如果学习率太小，比如0.1，要训练更久才收敛；如果太大，比如5.0，损失会来回震荡。

learning_rate = 1.0 epochs = 5000 for epoch in range(epochs): z1, a1, z2, a2 = forward(X, W1, b1, W2, b2) loss = compute_loss(y, a2) dW1, db1, dW2, db2 = backward(X, y, a1, a2, W2) W1 -= learning_rate * dW1 b1 -= learning_rate * db1 W2 -= learning_rate * dW2 b2 -= learning_rate * db2 if epoch % 1000 == 0: print(f"epoch {epoch}, loss {loss:.6f}")

3.5 训练结果和预测逻辑

我实际运行时，固定随机种子为42，上面这组代码大概几十个epoch后损失就降到了一个很低的值。5000轮训练结束时，预测输出大概是这样的：

准确率100%。而且关键是在于模型输出已经非常接近0或1，不是模棱两可的0.5附近，说明网络没有“躺平”，而是真正学到了XOR的非线性边界。

如果你手写代码跑出来发现输出是0.5、0.5、0.5、0.5，那大概率是反向传播公式写错了，或者学习率太小、epoch不够。别急着调参，先去检查梯度。我在后面第5节会专门讲这个排查过程。

3.6 如果用PyTorch或Keras会怎样

如果你只是想验证原理，用框架肯定更省事。PyTorch版的核心就是定义两层全连接网络，然后自动求导。但这里我想说一句可能会被喷的话：框架把梯度计算完全自动化，所以很多人跑通了XOR，却根本不知道梯度是怎么流回W1的。这也就是我一直建议至少手写一次Numpy版本的原因。框架版本适合用来做“验证”，不适合用来替代“理解”。

如果你实在没耐心手写，可以用以下思路在PyTorch里实现：网络是2层Linear，隐藏层激活用Tanh，输出层接Sigmoid，损失函数用BCEWithLogitsLoss。注意BCEWithLogitsLoss内部已经包含了Sigmoid，所以网络最后一层不要再手动加Sigmoid。训练5000轮，同样能得到100%准确率。这个坑我在刚开始用PyTorch时就踩过，加了Sigmoid又用BCEWithLogitsLoss，导致输出范围不对，损失一直不降。

4. 训练实战：超参数如何影响收敛效果

4.1 学习率为什么是最敏感的超参数

XOR问题因为样本少，学习率对训练的影响比很多大型任务更明显。我自己做过一组对比试验，在2-2-1结构下，学习率分别设为0.1、1.0、5.0，每1000个epoch记录一下损失：

学习率5.0时，权重每次更新幅度太大，导致损失在初始值附近来回横跳。这就像你在下山时步子迈得太大，每一步都是从山的一侧跳到另一侧，始终下不到谷底。遇到这种情况，优先把学习率降到1.0以下，再把epoch数拉长。

4.2 随机种子和初始化的重要性

很多人跑XOR时会遇到一个很迷的现象：同一份代码，这次训练成功了，下次换了随机种子，损失就卡在0.69附近不下降。这不是代码写错了，而是初始权重恰好落到了一个比较尴尬的局部最优点或者“鞍点”附近。

我建议你同时初始化多组不同随机种子，观察损失曲线的分布。在Numpy版中一张非常实用的做法是：写一个循环，分别用seed=0到seed=9初始化，训练相同的epoch，记录准确率。你大概率会发现其中几组收敛得很快，另外几组需要更多轮次。对于只有9个参数的小网络，这不是bug，而是优化问题的常态。做好种子管理，是保证实验可复现的基本功。

4.3 隐藏层节点个数真的越多越好吗

2-2-1结构的隐藏层只有2个神经元，2-4-1结构有4个。在XOR任务上，2-4-1通常更容易收敛，因为容量大，网络更容易找到满足条件的映射关系。但隐藏层神经元过多也存在一个现象：训练时能快速降到很低的损失，但中间层某些神经元的输出可能变得非常极端，比如始终是-0.9999，其实就是这个神经元几乎不参与计算了。

从解决XOR的角度看，两种结构都能做到100%准确率，差别只在训练难度。我的建议是：新手从2-2-1开始，虽然它更“倔”，但正因为不够宽裕，你才需要认真调整学习率、初始化、epoch这些参数，反而能加深理解。等跑通之后，再用2-4-1对比一下收敛速度。

4.4 激活函数对收敛的影响实测

我分别用 Tanh、Sigmoid、ReLU 作为隐藏层激活函数，保持其他条件完全一致，测试了2000轮训练后的表现：

Sigmoid收敛偏慢，是因为它的导数最大只有0.25，反向传播梯度在隐藏层很容易被压缩。ReLU在这里表现不佳，主要是因为部分神经元进入了负区间，梯度变成0，网络实际有效参数变少了。Tanh在这里表现最好，既有非线性，梯度范围又更大。所以这个小项目里，隐藏层激活函数首选Tanh，输出层用Sigmoid。

4.5 决策边界是什么样的

XOR的决策边界很有意思。训练完成后，把二维平面上的点从 -0.5 到 1.5 均匀采样，输入网络得到预测输出，你会发现模型输出的形状不是一条直线，而是两个对角方向上的高概率区域。说白了，网络学到的是把（0,1）和（1,0）这两个点附近的区域识别为类别1，把（0,0）和（1,1）附近的区域识别为类别0。

如果你想可视化，可以先用网格生成数据，通过训练好的网络得到每个网格点的预测值，再用matplotlib的contourf画等高线图，最后把4个原始点叠加折线图。看到那个“X”形决策区域出现的时候，你会对“隐藏层做了非线性特征变换”有真正的体感认识。

5. 常见问题与排查技巧实录

5.1 损失一直停在0.69附近

这是最典型的问题。0.69约等于 ln(2)，也就是模型输出稳定在0.5时交叉熵损失的值。出现这种情况，基本可以判断网络没有学到任何有效特征。排查顺序我建议是：先检查标签维度，再确认反向传播公式，最后换一组随机种子。你也可以把前向传播的结果打印出来，看看隐藏层输出 a1 是否都是同一个值。如果两个隐藏神经元的输出几乎一样，就是初始化对称性或者网络退化的问题。

5.2 输出全部接近0.5，像“没训练”

这种情况很多是学习率太小或者epoch太少。XOR只有4个样本，但优化过程依然需要足够的迭代次数。如果你设了0.01的学习率，那么哪怕是5000轮也可能只走了很小的一段距离。先把学习率提到0.5或1.0试试，如果损失开始明显下降，就说明之前是学习率太低了。如果学习率已经很大，损失还是不动，那就去检查一下梯度数值：在反向传播后打印 dW1 的绝对值，如果全部接近0，梯度流断了，大概率是激活函数选择或公式计算的问题。

5.3 梯度消失导致隐藏层权重几乎不更新

使用Sigmoid隐藏层时，梯队消失很容易发生。Sigmoid的导数最大0.25，当神经元输出位于0或1附近时，导数近乎0，反向传播到隐藏层的梯度几乎消失。解决方法是换用Tanh或ReLU。我在自己调试时有个习惯，每训练100轮打印一次梯度的均值，一旦发现梯度数量级从1e-2掉到1e-7，基本就是梯度消失了。学会了看梯度，很多玄学问题都能变成可定位的问题。

5.4 准确率停在75%，总是错一个点

XOR一共4个样本，75%意味着模型稳定地错掉其中1个。这种情况通常不是初始化问题，而是网络陷入了一个局部最优解：比如它把所有样本都预测成标签更多的那一类的概率分布。虽然XOR比较简单，但凸性并不存在，梯度下降完全可能走进一个局部浅谷。解决方法是换随机种子、增大神经网络宽度或者提高学习率，让优化过程有更大几率跳出浅谷。

5.5 多次运行结果不一致，怎么复现

没有固定随机种子，即使代码完全一样，运行两次得到的初始权重也不同，最终训练结果会有细微差别。为了可复现，在所有随机操作之前加上 np.random.seed(42) 只是第一步；如果你使用了框架，还需要设置 torch.manual_seed(42) 或 tf.random.set_seed(42)。固定种子之后，同一份代码在同一环境下应该能得到完全一致的结果。如果换了环境还要求完全一致，就得再限制更多底层随机源，但对XOR这种任务完全没必要。

5.6 一个容易忽略的维度陷阱

写Numpy版时，最容易报错的不是公式，而是矩阵维度。比如计算 a1.T.dot(dz2) 时，a1 是 (4,2)，dz2 是 (4,1)，转置后变成 (2,4)，点乘 (4,1) 得到 (2,1)，正好和 W2 形状相同。很多人因为一开始把 y 写成一维 (4,)，dz2 就变成 (4,)，再往下点乘就乱了。所以我建议所有中间变量都保持二维矩阵形状，哪怕样本数只有一个。这会让你少调很多bug。

6. 延伸思考：从XOR到更大规模的分类任务

6.1 为什么把XOR称为深度学习的“Hello World”

XOR虽然简单，但它同时包含了神经网络中最核心的几个要素：非线性激活、隐藏层、反向传播、梯度下降。把XOR吃透，并不是因为你以后要处理的问题都这么小，而是因为优化过程中的现象是相通的。比如局部最优、梯度消失、初始化敏感性，在大模型训练里换个名字一样存在。理解XOR的收敛机制，能帮你建立一种“诊断模型为什么学不好”的思路。以后哪怕面对百万级数据，你也会下意识地先看损失曲线、再看梯度量级、再检查数据维度，而不是盲调超参数。

6.2 异或运算在其他领域的影子

异或运算本身在计算机领域出现频率极高，比如奇偶校验、加密算法、状态切换。如果你刷过一些CTF平台，像BUUCTF、GKCTF里会有不少以xor命名的逆向或密码题，基本上就是拿一个未知key对flag逐字节做异或，你需要根据已知明文或统计特征把key逆推出来。那和这里用神经网络学XOR不是一回事，但两者都说明同一个点：XOR这种“非线性开关”特性在计算机底层无处不在。理解这点之后，你对二进制的位运算会更有感觉。

6.3 给新手的几个实操建议

第一个建议是别只改参数，一定要学会“观察过程”。每500轮打印一次损失，甚至打印隐藏层输出，训练过程就会从黑盒变成白盒。第二个建议是手推一遍反向传播，哪怕只在纸上把2-2-1网络的每一个梯度算一遍，收获也比刷十遍网课大得多。第三个建议是跑通Numpy版后，再用PyTorch或Keras复现，比对两种实现下训练曲线的差异——框架帮你省掉的是积分，不是理解。

如果你能按照这篇文章的步骤完整走下来，亲手看到一个两层小网络的决策边界变成“X”形，那你对前馈神经网络的直觉就已经超过很多只会调包调参的人。接下来再去学CNN、RNN或者Transformer，你会发现它们本质上仍然是在做“特征变换加参数学习”这件事，只是结构更复杂、数据规模更大而已。

我自己在重复做这个项目的过程中，最大的收获其实不是学会了XOR本身，而是建立了“出现问题先看梯度、再调超参数”的调试习惯。以前遇到模型不收敛，第一反应就是堆层数、加轮数，现在我会先打印中间梯度，确认信息流到底断在哪里。这种从玄学调到理性调的思路转变，才是这个小项目最值钱的地方。