17-3 反向传播与模型训练

1第17-1课：单个神经元 → 梯度公式 ∂J/∂w = (1/m)∑(ŷ-y)x
2              ↓
3第17-2课：多层网络 → 参数变多了，梯度怎么算？
4              ↓
5第17-3课：反向传播 → 从输出层向输入层逐层计算梯度

1计算图（前向与反向的可视化）
2        ↓
3链式法则（反向传播的数学基础）
4        ↓
5输出层梯度推导（回归 + 分类）
6        ↓
7隐藏层梯度推导（逐层回传）
8        ↓
9完整训练循环的实现

  1import numpy as np
  2import matplotlib.pyplot as plt
  3from sklearn.datasets import make_classification
  4from sklearn.model_selection import train_test_split
  5from sklearn.preprocessing import StandardScaler
  6
  7class NeuralNetwork:
  8    def __init__(self, n_input, n_hidden, n_output, learning_rate=0.1, seed=42):
  9        self.lr = learning_rate
 10        np.random.seed(seed)
 11
 12        # He 初始化（用于 ReLU）
 13        self.W1 = np.random.randn(n_hidden, n_input) * np.sqrt(2.0 / n_input)
 14        self.b1 = np.zeros((n_hidden, 1))
 15        self.W2 = np.random.randn(n_output, n_hidden) * np.sqrt(2.0 / n_hidden)
 16        self.b2 = np.zeros((n_output, 1))
 17
 18        # 存储中间变量（用于反向传播）
 19        self.cache = {}
 20
 21    def _sigmoid(self, z):
 22        return 1 / (1 + np.exp(-z))
 23
 24    def _relu(self, z):
 25        return np.maximum(0, z)
 26
 27    def _relu_derivative(self, z):
 28        return (z > 0).astype(float)
 29
 30    def forward(self, X):
 31        """
 32        X: 维度 (n_input, m)，m 为样本数
 33        返回: 预测值 (n_output, m)
 34        """
 35        Z1 = np.dot(self.W1, X) + self.b1
 36        A1 = self._relu(Z1)
 37        Z2 = np.dot(self.W2, A1) + self.b2
 38        A2 = self._sigmoid(Z2)
 39
 40        self.cache = {'Z1': Z1, 'A1': A1, 'Z2': Z2, 'A2': A2, 'X': X}
 41        return A2
 42
 43    def compute_loss(self, Y, A2, eps=1e-8):
 44        """
 45        Y: 真实标签，维度 (n_output, m)
 46        A2: 预测值，维度 (n_output, m)
 47        """
 48        m = Y.shape[1]
 49        loss = -np.mean(Y * np.log(A2 + eps) + (1 - Y) * np.log(1 - A2 + eps))
 50        return loss
 51
 52    def backward(self, Y):
 53        """
 54        执行反向传播，计算并存储梯度
 55        """
 56        m = Y.shape[1]
 57        X = self.cache['X']
 58        Z1 = self.cache['Z1']
 59        A1 = self.cache['A1']
 60        A2 = self.cache['A2']
 61
 62        # 输出层误差: δ2 = ŷ - y (交叉熵 + Sigmoid)
 63        dZ2 = A2 - Y
 64        dW2 = (1 / m) * np.dot(dZ2, A1.T)
 65        db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
 66
 67        # 隐藏层误差: δ1 = W2^T · δ2 ⊙ ReLU'(Z1)
 68        dZ1 = np.dot(self.W2.T, dZ2) * self._relu_derivative(Z1)
 69        dW1 = (1 / m) * np.dot(dZ1, X.T)
 70        db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)
 71
 72        # 保存梯度
 73        self.grads = {'dW1': dW1, 'db1': db1, 'dW2': dW2, 'db2': db2}
 74
 75    def update(self):
 76        self.W1 -= self.lr * self.grads['dW1']
 77        self.b1 -= self.lr * self.grads['db1']
 78        self.W2 -= self.lr * self.grads['dW2']
 79        self.b2 -= self.lr * self.grads['db2']
 80
 81    def fit(self, X, Y, epochs=1000, verbose=True):
 82        losses = []
 83        for epoch in range(epochs):
 84            A2 = self.forward(X)
 85            loss = self.compute_loss(Y, A2)
 86            losses.append(loss)
 87
 88            self.backward(Y)
 89            self.update()
 90
 91            if verbose and epoch % 100 == 0:
 92                print(f"Epoch {epoch}: Loss = {loss:.4f}")
 93
 94        return losses
 95
 96    def predict(self, X):
 97        A2 = self.forward(X)
 98        return (A2 >= 0.5).astype(int)
 99
100    def score(self, X, Y):
101        pred = self.predict(X)
102        return np.mean(pred == Y)

 1# 生成数据
 2X, y = make_classification(n_samples=2000, n_features=10, n_informative=8,
 3                           n_redundant=2, n_clusters_per_class=1,
 4                           random_state=42)
 5y = y.reshape(1, -1)  # 转为 (1, m) 形式
 6
 7# 数据标准化
 8scaler = StandardScaler()
 9X_scaled = scaler.fit_transform(X).T  # 转为 (n_features, m)
10
11# 划分训练集/测试集
12X_train = X_scaled[:, :1500]
13y_train = y[:, :1500]
14X_test = X_scaled[:, 1500:]
15y_test = y[:, 1500:]
16
17# 训练
18model = NeuralNetwork(n_input=10, n_hidden=32, n_output=1, learning_rate=0.1)
19losses = model.fit(X_train, y_train, epochs=1000, verbose=True)
20
21# 评估
22train_acc = model.score(X_train, y_train)
23test_acc = model.score(X_test, y_test)
24print(f"\n训练集准确率: {train_acc:.4f}")
25print(f"测试集准确率: {test_acc:.4f}")
26
27# 绘制损失曲线
28plt.figure(figsize=(8, 5))
29plt.plot(losses)
30plt.xlabel('Epoch')
31plt.ylabel('Loss')
32plt.title('训练损失下降曲线')
33plt.grid(True, alpha=0.3)
34plt.show()