从零实现神经网络：用NumPy手写前向传播与反向传播

1. 项目概述：从零搭建一个可运行的神经网络

如果你对“神经网络”这个词既感到好奇又有点望而生畏，觉得它背后是深奥的数学和复杂的框架，那今天这篇分享或许能改变你的看法。我的目标很简单：不依赖任何深度学习框架（比如TensorFlow或PyTorch），只用最基础的Python和NumPy库，从数学原理开始，亲手搭建一个能真正学习、能做出预测的神经网络。这个过程就像在搭乐高，我们得先理解每一块积木（神经元、权重、激活函数）的形状和作用，再把它们按照特定的结构（前向传播、反向传播）组装起来，最终让这个结构具备“智能”。

这个项目适合所有对机器学习有初步兴趣，并且具备基本Python编程能力的朋友。无论你是想夯实基础的学生，还是希望理解模型“黑箱”背后机制的开发者，通过亲手实现一遍，你会对梯度下降、损失函数、链式法则这些核心概念有刻骨铭心的理解。这远比调用几行model.fit()来得深刻。我们将实现一个经典的多层感知机（MLP），用它来学习一个简单的模式（比如异或问题），并附上每一行都有详细注释的完整代码。你会发现，神经网络的本质，其实就是一连串精心设计的矩阵运算和梯度计算。

2. 核心原理拆解：神经网络的“发动机”是如何工作的

在动手写代码之前，我们必须把核心的数学原理捋清楚。一个最简单的神经网络，主要由三部分构成：输入层、隐藏层（至少一层）、输出层。信息从输入层流入，经过隐藏层变换，最终从输出层产生结果，这个过程叫前向传播。而让网络能够学习的关键，则是反向传播算法，它负责根据预测结果和真实值之间的误差，来调整网络内部的参数。

2.1 前向传播：信息是如何流动的

前向传播就是一次计算预测值的过程。我们以单隐藏层网络为例，假设输入数据X是一个矩阵，隐藏层有n_hidden个神经元，输出层有n_output个神经元。

1. 输入到隐藏层：输入数据X首先与权重矩阵W1相乘，再加上偏置向量b1，得到隐藏层的加权输入Z1 = X · W1 + b1。这里的W1的维度是(n_input, n_hidden)，它决定了每个输入特征对每个隐藏神经元的重要性。
2. 激活函数引入非线性：直接使用Z1是线性的，多个线性变换叠加依然是线性变换，无法拟合复杂模式。因此，我们需要一个非线性激活函数，比如Sigmoid或ReLU。我们计算隐藏层的激活值A1 = activation_function(Z1)。非线性激活函数是神经网络能够逼近任意函数的基础。
3. 隐藏层到输出层：将A1视为新的输入，与输出层权重W2相乘并加上偏置b2，得到输出层的加权输入Z2 = A1 · W2 + b2。
4. 输出层激活：对于不同的任务，输出层的激活函数不同。比如二分类问题常用Sigmoid（将输出压缩到0-1之间，表示概率），多分类用Softmax，回归问题则可能不用激活函数（线性输出）。我们得到最终的预测输出A2 = output_activation(Z2)。

注意：权重矩阵的初始化至关重要。不能全部初始化为0，否则所有神经元在反向传播时会获得相同的梯度，导致对称失效，无法学习。通常采用小的随机数，比如np.random.randn(*shape) * 0.01。

2.2 反向传播与梯度下降：网络是如何学习的

网络做出了预测A2，但一开始肯定不准。我们需要一个标准来衡量“不准”的程度，这就是损失函数（Loss Function）。例如，对于二分类的交叉熵损失为：L = - (y * log(A2) + (1-y) * log(1-A2))的平均值。我们的目标就是通过调整W1, b1, W2, b2，让损失L最小化。

梯度下降告诉我们：要最小化一个函数，就沿着它梯度的反方向更新参数。梯度指向函数增长最快的方向，反方向就是下降最快的方向。反向传播，就是高效计算损失函数对于网络中每一个参数（W, b）的梯度（偏导数）的算法。它巧妙地利用了链式法则，从输出层开始，逐层向后（反向）传播误差，并计算梯度。

以输出层权重W2的梯度计算为例：

1. 计算损失L对网络输出A2的梯度：dA2。
2. 根据A2的激活函数（如Sigmoid），计算A2对其输入Z2的梯度：dZ2 = dA2 * activation_derivative(Z2)。
3. 根据Z2 = A1 · W2 + b2，利用链式法则，L对W2的梯度dW2就等于A1.T · dZ2（这里A1.T是A1的转置）。同理，L对b2的梯度db2就是dZ2在样本维度上的求和（因为偏置对每个样本的贡献一样）。

得到梯度dW2, db2后，我们就可以用最朴素的梯度下降法更新参数：W2 = W2 - learning_rate * dW2。learning_rate（学习率）是一个超参数，控制每次更新的步长，太小则学习慢，太大可能无法收敛甚至发散。

隐藏层参数W1, b1的梯度计算过程类似，只是误差信号需要从dZ2继续通过W2反向传播到A1，再传播到Z1，最终得到dW1和db1。这个过程就像一层层地将输出层的“责任”（误差）分配回前面的层。

3. 关键组件实现：激活函数、损失函数与初始化

理解了原理，我们就可以用代码把这些核心组件实现出来。这些函数将是我们神经网络类的基石。

3.1 激活函数及其导数

激活函数给网络引入了非线性。这里我们实现两个最常用的：

import numpy as np def sigmoid(x): """Sigmoid激活函数，将输入压缩到(0,1)区间。""" return 1 / (1 + np.exp(-x)) def sigmoid_derivative(x): """Sigmoid函数的导数，用于反向传播。 注意：这里的输入x是sigmoid函数的输出值，即a=sigmoid(z)。 根据求导公式，da/dz = a * (1 - a)。 """ return x * (1 - x) def relu(x): """ReLU激活函数，解决Sigmoid的梯度消失问题，加速收敛。""" return np.maximum(0, x) def relu_derivative(x): """ReLU函数的导数：输入大于0时为1，否则为0。""" return (x > 0).astype(float)

实操心得：在反向传播计算梯度时，我们通常已经得到了该层的激活值输出A。对于Sigmoid，直接用A * (1 - A)计算导数效率最高，无需重复计算sigmoid(z)。对于ReLU，导数计算更简单，但需要注意“死亡ReLU”问题，即某些神经元可能永远不被激活。有时使用Leaky ReLU（np.maximum(0.01*x, x)）可以缓解。

3.2 损失函数及其导数

损失函数衡量预测值与真实值的差距。我们实现均方误差（MSE，常用于回归）和交叉熵损失（用于分类）：

def mse_loss(y_true, y_pred): """均方误差损失，适用于回归问题。""" return np.mean((y_true - y_pred) ** 2) def mse_loss_derivative(y_true, y_pred): """MSE损失对预测值y_pred的导数。""" return -2 * (y_true - y_pred) / y_true.size def binary_cross_entropy_loss(y_true, y_pred): """二分类交叉熵损失。 为了防止log(0)导致数值问题，对y_pred进行数值稳定处理。 """ # 将y_pred限制在[epsilon, 1-epsilon]区间，避免log(0) epsilon = 1e-15 y_pred = np.clip(y_pred, epsilon, 1 - epsilon) return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred)) def binary_cross_entropy_loss_derivative(y_true, y_pred): """二分类交叉熵损失对预测值y_pred的导数。 推导后形式非常简洁：dL/dy_pred = (y_pred - y_true) / (y_pred * (1 - y_pred)) / n_samples 但同样需要数值稳定处理。 """ epsilon = 1e-15 y_pred = np.clip(y_pred, epsilon, 1 - epsilon) return (y_pred - y_true) / (y_pred * (1 - y_pred)) / y_true.size

注意事项：交叉熵损失函数中的对数计算在y_pred接近0或1时会产生极大的数值（趋于无穷），导致程序崩溃。因此，必须使用np.clip将预测值限制在一个很小的非零区间内（如[1e-15, 1-1e-15]），这是实现中的关键细节，也是新手常踩的坑。

3.3 参数初始化策略

参数的初始值不能随意设置。全零初始化会导致对称性问题，大的随机数可能导致梯度爆炸（尤其是配合Sigmoid时）。常见的策略有：

def initialize_parameters(n_input, n_hidden, n_output, initialization='he'): """ 初始化网络参数。 Args: initialization: 'random'（简单小随机数）, 'xavier'（适用于Sigmoid/Tanh）, 'he'（适用于ReLU）。 """ np.random.seed(42) # 设置随机种子，确保结果可复现 parameters = {} if initialization == 'random': # 简单缩放的小随机数 parameters['W1'] = np.random.randn(n_input, n_hidden) * 0.01 parameters['b1'] = np.zeros((1, n_hidden)) parameters['W2'] = np.random.randn(n_hidden, n_output) * 0.01 parameters['b2'] = np.zeros((1, n_output)) elif initialization == 'xavier': # Xavier/Glorot初始化，方差为 1/n_input scale = np.sqrt(1.0 / n_input) parameters['W1'] = np.random.randn(n_input, n_hidden) * scale parameters['b1'] = np.zeros((1, n_hidden)) scale = np.sqrt(1.0 / n_hidden) parameters['W2'] = np.random.randn(n_hidden, n_output) * scale parameters['b2'] = np.zeros((1, n_output)) elif initialization == 'he': # He初始化，方差为 2/n_input，专为ReLU设计 scale = np.sqrt(2.0 / n_input) parameters['W1'] = np.random.randn(n_input, n_hidden) * scale parameters['b1'] = np.zeros((1, n_hidden)) scale = np.sqrt(2.0 / n_hidden) parameters['W2'] = np.random.randn(n_hidden, n_output) * scale parameters['b2'] = np.zeros((1, n_output)) return parameters

为什么初始化这么重要？以Sigmoid函数为例，其导数在输入值很大或很小时会接近0（梯度饱和区）。如果初始权重过大，线性变换后的Z很容易落入饱和区，导致梯度极小，参数几乎无法更新，这就是“梯度消失”。He和Xavier初始化通过控制初始权重的方差，使得各层激活值的分布保持在合理的范围内，从而保障训练初期梯度的稳定流动。

4. 神经网络类的完整实现与训练流程

现在，我们将所有部分组装成一个完整的神经网络类。这个类将封装前向传播、反向传播和参数更新的所有逻辑。

4.1 神经网络类结构设计

我们设计一个NeuralNetwork类，它至少包含以下方法：

• __init__: 初始化网络结构（各层神经元数）、超参数（学习率、迭代次数）和参数。
• _forward_propagation: 执行一次前向传播，并缓存中间结果（Z, A）供反向传播使用。
• _backward_propagation: 执行一次反向传播，计算所有参数的梯度。
• _update_parameters: 使用梯度下降法更新参数。
• fit: 训练模型，在多个周期（epoch）内循环执行前向、反向传播和参数更新。
• predict: 使用训练好的模型进行预测。
• calculate_loss: 计算当前模型在给定数据上的损失。

下面是这个类的骨架和核心方法实现：

class NeuralNetwork: def __init__(self, n_input, n_hidden, n_output, learning_rate=0.1, epochs=10000, initialization='he'): """ 初始化神经网络。 Args: n_input: 输入特征数 n_hidden: 隐藏层神经元数 n_output: 输出层神经元数（二分类为1） learning_rate: 学习率 epochs: 训练迭代次数 initialization: 参数初始化方法 """ self.n_input = n_input self.n_hidden = n_hidden self.n_output = n_output self.lr = learning_rate self.epochs = epochs # 初始化参数 self.params = initialize_parameters(n_input, n_hidden, n_output, initialization) # 缓存，用于存储前向传播的中间结果，方便反向传播 self.cache = {} # 记录训练过程中的损失，用于可视化 self.loss_history = [] def _forward_propagation(self, X): """前向传播，并缓存中间结果。""" # 从参数字典中取出参数 W1, b1 = self.params['W1'], self.params['b1'] W2, b2 = self.params['W2'], self.params['b2'] # 输入层 -> 隐藏层 Z1 = np.dot(X, W1) + b1 # 线性变换 A1 = relu(Z1) # 非线性激活，这里隐藏层使用ReLU # A1 = sigmoid(Z1) # 也可以使用Sigmoid # 隐藏层 -> 输出层 Z2 = np.dot(A1, W2) + b2 A2 = sigmoid(Z2) # 输出层使用Sigmoid，将结果映射到(0,1)，适用于二分类 # 将中间结果存入缓存 self.cache['Z1'], self.cache['A1'] = Z1, A1 self.cache['Z2'], self.cache['A2'] = Z2, A2 return A2 def _backward_propagation(self, X, y, A2): """反向传播，计算损失关于所有参数的梯度。""" m = X.shape[0] # 样本数量 # 从缓存中取出前向传播的结果 A1 = self.cache['A1'] W2 = self.params['W2'] # 输出层的梯度计算 # 损失函数对A2的导数（交叉熵损失 + Sigmoid激活的组合导数有简化形式） # dL/dZ2 = A2 - y， 这是Sigmoid输出层配合交叉熵损失的一个优美性质 dZ2 = A2 - y dW2 = (1 / m) * np.dot(A1.T, dZ2) db2 = (1 / m) * np.sum(dZ2, axis=0, keepdims=True) # 隐藏层的梯度计算 dA1 = np.dot(dZ2, W2.T) # 隐藏层使用的是ReLU，其导数为1 (if Z1>0) else 0 dZ1 = dA1 * relu_derivative(self.cache['Z1']) # 如果隐藏层用的是Sigmoid，则应为：dZ1 = dA1 * sigmoid_derivative(A1) dW1 = (1 / m) * np.dot(X.T, dZ1) db1 = (1 / m) * np.sum(dZ1, axis=0, keepdims=True) # 将梯度存入字典 grads = {'dW1': dW1, 'db1': db1, 'dW2': dW2, 'db2': db2} return grads def _update_parameters(self, grads): """使用梯度下降更新参数。""" self.params['W1'] -= self.lr * grads['dW1'] self.params['b1'] -= self.lr * grads['db1'] self.params['W2'] -= self.lr * grads['dW2'] self.params['b2'] -= self.lr * grads['db2'] def fit(self, X, y, verbose=False, print_every=1000): """ 训练神经网络。 Args: X: 训练特征，形状 (n_samples, n_features) y: 训练标签，形状 (n_samples, n_output) verbose: 是否打印训练过程 print_every: 每隔多少轮打印一次损失 """ for i in range(self.epochs): # 前向传播 A2 = self._forward_propagation(X) # 计算损失（这里使用交叉熵损失） loss = binary_cross_entropy_loss(y, A2) self.loss_history.append(loss) # 反向传播 grads = self._backward_propagation(X, y, A2) # 更新参数 self._update_parameters(grads) # 打印进度 if verbose and i % print_every == 0: print(f"Epoch {i}, Loss: {loss:.6f}") def predict(self, X, threshold=0.5): """使用训练好的模型进行预测，并可根据阈值进行二分类。""" A2 = self._forward_propagation(X) # 将概率转换为类别（0或1） predictions = (A2 > threshold).astype(int) return predictions, A2 # 同时返回概率值 def calculate_accuracy(self, X, y): """计算模型在给定数据上的准确率。""" predictions, _ = self.predict(X) accuracy = np.mean(predictions == y) return accuracy

4.2 训练一个实例：解决异或（XOR）问题

异或问题是一个经典的线性不可分问题，单层感知机无法解决，但两层神经网络可以。这是一个完美的测试用例。

# 1. 准备数据：异或（XOR）问题的输入和输出 # 输入: (0,0)->0, (0,1)->1, (1,0)->1, (1,1)->0 X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) y = np.array([[0], [1], [1], [0]]) # 注意保持形状 (4, 1) # 2. 创建并训练神经网络 nn = NeuralNetwork(n_input=2, n_hidden=4, n_output=1, learning_rate=0.1, epochs=10000) nn.fit(X, y, verbose=True, print_every=2500) # 3. 评估模型 print("\n训练完成！") print("最终损失:", nn.loss_history[-1]) print("在训练集上的准确率:", nn.calculate_accuracy(X, y)) # 4. 查看预测结果 predictions, probabilities = nn.predict(X) print("\n输入样本:") print(X) print("预测概率:") print(probabilities) print("预测类别 (阈值=0.5):") print(predictions) print("真实标签:") print(y)

运行这段代码，你会看到损失随着训练轮数增加而稳步下降，最终准确率达到100%。网络成功学会了异或的逻辑。你可以尝试调整隐藏层神经元数量（n_hidden）、学习率（learning_rate）和训练轮数（epochs），观察它们对训练速度和结果的影响。

5. 高级话题与优化技巧

实现了一个基础版本后，我们可以探讨一些让神经网络更强大、更稳定的技术和概念。

5.1 处理过拟合：正则化与Dropout

当模型在训练集上表现很好，但在未见过的数据上表现很差时，就发生了过拟合。以下是两种常用技术：

1. L2正则化：在损失函数中增加一个惩罚项，等于所有权重平方和的乘以一个系数（λ）。这倾向于让权重值变小、更分散，从而简化模型。

   # 在损失计算中增加L2惩罚项 lambda_reg = 0.01 # 正则化强度 mse = np.mean((y_pred - y_true)**2) # 计算所有权重（W1, W2）的L2范数（平方和） l2_penalty = (lambda_reg / (2 * m)) * (np.sum(W1**2) + np.sum(W2**2)) loss = mse + l2_penalty # 在反向传播计算梯度时，需要加上正则化项的梯度 # 例如，dW2 原本是 dW2 = (1/m) * A1.T.dot(dZ2) # 加上L2正则化后：dW2 = (1/m) * A1.T.dot(dZ2) + (lambda_reg / m) * W2

2. Dropout：在训练过程中，随机“丢弃”（即暂时忽略）一部分神经元（例如50%）。这可以防止神经元之间产生复杂的协同适应，迫使网络学习更鲁棒的特征。在预测时，不使用Dropout，但要将所有神经元的输出乘以Dropout的保留概率（如0.5），以保持输出的期望值不变。

5.2 梯度下降优化器

我们之前使用的是最基础的批量梯度下降（Batch Gradient Descent），它使用整个训练集计算梯度，更新一次。这在大数据集上非常慢。更常用的变体有：

• 随机梯度下降（SGD）：每次只用一个样本计算梯度并更新，速度快，但波动大。
• 小批量梯度下降（Mini-batch GD）：折中方案，每次使用一个小批量（如32、64个）样本。这是工业界的标准做法。
• 带动量的SGD：在更新时不仅考虑当前梯度，还加入上一次更新的方向，有助于加速收敛并减少震荡。
• Adam：结合了动量（Momentum）和自适应学习率（RMSProp）的优点，是目前最流行、默认推荐的优化器。

在我们的简单实现中，可以尝试实现小批量梯度下降。需要在fit方法中增加数据打乱和分批的逻辑。

5.3 超参数调优实战

神经网络的性能极大地依赖于超参数的选择。没有银弹，需要系统性地尝试：

1. 网格搜索（Grid Search）：为每个超参数（如学习率、隐藏层大小、正则化强度）设定一组候选值，遍历所有组合。计算量大，但彻底。
2. 随机搜索（Random Search）：在超参数空间内随机采样。研究表明，对于某些对性能影响差异大的参数，随机搜索比网格搜索更高效。
3. 学习率衰减（Learning Rate Decay）：训练初期使用较大的学习率快速下降，后期使用较小的学习率精细调整。策略可以是每隔一定轮数将学习率乘以一个衰减因子（如0.95），或者根据验证集损失动态调整。

一个简单的学习率衰减可以这样加入训练循环：

initial_lr = 0.1 decay_rate = 0.95 decay_steps = 1000 for epoch in range(epochs): # 计算当前学习率 current_lr = initial_lr * (decay_rate ** (epoch // decay_steps)) # ... 前向传播、反向传播 ... # 在更新参数时使用 current_lr self.params['W1'] -= current_lr * grads['dW1'] # ...

6. 从零实现到实际应用的思考

亲手实现一遍之后，你可能会问：既然有TensorFlow、PyTorch这样成熟高效的框架，为什么还要从零开始？我的体会是，这个过程的价值不在于造一个比框架更好的轮子，而在于彻底理解车轮是如何转动的。

当你以后在使用高级API，遇到梯度消失、爆炸，或者模型不收敛时，你脑海中对反向传播链式法则的清晰图景，能帮助你快速定位问题。当你在调整学习率、初始化方法时，你能理解每一个选择背后的数学直觉。更重要的是，它消除了对深度学习“黑箱”的恐惧，让你明白，再复杂的模型，其基石也不过是微积分、线性代数和概率论。

当然，对于实际项目，我们绝对应该使用成熟的框架。它们提供了自动微分（无需我们手动推导梯度公式）、GPU加速、丰富的预训练模型和便捷的数据管道。从零实现的经历，会让你成为一个更自信、更深刻的使用者。你可以把这里的代码看作一个“教学用具”，它的使命是让你理解原理。理解了原理之后，就大胆地去用PyTorch的nn.Module和optim.Adam吧，那才是生产力工具。

最后，如果你想挑战自己，可以基于这个基础版本尝试以下扩展：增加更多的隐藏层（实现深度网络）、实现不同的优化器（如SGD with Momentum）、添加Batch Normalization层、或者尝试用这个网络解决一个更实际的小数据集分类问题（如鸢尾花数据集）。每一个扩展，都会让你对神经网络的理解更深一层。