python+tensorflow LeNet---深度学习MINST手写体训练识别

数据样本

1、首先我们要有手写体的数据集文件
下载地址MINST手写体数据

2、训练集：共60000个，其中55000个用于训练，另外5000个用于验证
  测试集：共10000个
 训练集：和机器学习一样用来训练参数的，这里是神经网络的weight（权重）和biases（偏置）
 测试集：和机器学习也一样，就是对训练好的模型，进行一个模型测试

 在MNIST数据集中的每一张图片都代表了0~9中的一个数字。图片的大小都为28*28的像素点，所以每个样本有784维特征，且数字都会出现在图片的正中间。

3、数据集中像素值
（a）使用python读取二进制文件方法读取mnist数据集，则读进来的图像像素值为0-255之间；标签是0-9的数值。
（b）采用TensorFlow的封装的函数读取mnist，则读进来的图像像素值为0-1之间；标签是0-1值组成的大小为1*10的行向量

本文采用b方式

数据集分析

0：部分数据与6相似

预测结果：

1：

预测结果：

从预测结果中可以看出，后四张从人眼看去相差不多，但在机器识别里结果却大相径庭

2：

预测结果：


当书写“2”的上方出现1圆圈，则会被判定为“0”

3：

预测结果：

可以看出，3与8容易混淆

4：

预测结果：

当书写4向右偏的时候，极有可能会被判定为“9”

5：

结果：

数字5易与3和0混淆

6：

预测结果：


可以发现当书写“6”向左“平躺”时，人眼识别与4相像，但机器判别为7；当6的“头”过短时，会被判定为“0”

7：

结果：


7容易与1混淆

8：

预测：

在数据8的测试过程中，相对于其他数字，预测错与的情况较少。

9：

结果：

第一张图人眼看与“8”相似，但机器可以识别出

在对0-9数字的训练观察中，发现：
（1）数字边缘模糊，以及数字的粗细对数字的识别并不存在影响
（2）若数字整体书写完好，缺少一小部分不影响识别
（3）由于训练集足够多，对于一些人眼无法辨别的，机器可以识别

识别原理

卷积神经网络和普通神经网络的区别

 卷积神经网络比神经网络多包含了一个由卷积层和子采样层构成的特征抽取器。在卷积神经网络的卷积层中，一个神经元只与部分邻层神经元连接。
 卷积神经网络是一种特殊的多层神经网络。像几乎所有其他神经网络一样，它们使用反向传播算法的版本进行训练。它们的不同之处在于架构。
 卷积神经网络旨在通过最少的预处理直接从像素图像识别视觉图案。 它们可以识别具有极端可变性的图案（例如手写字符），并且具有对扭曲和简单几何变换的鲁棒性。
 在CNN的一个卷积层中，通常包含若干个特征平面(featureMap)，每个特征平面由一些矩形排列的的神经元组成，同一特征平面的神经元共享权值（这里共享的权值就是卷积核）。
 卷积核一般以随机小数矩阵的形式初始化，在网络的训练过程中卷积核将学习得到合理的权值。卷积核带来的直接好处是减少网络各层之间的连接，同时又降低了过拟合的风险。

基本步骤
1、将要识别的图片转为灰度图，并且转化为2828矩阵（单通道，每个像素范围0-255，0为黑色，255为白色）
2、将2828的矩阵转换成1维矩阵（也就是把第2,3,4,5…行矩阵纷纷接入到第一行的后面）
3、用一个1*10的向量代表标签，也就是这个数字到底是几，举个例子e数字1对应的矩阵就是[0,1,0,0,0,0,0,0,0,0]
4、softmax回归预测图片是哪个数字的概率
5、用梯度下降法训练参数

本文将从以下几个方面介绍CNN、卷积神经网络

当我们拿到一张图片时，首先要对这张图片进行识别，如下图，这张图中是什么？

比如现在要训练一个最简单的CNN，用来识别一张图片里的字母是X还是O。

我们人眼一看，很简单，这明显就是X啊，但是计算机并不知道，它不明白长什么样的可以被认定为是“X”。所以现在给这张图片加一个标签，也就是Label，Label=X，就告诉了计算机这张图代表的是X。它就记住了X的“长相”。

但并不是所有的X都长成这个样子

如上图中是四张图，从人眼判断均为X。但计算机不知道，这四张图与刚刚那张X长的不一样，计算机就又识别不出来了。（这也就是机器学习中所说的“欠拟合”）

这时候CNN要做的，就是如何提取内容为X的图片的特征。

我们知道，图片在计算机内部以像素值的方式被存储，也就是说两张X在计算机看来，其实是这样子的。

其中1代表白色，-1代表黑色。
如果按照每个像素逐个比较肯定是不科学的，不仅匹配准确率低而且效率低下，因此这里我们引入一个匹配方法--patch。

Patch

观察这两张X图，可以发现尽管像素值无法一一对应，但也存在着某些共同点。

如上图所示，两张图中三个同色区域的结构一致

因此，要将这两张图联系起来，既然无法进行全体像素对应，但是否能进行局部特征匹配？

答案是肯定的。这就相当于如果要在一张照片中进行人脸定位，但是CNN不知道什么是人脸，我们就告诉它：人脸上有三个特征，眼睛鼻子嘴巴是什么样，再告诉它这三个长什么样，这样，只要CNN去搜索整张图，找到了这三个特征在的地方就定位到了人脸。

同理，从标准的X图中我们提取出三个特征（feature）


由上发现只要用这三个feature就可以定位到X的某个局部。

feature在CNN中也被成为卷积核（filter）

卷积运算

核心思想：对应相乘

取 feature里的（1，1）元素值，再取图像上蓝色框内的（1，1）元素值，二者相乘等于1。把这个结果1填入新的图中。


同理再继续计算其他8个坐标处的值

9个都计算完了就会像下图这样。

接下来的工作是对右图九个值求平均，得到一个均值，将均值填入一张新的图中
这张新的图我们称之为 feature map （特征图）

这个蓝色框我们称之为 “窗口”，窗口的特性呢，就是会滑动。
最开始，它在起始位置。

进行卷积对应相乘运算并求得均值后，滑动窗便开始向右边滑动。根据步长的不同选择滑动幅度。
比如，若 步长 stride=1，就往右平移一个像素。

若 步长 stride=2，就往右平移两个像素。以此类推

就这么移动到最右边后，返回左边，开始第二排。同样，若步长stride=1，向下平移一个像素；stride=2则向下平移2个像素。

经过一系列卷积对应相乘，求均值运算后，把一张完整的feature map填满。

feature map是每一个feature从原始图像中提取出来的“特征”。其中的值，越接近为1表示对应位置和feature的匹配越完整，越是接近-1，表示对应位置和feature的反面匹配越完整，而值接近0的表示对应位置没有任何匹配或者说没有什么关联。

一个feature作用于图片产生一张feature map，对这张X图来说，我们用的是3个feature，因此最终产生3个 feature map。

非线性激活层

卷积层对原图运算多个卷积产生一组线性激活响应，而非线性激活层是对之前的结果进行一个非线性的激活响应。
在神经网络中用到最多的非线性激活函数是Relu函数，它的公式定义如下：
        f(x)=max(0,x)
即，保留大于等于0的值，其余所有小于0的数值为0。

上面说到，卷积后产生的特征图中的值，越靠近1表示与该特征越关联，越靠近-1表示越不关联，而我们进行特征提取时，为了使得数据更少，操作更方便，就直接舍弃掉那些不相关联的数据。

和sigmoid函数需要计算指数和倒数相比，relu函数其实就是一个max(0,x)，计算代价小很多。

如下图所示：>=0的值不变

而<0的值一律为0

得到非线性激活函数作用后 的结果：

Pooling 池化

卷积操作后，我们得到了一张张有着不同值的feature map，尽管数据量比原图少了很多，但还是过于庞大（深度学习数据量可以达到几十万张训练图片），因此接下来的池化操作就可以发挥作用了，它最大的目标就是减少数据量。

池化分为两种，Max Pooling 最大池化、Average Pooling平均池化。最大池化就是取最大值，平均池化就是取平均值。

拿最大池化举例：选择池化尺寸为2x2，因为选定一个2x2的窗口，在其内选出最大值更新进新的feature map。

同样向右依据步长滑动窗口。


最终得到池化后的feature map。可明显发现数据量减少了很多。

因为最大池化保留了每一个小块内的最大值，所以它相当于保留了这一块最佳匹配结果（因为值越接近1表示匹配越好）。这也就意味着它不会具体关注窗口内到底是哪一个地方匹配了，而只关注是不是有某个地方匹配上了。这也就能够看出，CNN能够发现图像中是否具有某种特征，而不用在意到底在哪里具有这种特征。这也就能够帮助解决之前提到的计算机逐一像素匹配的做法。

在常见的几种CNN中，这三层都是可以堆叠使用的，将前一层的输入作为后一层的输出。比如：

也可以自行添加更多的层以实现更为复杂的神经网络。

全连接层

全连接层的形式和前馈神经网络（feedforward neural network）的形式一样，或者称为多层感知机（multilayer perceptron，MLP）

在上图为9X9，在一系列的卷积、relu、池化操作后，得到尺寸被压缩为2X2的三张特征图。

全连接层要做的，就是对之前的所有操作进行一个总结，给我们一个最终的结果。

它最大的目的是对特征图进行维度上的改变，来得到每个分类类别对应的概率值。

全连接层，顾名思义就是全部都连接起来，卷积层采用的是“局部连接”的思想，卷积层的操作，是用一个3X3的图与原图进行连接操作，很明显原图中只有一个3X3的窗口能够与它连接起来。

那除窗口之外的、未连接的部分怎么办呢？ 我们都知道，采用的是将窗口滑动起来的方法后续进行连接。这个方法的思想就是“参数共享” ，参数指的就是filter，用滑动窗口的方式，将这个filter值共享给原图中的每一块区域连接进行卷积运算。

局部连接与参数共享是卷积神经网络最重要的两个性质

那么接下来再来看全连接神经网络。

还是拿9X9的输入原图做例子，要进行全连接的话，那权值参数矩阵应该也是9x9才对，保证每一个值都有对应的权值参数来运算。（二者坐标直接一一对应）

得到了2X2的特征图后，对其应用全连接网络，再全连接层中有一个非常重要的函数----Softmax，它是一个分类函数，输出的是每个对应类别的概率值。

这是一个分类器，可以认为是Logistic回归的扩展，是生物学上的S型曲线，它只能分两类，用0和1表示，这个用来表示答题对错之类只有两种状态的问题时足够了，但是像这里的MNIST要把它分成10类，就必须用softmax来进行分类了。

Softmax将可以判定为某类的特征相加，然后将这些特征转化为判定是这一个类的概率。我们对图片的所以像素求一个加权和。如某个像素的灰度值大代表很有可能是数字n，这个像素权重就很大，反之，这个权重很有可能为负值。
特征公式

bi 为偏置值，就是这个数据本身的一些倾向。
然后用 softmax 函数把这些特征转换成概率 y :

对所有特征计算 softmax，并进行标准化（所有类别输出的概率值和为1）：

判定为第 i 类的概率为：

Softmax Regression 流程如下：

转换为矩阵乘法：

我们也可以用向量表示这个计算过程：用矩阵乘法和向量相加。这有助于提高计算效率。

写成公式如下：

W的每一行与整个图片像素相乘的结果是一个分数score，分数越高表示图片越接近该行代表的类别。因此，W x + b 的结果其实是一个列向量，每一行代表图片属于该类的评分。通常分类的结果并非评分，而是概率，表示有多大的概率属于此类别。

比如：【0.5，0.03，0.89，0.97，0.42，0.15】就表示有6个类别，并且属于第四个类别的概率值0.89最大，因此判定属于第四个类别。

展开的数据即为属于类别X的概率值，值大小也在对应X的线条粗细中表现出来了。
假设对一张看起来并不标准的图进行分类。如下

对于进行上述操作后，假设得到的概率值如下所示：

0.9表示极其大可能是X，因此对应到X的黄色线条比对应到O的绿色线条要粗很多很多。
我们对结果进行统计分析后可判断这张图片里的字母为X。

神经网络优化

神经网络训练的就是卷积核（filter）

针对这个识别X的例子，我们可以假设定义三个3X3的卷积核，便可实现对X的特征提取。但是在实际运用中，比如识别手写体，每个人的字迹都不同，因此原来的那三个标准的卷积核就变得不再适用了，为了提高CNN模型的通用性（“泛化能力”），就需要对卷积核进行改写。经过成千上万的训练集来训练，每一次加入新的数据，都有可能对卷积核里的值造成影响。

具体的训练方法就是BP算法—BackProp反向传播算法。

在训练时，我们采用的训练数据一般都是带有标签label的图片。如果图片中的字母是1，则label=1，如果图片中的字母是2，则label=2。 标签能直观地反映图片。

在最开始，训练前，我们定义一个大小为3X3的卷积核，那么里面具体的值是多少，采用随机初始化法来进行赋值，卷积核获取到了一个随机值，便可以开始工作。

卷积神经网络便可以开始工作了，输入一张带有标签的图片（假设图片内容是数字1）。经网络识别后判断是1的概率为0.3。本来应该是1.0的概率，现在只有0.3，这存在了很大的误差。

一种简单定义误差error的计算公式为
         error=（result-label）²

训练的终极目的就是使得这个误差最小，常用的方法是 梯度下降法和交叉熵

要使得误差error最小，就是让卷积核里的参数w往梯度下降最小的反向改变。

用这种方法来改变卷积核里的参数W使得误差最小。

交叉熵
在训练过程中，我们将真实的结果和预测的结果相比（交叉熵比较法），会得到一个残差。公式：

y 是我们预测的概率值, y’ 是实际的值。这个残差越小越好，使用梯度下降法，不停地改变W和b的值，使得残差逐渐变小，最后收敛到最小值。这样训练就完成了，就得到了一个模型（W和b的最优化值）。

具体实现

trainMnistFromImages.py

#coding:utf8
import os 
import cv2 
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

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 = 1500#训练1000次
batch_size=1024

print("load train dataset.")
train=getTrain()
print("load test dataset.")
test0,test1=getTest()

sess = tf.InteractiveSession()
# 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")#784：维度
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")

trainMnistFromPackage.py

import tensorflow as tf
import numpy as np # 习惯加上这句，但这边没有用到
from tensorflow.examples.tutorials.mnist import input_data
import matplotlib.pyplot as plt
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)

sess = tf.InteractiveSession()

# 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')


# 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(1000):
    batch = mnist.train.next_batch(64)
    if i % 100 == 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))
    train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
print("test accuracy %f " % accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

# 保存模型于文件夹
saver.save(sess,"save/model")

Demo.py
这是可视化界面

import tensorflow as tf
import numpy as np
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk
from tkinter import filedialog
import time


def creat_windows():
    win = tk.Tk() # 创建窗口
    sw = win.winfo_screenwidth()
    sh = win.winfo_screenheight()
    ww, wh = 400, 450
    x, y = (sw-ww)/2, (sh-wh)/2
    win.geometry("%dx%d+%d+%d"%(ww, wh, x, y-40)) # 居中放置窗口

    win.title('手写体识别') # 窗口命名

    bg1_open = Image.open("timg.jpg").resize((300, 300))
    bg1 = ImageTk.PhotoImage(bg1_open)
    canvas = tk.Label(win, image=bg1)
    canvas.pack()


    var = tk.StringVar() # 创建变量文字
    var.set('')
    tk.Label(win, textvariable=var, bg='#C1FFC1', font=('宋体', 21), width=20, height=2).pack()

    tk.Button(win, text='选择图片', width=20, height=2, bg='#FF8C00', command=lambda:main(var, canvas), font=('圆体', 10)).pack()
    
    win.mainloop()

def main(var, canvas):
    file_path = filedialog.askopenfilename()
    bg1_open = Image.open(file_path).resize((28, 28))
    pic = np.array(bg1_open).reshape(784,)
    bg1_resize = bg1_open.resize((300, 300))
    bg1 = ImageTk.PhotoImage(bg1_resize)
    canvas.configure(image=bg1)
    canvas.image = bg1

    init = tf.global_variables_initializer()

    with tf.Session() as sess:
            sess.run(init)
            saver = tf.train.import_meta_graph('save/model.meta')  # 载入模型结构
            saver.restore(sess, 'save/model')  # 载入模型参数
            graph = tf.get_default_graph()       # 加载计算图
            x = graph.get_tensor_by_name("x-input:0")  # 从模型中读取占位符变量
            keep_prob = graph.get_tensor_by_name("keep_prob:0")
            y_conv = graph.get_tensor_by_name("y-pred:0")  # 关键的一句  从模型中读取占位符变量
            prediction = tf.argmax(y_conv, 1)
            predint = prediction.eval(feed_dict={x: [pic], keep_prob: 1.0}, session=sess)  # feed_dict输入数据给placeholder占位符
            answer = str(predint[0])
    var.set("预测的结果是：" + answer)

if __name__ == "__main__":
    creat_windows()

实验结果

1、可以看出，在训练1000次 的时候，准确度已经达到了98%

2、因为卷积神经网络的决定因素由输入层，隐含层（卷积层、池化层），输出层。因此在测试时数据时，首先从改变输出层的个数，于是从增加输出层的个数，等，结果正确率相比之前确有提高，增加输出层的数量会增加神经网络对数字识别的正确率。我认为随着输入数据的增加，识别率也会逐渐变高。于是下一步我进行改变了隐含层，当我把神经元的数量增加的时候，正确率相比之前有了很大的提高，于是我继续增加神经元的数量，但是在后面神经元的数量达到180时，正确率反而降低了，于是我把神经元的数量改回第一次的数量。

3、把所有的训练图片处理成2值图（若果是添加自己的图片时），然后给模型训练，测试图片也用二值图，只有0和1，没有0~1之间的任何数，避免了图片预处理导致的识别率下降，识别率会极大提升。

tf做的就是给出一个数据，因为minst数据是这样处理的。要看到数字结果，简单变换一下就可以：

run = sess.run(y_, feed_dict={x: minst.test.images, y_: minst.test.labels})for b in run:
    t = 0
    for c in b:
        if c == 1:
            print(t)
        else:
            t = t + 1

参考博客：https://blog.csdn.net/u010858605/article/details/69830657