当前位置：首页 > news >正文

从零实现两层BP神经网络：深入理解前向传播与反向传播原理

news 2026/8/26 10:21:01

1. 项目缘起：为什么需要手搓一个两层的BP神经网络？

在数学建模竞赛或者初涉机器学习的项目中，我们经常会遇到一个经典场景：拿到一份数据，需要预测一个连续值（比如房价、销量），或者进行分类（比如判断邮件是否为垃圾邮件）。这时候，很多人会第一时间想到调用现成的库，比如sklearn里的MLPRegressor或MLPClassifier，又或者是TensorFlow、PyTorch这些深度学习框架。几行代码，模型就搭好了，看起来非常高效。

但问题恰恰就出在这个“看起来”上。当你把模型提交上去，发现预测结果一塌糊涂，或者收敛速度慢得离谱，甚至直接梯度爆炸/消失的时候，你往往会陷入一种“黑盒”式的迷茫。你不知道是数据预处理出了问题，还是网络结构设计有缺陷，亦或是那个神秘的“学习率”参数没调对。因为你只是调用了model.fit(X, y)，中间发生了什么，你一无所知。

这就是我坚持认为，每一个想真正理解机器学习的人，都应该至少“手搓”一次最基础的前馈神经网络（Feedforward Neural Network）和它的反向传播（Backpropagation, BP）算法的原因。这个过程，就像学开车不能只学按按钮，还得知道离合器、油门和方向盘是怎么联动的一样。通过从零实现一个两层的BP网络（即只有一个隐藏层），你能彻底搞明白：

前向传播（Forward Propagation）：数据是如何从输入层，经过加权求和、激活函数，一层层传递到输出层的。你会亲手写出Z = W·A_prev + b和A = activation(Z)这样的计算。
损失函数（Loss Function）：模型预测的结果和真实值差距有多大？这个“差距”是如何被量化的（比如用均方误差MSE或交叉熵损失）？
反向传播（Backpropagation）：这是核心中的核心。损失是如何从输出层“反向”传递回去，并精确计算出每一层权重（W）和偏置（b）应该调整多少的。你会亲手推导并实现dW和db的计算公式。
参数更新：如何利用计算出的梯度（dW,db）和学习率，来更新网络的参数，完成一次学习迭代。

当你亲手用Python和NumPy把这些步骤都实现一遍后，你再去看sklearn或者PyTorch的文档，就会有一种“原来如此”的通透感。你不仅能更好地使用高级工具，更能独立地诊断和解决模型训练中遇到的大部分问题。今天，我们就来完整地走一遍这个过程，构建一个用于回归任务的两层BP神经网络。我会假设你有一些基础的Python和线性代数知识，但即使你是个新手，跟着步骤和注释，也一定能理解其精髓。

2. 蓝图设计：理解我们的两层神经网络架构

在动手写代码之前，我们必须先把我们要建造的“机器”的蓝图搞清楚。我们目标是构建一个经典的两层前馈神经网络。这里的“两层”指的是具有可学习参数的层，即一个隐藏层和一个输出层。输入层通常不计入层数，因为它只是接收数据，没有参数需要学习。

网络结构详解：

我们的网络将处理这样的数据流：假设我们有m个样本，每个样本有n_x个特征。那么输入数据X的形状就是(n_x, m)。这里采用列向量堆叠的表示法，是神经网络计算中的常见做法，便于利用矩阵运算进行批量处理。

第0层 - 输入层：有n_x个神经元，每个神经元对应输入数据的一个特征。这一层没有计算，只是将数据X传递给下一层。
第1层 - 隐藏层：这是我们网络的第一个可学习层。假设我们设置该层有n_h个神经元。
- 参数：权重矩阵W1和偏置向量b1。W1的形状是(n_h, n_x)，它的每一行对应隐藏层一个神经元对所有输入特征的连接权重。b1的形状是(n_h, 1)，它会通过广播机制加到每个样本的计算结果上。
- 计算：Z1 = np.dot(W1, X) + b1。这一步是线性变换。
- 激活：A1 = activation_function(Z1)。我们引入非线性激活函数（如tanh或ReLU），这是神经网络能够拟合复杂非线性关系的核心。A1的形状是(n_h, m)，它将作为下一层的输入。
第2层 - 输出层：这是我们网络的最后一层。对于回归任务，我们通常只设置一个输出神经元（预测一个连续值）。
- 参数：权重矩阵W2和偏置向量b2。W2的形状是(1, n_h)，b2的形状是(1, 1)。
- 计算：Z2 = np.dot(W2, A1) + b2。
- 激活：对于回归任务，输出层有时不使用激活函数（即恒等函数），有时使用Sigmoid（将输出约束到0-1）或tanh（约束到-1到1），这取决于你对输出值范围的要求。这里我们为了通用性，先使用Sigmoid，但会说明如何更改。A2 = sigmoid(Z2)，形状为(1, m)，这就是我们对m个样本的最终预测值。

为什么选择这个结构？

两层网络（一个隐藏层）在理论上已经被证明是“万能近似器”（Universal Approximator），只要隐藏层神经元足够多，它可以以任意精度逼近任何在紧凑子集上的连续函数。这对于解决数学建模中遇到的大部分非线性拟合问题已经足够了。更深层的网络虽然表达能力更强，但同时也带来了过拟合、梯度消失和计算成本增加等问题。从最简单的结构开始理解，是更稳妥的路径。

关键组件选择：

激活函数：隐藏层我推荐使用tanh或ReLU。tanh函数输出均值为0，在训练初期能使梯度更稳定，收敛速度通常比Sigmoid快。ReLU计算简单，能有效缓解梯度消失问题，是目前最流行的选择。输出层根据任务选择：二分类用Sigmoid，多分类用Softmax，回归任务可以不用或用Sigmoid/tanh（缩放输出）。
损失函数：对于回归任务，最常用的是均方误差（Mean Squared Error, MSE）。L = (1/m) * np.sum((Y - A2) ** 2)。我们的目标就是通过调整参数W1, b1, W2, b2来最小化这个损失L。
初始化：参数的初始化至关重要。不能简单地将W初始化为0，这会导致所有神经元对称更新，失去学习能力。通常采用“Xavier初始化”或“He初始化”。对于使用tanh的层，常用np.random.randn(shape) * np.sqrt(1/n_prev)，其中n_prev是上一层的神经元数。对于ReLU，常用np.random.randn(shape) * np.sqrt(2/n_prev)。

有了清晰的蓝图，我们就可以开始准备“施工材料”了。

3. 环境准备与工具函数编写

我们不需要任何复杂的深度学习框架，核心工具就是NumPy，它提供了高效的矩阵运算能力。确保你的Python环境已经安装了它。

pip install numpy

接下来，我们先实现几个关键的辅助函数，它们是构建网络的基础模块。

3.1 激活函数及其导数

激活函数给神经网络引入了非线性。我们必须同时实现函数本身和它的导数，因为反向传播时需要用到导数。

import numpy as np def sigmoid(z): """Sigmoid激活函数。""" # 为了防止z过大导致计算溢出，可以进行数值稳定处理 # 但这里为了清晰，先写标准形式 a = 1 / (1 + np.exp(-z)) return a def sigmoid_backward(da, z): """Sigmoid函数的反向传播。 参数： da -- 从上一层传来的关于激活值的梯度。 z -- 前向传播时计算出的线性输出Z。 返回： dz -- 关于线性输出Z的梯度。 """ s = sigmoid(z) dz = da * s * (1 - s) # sigmoid的导数是 s*(1-s) return dz def relu(z): """ReLU激活函数。""" a = np.maximum(0, z) return a def relu_backward(da, z): """ReLU函数的反向传播。""" # 创建一个与z形状相同的掩码，z>0的位置为True，否则为False dz = np.array(da, copy=True) # 先复制da的值 dz[z <= 0] = 0 # 当z<=0时，梯度为0 return dz def tanh(z): """tanh激活函数。""" a = np.tanh(z) return a def tanh_backward(da, z): """tanh函数的反向传播。""" a = tanh(z) dz = da * (1 - a**2) # tanh的导数是 1 - tanh^2 return dz

3.2 参数初始化

如前所述，好的初始化能加速收敛。我们实现一个通用的初始化函数。

def initialize_parameters(n_x, n_h, n_y): """ 初始化两层神经网络的参数。 参数： n_x -- 输入层特征数 n_h -- 隐藏层神经元数 n_y -- 输出层神经元数（回归任务通常为1） 返回： parameters -- 包含初始化参数的字典： W1 -- 形状 (n_h, n_x) b1 -- 形状 (n_h, 1) W2 -- 形状 (n_y, n_h) b2 -- 形状 (n_y, 1) """ # 设置随机种子，确保每次初始化结果一致，便于调试 np.random.seed(1) # He初始化，适用于ReLU。若用tanh，可将sqrt(2./n_x)改为sqrt(1./n_x) W1 = np.random.randn(n_h, n_x) * np.sqrt(2. / n_x) b1 = np.zeros((n_h, 1)) # 偏置通常初始化为0 W2 = np.random.randn(n_y, n_h) * np.sqrt(2. / n_h) b2 = np.zeros((n_y, 1)) parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2} return parameters

3.3 前向传播

前向传播计算预测值并缓存中间结果（Z,A），供反向传播使用。

def linear_forward(A_prev, W, b): """ 单层线性部分的前向传播。 参数： A_prev -- 上一层的激活值，形状 (上一层神经元数, 样本数) W -- 权重矩阵，形状 (本层神经元数, 上一层神经元数) b -- 偏置向量，形状 (本层神经元数, 1) 返回： Z -- 本层线性计算结果 cache -- 包含(A_prev, W, b)的元组，用于反向传播 """ Z = np.dot(W, A_prev) + b # 核心的矩阵乘法 cache = (A_prev, W, b) return Z, cache def linear_activation_forward(A_prev, W, b, activation): """ 单层（线性+激活）的前向传播。 参数： A_prev, W, b -- 同上 activation -- 激活函数名，字符串 "sigmoid", "relu", "tanh" 返回： A -- 本层激活输出 cache -- 包含 (linear_cache, activation_cache) 的元组 linear_cache: (A_prev, W, b) activation_cache: Z """ Z, linear_cache = linear_forward(A_prev, W, b) if activation == "sigmoid": A = sigmoid(Z) elif activation == "relu": A = relu(Z) elif activation == "tanh": A = tanh(Z) activation_cache = Z cache = (linear_cache, activation_cache) return A, cache def forward_propagation(X, parameters): """ 完整的两层网络前向传播。 参数： X -- 输入数据，形状 (n_x, m) parameters -- 参数字典，包含 W1, b1, W2, b2 返回： A2 -- 最后一层的输出（预测值） caches -- 包含每一层cache的列表 """ caches = [] A = X # 第一层的输入就是原始数据X # 第1层：线性 -> ReLU (或 tanh) A1, cache1 = linear_activation_forward(A, parameters['W1'], parameters['b1'], activation="relu") caches.append(cache1) # 第2层：线性 -> Sigmoid (回归任务，若输出需限制在0-1) A2, cache2 = linear_activation_forward(A1, parameters['W2'], parameters['b2'], activation="sigmoid") caches.append(cache2) return A2, caches

3.4 计算损失

def compute_cost(A2, Y): """ 计算均方误差损失。 参数： A2 -- 模型预测值，形状 (1, m) Y -- 真实标签，形状 (1, m) 返回： cost -- 标量损失值 """ m = Y.shape[1] # 样本数 # 均方误差 cost = (1. / (2 * m)) * np.sum(np.square(A2 - Y)) # 为了数值稳定，也可以这样写： # cost = np.mean((A2 - Y) ** 2) / 2 cost = np.squeeze(cost) # 确保cost是标量，例如将 [[17]] 变成 17 return cost

4. 核心引擎：反向传播算法的逐步推导与实现

反向传播是神经网络学习的引擎。它的目标是根据损失函数计算出的误差，求出损失函数关于每一个参数（W1, b1, W2, b2）的梯度（偏导数）。有了梯度，我们才能知道如何调整参数以减少损失。

我们以均方误差损失和Sigmoid输出激活函数为例进行推导。记住我们的链式法则：dL/dW = (dL/dA) * (dA/dZ) * (dZ/dW)。

第2层（输出层）反向传播：

初始化：损失函数L对网络输出A2的梯度。对于 MSE 损失，dA2 = A2 - Y。（推导：L = (1/2m)*Σ(A2-Y)^2，所以dL/dA2 = (1/m)*(A2-Y)。我们常把1/m放在参数更新时统一处理，所以这里dA2 = A2 - Y）。
Sigmoid反向：已知dA2和缓存的Z2，计算dZ2 = sigmoid_backward(dA2, Z2)。根据我们之前写的函数，这等于dA2 * A2 * (1 - A2)。
线性部分反向：已知dZ2和缓存的(A1, W2, b2)。
- dW2 = (1/m) * np.dot(dZ2, A1.T)
- db2 = (1/m) * np.sum(dZ2, axis=1, keepdims=True)
- dA1_prev = np.dot(W2.T, dZ2)（这是传递给前一层的梯度）

第1层（隐藏层）反向传播：

现在我们有从第2层传回来的dA1_prev。
ReLU反向：已知dA1_prev和缓存的Z1，计算dZ1 = relu_backward(dA1_prev, Z1)。
线性部分反向：已知dZ1和缓存的(X, W1, b1)。
- dW1 = (1/m) * np.dot(dZ1, X.T)
- db1 = (1/m) * np.sum(dZ1, axis=1, keepdims=True)
- （因为这是第一层，所以不需要再计算dA0了）

现在，我们把推导过程转化为代码：

def linear_backward(dZ, cache): """ 单层线性部分的反向传播。 参数： dZ -- 关于本层线性输出Z的梯度 cache -- 来自前向传播的元组 (A_prev, W, b) 返回： dA_prev -- 关于上一层激活值的梯度 dW -- 关于本层W的梯度 db -- 关于本层b的梯度 """ A_prev, W, b = cache m = A_prev.shape[1] # 样本数 dW = (1. / m) * np.dot(dZ, A_prev.T) db = (1. / m) * np.sum(dZ, axis=1, keepdims=True) dA_prev = np.dot(W.T, dZ) return dA_prev, dW, db def linear_activation_backward(dA, cache, activation): """ 单层（线性+激活）的反向传播。 参数： dA -- 关于本层激活输出A的梯度 cache -- 来自前向传播的元组 (linear_cache, activation_cache) activation -- 激活函数名 返回： dA_prev, dW, db """ linear_cache, activation_cache = cache Z = activation_cache if activation == "relu": dZ = relu_backward(dA, Z) elif activation == "sigmoid": dZ = sigmoid_backward(dA, Z) elif activation == "tanh": dZ = tanh_backward(dA, Z) dA_prev, dW, db = linear_backward(dZ, linear_cache) return dA_prev, dW, db def backward_propagation(A2, Y, caches): """ 完整的两层网络反向传播。 参数： A2 -- 前向传播的输出 Y -- 真实标签 caches -- 前向传播缓存的列表 返回： grads -- 包含各参数梯度的字典 """ grads = {} m = Y.shape[1] # 初始化输出层的 dA。对于MSE损失 + Sigmoid输出，可以合并为 A2 - Y # 更通用的写法是先计算dA2，再调用激活函数反向。这里我们直接计算dZ2。 # dA2 = A2 - Y # 对于MSE # 但为了与我们的函数结构一致，我们假设从损失函数直接得到了dA2。 # 实际上，对于Sigmoid+MSE的组合，dZ2可以直接简化为 A2 - Y。 # 我们采用通用步骤：先计算dA2（损失对A2的导），再通过激活函数反向。 # 计算损失对A2的导数 (dA2) # 对于二分类交叉熵损失： dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2)) # 对于均方误差损失： dA2 = A2 - Y dA2 = A2 - Y # 这里使用MSE损失 # 第2层反向传播 (SIGMOID -> LINEAR) current_cache = caches[1] # 获取第2层的cache dA1, dW2, db2 = linear_activation_backward(dA2, current_cache, activation="sigmoid") grads['dA1'] = dA1 # 通常不返回，这里为了清晰 grads['dW2'] = dW2 grads['db2'] = db2 # 第1层反向传播 (RELU -> LINEAR) current_cache = caches[0] # 获取第1层的cache dA0, dW1, db1 = linear_activation_backward(dA1, current_cache, activation="relu") # dA0 是输入层的梯度，我们不需要 grads['dW1'] = dW1 grads['db1'] = db1 return grads

5. 参数更新与模型训练循环

有了梯度，我们就可以用梯度下降法来更新参数了。最基础的更新规则是：W = W - learning_rate * dW，b = b - learning_rate * db。

def update_parameters(parameters, grads, learning_rate): """ 使用梯度下降更新参数。 参数： parameters -- 参数字典 grads -- 梯度字典 learning_rate -- 学习率 返回： parameters -- 更新后的参数字典 """ L = len(parameters) // 2 # 网络层数（参数对的数量） for l in range(1, L+1): parameters["W" + str(l)] = parameters["W" + str(l)] - learning_rate * grads["dW" + str(l)] parameters["b" + str(l)] = parameters["b" + str(l)] - learning_rate * grads["db" + str(l)] return parameters

现在，我们把前向传播、计算损失、反向传播、参数更新这四个步骤组合起来，形成一个完整的训练循环。

def model(X, Y, n_h, learning_rate=0.01, num_iterations=10000, print_cost=False): """ 构建并训练一个两层神经网络。 参数： X -- 训练数据，形状 (n_x, m) Y -- 训练标签，形状 (1, m) n_h -- 隐藏层神经元数量 learning_rate -- 学习率 num_iterations -- 迭代次数 print_cost -- 是否每1000次迭代打印一次损失 返回： parameters -- 训练好的参数字典 costs -- 记录每次迭代损失值的列表（用于绘图） """ np.random.seed(1) n_x = X.shape[0] n_y = Y.shape[0] costs = [] # 记录损失 # 1. 初始化参数 parameters = initialize_parameters(n_x, n_h, n_y) # 2. 训练循环 for i in range(num_iterations): # 前向传播 A2, caches = forward_propagation(X, parameters) # 计算损失 cost = compute_cost(A2, Y) # 反向传播 grads = backward_propagation(A2, Y, caches) # 更新参数 parameters = update_parameters(parameters, grads, learning_rate) # 记录损失 if i % 100 == 0: # 每100次记录一次 costs.append(cost) if print_cost and i % 1000 == 0: print(f"迭代次数 {i}: 损失 {cost:.6f}") # 绘制损失曲线 if print_cost: import matplotlib.pyplot as plt plt.plot(costs) plt.ylabel('损失') plt.xlabel('迭代次数 (每百次)') plt.title(f'学习率 = {learning_rate}') plt.show() return parameters, costs

6. 实战测试：用一个简单数据集验证我们的模型

理论说得再多，不如跑一遍代码看看。我们用一个非常简单的非线性数据集来测试我们的模型：根据一个特征X，预测Y = X^2 + noise。

# 生成模拟数据 def load_simple_data(): np.random.seed(3) m = 100 # 样本数 X = np.random.randn(1, m) * 2 # 生成-4到4之间的数据 Y = X ** 2 + np.random.randn(1, m) * 0.1 # Y = X^2 + 一些噪声 return X, Y X_train, Y_train = load_simple_data() print(f"X的形状: {X_train.shape}") print(f"Y的形状: {Y_train.shape}") # 训练模型 parameters, costs = model(X_train, Y_train, n_h=10, learning_rate=0.1, num_iterations=10000, print_cost=True) # 用训练好的模型进行预测 def predict(X, parameters): A2, _ = forward_propagation(X, parameters) # 对于回归任务，A2就是预测值。如果是分类，可能需要阈值处理。 predictions = A2 return predictions X_test = np.array([[ -2, -1, 0, 1, 2]]) # 测试几个点 Y_pred = predict(X_test, parameters) print(f"测试输入 X: {X_test}") print(f"模型预测 Y: {Y_pred}") print(f"真实近似值 (X^2): {X_test ** 2}") # 可视化拟合结果 import matplotlib.pyplot as plt plt.scatter(X_train.flatten(), Y_train.flatten(), c='b', label='训练数据', alpha=0.5) X_line = np.linspace(-4, 4, 100).reshape(1, 100) Y_line_pred = predict(X_line, parameters) plt.plot(X_line.flatten(), Y_line_pred.flatten(), c='r', linewidth=3, label='模型拟合') plt.xlabel('X') plt.ylabel('Y') plt.legend() plt.title('两层神经网络拟合 y ≈ x^2') plt.show()

运行这段代码，你应该能看到损失曲线随着迭代次数增加而稳步下降，最终模型对y=x^2这条曲线有了一个不错的拟合。这说明我们手写的BP神经网络是有效的！

7. 调参心得与常见陷阱排查

模型跑起来只是第一步，让它跑得好才是关键。以下是我在无数次“炼丹”中总结出的几点核心经验：

1. 学习率（Learning Rate）：最重要的超参数学习率决定了参数更新的步长。太大容易震荡甚至发散（损失变成NaN），太小则收敛缓慢。

现象：损失在初期骤降后，在某个值附近剧烈上下跳动 ->学习率太大。
现象：损失下降得非常缓慢，迭代几千次都没什么变化 ->学习率太小。
策略：通常从0.01、0.001、0.1这几个数量级开始尝试。一个实用的技巧是使用学习率衰减，例如每1000次迭代将学习率乘以0.95。

2. 隐藏层神经元数量（n_h）：模型的容量神经元太少，模型“智商”不够，学不会复杂模式（欠拟合）。神经元太多，模型容易记住训练数据中的噪声（过拟合）。

欠拟合迹象：训练集和验证集损失都很高，且模型拟合曲线过于平滑简单。
过拟合迹象：训练集损失极低，但验证集损失很高，模型拟合曲线“抖动”剧烈，完美穿过每一个训练点。
策略：对于简单问题（如我们的x^2），5-20个神经元足矣。对于更复杂的问题，可以从一个较小的数（如32、64）开始，如果欠拟合再增加。也可以尝试使用L2正则化来抑制过拟合。

3. 初始化：好的开始是成功的一半我们使用了He初始化，这对ReLU激活函数很友好。如果你换用tanh，可以尝试Xavier初始化np.random.randn() * np.sqrt(1./n_prev)。永远不要将所有权重初始化为0，这会导致对称性破坏问题，所有神经元学不到不同的特征。

4. 激活函数的选择

隐藏层：ReLU是默认首选，因为它计算快，能缓解梯度消失。但在某些情况下，tanh在训练初期可能表现更稳定，尤其是当你的数据已经标准化到0均值附近时。
输出层：回归任务，若输出值范围无限制，可以不用激活函数（恒等函数）。若希望输出在0-1之间，用Sigmoid；在-1到1之间，用tanh。需要修改forward_propagation和backward_propagation中对应层的激活函数。

5. 梯度消失/爆炸这是深层网络的经典问题，在我们这个两层的浅网络中不明显，但原理要懂。如果梯度在反向传播过程中指数级减小（消失）或增大（爆炸），学习就会停滞或崩溃。

检查：在训练初期打印出grads['dW1']和grads['dW2']的范数（np.linalg.norm()）。如果它们与1相差几个数量级（比如1e-7或1e7），就可能有问题。
对策：合适的初始化（He/Xavier）、使用ReLU、梯度裁剪（np.clip(grads, -max_val, max_val)）都是常用手段。

6. 数据预处理：标准化/归一化神经网络对输入数据的尺度非常敏感。如果特征X的取值范围差异很大（比如一个特征范围是0-1，另一个是1000-10000），那么梯度更新会在不同方向上失衡，导致训练困难。

必须做：将每个特征单独进行标准化（减去均值，除以标准差），使其均值为0，方差为1。X_norm = (X - mean) / std。对于输出Y，如果是回归任务，也建议做同样的处理，训练好之后再将预测值反标准化回去。这能极大加速收敛并提高稳定性。

8. 从手搓到实战：在数学建模中应用BP神经网络

在数学建模竞赛中，BP神经网络常用于解决预测类、分类类和非线性拟合问题。比如预测城市用电量、股票价格趋势，或者对客户进行信用评级分类。

应用流程：

问题抽象与数据准备：明确你的输出Y是什么（连续值还是类别）。收集数据，进行彻底的数据清洗（处理缺失值、异常值）和特征工程（构造新特征、选择相关特征）。这是最重要的一步，决定了模型性能的上限。
数据预处理：将数据划分为训练集、验证集和测试集（例如7:2:1）。对训练集进行特征标准化，并用训练集计算出的均值和标准差去标准化验证集和测试集。
模型构建与训练：使用我们上面编写的代码框架，或者在其基础上进行扩展（比如增加层数、加入Dropout正则化、改用Adam优化器）。在训练集上训练，在验证集上监控损失，防止过拟合。
超参数调优：像第7部分所述，系统性地调整学习率、隐藏层神经元数、迭代次数等。可以使用网格搜索或随机搜索。
模型评估与预测：在从未参与训练的测试集上评估最终模型的性能（如用均方根误差RMSE、R²分数）。然后用它进行最终预测。

扩展方向：

当你熟练掌握了这个两层的BP网络后，可以尝试以下扩展，让你的模型更强大、更实用：

增加网络深度：将代码模块化，使其支持任意层数。这需要将参数、缓存、前向/反向传播都用循环来处理。
实现不同的优化器：将基础的梯度下降（Gradient Descent）替换为更先进的Momentum、RMSprop或Adam。这些优化器能自适应调整学习率，收敛更快、更稳。
加入正则化：实现L2正则化（在损失函数中加入权重的平方和）或Dropout（随机丢弃一部分神经元）来对抗过拟合。
实现Mini-batch梯度下降：一次性用全部数据（Batch GD）计算梯度在大数据集上很慢。实现每次迭代只用一小批（如64、128个）样本计算梯度并更新，能极大加速训练。
早停法（Early Stopping）：监控验证集损失，当其在连续多个迭代周期内不再下降时，就停止训练，避免过拟合。

亲手实现这个简单的两层BP网络，就像是掌握了内功心法。之后无论你使用多么高级、封装的框架，你都能清楚地知道在model.fit()那一行代码背后，数据是如何流动的，误差是如何反向传播的，参数是如何被一点点调整的。这种深刻的理解，是解决复杂建模问题时进行有效调试和创新的基石。希望这篇长文能帮你打通任督二脉，在数学建模和机器学习的路上走得更稳、更远。如果在实现过程中遇到任何问题，回头仔细检查每一步的矩阵维度，确保np.dot的两边维度匹配，这能解决90%的bug。

查看全文

http://www.cnnetsun.cn/news/4223066.html