Mnist手写数字识别 Tensorflow

Ｍnist手写数字识别 Tensorflow

任务目标

• 了解mnist数据集
• 搭建和测试模型

---

编辑环境

操作系统:Win10

python版本:3.6

集成开发环境:pycharm

tensorflow版本:1.*

---

程序流程图

了解mnist数据集

mnist数据集:mnist数据集下载地址

  MNIST 数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据.

  图片是以字节的形式进行存储, 我们需要把它们读取到 NumPy array 中, 以便训练和测试算法。

读取mnist数据集

mnist = input_data.read_data_sets("mnist_data", one_hot=True)

---

模型结构

输入层

with tf.variable_scope("data"):
      x = tf.placeholder(tf.float32,shape=[None,784],name='x_pred') # 784=28*28*1 宽长为28，单通道图片
      y_true = tf.placeholder(tf.int32,shape=[None,10]) # 10个类别

第一层卷积

  现在我们可以开始实现第一层了。它由一个卷积接一个max pooling完成。卷积在每个5x5的patch中算出32个特征。卷积的权重张量形状是[5, 5, 1, 32]，前两个维度是patch的大小，接着是输入的通道数目，最后是输出的通道数目。 而对于每一个输出通道都有一个对应的偏置量。

为了用这一层，我们把x变成一个4d向量，其第2、第3维对应图片的宽、高，最后一维代表图片的颜色通道数(因为是灰度图所以这里的通道数为1，如果是rgb彩色图，则为3)。

我们把x_image和权值向量进行卷积，加上偏置项，然后应用ReLU激活函数，最后进行max pooling。

with tf.variable_scope("conv1"):
      w_conv1 = tf.Variable(tf.random_normal([5,5,1,32])) # 5*5的卷积核  1个通道的输入图像  32个不同的卷积核，得到32个特征图
      b_conv1 = tf.Variable(tf.constant(0.0,shape=[32]))
      x_reshape = tf.reshape(x,[-1,28,28,1]) # n张 28*28 的单通道图片
      conv1 = tf.nn.relu(tf.nn.conv2d(x_reshape,w_conv1,strides=[1,1,1,1],padding="SAME")+b_conv1) #strides为过滤器步长 padding='SAME' 边缘自动补充
      pool1 = tf.nn.max_pool(conv1,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME") # ksize为池化层过滤器的尺度，strides为过滤器步长  padding="SAME" 考虑边界，如果不够用 用0填充

第二层卷积

  为了构建一个更深的网络，我们会把几个类似的层堆叠起来。第二层中，每个5x5的patch会得到64个特征

with tf.variable_scope("conv2"):
    w_conv2 = tf.Variable(tf.random_normal([5,5,32,64]))
    b_conv2 = tf.Variable(tf.constant(0.0,shape=[64]))
    conv2 = tf.nn.relu(tf.nn.conv2d(pool1,w_conv2,strides=[1,1,1,1],padding="SAME")+b_conv2)
    pool2 = tf.nn.max_pool(conv2,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")

密集连接层

  现在，图片尺寸减小到7x7，我们加入一个有1024个神经元的全连接层，用于处理整个图片。我们把池化层输出的张量reshape成一些向量，乘上权重矩阵，加上偏置，然后对其使用ReLU。

  为了减少过拟合，我们在输出层之前加入dropout。我们用一个placeholder来代表一个神经元的输出在dropout中保持不变的概率。这样我们可以在训练过程中启用dropout，在测试过程中关闭dropout。 TensorFlow的tf.nn.dropout操作除了可以屏蔽神经元的输出外，还会自动处理神经元输出值的scale。所以用dropout的时候可以不用考虑scale。

with tf.variable_scope("fc1"):
      w_fc1 = tf.Variable(tf.random_normal([7*7*64,1024])) # 经过两次卷积和池化 28 * 28/(2+2) = 7 * 7
      b_fc1 = tf.Variable(tf.constant(0.0,shape=[1024]))
      h_pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
      h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, w_fc1) + b_fc1)
      # 在输出层之前加入dropout以减少过拟合
      keep_prob = tf.placeholder("float32",name="keep_prob")
      h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

输出层

&emsp' 最后，我们添加一个softmax层，就像前面的单层softmax regression一样。

with tf.variable_scope("fc2"):
      w_fc2 = tf.Variable(tf.random_normal([1024,10])) # 经过两次卷积和池化 28 * 28/(2+2) = 7 * 7
      b_fc2 = tf.Variable(tf.constant(0.0,shape=[10]))
      y_predict = tf.matmul(h_fc1_drop,w_fc2)+b_fc2
      tf.add_to_collection('pred_network', y_predict)  # 用于加载模型获取要预测的网络结构

训练和评估模型

  为了进行训练和评估，我们使用与之前简单的单层SoftMax神经网络模型几乎相同的一套代码，只是我们会用更加复杂的ADAM优化器来做梯度最速下降，在feed_dict中加入额外的参数keep_prob来控制dropout比例。然后每100次迭代输出一次日志。

with tf.variable_scope("loss"):
    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true,logits=y_predict))
with tf.variable_scope("optimizer"):
    # 使用反向传播，利用优化器使损失函数最小化
    train_op = tf.train.AdamOptimizer(0.001).minimize(loss)
with tf.variable_scope("acc"):
    # 检测我们的预测是否真实标签匹配(索引位置一样表示匹配)
    # tf.argmax(y_conv,dimension), 返回最大数值的下标 通常和tf.equal()一起使用，计算模型准确度
    # dimension=0 按列找  dimension=1 按行找
    equal_list = tf.equal(tf.arg_max(y_true,1),tf.arg_max(y_predict,1))
    # 统计测试准确率， 将correct_prediction的布尔值转换为浮点数来代表对、错，并取平均值。
    accuracy = tf.reduce_mean(tf.cast(equal_list,tf.float32))
# tensorboard
# tf.summary.histogram用来显示直方图信息
# tf.summary.scalar用来显示标量信息
# Summary：所有需要在TensorBoard上展示的统计结果
tf.summary.histogram("weight",w_fc2)
tf.summary.histogram("bias",b_fc2)
tf.summary.scalar("loss",loss)
tf.summary.scalar("acc",accuracy)
merged = tf.summary.merge_all()
saver = tf.train.Saver()
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    filewriter = tf.summary.FileWriter("tfboard",graph=sess.graph)
    if is_train: # 训练
        for i in range(20001):
            x_train, y_train = mnist.train.next_batch(50)
            if i%100==0:
                # 评估模型准确度，此阶段不使用Dropout
                print("第%d训练，准确率为%f" % (i + 1, sess.run(accuracy, feed_dict={x: x_train, y_true: y_train, keep_prob: 1.0})))
            # # 训练模型，此阶段使用50%的Dropout
            sess.run(train_op,feed_dict={x:x_train,y_true:y_train,keep_prob: 0.5})
            summary = sess.run(merged,feed_dict={x:x_train,y_true:y_train, keep_prob: 1})
            filewriter.add_summary(summary,i)
        saver.save(sess,savemodel)
    else: # 测试集预测
        count = 0.0
        epochs = 300
        saver.restore(sess, savemodel)
        for i in range(epochs):
            x_test, y_test = mnist.train.next_batch(1)
            print("第%d张图片，真实值为：%d预测值为：%d" % (i + 1,
                                             tf.argmax(sess.run(y_true, feed_dict={x: x_test, y_true: y_test,keep_prob: 1.0}),
                                                       1).eval(),
                                             tf.argmax(
                                                 sess.run(y_predict, feed_dict={x: x_test, y_true: y_test,keep_prob: 1.0}),
                                                 1).eval()
                                             ))
            if (tf.argmax(sess.run(y_true, feed_dict={x: x_test, y_true: y_test,keep_prob: 1.0}), 1).eval() == tf.argmax(
                    sess.run(y_predict, feed_dict={x: x_test, y_true: y_test,keep_prob: 1.0}), 1).eval()):
                count = count + 1
        print("正确率为 %.2f " % float(count * 100 / epochs) + "%")

评估结果

传入手写图片，利用模型预测

  首先利用opencv包将图片转为单通道（灰度图），调整图像尺寸28*28,并且二值化图像，通过处理最后得到一个(0~1)扁平的图片像素值（一个二维数组）。

手写数字图片



处理手写数字图片

def dealFigureImg(imgPath):
    img = cv2.imread(imgPath)  # 手写数字图像所在位置
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # 转换图像为单通道(灰度图)
    resize_img = cv2.resize(img, (28, 28))  # 调整图像尺寸为28*28
    ret, thresh_img = cv2.threshold(resize_img, 127, 255, cv2.THRESH_BINARY)  # 二值化
    cv2.imwrite("image/temp.jpg",thresh_img)
    im = Image.open('image/temp.jpg')
    data = list(im.getdata()) # 得到一个扁平的 图片像素
    result = [(255 - x) * 1.0 / 255.0 for x in data] # 像素值范围(0-255)，转换为(0-1) ->符合模型训练时传入数据的值
    result = np.expand_dims(result, 0) # 扩展维度 ->符合模型训练时传入数据的维度
    os.remove('image/temp.jpg')
    return result

载入模型进行预测

def predictFigureImg(imgPath):
    result = dealFigureImg(imgPath)
    with tf.Session() as sess:
        new_saver = tf.train.import_meta_graph("model/mnist_model.meta")
        new_saver.restore(sess, "model/mnist_model")
        graph = tf.get_default_graph()
        x = graph.get_operation_by_name('data/x_pred').outputs[0]
        keep_prob = graph.get_operation_by_name('fc1/keep_prob').outputs[0]
        y = tf.get_collection("pred_network")[0]
        predict = np.argmax(sess.run(y, feed_dict={x: result,keep_prob:1.0}))
        print("result:",predict)

预测结果

完整代码

import tensorflow as tf
import cv2
import os
import numpy as np
from PIL import Image
from tensorflow.examples.tutorials.mnist import input_data
# 构造模型
def getMnistModel(savemodel,is_train):
    """
    :param savemodel:  模型保存路径
    :param is_train: True为训练，False为测试模型
    :return:None
    """
    mnist = input_data.read_data_sets("mnist_data", one_hot=True)
    with tf.variable_scope("data"):
        x = tf.placeholder(tf.float32,shape=[None,784],name='x_pred') # 784=28*28*1 宽长为28，单通道图片
        y_true = tf.placeholder(tf.int32,shape=[None,10]) # 10个类别
    with tf.variable_scope("conv1"):
        w_conv1 = tf.Variable(tf.random_normal([5,5,1,32])) # 5*5的卷积核  1个通道的输入图像  32个不同的卷积核，得到32个特征图
        b_conv1 = tf.Variable(tf.constant(0.0,shape=[32]))
        x_reshape = tf.reshape(x,[-1,28,28,1]) # n张 28*28 的单通道图片
        conv1 = tf.nn.relu(tf.nn.conv2d(x_reshape,w_conv1,strides=[1,1,1,1],padding="SAME")+b_conv1) #strides为过滤器步长 padding='SAME' 边缘自动补充
        pool1 = tf.nn.max_pool(conv1,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME") # ksize为池化层过滤器的尺度，strides为过滤器步长  padding="SAME" 考虑边界，如果不够用 用0填充
    with tf.variable_scope("conv2"):
        w_conv2 = tf.Variable(tf.random_normal([5,5,32,64]))
        b_conv2 = tf.Variable(tf.constant(0.0,shape=[64]))
        conv2 = tf.nn.relu(tf.nn.conv2d(pool1,w_conv2,strides=[1,1,1,1],padding="SAME")+b_conv2)
        pool2 = tf.nn.max_pool(conv2,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")
    with tf.variable_scope("fc1"):
        w_fc1 = tf.Variable(tf.random_normal([7*7*64,1024])) # 经过两次卷积和池化 28 * 28/(2+2) = 7 * 7
        b_fc1 = tf.Variable(tf.constant(0.0,shape=[1024]))
        h_pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 64])
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, w_fc1) + b_fc1)
        # 在输出层之前加入dropout以减少过拟合
        keep_prob = tf.placeholder("float32",name="keep_prob")
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
    with tf.variable_scope("fc2"):
        w_fc2 = tf.Variable(tf.random_normal([1024,10])) # 经过两次卷积和池化 28 * 28/(2+2) = 7 * 7
        b_fc2 = tf.Variable(tf.constant(0.0,shape=[10]))
        y_predict = tf.matmul(h_fc1_drop,w_fc2)+b_fc2
        tf.add_to_collection('pred_network', y_predict)  # 用于加载模型获取要预测的网络结构
    with tf.variable_scope("loss"):
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true,logits=y_predict))
    with tf.variable_scope("optimizer"):
        # 使用反向传播，利用优化器使损失函数最小化
        train_op = tf.train.AdamOptimizer(0.001).minimize(loss)
    with tf.variable_scope("acc"):
        # 检测我们的预测是否真实标签匹配(索引位置一样表示匹配)
        # tf.argmax(y_conv,dimension), 返回最大数值的下标 通常和tf.equal()一起使用，计算模型准确度
        # dimension=0 按列找  dimension=1 按行找
        equal_list = tf.equal(tf.arg_max(y_true,1),tf.arg_max(y_predict,1))
        # 统计测试准确率， 将correct_prediction的布尔值转换为浮点数来代表对、错，并取平均值。
        accuracy = tf.reduce_mean(tf.cast(equal_list,tf.float32))
    # tensorboard
    # tf.summary.histogram用来显示直方图信息
    # tf.summary.scalar用来显示标量信息
    # Summary：所有需要在TensorBoard上展示的统计结果
    tf.summary.histogram("weight",w_fc2)
    tf.summary.histogram("bias",b_fc2)
    tf.summary.scalar("loss",loss)
    tf.summary.scalar("acc",accuracy)
    merged = tf.summary.merge_all()
    saver = tf.train.Saver()
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        filewriter = tf.summary.FileWriter("tfboard",graph=sess.graph)
        if is_train: # 训练
            for i in range(20001):
                x_train, y_train = mnist.train.next_batch(50)
                if i%100==0:
                    # 评估模型准确度，此阶段不使用Dropout
                    print("第%d训练，准确率为%f" % (i + 1, sess.run(accuracy, feed_dict={x: x_train, y_true: y_train, keep_prob: 1.0})))
                # # 训练模型，此阶段使用50%的Dropout
                sess.run(train_op,feed_dict={x:x_train,y_true:y_train,keep_prob: 0.5})
                summary = sess.run(merged,feed_dict={x:x_train,y_true:y_train, keep_prob: 1})
                filewriter.add_summary(summary,i)
            saver.save(sess,savemodel)
        else: # 测试集预测
            count = 0.0
            epochs = 300
            saver.restore(sess, savemodel)
            for i in range(epochs):
                x_test, y_test = mnist.train.next_batch(1)
                print("第%d张图片，真实值为：%d预测值为：%d" % (i + 1,
                                                 tf.argmax(sess.run(y_true, feed_dict={x: x_test, y_true: y_test,keep_prob: 1.0}),
                                                           1).eval(),
                                                 tf.argmax(
                                                     sess.run(y_predict, feed_dict={x: x_test, y_true: y_test,keep_prob: 1.0}),
                                                     1).eval()
                                                 ))
                if (tf.argmax(sess.run(y_true, feed_dict={x: x_test, y_true: y_test,keep_prob: 1.0}), 1).eval() == tf.argmax(
                        sess.run(y_predict, feed_dict={x: x_test, y_true: y_test,keep_prob: 1.0}), 1).eval()):
                    count = count + 1
            print("正确率为 %.2f " % float(count * 100 / epochs) + "%")
# 手写数字图像预测
def dealFigureImg(imgPath):
    img = cv2.imread(imgPath)  # 手写数字图像所在位置
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # 转换图像为单通道(灰度图)
    resize_img = cv2.resize(img, (28, 28))  # 调整图像尺寸为28*28
    ret, thresh_img = cv2.threshold(resize_img, 127, 255, cv2.THRESH_BINARY)  # 二值化
    cv2.imwrite("image/temp.jpg",thresh_img)
    im = Image.open('image/temp.jpg')
    data = list(im.getdata()) # 得到一个扁平的 图片像素
    result = [(255 - x) * 1.0 / 255.0 for x in data] # 像素值范围(0-255)，转换为(0-1) ->符合模型训练时传入数据的值
    result = np.expand_dims(result, 0) # 扩展维度 ->符合模型训练时传入数据的维度
    os.remove('image/temp.jpg')
    return result
def predictFigureImg(imgPath):
    result = dealFigureImg(imgPath)
    with tf.Session() as sess:
        new_saver = tf.train.import_meta_graph("model/mnist_model.meta")
        new_saver.restore(sess, "model/mnist_model")
        graph = tf.get_default_graph()
        x = graph.get_operation_by_name('data/x_pred').outputs[0]
        keep_prob = graph.get_operation_by_name('fc1/keep_prob').outputs[0]
        y = tf.get_collection("pred_network")[0]
        predict = np.argmax(sess.run(y, feed_dict={x: result,keep_prob:1.0}))
        print("result:",predict)
if __name__ == '__main__':
    # 训练和预测
    modelPath = "model/mnist_model"
    getMnistModel(modelPath,True) # True 训练 False 预测
    # 图片传入模型 进行预测
    # imgPath = "image/8.jpg"
    # predictFigureImg(imgPath)