和鲸社区深度学习基础训练营2025年关卡2（1）纯numpy

拟分3种实现方法：

1.纯numpy

2.sklearn中的MLPClassifier

3.pytorch

题目：
在 MNIST 数据集上训练 MLP 模型并比较不同的激活函数和优化算法

任务描述：

使用 MNIST 数据集中的前 20,000 个样本训练一个多层感知机 (MLP) 模型。你需要比较三种不同的激活函数（ReLU、Sigmoid、Tanh）和三种不同的优化算法（SGD、Momentum、Adam），以找到表现最好的组合。模型需要使用一层隐藏层，隐藏单元数量为 128。

要求：

加载并预处理数据，将每个图像展平成 28x28 的向量，并进行标准化（除以 255）。
使用 one-hot 编码将标签进行转换。
在训练过程中，分别使用以下激活函数和优化算法：
激活函数：ReLU、Sigmoid、Tanh
优化算法：SGD、Momentum、Adam
对每种激活函数和优化算法组合，训练模型 10000 个 epoch。
评估模型在验证集上的准确率，并输出最优的激活函数与优化算法组合。
输入：

训练数据：MNIST 数据集中的前 20,000 个样本。
每个样本是一个 28x28 的灰度图像，标签为 0-9 的分类。
输出：

输出最优激活函数与优化算法组合，以及在验证集上的准确率。
要求：

不同激活函数与优化算法的组合实现。
对模型的正确率进行评估，并选择最优方案。
提示：

你可以使用 OneHotEncoder 将标签进行 one-hot 编码。
在模型的反向传播过程中，根据不同的优化算法更新权重。
激活函数可以用 ReLU、Sigmoid 和 Tanh，确保在前向传播和反向传播时分别计算激活值及其导数。

import numpy as np
from sklearn.preprocessing import OneHotEncoder
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
np.random.seed(999)def load_data(path="mnist.npz"):# np.load加载数据文件f = np.load(path)# 提取训练集和测试集的图片和标签数据X_train, y_train = f['x_train'], f['y_train']X_test, y_test = f['x_test'], f['y_test']f.close()  # 关闭文件# 返回训练集和测试集return (X_train, y_train), (X_test, y_test)# 加载MNIST数据集
(X_train, y_train), (X_test, y_test) = load_data()X_train=X_train[:2000]
y_train=y_train[:2000]
X_test=X_test[:1000]
y_test=y_test[:1000]
# 数据预处理
X_train = X_train.reshape((-1,  28 * 28)).astype('float32') / 255
X_test = X_test.reshape((-1,  28 * 28)).astype('float32') / 255# 标签进行独热编码
def one_hot_encoding(labels, num_classes):encoded = np.zeros((len(labels),  num_classes))for i, label in enumerate(labels):encoded[i][label] = 1return encodedy_train = one_hot_encoding(y_train, 10)
y_test = one_hot_encoding(y_test, 10)# MLP类的实现
class MLP:def __init__(self, input_size, hidden_size, output_size, activation='relu'):# 初始化权重（Xavier初始化适应Sigmoid/Tanh）self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2 / input_size)self.b1 = np.zeros((1, hidden_size))self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(2 / hidden_size)self.b2 = np.zeros((1, output_size))self.activation = activation  # 支持relu/sigmoid/tanhself.losses = []  # 记录训练损失# Adam专用初始化self.t = 0  # 时间步计数器[1,2]self.m_W1, self.v_W1 = None, None  # 一阶/二阶矩（权重1）self.m_b1, self.v_b1 = None, None  # 一阶/二阶矩（偏置1）self.m_W2, self.v_W2 = None, None  # 一阶/二阶矩（权重2）self.m_b2, self.v_b2 = None, None  # 一阶/二阶矩（偏置2）# Adam超参数（可调整）self.beta1 = 0.9    # 一阶矩衰减率self.beta2 = 0.999  # 二阶矩衰减率self.epsilon = 1e-8 # 防除零常数def _activate(self, x):"""激活函数及其导数"""if self.activation == 'relu':return np.maximum(0, x), np.where(x > 0, 1, 0)  # 函数值 + 导数elif self.activation == 'sigmoid':s = 1 / (1 + np.exp(-x))return s, s * (1 - s)elif self.activation == 'tanh':t = np.tanh(x)return t, 1 - t**2def forward(self, X):"""前向传播"""self.z1 = np.dot(X, self.W1) + self.b1self.a1, self.da1 = self._activate(self.z1)  # 隐藏层激活值及导数self.z2 = np.dot(self.a1, self.W2) + self.b2self.a2 = np.exp(self.z2) / np.sum(np.exp(self.z2), axis=1, keepdims=True)  # Softmax输出return self.a2def compute_loss(self, y_pred, y_true):"""交叉熵损失"""return -np.mean(y_true * np.log(y_pred + 1e-8))def backward(self, X, y_true, y_pred):"""反向传播"""m = X.shape[0]# 输出层梯度 (dL/dz2)error_output = y_pred - y_truedW2 = np.dot(self.a1.T, error_output) / mdb2 = np.sum(error_output, axis=0, keepdims=True) / m# 隐藏层梯度 (dL/dz1)error_hidden = np.dot(error_output, self.W2.T) * self.da1dW1 = np.dot(X.T, error_hidden) / mdb1 = np.sum(error_hidden, axis=0, keepdims=True) / mreturn dW1, db1, dW2, db2def update_params(self, dW1, db1, dW2, db2, lr=0.01, optimizer='sgd', momentum=0.9):"""参数更新（支持SGD/Momentum/Adam）"""if optimizer == 'sgd':self.W1 -= lr * dW1self.b1 -= lr * db1self.W2 -= lr * dW2self.b2 -= lr * db2elif optimizer == 'momentum':# 初始化动量缓存if not hasattr(self, 'v_dW1'):self.v_dW1, self.v_db1 = np.zeros_like(dW1), np.zeros_like(db1)self.v_dW2, self.v_db2 = np.zeros_like(dW2), np.zeros_like(db2)# 更新动量self.v_dW1 = momentum * self.v_dW1 + lr * dW1self.v_db1 = momentum * self.v_db1 + lr * db1self.v_dW2 = momentum * self.v_dW2 + lr * dW2self.v_db2 = momentum * self.v_db2 + lr * db2# 应用更新self.W1 -= self.v_dW1self.b1 -= self.v_db1self.W2 -= self.v_dW2self.b2 -= self.v_db2# Adam实现elif optimizer == 'adam':# 首次调用时初始化矩估计if self.m_W1 is None:self.m_W1, self.v_W1 = np.zeros_like(dW1), np.zeros_like(dW1)self.m_b1, self.v_b1 = np.zeros_like(db1), np.zeros_like(db1)self.m_W2, self.v_W2 = np.zeros_like(dW2), np.zeros_like(dW2)self.m_b2, self.v_b2 = np.zeros_like(db2), np.zeros_like(db2)self.t += 1  # 更新时间步# 更新W1/b1的矩估计self.m_W1 = self.beta1*self.m_W1 + (1-self.beta1)*dW1self.v_W1 = self.beta2*self.v_W1 + (1-self.beta2)*(dW1**2)self.m_b1 = self.beta1*self.m_b1 + (1-self.beta1)*db1self.v_b1 = self.beta2*self.v_b1 + (1-self.beta2)*(db1**2)# 更新W2/b2的矩估计self.m_W2 = self.beta1*self.m_W2 + (1-self.beta1)*dW2self.v_W2 = self.beta2*self.v_W2 + (1-self.beta2)*(dW2**2)self.m_b2 = self.beta1*self.m_b2 + (1-self.beta1)*db2self.v_b2 = self.beta2*self.v_b2 + (1-self.beta2)*(db2**2)# 偏差校正m_W1_hat = self.m_W1 / (1 - self.beta1**self.t)v_W1_hat = self.v_W1 / (1 - self.beta2**self.t)m_b1_hat = self.m_b1 / (1 - self.beta1**self.t)v_b1_hat = self.v_b1 / (1 - self.beta2**self.t)m_W2_hat = self.m_W2 / (1 - self.beta1**self.t)v_W2_hat = self.v_W2 / (1 - self.beta2**self.t)m_b2_hat = self.m_b2 / (1 - self.beta1**self.t)v_b2_hat = self.v_b2 / (1 - self.beta2**self.t)# 参数更新self.W1 -= lr * m_W1_hat / (np.sqrt(v_W1_hat) + self.epsilon)self.b1 -= lr * m_b1_hat / (np.sqrt(v_b1_hat) + self.epsilon)self.W2 -= lr * m_W2_hat / (np.sqrt(v_W2_hat) + self.epsilon)self.b2 -= lr * m_b2_hat / (np.sqrt(v_b2_hat) + self.epsilon)def train(self, X, y, epochs=1000, lr=0.01, optimizer='sgd'):for epoch in range(epochs):y_pred = self.forward(X)loss = self.compute_loss(y_pred, y)self.losses.append(loss)dW1, db1, dW2, db2 = self.backward(X, y, y_pred)self.update_params(dW1, db1, dW2, db2, lr, optimizer)#if epoch % 100 == 0:#print(f"Epoch {epoch}: Loss={loss:.4f}")def predict(self, X):return np.argmax(self.forward(X), axis=1)# 创建MLP模型
input_size = 28 * 28
hidden_size = 128
output_size = 10# 训练模型
lr = 0.001
epochs = 1000# 训练和评估模型
best_accuracy = 0  # 保存最佳模型的准确率
best_model = None  # 保存最佳模型
best_activation = None  # 保存最佳的激活函数
best_optimizer = None  # 保存最佳的优化器for activation in ['relu', 'sigmoid', 'tanh']:  # 激活函数分别为ReLU、Sigmoid、Tanhfor optimizer in ['sgd', 'momentum', 'adam']:  # 优化器分别为SGD、Momentum和Adamprint(f"\nTraining with {activation} activation and {optimizer} optimizer")mlp = MLP(input_size=input_size, hidden_size=hidden_size, output_size=output_size, activation=activation)mlp.train(X_train, y_train, epochs=epochs, lr=lr, optimizer=optimizer)# 评估准确率y_pred = mlp.predict(X_test)accuracy = np.mean(np.argmax(y_test, axis=1) == y_pred)print(f"测试集准确率: {accuracy * 100:.2f}%")# 保存最佳模型if accuracy > best_accuracy:best_accuracy = accuracy # 保存最佳模型的准确率best_model = None  # 保存最佳模型best_activation = activation  # 保存最佳的激活函数best_optimizer = optimizer # 保存最佳的优化器print(f"\nBest model with activation '{best_activation}' and optimizer '{best_optimizer}'")
print(f"Validation Accuracy: {best_accuracy * 100:.2f}%")

运行结果如下：