企业官网建设流程全解析

用Python从零实现4层神经网络：与吴恩达课程对应的代码实践

在Coursera的深度学习课程中，吴恩达教授系统性地讲解了神经网络的理论基础，但许多学习者在将公式转化为实际代码时仍会遇到障碍。本文将带你用NumPy逐步构建一个4层全连接神经网络，重点解释每个代码块与课程中数学公式的对应关系，并分享矩阵维度核对的实用技巧。

1. 神经网络架构设计与初始化

我们构建的神经网络包含：1个输入层（3个特征）、2个隐藏层（分别5个和3个神经元）和1个输出层（二分类任务）。这与课程中4层神经网络的示例完全一致：

layer_dims = [3, 5, 3, 1] # 对应n_x=3, n^[1]=5, n^[2]=3, n^[4]=1

参数初始化需要特别注意课程强调的"对称权重"问题。正确的初始化应保证不同神经元学习到不同特征：

def initialize_parameters(layer_dims): parameters = {} L = len(layer_dims) - 1 # 不计算输入层 for l in range(1, L+1): parameters['W' + str(l)] = np.random.randn( layer_dims[l], layer_dims[l-1]) * 0.01 # 课程建议的小随机值 parameters['b' + str(l)] = np.zeros((layer_dims[l], 1)) return parameters

关键点验证：

• W^[1]形状应为(5,3)：第1隐藏层5个神经元，每个接收3个输入特征
• b^[1]形状为(5,1)：每个神经元一个偏置项
• 这与课程4.3节强调的维度核对原则完全一致

2. 前向传播的模块化实现

按照课程4.2节的分层计算思路，我们将每层计算封装为独立函数。特别注意各层激活函数的选择——这与课程4.1节讨论的激活函数选择建议一致：

def linear_activation_forward(A_prev, W, b, activation): Z = np.dot(W, A_prev) + b # 线性部分 cache = (A_prev, W, b, Z) if activation == "sigmoid": A = 1/(1+np.exp(-Z)) # 输出层用sigmoid elif activation == "relu": A = np.maximum(0,Z) # 隐藏层用ReLU return A, cache

完整前向传播流程再现了课程中的向量化实现：

def L_model_forward(X, parameters): caches = [] A = X L = len(parameters) // 2 # 隐藏层使用ReLU for l in range(1, L): A_prev = A A, cache = linear_activation_forward( A_prev, parameters['W'+str(l)], parameters['b'+str(l)], "relu") caches.append(cache) # 输出层使用sigmoid AL, cache = linear_activation_forward( A, parameters['W'+str(L)], parameters['b'+str(L)], "sigmoid") caches.append(cache) return AL, caches

注意：缓存Z值对反向传播至关重要，这与课程4.5节强调的"搭建神经网络块"概念完全对应

3. 损失函数与反向传播

课程4.6节详细推导的交叉熵损失实现如下：

def compute_cost(AL, Y): m = Y.shape[1] cost = -np.mean(Y*np.log(AL) + (1-Y)*np.log(1-AL)) return np.squeeze(cost) # 确保cost是标量

反向传播是许多学习者的难点，我们将课程公式转化为代码时特别需要注意矩阵转置的顺序：

def linear_activation_backward(dA, cache, activation): A_prev, W, b, Z = cache m = A_prev.shape[1] if activation == "relu": dZ = np.array(dA, copy=True) dZ[Z <= 0] = 0 # ReLU导数 elif activation == "sigmoid": s = 1/(1+np.exp(-Z)) dZ = dA * s * (1-s) # sigmoid导数 dW = np.dot(dZ, A_prev.T)/m db = np.sum(dZ, axis=1, keepdims=True)/m dA_prev = np.dot(W.T, dZ) return dA_prev, dW, db

完整反向传播流程对应课程4.6节的向量化实现：

def L_model_backward(AL, Y, caches): grads = {} L = len(caches) Y = Y.reshape(AL.shape) # 初始化反向传播 (课程公式5) dAL = - (np.divide(Y, AL) - np.divide(1-Y, 1-AL)) # 输出层梯度 (sigmoid) current_cache = caches[L-1] grads["dA"+str(L-1)], grads["dW"+str(L)], grads["db"+str(L)] = \ linear_activation_backward(dAL, current_cache, "sigmoid") # 隐藏层梯度 (ReLU) for l in reversed(range(L-1)): current_cache = caches[l] dA_prev_temp, dW_temp, db_temp = \ linear_activation_backward(grads["dA"+str(l+1)], current_cache, "relu") grads["dA"+str(l)] = dA_prev_temp grads["dW"+str(l+1)] = dW_temp grads["db"+str(l+1)] = db_temp return grads

4. 参数更新与维度验证

课程4.3节强调的矩阵维度核对可以通过以下方法实现：

def check_dimensions(parameters, grads, X, Y): print("=== 维度验证 ===") print(f"输入X: {X.shape} (n_x, m)") print(f"标签Y: {Y.shape} (1, m)") L = len(parameters) // 2 for l in range(1, L+1): print(f"\n第{l}层:") print(f"W{l}: {parameters['W'+str(l)].shape} (n^{[l]}, n^{[l-1]})") print(f"b{l}: {parameters['b'+str(l)].shape} (n^{[l]}, 1)") print(f"dW{l}: {grads['dW'+str(l)].shape} (应与W{l}相同)") print(f"db{l}: {grads['db'+str(l)].shape} (应与b{l}相同)")

参数更新遵循课程中的梯度下降规则：

def update_parameters(parameters, grads, learning_rate): L = len(parameters) // 2 for l in range(1, L+1): parameters["W" + str(l)] -= learning_rate * grads["dW" + str(l)] parameters["b" + str(l)] -= learning_rate * grads["db" + str(l)] return parameters

5. 整合训练流程与超参数调优

将上述模块组合成完整训练流程，并加入课程4.7节讨论的超参数调节：

def L_layer_model(X, Y, layer_dims, learning_rate=0.01, num_iterations=3000): costs = [] # 初始化参数 parameters = initialize_parameters(layer_dims) # 梯度下降循环 for i in range(num_iterations): # 前向传播 AL, caches = L_model_forward(X, parameters) # 计算损失 cost = compute_cost(AL, Y) costs.append(cost) # 反向传播 grads = L_model_backward(AL, Y, caches) # 参数更新 parameters = update_parameters(parameters, grads, learning_rate) # 每100次打印损失 if i % 100 == 0: print(f"第{i}次迭代后的损失值: {cost:.4f}") # 绘制损失曲线 plt.plot(costs) plt.ylabel('cost') plt.xlabel('iterations (per hundreds)') plt.title(f"学习率 = {learning_rate}") plt.show() return parameters

提示：实际应用中应像课程建议的那样，将数据集分为训练集/验证集/测试集来评估不同超参数组合

6. 实际应用示例与调试技巧

用合成数据测试我们的实现：

# 生成数据 (n_x=3, m=100) np.random.seed(1) X = np.random.randn(3, 100) * 0.01 Y = (np.random.rand(1, 100) > 0.5).astype(float) # 训练网络 parameters = L_layer_model(X, Y, [3,5,3,1], learning_rate=0.1, num_iterations=2500) # 预测函数 def predict(X, parameters): AL, _ = L_model_forward(X, parameters) predictions = (AL > 0.5).astype(int) return predictions # 计算准确率 preds = predict(X, parameters) print(f"训练集准确率: {np.mean(preds == Y)*100:.2f}%")

常见调试技巧：

• 检查初始损失值是否与预期一致（对于sigmoid输出，初始损失应接近-ln(0.5)≈0.693）
• 使用梯度检验（gradient checking）验证反向传播实现
• 尝试不同的学习率（课程建议的常用范围：0.1, 0.01, 0.001）

7. 与浅层网络的对���实验

为验证课程4.4节"为什么使用深层表示"的观点，我们对比2层和4层网络的性能：

深层网络确实能学习更复杂的特征表示，但需要更多计算资源——这与课程中关于计算复杂度的讨论一致。