keras实现mnist数据集手写数字识别

Posted 2021-01-12 ncuhwxiong

一. Tensorflow环境的安装

这里我们只讲CPU版本，使用 Anaconda 进行安装

a.首先我们要安装 Anaconda

链接：https://pan.baidu.com/s/1AxdGi93oN9kXCLdyxOMnRA 密码：79ig

过程如下：

第一步：点击next

第二步：I Agree

第三步：Just ME

第四步：自己选择一个恰当位置放它就好

第五步：建议只选择第二个

第六步：就直接install啦啦啦啦，然后你就可以上手万能库了

b.找到Anaconda prompt，然后

 

以管理员的身份打开终端

c.按照以下步骤在 Anaconda 环境中安装 TensorFlow：

1. 通过调用以下命令创建名为 tensorflow 的 conda 环境：

C:> conda create -n tensorflow pip python=3.5

1. 通过发出以下命令激活 conda 环境：

C:> activate tensorflow (tensorflow)C:> # Your prompt should change

1. 发出相应命令以在 conda 环境中安装 TensorFlow。要安装仅支持 CPU 的 TensorFlow 版本，请输入以下命令：

(tensorflow)C:> pip install --ignore-installed --upgrade tensorflow

d.测试tensorflow的安装

启动Anaconda prompt（同样是以管理员身份打开）终端。

如果您是通过 Anaconda 进行安装，请激活您的 Anaconda 环境。

终端输入 activate tensorflow即可

然后再输入python

如：

在 Python 交互式 shell 中输入以下几行简短的程序代码：

>>> import tensorflow as tf

>>> hello = tf.constant(‘Hello, TensorFlow!‘)

>>> sess = tf.Session()

>>> print(sess.run(hello))

如果系统输出以下内容，说明您可以开始编写 TensorFlow 程序了：

Hello, TensorFlow!

完成以上步骤，你就把tensorflow搭建好了......

二.安装keras

a.首先，担心我们anaconda里面各个包未更新到最新，所以我们以管理员的身份打开Anaconda终端，输入 conda update conda,执行完后，再输入：conda update --all

b.然后我们激活我们的tensorflow环境：activate tensorflow

c.然后我们就可以输入：pip install keras

三.完成上述步骤，我们就可以来试下加载keras里面的mnist数据集了

# Plot ad hoc mnist instances
from keras.datasets import mnist
import matplotlib.pyplot as plt
# load (downloaded if needed) the MNIST dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# plot 4 images as gray scale
plt.subplot(221)
plt.imshow(X_train[0], cmap=plt.get_cmap(‘gray‘))
plt.subplot(222)
plt.imshow(X_train[1], cmap=plt.get_cmap(‘gray‘))
plt.subplot(223)
plt.imshow(X_train[2], cmap=plt.get_cmap(‘gray‘))
plt.subplot(224)
plt.imshow(X_train[3], cmap=plt.get_cmap(‘gray‘))
# show the plot
plt.show()

 

 

好了接下来我们对上述代码进行进一步的解释：
 
from keras.datasets import mnist 这里是从keras的datasets中导入mnist数据集
import matplotlib.pyplot as plt  这里是将matplotlib.pyplot重名为plt
(X_train, y_train), (X_test, y_test) = mnist.load_data()#
所以这里返回的是手写图片的两个tuple，第一个tuple存储的是我们已经人工分类好的图片，也就是每一张图片都有自己对应的标签，然后可以拿来训练，第二个tuple存储的是我们还没分类的图片，在第一个tuple训练完后，我们可以把第二个tuple利用神经网络进行分类，根据实验结果的真实值与我们的预测值进行对比得到相应的损失值，再利用反向传播进行参数更新，再进行分类，然后重复前述步骤直至损失值最小
# plot 4 images as gray scale
plt.subplot(331)
这个subplot函数的作用是确定图像的位置以及图像的个数，前两个3的意思是可以放9张图片，如果变成221的话，就是可以放4张图片，然后后面的1，是确定图像的位置，处于第一个，以下的subplot同理
plt.imshow(X_test[0], cmap=plt.get_cmap(‘gray‘))
这里个把图片显示出来
X_train存储的是图像的像素点组成的list数据类型，这里面又由一个二维的list（28 x 28的像素点值）和一个对应的标签list组成，y_train存储的是对应图像的标签，也就是该图像代表什么数字
plt.subplot(332)
plt.imshow(X_train[1], cmap=plt.get_cmap(‘gray‘))
plt.subplot(333)
plt.imshow(X_train[2], cmap=plt.get_cmap(‘gray‘))
plt.subplot(334)
plt.imshow(X_train[3], cmap=plt.get_cmap(‘gray‘))
plt.subplot(335)
plt.imshow(X_train[4], cmap=plt.get_cmap(‘gray‘))
plt.subplot(336)
plt.imshow(X_train[5], cmap=plt.get_cmap(‘gray‘))
plt.subplot(337)
plt.imshow(X_train[6], cmap=plt.get_cmap(‘gray‘))
plt.subplot(338)
plt.imshow(X_train[7], cmap=plt.get_cmap(‘gray‘))
plt.subplot(339)
plt.imshow(X_train[8], cmap=plt.get_cmap(‘gray‘))
在这里imshow函数的官方文档：https://matplotlib.org/api/_as_gen/matplotlib.pyplot.imshow.html#matplotlib.pyplot.imshow
我们这里第一个参数是图片的像素点值组成的数组（列表），第二个参数是指明图片的色彩
# show the plot
plt.show()最后这里官方文档是这样说的：Display a figure. When running in ipython with its pylab mode, display all figures and return to the ipython prompt.，所以我们可以知道show函数是把所有图片都展示出来。

 

效果：

多层感知机的baseline模型

import numpy
from keras.datasets import mnist # 从keras的datasets中导入mnist数据集
from keras.models import Sequential # 导入Sequential模型
from keras.layers import Dense # 全连接层用Dense类
from keras.layers import Dropout # 为输入数据施加Dropout。Dropout将在训练过程中每次更新参数时按一定概率（rate）随机断开输入神经元，Dropout层用于防止过拟合
from keras.utils import np_utils # 导入np_utils是为了用one hot encoding方法将输出标签的向量（vector）转化为只在出现对应标签的那一列为1，其余为0的布尔矩阵

seed = 7 #设置随机种子
numpy.random.seed(seed)
(X_train,y_train),(X_test,y_test) = mnist.load_data() #加载数据
#print(X_train.shape[0])
#数据集是3维的向量（instance length,width,height).对于多层感知机，模型的输入是二维的向量，因此这里需要将数据集reshape，即将28*28的向量转成784长度的数组。可以用numpy的reshape函数轻松实现这个过程。
num_pixels = X_train.shape[1] * X_train.shape[2] 
X_train = X_train.reshape(X_train.shape[0],num_pixels).astype(‘float32‘)
X_test = X_test.reshape(X_test.shape[0],num_pixels).astype(‘float32‘)

#给定的像素的灰度值在0-255，为了使模型的训练效果更好，通常将数值归一化映射到0-1
X_train = X_train / 255
X_test = X_test / 255
# one hot encoding
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1]
# 搭建神经网络模型了，创建一个函数，建立含有一个隐层的神经网络
def baseline_model():
    model = Sequential() # 建立一个Sequential模型,然后一层一层加入神经元
    # 第一步是确定输入层的数目正确：在创建模型时用input_dim参数确定。例如，有784个个输入变量，就设成num_pixels。
    #全连接层用Dense类定义：第一个参数是本层神经元个数，然后是初始化方式和激活函数。这里的初始化方法是0到0.05的连续型均匀分布（uniform），Keras的默认方法也是这个。也可以用高斯分布进行初始化（normal）。
    # 具体定义参考：https://cnbeining.github.io/deep-learning-with-python-cn/3-multi-layer-perceptrons/ch7-develop-your-first-neural-network-with-keras.html
    model.add(Dense(num_pixels,input_dim=num_pixels,kernel_initializer=‘normal‘,activation=‘relu‘))
    model.add(Dense(num_classes,kernel_initializer=‘normal‘,activation=‘softmax‘))
    model.compile(loss=‘categorical_crossentropy‘,optimizer=‘adam‘,metrics=[‘accuracy‘])
    return model

model = baseline_model()
#model.fit() 函数每个参数的意义参考：https://blog.csdn.net/a1111h/article/details/82148497
model.fit(X_train,y_train,validation_data=(X_test,y_test),epochs=10,batch_size=200,verbose=2) 
# 1、模型概括打印
model.summary()

scores = model.evaluate(X_test,y_test,verbose=0) #model.evaluate 返回计算误差和准确率
print(scores)
print("Base Error:%.2f%%"%(100-scores[1]*100))

效果：

简单的卷积神经网络

前面介绍了如何加载训练数据并实现一个简单的单隐层神经网络，并在测试集上取得了不错的效果。现在要实现一个卷积神经网络，想要在MNIST问题上取得更好的效果。

卷积神经网络（CNN）是一种深度神经网络，与单隐层的神经网络不同的是它还包含卷积层、池化层、Dropout层等，这使得它在图像分类的问题上有更优的效果。

# 导入需要的函数库
import numpy
from keras.datasets import mnist
from keras.models import Sequential
# 神经网络各层作用参考：https://blog.csdn.net/zhuzuwei/article/details/78651601
# Keras 层layers总结：https://blog.csdn.net/u010159842/article/details/78983841
from keras.layers import Dense
from keras.layers import Dropout # Dropout将在训练过程中每次更新参数时按一定概率（rate）随机断开输入神经元，Dropout层用于防止过拟合。
from keras.layers import Flatten # Flatten层用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。Flatten不影响batch的大小。
from keras.layers.convolutional import Conv2D # 二维卷积层，即对图像的空域卷积。
from keras.layers.convolutional import MaxPooling2D # 空间池化（也叫亚采样或下采样）降低了每个特征映射的维度，但是保留了最重要的信息
from keras.utils import np_utils
from keras import backend as K
K.set_image_dim_ordering(‘th‘) # 设置图像的维度顺序（‘tf’或‘th’）# 当前的维度顺序如果为‘th‘，则输入图片数据时的顺序为：channels,rows,cols，否则:rows,cols,channels

seed = 7
numpy.random.seed(seed)
#将数据reshape，CNN的输入是4维的张量（可看做多维的向量），第一维是样本规模，第二维是像素通道，第三维和第四维是长度和宽度。并将数值归一化和类别标签向量化。

# load data
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# reshape to be [samples][pixels][width][height]
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype(‘float32‘)
X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype(‘float32‘)
 
X_train = X_train / 255
X_test = X_test / 255
# one hot encode outputs
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
num_classes = y_test.shape[1]


# 接下来构造CNN。

# 第一层是卷积层。该层有32个feature map,或者叫滤波器，作为模型的输入层，接受[pixels][width][height]大小的输入数据。feature map的大小是5*5，其输出接一个‘relu’激活函数。
# 下一层是pooling层，使用了MaxPooling，大小为2*2。
# 下一层是Dropout层，该层的作用相当于对参数进行正则化来防止模型过拟合。
# 接下来是全连接层，有128个神经元，激活函数采用‘relu’。
# 最后一层是输出层，有10个神经元，每个神经元对应一个类别，输出值表示样本属于该类别的概率大小。
def baseline_model():
    # create model
    model = Sequential()
    model.add(Conv2D(32, (5, 5), input_shape=(1, 28, 28), activation=‘relu‘))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.2))
    model.add(Flatten())
    model.add(Dense(128, activation=‘relu‘))
    model.add(Dense(num_classes, activation=‘softmax‘))
    # Compile model
    model.compile(loss=‘categorical_crossentropy‘, optimizer=‘adam‘, metrics=[‘accuracy‘])
    return model

# 开始训练
# build the model
model = baseline_model()
# Fit the model
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=10, batch_size=200, verbose=2)
# 1、模型概括打印
model.summary()
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" % (100-scores[1]*100))

效果（时间较长）：

作者：_kimcho 来源：CSDN 原文：https://blog.csdn.net/weixin_41055137/article/details/81071226?utm_source=copy 版权声明：本文为博主原创文章，转载请附上博文链接！