### 在Jupyter Notebook中实现全连接神经网络的手写数字识别任务 以下是一个完整的解决方案，包含模型构建、训练过程、梯度验证、激活函数实现、损失函数计算以及可视化训练曲线和评估结果。代码分段展示，便于逐步运行和调试。 --- ### 数据加载与预处理 加载MNIST数据集并进行归一化处理。 ```python ### 数据加载与预处理 from tensorflow.keras.datasets import mnist import numpy as np def load_and_preprocess_data(): (X_train, y_train), (X_test, y_test) = mnist.load_data() X_train = X_train.reshape(-1, 784).astype('float32') / 255.0 X_test = X_test.reshape(-1, 784).astype('float32') / 255.0 return X_train, y_train, X_test, y_test X_train, y_train, X_test, y_test = load_and_preprocess_data() print("Data loaded and preprocessed.") ``` --- ### 激活函数与损失函数实现 定义ReLU、Sigmoid、Softmax激活函数及其导数，以及交叉熵损失函数。 ```python ### 激活函数与损失函数 def relu(x): return np.maximum(0, x) def relu_derivative(x): return (x > 0).astype(float) def sigmoid(x): return 1 / (1 + np.exp(-x)) def sigmoid_derivative(x): sig = sigmoid(x) return sig * (1 - sig) def softmax(x): exp_x = np.exp(x - np.max(x, axis=1, keepdims=True)) return exp_x / np.sum(exp_x, axis=1, keepdims=True) def cross_entropy_loss(y_pred, y_true): m = y_true.shape[0] log_prob = -np.log(y_pred[range(m), y_true] + 1e-8) loss = np.sum(log_prob) / m return loss def cross_entropy_derivative(y_pred, y_true_onehot): return y_pred - y_true_onehot ``` --- ### 模型构建 定义三层全连接神经网络的前向传播和反向传播。 ```python ### 网络结构与前向传播 class FullyConnectedNN: def __init__(self, input_size, hidden_size1, hidden_size2, output_size): self.w1 = np.random.randn(input_size, hidden_size1) * np.sqrt(2 / input_size) self.b1 = np.zeros((1, hidden_size1)) self.w2 = np.random.randn(hidden_size1, hidden_size2) * np.sqrt(2 / hidden_size1) self.b2 = np.zeros((1, hidden_size2)) self.w3 = np.random.randn(hidden_size2, output_size) * np.sqrt(2 / hidden_size2) self.b3 = np.zeros((1, output_size)) def forward(self, X): self.z1 = np.dot(X, self.w1) + self.b1 self.a1 = relu(self.z1) self.z2 = np.dot(self.a1, self.w2) + self.b2 self.a2 = sigmoid(self.z2) self.z3 = np.dot(self.a2, self.w3) + self.b3 y_pred = softmax(self.z3) return y_pred def backward(self, X, y_true, y_pred, learning_rate): m = X.shape[0] y_true_onehot = np.eye(10)[y_true] # 输出层 dz3 = cross_entropy_derivative(y_pred, y_true_onehot) dw3 = np.dot(self.a2.T, dz3) / m db3 = np.sum(dz3, axis=0, keepdims=True) / m da2 = np.dot(dz3, self.w3.T) # 隐藏层2 dz2 = da2 * sigmoid_derivative(self.z2) dw2 = np.dot(self.a1.T, dz2) / m db2 = np.sum(dz2, axis=0, keepdims=True) / m da1 = np.dot(dz2, self.w2.T) # 隐藏层1 dz1 = da1 * relu_derivative(self.z1) dw1 = np.dot(X.T, dz1) / m db1 = np.sum(dz1, axis=0, keepdims=True) / m # 参数更新 self.w3 -= learning_rate * dw3 self.b3 -= learning_rate * db3 self.w2 -= learning_rate * dw2 self.b2 -= learning_rate * db2 self.w1 -= learning_rate * dw1 self.b1 -= learning_rate * db1 ``` --- ### 训练过程 实现小批量梯度下降训练循环，并记录损失和准确率。 ```python ### 训练过程 def train_model(model, X_train, y_train, X_val, y_val, epochs, batch_size, learning_rate): train_losses, val_losses, accuracies = [], [], [] for epoch in range(epochs): indices = np.arange(X_train.shape[0]) np.random.shuffle(indices) X_train = X_train[indices] y_train = y_train[indices] for i in range(0, X_train.shape[0], batch_size): X_batch = X_train[i:i+batch_size] y_batch = y_train[i:i+batch_size] y_pred = model.forward(X_batch) loss = cross_entropy_loss(y_pred, y_batch) model.backward(X_batch, y_batch, y_pred, learning_rate) # 验证集评估 y_val_pred = model.forward(X_val) val_loss = cross_entropy_loss(y_val_pred, y_val) val_acc = np.mean(np.argmax(y_val_pred, axis=1) == y_val) train_losses.append(loss) val_losses.append(val_loss) accuracies.append(val_acc) print(f"Epoch {epoch+1}/{epochs}, Loss: {loss:.4f}, Val Loss: {val_loss:.4f}, Val Acc: {val_acc:.4f}") return train_losses, val_losses, accuracies model = FullyConnectedNN(784, 128, 64, 10) train_losses, val_losses, accuracies = train_model( model, X_train[:5000], y_train[:5000], X_test[:1000], y_test[:1000], epochs=10, batch_size=64, learning_rate=0.01 ) ``` --- ### 可视化训练曲线 绘制损失和准确率的变化曲线。 ```python ### 可视化训练曲线 import matplotlib.pyplot as plt plt.figure(figsize=(12, 4)) plt.subplot(1, 2, 1) plt.plot(train_losses, label="Train Loss") plt.plot(val_losses, label="Validation Loss") plt.legend() plt.title("Loss Curve") plt.subplot(1, 2, 2) plt.plot(accuracies, label="Validation Accuracy") plt.legend() plt.title("Accuracy Curve") plt.show() ``` --- ### 测试集评估 在测试集上评估模型性能。 ```python ### 测试集评估 def evaluate_model(model, X_test, y_test): y_test_pred = model.forward(X_test) test_acc = np.mean(np.argmax(y_test_pred, axis=1) == y_test) print(f"Test Accuracy: {test_acc:.4f}") return test_acc test_accuracy = evaluate_model(model, X_test, y_test) ``` ---