devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

mnist手写数字识别神经网络

作者：盐析白兔 | 2024-08-06 09:41:58

赞

踩

mnist手写数字识别

一.数据集的导入

1.MNIST数据集介绍

        MNIST数据集是由0 到9 的数字图像构成。训练图像有6 万张，测试图像有1 万张，这些图像可以用于学习和推理。MNIST数据集的一般使用方法是，先用训练图像进行学习，再用学习到的模型度量能在多大程度上对测试图像进行正确的分类。 MNIST的图像数据是28 像素 × 28 像素的灰度图像（1 通道），各个像素的取值在0 到255 之间。每个图像数据都相应地标有“7”、“2”、“1”等标签。load_mnist函数以“( 训练图像, 训练标签)，( 测试图像，测试标签)”的形式返回读入的MNIST数据。

1.1MNIST数据集的参数设置

1.1.1normalize

        normalize:是否将图像正规化为0.0-1.0的值，如果设置为False,z=则图像输入保持0~255，这是像素的取值。

  1. (x_train, t_train),(x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
  2. print(x_test)
  3.  
  4.  
  5. [[0. 0. 0. ... 0. 0. 0.]
  6.  [0. 0. 0. ... 0. 0. 0.]
  7.  [0. 0. 0. ... 0. 0. 0.]
  8.  ...
  9.  [0. 0. 0. ... 0. 0. 0.]
  10.  [0. 0. 0. ... 0. 0. 0.]
  11.  [0. 0. 0. ... 0. 0. 0.]]
  12.  
  13.  
  14.  
  15. (x_train, t_train), (x_test, t_test) = load_mnist(normalize=False, flatten=True, one_hot_label=False)
  16. print(x_test)
  17.  
  18.  
  19. [[0 0 0 ... 0 0 0]
  20.  [0 0 0 ... 0 0 0]
  21.  [0 0 0 ... 0 0 0]
  22.  ...
  23.  [0 0 0 ... 0 0 0]
  24.  [0 0 0 ... 0 0 0]
  25.  [0 0 0 ... 0 0 0]]

1.1.2flatten

        faltten:是否将输入图像展开为一维数组，否则图像为1x28x28，展开后为784。

  1. (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
  2. print(x_test)
  3.  
  4.  
  5. [[0. 0. 0. ... 0. 0. 0.]
  6.  [0. 0. 0. ... 0. 0. 0.]
  7.  [0. 0. 0. ... 0. 0. 0.]
  8.  ...
  9.  [0. 0. 0. ... 0. 0. 0.]
  10.  [0. 0. 0. ... 0. 0. 0.]
  11.  [0. 0. 0. ... 0. 0. 0.]]
  12.  
  13.  
  14. (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=False, one_hot_label=False)
  15. print(x_test)
  16.  
  17.  
  18. [[[[0. 0. 0. ... 0. 0. 0.]
  19.    [0. 0. 0. ... 0. 0. 0.]
  20.    [0. 0. 0. ... 0. 0. 0.]
  21.    ...
  22.    [0. 0. 0. ... 0. 0. 0.]
  23.    [0. 0. 0. ... 0. 0. 0.]
  24.    [0. 0. 0. ... 0. 0. 0.]]]
  25.  
  26.  
  27.  [[[0. 0. 0. ... 0. 0. 0.]
  28.    [0. 0. 0. ... 0. 0. 0.]
  29.    [0. 0. 0. ... 0. 0. 0.]
  30.    ...
  31.    [0. 0. 0. ... 0. 0. 0.]
  32.    [0. 0. 0. ... 0. 0. 0.]
  33.    [0. 0. 0. ... 0. 0. 0.]]]
  34.  
  35.  
  36.  [[[0. 0. 0. ... 0. 0. 0.]
  37.    [0. 0. 0. ... 0. 0. 0.]
  38.    [0. 0. 0. ... 0. 0. 0.]
  39.    ...
  40.    [0. 0. 0. ... 0. 0. 0.]
  41.    [0. 0. 0. ... 0. 0. 0.]
  42.    [0. 0. 0. ... 0. 0. 0.]]]
  43.  
  44.  
  45.  ...
  46.  
  47.  
  48.  [[[0. 0. 0. ... 0. 0. 0.]
  49.    [0. 0. 0. ... 0. 0. 0.]
  50.    [0. 0. 0. ... 0. 0. 0.]
  51.    ...
  52.    [0. 0. 0. ... 0. 0. 0.]
  53.    [0. 0. 0. ... 0. 0. 0.]
  54.    [0. 0. 0. ... 0. 0. 0.]]]
  55.  
  56.  
  57.  [[[0. 0. 0. ... 0. 0. 0.]
  58.    [0. 0. 0. ... 0. 0. 0.]
  59.    [0. 0. 0. ... 0. 0. 0.]
  60.    ...
  61.    [0. 0. 0. ... 0. 0. 0.]
  62.    [0. 0. 0. ... 0. 0. 0.]
  63.    [0. 0. 0. ... 0. 0. 0.]]]
  64.  
  65.  
  66.  [[[0. 0. 0. ... 0. 0. 0.]
  67.    [0. 0. 0. ... 0. 0. 0.]
  68.    [0. 0. 0. ... 0. 0. 0.]
  69.    ...
  70.    [0. 0. 0. ... 0. 0. 0.]
  71.    [0. 0. 0. ... 0. 0. 0.]
  72.    [0. 0. 0. ... 0. 0. 0.]]]]
  73.

1.1.3one_hot_label

        one_hot_label:是否将标签保存为one_hot，指的是如原本图像的标签为[1,2,3,4,5],one_hot之后只有1和0，经过计算后，最符合的标签为1，如识别出这个图像的数字是2，则one_hot表现为[0,1,0,0,0]这种模式。

  1. (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
  2. print(t_test)
  3.  
  4.  
  5. [7 2 1 ... 4 5 6]
  6.  
  7.  
  8. (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=True)
  9. print(t_test)
  10.  
  11.  
  12. [[0. 0. 0. ... 1. 0. 0.]
  13.  [0. 0. 1. ... 0. 0. 0.]
  14.  [0. 1. 0. ... 0. 0. 0.]
  15.  ...
  16.  [0. 0. 0. ... 0. 0. 0.]
  17.  [0. 0. 0. ... 0. 0. 0.]
  18.  [0. 0. 0. ... 0. 0. 0.]]
  19.

2.导入MNIST数据集

  1. def get_data():
  2.     """
  3.     读取数据
  4.     :return:
  5.     """
  6.     (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, flatten=True, one_hot_label=False)
  7.     """                                               normalize:是否将图像正规化为0.0-1.0的值，如果设置为False,z=则图像输入保持0~255，这是像素的取值。
  8.                                                       faltten:是否将输入图像展开为一维数组，否则图像为1x28x28，展开后为784。
  9.                                                       one_hot_label:是否将标签保存为one_hot，如原本图像的标签为[1,2,3,4,5],one_hot之后只有1和0，
  10.                                                       如识别出这个图像的数字是2，则one_hot表现为[0,1,0,0,0]这种模式。
  11.     """
  12.     return x_test, t_test

二.神经网络的搭建

1.激活函数

1.1sigmoid激活函数

1.2softmax激活函数

1.3激活函数代码

  1. def sigmoid(x):
  2.     return 1 / (1 + np.exp(-x))
  3.  
  4. def softmax(x):
  5.     x = x - np.max(x)  # 溢出对策
  6.     return np.exp(x) / np.sum(np.exp(x))

2.模型参数

        这里使用了pickle功能，此功能可以将程序运行中的对象保存为文件，第二次加载时可以快速复原此程序运行中的对象。sample_weight是训练好的权重与偏置参数。

  1. #训练好的参数
  2. def init_network():
  3.     with open("sample_weight.pkl", 'rb') as f:
  4.         network = pickle.load(f)#load()从字符串中恢复对象。sample_weight.pkl是以字典形式储存的训练好的样本权重
  5.     return network

3.构建模型

        神经网络的输入层有784 个神经元，输出层有10 个神经元。输入层的784 这个数字来源于图像大小的28 × 28 = 784，输出层的10 这个数字来源于10 类别分类（数字0 到9，共10 类别）。此外，这个神经网络有2 个隐藏层，第1 个隐藏层有50 个神经元，第2 个隐藏层有100 个神经元。这个50 和100 可以设置为任何值。

  1. def predict(network, x):
  2.     w1, w2, w3 = network['W1'], network['W2'], network['W3']
  3.     b1, b2, b3 = network['b1'], network['b2'], network['b3']
  4.  
  5.     """
  6.     输入层784个神经元
  7.     第二层隐藏层50个神经元
  8.     第三层隐藏层100个神经元
  9.     输出层10个神经元
  10.     """
  11.  
  12.     a1 = np.dot(x, w1) + b1#x.shape=(1000,784),w1.shape=(784,50),b1.shape=(50,)
  13.     z1 = sigmoid(a1)
  14.     a2 = np.dot(z1, w2) + b2#z1.shape=(1000,50),w2.shape=(50,100),b2.shape=(100,）
  15.     z2 = sigmoid(a2)
  16.     a3 = np.dot(z2, w3) + b3#z2.shape=(1000,100),w3.shape=(100,10),b3.shape(10,)
  17.     y = softmax(a3)#y.shape=(1000,10)
  18.  
  19.     return y

三.批处理

        如果我们改成每次处理100张图片，基于数值计算的库都能够高效处理大型数组的运算，并且在神经网络的运算中当数据传送成为瓶颈时，批处理可以减小数据总线的负荷，将更多资源用于计算上。批处理的数量可以更改，在实际测试中并未影响正确率。

  1. #预设
  2. x, t = get_data()
  3. network = init_network()
  4. batch_size = 1000 # 批数量
  5. accuracy_cnt = 0#预测正确数初始化
  6.  
  7. for i in range(0, len(x), batch_size):
  8.     x_batch = x[i:i+batch_size]#每批次取1000张图片
  9.     y_batch = predict(network, x_batch)#1000张图片的预测结果 shape=(1000.10)
  10.     p = np.argmax(y_batch, axis=1)#每张图片的预测结果中找出概率最大值的下标，axis=1按行找出最大值的下标，下标达标该图片所代表的的预测值 p.shape=(1000,)
  11.     accuracy_cnt += np.sum(p == t[i:i+batch_size])#预测值和正确值相比较返回bool值矩阵，True的值是1,False的值是0，对矩阵求和即可得到预测正确数，并进行累加求和
  12.  
  13. print("正确率:" + str((accuracy_cnt/ len(x))))

四.完整代码

  1. import sys, os
  2. sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
  3. import numpy as np
  4. import pickle#python的pickle模块实现了基本的数据序列化和反序列化。序列化对象可以在磁盘上保存对象，并在需要的时候读取出来。任何对象都可以执行序列化操作
  5. from dataset.mnist import load_mnist
  6.  
  7.  
  8. def sigmoid(x):
  9.     return 1 / (1 + np.exp(-x))
  10.  
  11. def softmax(x):
  12.     x = x - np.max(x)  # 溢出对策
  13.     return np.exp(x) / np.sum(np.exp(x))
  14.  
  15. def get_data():
  16.     """
  17.     读取数据
  18.     :return:
  19.     """
  20.     (x_train, t_train), (x_test, t_test) = load_mnist(normalize=False, flatten=True, one_hot_label=False)
  21.     """                                               normalize:是否将图像正规化为0.0-1.0的值，如果设置为False,z=则图像输入保持0~255，这是像素的取值。
  22.                                                       faltten:是否将输入图像展开为一维数组，否则图像为1x28x28，展开后为784。
  23.                                                       one_hot_label:是否将标签保存为one_hot，如原本图像的标签为[1,2,3,4,5],one_hot之后只有1和0，
  24.                                                       如识别出这个图像的数字是2，则one_hot表现为[0,1,0,0,0]这种模式。
  25.     """
  26.     return x_test, t_test
  27.  
  28. #训练好的参数
  29. def init_network():
  30.     with open("sample_weight.pkl", 'rb') as f:
  31.         network = pickle.load(f)#load()从字符串中恢复对象。sample_weight.pkl是以字典形式储存的训练好的样本权重
  32.     return network
  33.  
  34.  
  35. def predict(network, x):
  36.     w1, w2, w3 = network['W1'], network['W2'], network['W3']
  37.     b1, b2, b3 = network['b1'], network['b2'], network['b3']
  38.  
  39.     """
  40.     输入层784个神经元
  41.     第二层隐藏层50个神经元
  42.     第三层隐藏层100个神经元
  43.     输出层10个神经元
  44.     """
  45.  
  46.     a1 = np.dot(x, w1) + b1#x.shape=(1000,784),w1.shape=(784,50),b1.shape=(50,)
  47.     z1 = sigmoid(a1)
  48.     a2 = np.dot(z1, w2) + b2#z1.shape=(1000,50),w2.shape=(50,100),b2.shape=(100,）
  49.     z2 = sigmoid(a2)
  50.     a3 = np.dot(z2, w3) + b3#z2.shape=(1000,100),w3.shape=(100,10),b3.shape(10,)
  51.     y = softmax(a3)#y.shape=(1000,10)
  52.  
  53.     return y
  54.  
  55. #预设
  56. x, t = get_data()
  57. network = init_network()
  58. batch_size = 1000 # 批数量
  59. accuracy_cnt = 0#预测正确数初始化
  60.  
  61. for i in range(0, len(x), batch_size):
  62.     x_batch = x[i:i+batch_size]#每批次取1000张图片
  63.     y_batch = predict(network, x_batch)#1000张图片的预测结果 shape=(1000.10)
  64.     p = np.argmax(y_batch, axis=1)#每张图片的预测结果中找出概率最大值的下标，axis=1按行找出最大值的下标，下标达标该图片所代表的的预测值 p.shape=(1000,)
  65.     accuracy_cnt += np.sum(p == t[i:i+batch_size])#预测值和正确值相比较返回bool值矩阵，True的值是1,False的值是0，对矩阵求和即可得到预测正确数，并进行累加求和
  66.  
  67. print("正确率:" + str((accuracy_cnt/ len(x))))
  68.

五.参考资料

深度学习入门--02 初识神经网络

深度学习入门——03 MNIST手写数字图像集识别实验

《大数据算法学习》（三）MNIST手写数字识别

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/936880
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号