Tensorflow之使用LeNet-5模型识别Minist手写体数字
文章目录
- 安装Tensorflow教程
- 一、Minist手写体数据集的特点
- 二、LeNet-5卷积神经网络模型的基本原理
- 三、运行结果及分析
安装Tensorflow教程
请移步到这篇博客 ☛ https://blog.csdn.net/weixin_38283428/article/details/84201733
下载的tensorflow版本要和自己的python版本一致。
一、Minist手写体数据集的特点
1.训练数据和测试数据各有多少
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
print('训练数据数量',mnist.train.num_examples)
print('验证数据数量',mnist.validation.num_examples)
print('测试数据数量',mnist.test.num_examples)
2.train集合数据及标签的形状
print('train集合数据矩阵形状：',mnist.train.images.shape)
print('train集合数据标签矩阵形状：',mnist.train.labels.shape)
print('train集合第一个数据标签长度、内容：',len(mnist.train.labels[0]),mnist.train.labels[0])
从上面的运行结果可以看出，在train集合数据中总共有55000个样本，每个样本有784个特征。原图片形状为28*28=784，每个图片样本展平后则有784维特征。在train集合数据标签中总共有55000个样本，每个样本有10维特征，根据所显示的内容能够推断出这幅图片为数字为7，因为它在第8个位置响应度为1，其他位置为0.
3.查看一部分图片内容
import os
import numpy as np
import matplotlib.pyplot as plt
import math
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
def drawdigit(position,image,title):
plt.subplot(*position)
plt.imshow(image,cmap='gray_r')
plt.axis('off')
plt.title(title)
def batchDraw(batch_size):
images,labels = mnist.train.next_batch(batch_size)
row_num = math.ceil(batch_size ** 0.5)
column_num = row_num
plt.figure(figsize=(row_num,column_num))
for i in range(row_num):
for j in range(column_num):
index = i * column_num + j
if index < batch_size:
position = (row_num,column_num,index+1)
image = images[index].reshape(-1,28)
title = 'actual:%d'%(np.argmax(labels[index]))
drawdigit(position,image,title)
if __name__ == '__main__':
batchDraw(196)
plt.show()
观察train集合中的数据发现
0类:有普通正常的0，未闭合成圈的0，容易被误认为6和8的0，圈极扁的0，朝着左右方向倾斜的0
1类:打印体的1(容易被误认为7)，朝着左右方向倾斜的1，弯曲的1，粗细不同的1
2类:第一笔弯曲弧度不够的2，最后结束那一笔写得过长的2(容易被误认为是3)或者过于短的2，粗细不同的2
3类:朝着左右方向倾斜的3，最后一笔向上勾的弧度不够的3，写得像烟圈的3，整体弯曲弧度不够的3，粗细不同的3
4类:写得像Y、A、H的4，像飘扬的旗帜的4，写得太过紧凑的4，粗细不同4
5类:写得像S的5，因为最后一笔而容易被认为是6的5，粗细不同的5
6类:下半部分的圆圈被涂满不是空心的6，横躺的6，下半部分未闭合成圆圈的6，最后一笔写出头容易被认成4的6
7类:打印体形状的7，多加一条横杠的7，横与竖形成的角度过小的7，粗细不同的7
8类:最上面是开口的8，朝着左右方向倾斜的8，最下面是开口的8，上下两个圈被涂满的8，手写习惯为先画上面一个圈再画下面一个圈的8
9类:打印体形状的9，圆圈过大容易被误认为0的9，粗细不同的9，上方未闭合成圆圈的9，像g的9
二、LeNet-5卷积神经网络模型的基本原理
卷积神经网络（Convolutional Neural Networks, CNN）是一类包含卷积计算且具有深度结构的前馈神经网络（Feedforward Neural Networks），是深度学习（deep learning）的代表算法之一。它仿造生物的视知觉（visual perception）机制构建，可以进行监督学习和非监督学习。
无监督学习的训练数据没有标签，也就是事先并没有将这些数据分类好；监督学习的训练数据事先将数据标上了标签，同一类的标签相同，不同类的标签不同。本实验识别Minist数据集则是监督学习，已经将0至9这10类数据分类好了，通过LeNet-5模型训练这些数据，之后将测试集中的数据放入训练好的模型中，测试这个模型能否正确识别输入数据是哪个数字。
上图是卷积神经网络的模型图。
LeNet-5模型除了输入层，共有7层。
INPUT为输入的图片，卷积核大小为5*5.
上图C1层是卷积层，为6幅28x28的特征图，一幅图也就是一个滤波器，一个滤波器会得到一个滤波结果。为什么输入图片为32x32，而到了卷积层却变成了28x28了呢?这是因为卷积核大小为5x5，原图边缘没有填充，卷积区域只会在特征图内，卷积核不会移动到特征图外。这一层待学习参数个数:(5*5+1)*6=156，1为模型自带的阈值。
上图S2层是池化层，这一层将28x28的特征图采样为14x14特征图。做法是将6幅特征图分别以2*2为单位进行最大值采样(取这4个值中最大的值作为代表)。
上图C3是卷积层，将6幅14x14的特征图卷积成16幅10x10图像，卷积核大小为5*5。
上图S4是一个池化层。C3层的16个10x10的图分别进行以2x2为单位的下抽样得到16个5x5的图。
上图C5层是一个全连接层，由于S4层的16个图的大小为5x5，与卷积核的大小相同，所以卷积后形成的图的大小为1x1。这里形成120个卷积结果。
上图F6层是全连接层。F6层有84个节点，对应于一个7x12的比特图，该层的训练参数和连接数都是(120 + 1)x84=10164.
Output层也是全连接层，共有10个节点，分别代表数字0到9。输入的数字对哪个节点响应度最高，就将这数字归类给那个节点。
这当然是会有误差的，那么如何将误差缩小呢?
这里有3种方法：第一种称为随机梯度下降，方法是只要一出现一个归类错误的数字就计算出期望值与估计值的误差，然后分别对w和b(网络结构中的参数)求偏导，求出来的偏导值乘上一个学习率再加上原来的w和b分别得到新的w和b。这样使误差不断收敛，直到误差不再变。这种方法速度快，时间短，但是会使分类线不断震荡。
第二种方法称为批量梯度下降法，做法是先计算出所有分类错误的数字的误差总量
然后分别对w和b(网络结构中的参数)求偏导，求出来的偏导值乘上一个学习率再加上原来的w和b分别得到新的w和b。这种方法精度高，但是时间复杂度也高，效率低，不适合样本数量大的数据。
第三种方法是随机批量下降法。做法是例如每100个样本计算一次总误差然后再分别对w和b求偏导，这种方法结合了上面两种方法的优点。
三、运行结果及分析
代码如下:
import os
import cv2
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)
sess = tf.InteractiveSession()
def getTrain():
train=[[],[]] # 指定训练集的格式，一维为输入数据，一维为其标签
# 读取所有训练图像，作为训练集
train_root="mnist_train"
labels = os.listdir(train_root)
for label in labels:
imgpaths = os.listdir(os.path.join(train_root,label))
for imgname in imgpaths:
img = cv2.imread(os.path.join(train_root,label,imgname),0)
array = np.array(img).flatten() # 将二维图像平铺为一维图像
array=MaxMinNormalization(array)
train[0].append(array)
label_ = [0,0,0,0,0,0,0,0,0,0]
label_[int(label)] = 1
train[1].append(label_)
train = shuff(train)
return train
def getTest():
test=[[],[]] # 指定训练集的格式，一维为输入数据，一维为其标签
# 读取所有训练图像，作为训练集
test_root="mnist_test"
labels = os.listdir(test_root)
for label in labels:
imgpaths = os.listdir(os.path.join(test_root,label))
for imgname in imgpaths:
img = cv2.imread(os.path.join(test_root,label,imgname),0)
array = np.array(img).flatten() # 将二维图像平铺为一维图像
array=MaxMinNormalization(array)
test[0].append(array)
label_ = [0,0,0,0,0,0,0,0,0,0]
label_[int(label)] = 1
test[1].append(label_)
test = shuff(test)
return test[0],test[1]
def shuff(data):
temp=[]
for i in range(len(data[0])):
temp.append([data[0][i],data[1][i]])
import random
random.shuffle(temp)
data=[[],[]]
for tt in temp:
data[0].append(tt[0])
data[1].append(tt[1])
return data
count = 0
def getBatchNum(batch_size,maxNum):
global count
if count ==0:
count=count+batch_size
return 0,min(batch_size,maxNum)
else:
temp = count
count=count+batch_size
if min(count,maxNum)==maxNum:
count=0
return getBatchNum(batch_size,maxNum)
return temp,min(count,maxNum)
def MaxMinNormalization(x):
x = (x - np.min(x)) / (np.max(x) - np.min(x))
return x
# 1、权重初始化,偏置初始化
# 为了创建这个模型，我们需要创建大量的权重和偏置项
# 为了不在建立模型的时候反复操作，定义两个函数用于初始化
def weight_variable(shape):
initial = tf.truncated_normal(shape,stddev=0.1)#正太分布的标准差设为0.1
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.constant(0.1,shape=shape)
return tf.Variable(initial)
# 2、卷积层和池化层也是接下来要重复使用的，因此也为它们定义创建函数
# tf.nn.conv2d是Tensorflow中的二维卷积函数，参数x是输入，w是卷积的参数
# strides代表卷积模块移动的步长，都是1代表会不遗漏地划过图片的每一个点，padding代表边界的处理方式
# padding = 'SAME'，表示padding后卷积的图与原图尺寸一致，激活函数relu()
# tf.nn.max_pool是Tensorflow中的最大池化函数，这里使用2 * 2 的最大池化，即将2 * 2 的像素降为1 * 1的像素
# 最大池化会保留原像素块中灰度值最高的那一个像素，即保留最显著的特征，因为希望整体缩小图片尺寸
# ksize：池化窗口的大小，取一个四维向量，一般是[1,height,width,1]
# 因为我们不想再batch和channel上做池化，一般也是[1,stride,stride,1]
def conv2d(x, w):
return tf.nn.conv2d(x, w, strides=[1,1,1,1],padding='SAME') # 保证输出和输入是同样大小
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1],padding='SAME')
iterNum = 4
batch_size=64
train=getTrain()
test0,test1=getTest()
# 3、参数
# 这里的x,y_并不是特定的值，它们只是一个占位符，可以在TensorFlow运行某一计算时根据该占位符输入具体的值
# 输入图片x是一个2维的浮点数张量，这里分配给它的shape为[None, 784]，784是一张展平的MNIST图片的维度
# None 表示其值的大小不定，在这里作为第1个维度值，用以指代batch的大小，means x 的数量不定
# 输出类别y_也是一个2维张量，其中每一行为一个10维的one_hot向量，用于代表某一MNIST图片的类别
x = tf.placeholder(tf.float32, [None,784], name="x-input")
y_ = tf.placeholder(tf.float32,[None,10]) # 10列
# 4、第一层卷积，它由一个卷积接一个max pooling完成
# 张量形状[5,5,1,32]代表卷积核尺寸为5 * 5，1个颜色通道，32个通道数目
w_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32]) # 每个输出通道都有一个对应的偏置量
# 我们把x变成一个4d 向量其第2、第3维对应图片的宽、高，最后一维代表图片的颜色通道数(灰度图的通道数为1，如果是RGB彩色图，则为3)
x_image = tf.reshape(x,[-1,28,28,1])
# 因为只有一个颜色通道，故最终尺寸为[-1，28，28，1]，前面的-1代表样本数量不固定，最后的1代表颜色通道数量
h_conv1 = tf.nn.relu(conv2d(x_image, w_conv1) + b_conv1) # 使用conv2d函数进行卷积操作，非线性处理
h_pool1 = max_pool_2x2(h_conv1) # 对卷积的输出结果进行池化操作
# 5、第二个和第一个一样，是为了构建一个更深的网络，把几个类似的堆叠起来
# 第二层中，每个5 * 5 的卷积核会得到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)
# 6、密集连接层
# 图片尺寸减小到7 * 7，加入一个有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)
# 7、使用dropout，防止过度拟合
# dropout是在神经网络里面使用的方法，以此来防止过拟合
# 用一个placeholder来代表一个神经元的输出
# tf.nn.dropout操作除了可以屏蔽神经元的输出外，
# 还会自动处理神经元输出值的scale，所以用dropout的时候可以不用考虑scale
keep_prob = tf.placeholder(tf.float32, name="keep_prob")# placeholder是占位符
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
# 8、输出层，最后添加一个softmax层
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, name="y-pred")
# 9、训练和评估模型
# 损失函数是目标类别和预测类别之间的交叉熵
# 参数keep_prob控制dropout比例，然后每100次迭代输出一次日志
cross_entropy = tf.reduce_sum(-tf.reduce_sum(y_ * tf.log(y_conv),reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
# 预测结果与真实值的一致性，这里产生的是一个bool型的向量
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
# 将bool型转换成float型，然后求平均值，即正确的比例
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 初始化所有变量，在2017年3月2号以后,用 tf.global_variables_initializer()替代tf.initialize_all_variables()
sess.run(tf.initialize_all_variables())
# 保存最后一个模型
saver = tf.train.Saver(max_to_keep=1)
for i in range(iterNum):
for j in range(int(len(train[1])/batch_size)):
imagesNum=getBatchNum(batch_size,len(train[1]))
batch = [train[0][imagesNum[0]:imagesNum[1]],train[1][imagesNum[0]:imagesNum[1]]]
train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
if i % 2 == 0:
train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1],keep_prob: 1.0})
print("Step %d ,training accuracy %g" % (i, train_accuracy))
print("test accuracy %f " % accuracy.eval(feed_dict={x: test0, y_:test1, keep_prob: 1.0}))
# 保存模型于文件夹
saver.save(sess,"save/model")
结果分析:
设置迭代次数为4
在这种情况下，我从测试集中选取了几张，出现了判断错误的几次情况
预测错误，期望结果应该为1。
预测错误，期望结果应该为7
预测错误，预期结果应该为5。（emmmmm。。不过这张就算是人类也很难识别出是5）
设置迭代次数为20
正确率提高了。再次选取之前测试错误的数字图片放入新的模型中
预测结果正确了！
预测结果也是正确的。特地选择了与容易与1和2混淆的数字图片进行测试，如下
也都预测正确了。
最惊喜的地方来了！！
之前被我吐槽人类可能都无法识别出是5的数字这个模型现在识别出来了!!!
迭代次数也就是来回滚动的次数，当迭代次数不断增大的时候，w和b不断改变，误差不断收敛，直到不变。由截出的结果图中的正确率可以得知这一次误差收敛得比上一次更快。
这次我将batch_size(为梯度下降时每个batch包含的样本数)由原来的64设置为100
误差收敛得没有上一次快，并且正确率稍微降低了一点。
可以得知随着 batch_size 增大，处理相同数据量的速度越快，但是达到相同精度所需要的迭代次数更多。由此我们知道当batch_size增加到一定程度之后，可以达到时间上的最优。
(emmmm我的电脑配置不允许我将迭代次数设置得过大。。。)