基于Tensorflow框架CNN实现手写数字识别（三）：测试模型

在模型训练好后我们可以下载MNIST数据集中的测试集来对模型的泛化能力进行测试,python可对MNIST数据集的格式进行转化可以下载为图片并保存。代码如下：

import os
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
from PIL import Image
#分别下载了MNIST数据集中的训练集和测试集
# 声明图片宽高
rows = 28
cols = 28
# 要提取的图片数量
images_to_extract = 1000
# 当前路径下的保存目录
save_path = "E:/pycharm/GraduationDesign/MnistTest"
#save_path = "E:/pycharm/GraduationDesign/MnistTrain"
# 读入mnist数据
mnist = input_data.read_data_sets("MNIST_data/", one_hot=False)
# 创建会话
sess = tf.Session()

# 获取图片总数
shape = sess.run(tf.shape(mnist.test.images))
images_count = shape[0]#图片数量
pixels_per_image = shape[1]#像素

# 获取标签总数
shape = sess.run(tf.shape(mnist.test.labels))
labels_count = shape[0]

# mnist.train.labels是一个二维张量，为便于后续生成数字图片目录名，有必要一维化(后来发现只要把数据集的one_hot属性设为False，mnist.train.labels本身就是一维)
# labels = sess.run(tf.argmax(mnist.train.labels, 1))
labels = mnist.test.labels

# 检查数据集是否符合预期格式
if (images_count == labels_count) and (shape.size == 1):
    print("数据集总共包含 %s 张图片，和 %s 个标签" % (images_count, labels_count))
    print("每张图片包含 %s 个像素" % (pixels_per_image))
    print("数据类型：%s" % (mnist.test.images.dtype))#float32

    # mnist图像数据的数值范围是[0,1]，需要扩展到[0,255]，以便于人眼观看
    if mnist.test.images.dtype == "float32":
        print("准备将数据类型从[0,1]转为binary[0,255]...")
        for i in range(0, images_to_extract):
            for n in range(pixels_per_image):
                if mnist.test.images[i][n] != 0:
                    mnist.test.images[i][n] = 255
            # 由于数据集图片数量庞大，转换可能要花不少时间，有必要打印转换进度
            if ((i + 1) % 50) == 0:
                print("图像浮点数值扩展进度：已转换 %s 张，共需转换 %s 张" % (i + 1, images_to_extract))
    if not os.path.exists(save_path):
        print("目录 ""%s"" 不存在！自动创建该目录..." % save_path)
        os.makedirs(save_path)
    # 创建数字图片的保存目录
    for i in range(10):
        dir = "%s/%s/" % (save_path, i)
        if not os.path.exists(dir):
            print("目录 ""%s"" 不存在！自动创建该目录..." % dir)
            os.makedirs(dir)

    # 通过python图片处理库，生成图片
    indices = [0 for x in range(0, 10)]
    for i in range(0, images_to_extract):

        img = Image.new("L", (cols, rows))
        for m in range(rows):
            for n in range(cols):
                img.putpixel((n, m), int(mnist.test.images[i][n + m * cols]))
        # 根据图片所代表的数字label生成对应的保存路径
        digit = labels[i]
        path = "%s/%s/%s.png" % (save_path, labels[i], indices[digit]+1)
        indices[digit] += 1
        img.save(path)
        # 由于数据集图片数量庞大，保存过程可能要花不少时间，有必要打印保存进度
        if ((i + 1) % 50) == 0:
            print("图片保存进度：已保存 %s 张，共需保存 %s 张" % (i + 1, images_to_extract))

下载好后效果为：

                                             

有十个文件夹分别以0—9的数字命名保存的是0—9数字的图片。

图片下载好后对其进行测试

代码如下：

import os
import tensorflow as tf
from PIL import Image
#使编译器只显示error，使程序更具可读性
os.environ["TF_CPP_MIN_LOG_LEVEL"] = '3'
def imageprepare(argv):

    im = Image.open(argv) #读取的图片所在路径
    im = im.convert('L')# 转换成灰度图
    im = im.resize((28, 28))  # 将图片重新以（28,28）尺寸存储

    tv = list(im.getdata())# 获取像素值
    # # 归一化像素值到0和1之间的一个值（这也在TensorFlow
    # # MNIST教程中完成）。其中0是白色的，1是纯黑色。
    # # 从步骤 tv = list(im.getdata())得到的像素值是与之相反的，其中255是白色的，0
    # # 黑色，所以数值必须反转。下述公式包括反转和规格化，归一化总的来说就是变成将图像的颜色变成黑底白字，
    # # 因为训练的时候Mnist数据集就是黑底白字的，归一化后识别率更高。
    # #如果不是黑底白字的图片就需要进行归一化，更有可能的到正确的识别结果
    #tv = [(255-x)*1.0/255.0 for x in tv]
    return tv

#卷积使用1步长（stride size），0边距（padding size）的模板，保证输出和输入是同一个大小
def conv2d(x, W):
    # 慕课上的视频未加x，W两个参数，参照Tensorflow社区里的MNIST进阶手册解决
    return tf.nn.conv2d(x, W, [1, 1, 1, 1], padding='SAME')
# 池化用简单传统的2x2大小的模板做max pooling
def max_pool_2x2(x):
    # 慕课网上未加padding='SAME'这个参数，运行时会出现如下报错：
    # max_pool() missing 1 required positional argument: 'padding'
    # return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], trides=[1, 2, 2, 1],padding='SAME')
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
#权重初始化
def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)
#偏置量初始化
def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)
Pngnum=0
Correctnum=0
#创建模型
x = tf.placeholder(tf.float32, [None, 784])  # 图像输入向量
y_ = tf.placeholder(tf.float32, [None, 10])  # 实际分布
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))

y = tf.nn.softmax(tf.matmul(x,W) + b)
# 第一层卷积由一个卷积接一个max pooling完成。
# 卷积在每个5x5的patch中算出32个特征。卷积的权重张量是[5, 5, 1, 32]，
# 前两个维度是patch的大小（5x5），接着是输入的通道数目（1），最后是输出的通道数目（32）。
W_conv1 = weight_variable([5, 5, 1, 32])

# 对于每一个输出通道都有一个对应的偏置量。故为32。
b_conv1 = bias_variable([32])

# 为了用这一层，我们把x变成一个4d向量，其第2、第3维对应图片的宽、高，
# 最后一维代表图片的颜色通道数(因为是灰度图所以这里的通道数为1，如果是rgb彩色图，则为3)。
#调整输入图片
x_image = tf.reshape(x, [-1, 28, 28, 1])

# 把x_image和权值向量进行卷积，加上偏置项，然后应用ReLU激活函数，最后进行max pooling。
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

# 第二层卷积，把几个类似的层堆叠起来，构建一个更深的网络。
# 第二层中，每个5x5的patch会得到64个特征。
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

# 密集连接层
# 图片尺寸减小到7x7，加入一个有1024个神经元的全连接层，用于处理整个图片。
# 我们把池化层输出的张量reshape成一些向量，乘上权重矩阵，加上偏置，然后对其使用ReLU。
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

# 梯度下降
# Dropout为了减少过拟合而加入。
# 用一个placeholder来代表一个神经元的输出在dropout中保持不变的概率。
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
# 输出层
# 添加一个softmax层，与前面的单层softmax regression一样。
w_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, w_fc2) + b_fc2)


saver = tf.train.Saver() #定义saver，保存模型
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    #载入模型，这是之前训练好的模型，模型训练的越成熟越好
    saver.restore(sess, "E:/pycharm/GraduationDesign/log/step20000.ckpt")
    array = []  # 将需要识别的手写数字图片按照其序号排序放在指定的文件夹中，然后将其存入数组
    b = []
    #获取该路径下的图片总数，并计数
    path ='E:/pycharm/GraduationDesign/MnistTest/1/'
    # listdir()函数遍历文件夹里所有文件
    for lists in os.listdir(path):
        sub_path = os.path.join(path, lists)
        if os.path.isfile(sub_path):
            Pngnum = Pngnum + 1

    #传入识别图片的路径,循环调用函数
    for i in range(Pngnum):
        #python中str()函数是将对象转换成其字符串表现形式，如果不传入参数，将返回空字符串
        array.append(imageprepare('E:/pycharm/GraduationDesign/MnistTest/1/'+ str(i+1) + '.png'))
        #识别图片中的数字，并统计结果
        prediction = tf.argmax(y_conv, 1)  # 预测结果
        prediction = prediction.eval(session=sess, feed_dict={x: [array[i]], keep_prob: 1.0})
        b.append(prediction[0])
        num="".join(str(i) for i in b)
        #对识别准确的数字进行计数，便于计算测试准确率
        if prediction[0] == 1:
            Correctnum=Correctnum+1
        print('第%d张图片识别结果是:%d' % (i+1, prediction[0]))
print('识别的图片总数为:', Pngnum)
print('识别正确的图片数:', Correctnum)
Errornum=Pngnum-Correctnum
print('识别失败的图片数:', Errornum)
print('识别正确率:', Correctnum/Pngnum)
print("识别出图片中的数字为：",num)

识别结果为：