MNIST手写字体识别：python不使用深度学习库函数

已于 2024-07-07 21:15:43 修改
阅读量219 收藏 5
点赞数 4
分类专栏： 机器学习 笔记 神经网络训练技巧 文章标签： python 深度学习 神经网络
于 2024-06-13 14:13:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sky_ying/article/details/139651851
版权

# 当一个门外汉做交叉方向研究，选修了神经网络之后的大作业

# 训练结果，预测精度达97.75%

手写体数字分类是机器学习中的一个经典问题，主要目的实现手写数字图像的自动识别。该问题使用MNIST数据集进行研究，MNIST数据集包含60000张训练图像和10000张测试图像，每张图像为28x28像素，表示从0到9的手写数字。目标是设计一个基于神经网络的分类器，能够准确地将每张图像分配到正确的数字类别。

手写体数字分类问题可以采用多种方法进行解决，包括但不限于：

  1. 基础分类算法：决策树；逻辑回归；支持向量机（SVM）；朴素贝叶斯；K-最近邻；神经网络；贝叶斯网络；线性判别分析；最大熵模型；
  2. 集成分类算法：随机森林；AdaBoost；梯度提升决策树（GBDT）；极端梯度提升（XGBoost）；
  3. 决策树桩；K-最近邻朴素贝叶斯

训练数据介绍：

mnist手写字体有60000组图片和标签做训练集，以及10000组图片和标签做测试集

mnist数据下载地址：http://yann.lecun.com/exdb/mnist/

    # 解压和读取MNIST数据
    def load_mnist_images(self, filename):
        with gzip.open(filename, 'rb') as f:
            f.read(16)  # 跳过前16个字节
            data = np.frombuffer(f.read(), dtype=np.uint8).reshape(-1, 28 * 28)
        return data / 255.0  # 归一化到[0, 1]

    def load_mnist_labels(self, filename):
        with gzip.open(filename, 'rb') as f:
            f.read(8)  # 跳过前8个字节
            labels = np.frombuffer(f.read(), dtype=np.uint8)
        return labels  # 转换为one-hot编码

网络结构

四层：分别是一层28*28的图案输入层，两层隐藏层（80，40），最后一层输出层（10）

    def init_network(self):

        self.W1 = 0.01 * np.random.randn(28 * 28, 80)
        self.b1 = 0.01 * np.random.randn(1, 80)

        self.W2 = 0.01 * np.random.randn(80, 40)
        self.b2 = 0.01 * np.random.randn(1, 40)

        self.W3 = 0.01 * np.random.randn(40, self.K)
        self.b3 = 0.01 * np.random.randn(1, self.K)

激活函数：前几层是Relu，最后一层是Softmax

    def train_network(self, img_batch_list, label_batch_list):

        train_example_num = img_batch_list.shape[0]
        # 使用relu激活函数
        hidden_layer1 = np.maximum(0, np.matmul(img_batch_list, self.W1) + self.b1)
        hidden_layer2 = np.maximum(0, np.matmul(hidden_layer1, self.W2) + self.b2)

        # 使用softmax激活函数
        scores = np.matmul(hidden_layer2, self.W3) + self.b3
        scores_e = np.exp(scores)
        scores_e_sum = np.sum(scores_e, axis=1, keepdims=True)
        probs = scores_e / scores_e_sum

迭代过程：batchsize是3000，训练2500轮，每轮都训练完整的训练集，不随机采样

    def train(self):
        # 所有数据循环训练一轮
        for i in range(2500):
            # 按batchsize训练完所有的数据
            for j in range(0, self.N, self.BATCHSIZE):
                img_list = self.train_img_list[j:j + self.BATCHSIZE]
                label_list = self.train_label_list[j:j + self.BATCHSIZE]
                self.train_network(img_list, label_list)
            if i % 500 == 0:
                print("Train Time: ", i)
                self. Predict()

损失函数：使用交叉熵损失函数，训练过程中加入了L2正则化项对损失函数修正，避免过拟合

        # 计算损失
        loss_list_tmp = np.zeros((train_example_num, 1))
        for i in range(train_example_num):
            loss_list_tmp[i] = scores_e[i][int(label_batch_list[i])] / scores_e_sum[i]
        loss_list = -np.log(loss_list_tmp)

        loss = np.mean(loss_list, axis=0)[0] + 0.5 * self.reg_factor * np.sum(self.W1 * self.W1) + 0.5 * self.reg_factor * np.sum(self.W2 * self.W2) + \
               0.5 * self.reg_factor * np.sum(self.W3 * self.W3)

        self.loss_list.append(loss)

权重和偏置更替：手推的过程之后再发，先欠着，这里也可以改进写得简洁一点

        dW3 = np.dot(hidden_layer2.T, dscore)
        db3 = np.sum(dscore, axis=0, keepdims=True)

        dh2 = np.dot(dscore, self.W3.T)
        dh2[hidden_layer2 <= 0] = 0

        dW2 = np.dot(hidden_layer1.T, dh2)
        db2 = np.sum(dh2, axis=0, keepdims=True)

        dh1 = np.dot(dh2, self.W2.T)
        dh1[hidden_layer1 <= 0] = 0

        dW1 = np.dot(img_batch_list.T, dh1)
        db1 = np.sum(dh1, axis=0, keepdims=True)

        dW3 += self.reg_factor * self.W3
        dW2 += self.reg_factor * self.W2
        dW1 += self.reg_factor * self.W1

        self.W3 += -self.stepsize * dW3
        self.W2 += -self.stepsize * dW2
        self.W1 += -self.stepsize * dW1

        self.b3 += -self.stepsize * db3
        self.b2 += -self.stepsize * db2
        self.b1 += -self.stepsize * db1

网络评估

最后使用测试集评估网络模型，评估模型预测的准确度

    def predict(self):

        hidden_layer1 = np.maximum(0, np.matmul(self.test_img_list, self.W1) + self.b1)
        hidden_layer2 = np.maximum(0, np.matmul(hidden_layer1, self.W2) + self.b2)
        scores = np.matmul(hidden_layer2, self.W3) + self.b3
        prediction = np.argmax(scores, axis=1)
        prediction = np.reshape(prediction, (10000, ))
        print(prediction == self.test_label_list)
        accuracy = np.mean(prediction == self.test_label_list)
        print('The accuracy of test data is:  ', accuracy)

        return

图案绘制及预测结果输出：

    for i in range(100):
        outputs = data.query(data.test_img_list[i])
        label = np.argmax(outputs)
        print(label)
        print(data.test_label_list[i])
        image_array = data.test_img_list[i].reshape(28, 28)
        plt.imshow(image_array, cmap="Greys", interpolation='None')
        plt.pause(0.001)
        plt.show()
    print('done')

保存权重偏置和损失：

    # 保存损失
    np.savetxt('./loss_mnist.txt', np.array(data.loss_list))
    # 保存模型权重和偏置
    weight_bias_mnist = {'W1': data.W1, 'b1': data.b1, 'W2': data.W2, 'b2': data.b2, 'W3': data.W3, 'b3': data.b3}
    np.save('./weight_bias_mnist.npy', weight_bias_mnist)

完整的代码如下：

import numpy as np
import matplotlib.pyplot as plt
import gzip


class Data:
    def __init__(self):

        self.K = 10
        self.N = 60000
        self.M = 10000
        self.BATCHSIZE = 3000
        self.reg_factor = 1e-3
        self.stepsize = 5e-2
        # 同目录下的文件
        self.train_img_list = self.load_mnist_images('mnist/train-images-idx3-ubyte.gz')
        self.train_label_list = self.load_mnist_labels('mnist/train-labels-idx1-ubyte.gz')
        self.test_img_list = self.load_mnist_images('mnist/t10k-images-idx3-ubyte.gz')
        self.test_label_list = self.load_mnist_labels('mnist/t10k-labels-idx1-ubyte.gz')
        self.loss_list = []
        self.init_network()

    # 解压和读取MNIST数据
    def load_mnist_images(self, filename):
        with gzip.open(filename, 'rb') as f:
            f.read(16)  # 跳过前16个字节
            data = np.frombuffer(f.read(), dtype=np.uint8).reshape(-1, 28 * 28)
        return data / 255.0  # 归一化到[0, 1]

    def load_mnist_labels(self, filename):
        with gzip.open(filename, 'rb') as f:
            f.read(8)  # 跳过前8个字节
            labels = np.frombuffer(f.read(), dtype=np.uint8)
        return labels  # 转换为one-hot编码

    def predict(self):

        hidden_layer1 = np.maximum(0, np.matmul(self.test_img_list, self.W1) + self.b1)
        hidden_layer2 = np.maximum(0, np.matmul(hidden_layer1, self.W2) + self.b2)
        scores = np.matmul(hidden_layer2, self.W3) + self.b3
        prediction = np.argmax(scores, axis=1)
        prediction = np.reshape(prediction, (10000, ))
        print(prediction == self.test_label_list)
        accuracy = np.mean(prediction == self.test_label_list)
        print('The accuracy of test data is:  ', accuracy)

        return

    def query(self, inputs_list):
        hidden_layer1 = np.maximum(0, np.matmul(inputs_list, self.W1) + self.b1)

        hidden_layer2 = np.maximum(0, np.matmul(hidden_layer1, self.W2) + self.b2)

        scores = np.matmul(hidden_layer2, self.W3) + self.b3
        return scores

    def train(self):
        # 所有数据循环训练一轮
        for i in range(2500):
            # 按batchsize训练完所有的数据
            for j in range(0, self.N, self.BATCHSIZE):
                img_list = self.train_img_list[j:j + self.BATCHSIZE]
                label_list = self.train_label_list[j:j + self.BATCHSIZE]
                self.train_network(img_list, label_list)
            if i % 500 == 0:
                print("Train Time: ", i)
                self.predict()

    def train_network(self, img_batch_list, label_batch_list):

        train_example_num = img_batch_list.shape[0]
        # 使用relu激活函数
        hidden_layer1 = np.maximum(0, np.matmul(img_batch_list, self.W1) + self.b1)
        hidden_layer2 = np.maximum(0, np.matmul(hidden_layer1, self.W2) + self.b2)

        # 使用softmax激活函数
        scores = np.matmul(hidden_layer2, self.W3) + self.b3
        scores_e = np.exp(scores)
        scores_e_sum = np.sum(scores_e, axis=1, keepdims=True)
        probs = scores_e / scores_e_sum

        # 计算损失
        loss_list_tmp = np.zeros((train_example_num, 1))
        for i in range(train_example_num):
            loss_list_tmp[i] = scores_e[i][int(label_batch_list[i])] / scores_e_sum[i]
        loss_list = -np.log(loss_list_tmp)

        loss = np.mean(loss_list, axis=0)[0] + 0.5 * self.reg_factor * np.sum(self.W1 * self.W1) + 0.5 * self.reg_factor * np.sum(self.W2 * self.W2) + \
               0.5 * self.reg_factor * np.sum(self.W3 * self.W3)

        self.loss_list.append(loss)

        dscore = np.zeros((train_example_num, self.K))
        for i in range(train_example_num):
            dscore[i][:] = probs[i][:]
            dscore[i][int(label_batch_list[i])] -= 1

        dscore /= train_example_num

        dW3 = np.dot(hidden_layer2.T, dscore)
        db3 = np.sum(dscore, axis=0, keepdims=True)

        dh2 = np.dot(dscore, self.W3.T)
        dh2[hidden_layer2 <= 0] = 0

        dW2 = np.dot(hidden_layer1.T, dh2)
        db2 = np.sum(dh2, axis=0, keepdims=True)

        dh1 = np.dot(dh2, self.W2.T)
        dh1[hidden_layer1 <= 0] = 0

        dW1 = np.dot(img_batch_list.T, dh1)
        db1 = np.sum(dh1, axis=0, keepdims=True)

        dW3 += self.reg_factor * self.W3
        dW2 += self.reg_factor * self.W2
        dW1 += self.reg_factor * self.W1

        self.W3 += -self.stepsize * dW3
        self.W2 += -self.stepsize * dW2
        self.W1 += -self.stepsize * dW1

        self.b3 += -self.stepsize * db3
        self.b2 += -self.stepsize * db2
        self.b1 += -self.stepsize * db1

        return

    def init_network(self):

        self.W1 = 0.01 * np.random.randn(28 * 28, 80)
        self.b1 = 0.01 * np.random.randn(1, 80)

        self.W2 = 0.01 * np.random.randn(80, 40)
        self.b2 = 0.01 * np.random.randn(1, 40)

        self.W3 = 0.01 * np.random.randn(40, self.K)
        self.b3 = 0.01 * np.random.randn(1, self.K)


def main():
    data = Data()
    data.train()
    data.predict()
    # 保存损失
    np.savetxt('./loss_mnist.txt', np.array(data.loss_list))
    # 保存模型权重和偏置
    weight_bias_mnist = {'W1': data.W1, 'b1': data.b1, 'W2': data.W2, 'b2': data.b2, 'W3': data.W3, 'b3': data.b3}
    np.save('./weight_bias_mnist.npy', weight_bias_mnist)

    for i in range(100):
        outputs = data.query(data.test_img_list[i])
        label = np.argmax(outputs)
        print(label)
        print(data.test_label_list[i])
        image_array = data.test_img_list[i].reshape(28, 28)
        plt.imshow(image_array, cmap="Greys", interpolation='None')
        plt.pause(0.001)
        plt.show()
    print('done')


if __name__ == '__main__':
    main()

各位好姐好哥要是需要，可以点个赞嗷

这里有完整的技术报告：包括问题描述，分类方法总结，该方法说明，实验结果，参考文献。训练损失图，权重偏置，以及完整的代码和数据集，下载即可食用MNIST手写字体识别：python不使用深度学习库函数

真难学啊
关注
专栏目录
通过MNIST手写数字识别任务快速入门深度学习（事无巨细版）
你不懂猪刚鬣
03-03 1180
深度学习(DL, Deep Learning)是机器学习(ML, Machine Learning)领域中一个研究方向。深度学习通过对样本数据的内在规律和特征的提取与抽象，在不同维度和层次上进行处理，让机器能够像人一样具有分析学习能力，能够识别文字、图像和声音等数据。相比于初期的机器学习，深度学习是更加复杂的算法，但是同时因为深度学习算法的普适性，以及在语音和图像识别方面取得的惊人效果，他的发展速度远远超过先前相关技术。
Pytorch入门一：卷积神经网络实现MNIST手写数字识别
热门推荐
GuDoerr的博客
02-13 1万+
1. pytorch介绍 Pytorch是Torch7团队开发的，与Torch的不同之处在于Pytorch使用了Python作为开发语言，同样说明它是一个以Python优先的深度学习框架，它不仅能够实现强大的GPU加速，同时还支持动态神经网络，这是TensorFlow等很多主流框架不支持的。而且Pytorch可以轻松扩展，近两年有赶超TensorFlow的势头 Pytorch中有两种变量类型，...
用Python实现BP神经网络mnist手写数字识别（不使用tensorflow）
douerw的博客
04-06 1070
效果展示 遇到的问题 为了使用Image这个包，查了好多博客……最终的解决方案见这里（待写好了添加超链接） 本文使用到的代码来源 BP神经网络mnist手写数字识别Python实现 Github网址直接下载源码（源于 ↑ 的博客） ...
深度学习-第P1周——实现mnist手写数字识别
qq_45735298的博客
12-06 1598
MNIST手写数字识别
基于Python的卷积神经网络分类器识别0-9的MNIST手写数据集
毕业作品网站
09-27 2034
以MNIST手写数据集划分训练集和验证集，将自己手写拍照上传的数字图片作为测试样本，训练卷积神经网络分类器识别0-9的手写数字。
深度学习之使用BP神经网络识别MNIST数据集
woweibiancheng的博客
04-08 1514
熵是用来描述一个系统的混乱程度,通过交叉熵我们就能够确定预测数据与真是数据之间的相近程度。交叉熵越小，表示数据越接近真实样本。（预测的概率就是我们的预测值的准确值）
Mnist手写数字集的识别和可视化
m0_58729094的博客
12-31 1500
Mnist的训练可视化处理
手写数字的识别，基于Mnist数据集，请用朴素贝叶斯分类器对手写数字进行识别，并输出准确率 要求： 编程语言：Python 不能使用额外的库函数，自己编写实现算法。
04-16
为了确保不使用任何库函数，我需要自己编写实现算法。以下是我的实现过程。 首先需要读取Mnist数据集，并将数据进行处理。 ```python import gzip import numpy as np def load_mnist_images(filename): with ...
自助餐剩余食品识别图像分割系统：教学内容全覆盖
sgcsdn99的博客
11-04 1361
数据集信息展示在本研究中，我们使用的数据集名为“9_5_Merged”，该数据集专门用于训练改进YOLOv8-seg的自助餐剩余食品识别图像分割系统。该数据集包含71个类别，涵盖了丰富多样的食品种类，旨在提高模型对不同类型剩余食品的识别和分割能力。通过对这些类别的细致划分，我们希望能够实现更高精度的图像分割，进而优化自助餐剩余食品的管理和利用。
【anaconda】使用记录
zhuyan108的博客
11-05 308
window11 下安装anaconda。
探索 Python 的新天地：Helium 库揭秘
AIGC搞起
11-04 792
在自动化测试和网页交互的领域，Selenium 是一个强大的工具，但它的复杂性和陡峭的学习曲线让许多开发者望而却步。Helium库的出现，以其简洁的 API 和易用性，为 Python 开发者提供了一个新的选择。它不仅简化了 Selenium 的使用，还自带 WebDriver，减少了配置的复杂性。Helium 以其简洁的 API 和易用性，为 Python 开发者提供了一个强大的 Selenium 替代方案。它不仅减少了代码量，还简化了 WebDriver 的管理，使得自动化测试和网页交互变得更加容易。
01_IAR新建CC2530工程
nanxl1的博客
11-02 1040
由于很多Zigbee商家提供的教程未有从零建立CC2530工程的讲解，可能会导致后面的开发中出现一些琐碎的问题。本文将以**LED流水灯**为例，从0到1用**IAR**建立CC2530工程。
Python小游戏21——拼图小游戏
cxh666888_的博客
11-05 987
如果图像大小不同，你需要调整tile_size和图像缩放代码。初始化Pygame：使用pygame.init()来初始化Pygame库，这是使用Pygame进行任何游戏开发的第一步。更新屏幕：使用pygame.display.flip()或pygame.display.update()来更新屏幕显示。调整图像大小：使用pygame.transform.scale()来调整图像的大小，以适应拼图游戏的需求。设置屏幕尺寸：使用pygame.display.set_mode()来设置游戏的屏幕尺寸和模式。
cleanfid库的fid使用，及其使用CLIP模型clip_vit_b_32计算FID
百年孤独百年的博客
11-02 970
这篇博客详细介绍了如何使用 cleanfid 库计算 Fréchet Inception Distance (FID)，特别是利用 CLIP 模型 clip_vit_b_32 计算 FID 分数来评估生成图像的质量。内容涵盖了 FID 的概念和原理、cleanfid 库的安装与配置、从缓存中加载与手动加载模型的方法，以及解决可能遇到的依赖问题。通过这篇教程，可以掌握使用 cleanfid 库计算fid的完整流程，并能够解决服务器环境中遇到的联网与模型下载问题。
Python的自然语言生成与对话系统介绍
最新发布
余生的博客
11-05 693
自然语言生成(Natural Language Generation，NLG)和对话系统是人工智能领域的重要研究方向。NLG 涉及将计算机理解的信息转换为自然语言文本，而对话系统则涉及计算机与用户之间的自然语言交互。Python 作为一种易于学习、易于使用的编程语言，在这两个领域中发挥了重要作用。核心概念与联系核心算法原理和具体操作步骤数学模型公式详细讲解具体最佳实践：代码实例和详细解释说明实际应用场景工具和资源推荐总结：未来发展趋势与挑战。
Python中的模块
piziliul的博客
11-04 244
创建introduce.py模块文件。创建my_info.py模块文件。
爬台阶问题
小杏儿的小家
11-05 424
爬楼梯问题的分析，思考，解析以及如何动手用代码进行实践。
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 257
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值