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

whabc1002025-07-14 21:27

拟分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，确保在前向传播和反向传播时分别计算激活值及其导数。

python 复制代码 
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] = 1
    return encoded

y_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/tanh
        self.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**2

    def forward(self, X):
        """前向传播"""
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1, self.da1 = self._activate(self.z1)  # 隐藏层激活值及导数
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = np.exp(self.z2) / np.sum(np.exp(self.z2), axis=1, keepdims=True)  # Softmax输出
        return self.a2

    def 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_true
        dW2 = np.dot(self.a1.T, error_output) / m
        db2 = np.sum(error_output, axis=0, keepdims=True) / m
        
        # 隐藏层梯度 (dL/dz1)
        error_hidden = np.dot(error_output, self.W2.T) * self.da1
        dW1 = np.dot(X.T, error_hidden) / m
        db1 = np.sum(error_hidden, axis=0, keepdims=True) / m
        return dW1, db1, dW2, db2

    def update_params(self, dW1, db1, dW2, db2, lr=0.01, optimizer='sgd', momentum=0.9):
        """参数更新（支持SGD/Momentum/Adam）"""
        if optimizer == 'sgd':
            self.W1 -= lr * dW1
            self.b1 -= lr * db1
            self.W2 -= lr * dW2
            self.b2 -= lr * db2
        elif 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 * dW1
            self.v_db1 = momentum * self.v_db1 + lr * db1
            self.v_dW2 = momentum * self.v_dW2 + lr * dW2
            self.v_db2 = momentum * self.v_db2 + lr * db2
            # 应用更新
            self.W1 -= self.v_dW1
            self.b1 -= self.v_db1
            self.W2 -= self.v_dW2
            self.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)*dW1
            self.v_W1 = self.beta2*self.v_W1 + (1-self.beta2)*(dW1**2)
            self.m_b1 = self.beta1*self.m_b1 + (1-self.beta1)*db1
            self.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)*dW2
            self.v_W2 = self.beta2*self.v_W2 + (1-self.beta2)*(dW2**2)
            self.m_b2 = self.beta1*self.m_b2 + (1-self.beta1)*db2
            self.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、Tanh
    for optimizer in ['sgd', 'momentum', 'adam']:  # 优化器分别为SGD、Momentum和Adam
        print(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}%")

运行结果如下：

相关推荐
DFRobot智位机器人34 分钟前
AIOT开发选型：行空板 K10 与 M10 适用场景与选型深度解析
人工智能
想成为风筝3 小时前
从零开始学习深度学习—水果分类之PyQt5App
人工智能·深度学习·计算机视觉·pyqt
F_D_Z3 小时前
MMaDA：多模态大型扩散语言模型
人工智能·语言模型·自然语言处理
大知闲闲哟3 小时前
深度学习G2周：人脸图像生成（DCGAN）
人工智能·深度学习
飞哥数智坊3 小时前
Coze实战第15讲：钱都去哪儿了？Coze+飞书搭建自动记账系统
人工智能·coze
wenzhangli73 小时前
低代码引擎核心技术：OneCode常用动作事件速查手册及注解驱动开发详解
人工智能·低代码·云原生
潘达斯奈基~4 小时前
大模型的Temperature、Top-P、Top-K、Greedy Search、Beem Search
人工智能·aigc
倔强青铜三5 小时前
苦练Python第18天：Python异常处理锦囊
人工智能·python·面试
倔强青铜三5 小时前
苦练Python第17天：你必须掌握的Python内置函数
人工智能·python·面试
Lifeng666666665 小时前
chatgpt是怎么诞生的，详解GPT1到GPT4的演化之路及相关背景知识
论文阅读·人工智能·语言模型·chatgpt
热门推荐
01全球最强模型Grok4，国内已可免费使用！（附教程）02KGG转MP3工具|非KGM文件|解密音频03Coze扣子平台完整体验和实践（附国内和国际版对比）04使用Ruby接入实时行情API教程05集群聊天服务器---MySQL数据库的建立06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07LOT: 通过逻辑增强大型语言模型的零样本Chain-of-Thought推理能力08基于odoo17的设计模式详解---单例模式09DeepSeek各版本说明与优缺点分析10身弱武修法：玄之又玄，奇妙之门