手写数字识别 ----卷积神经网络模型官方案例注释（基于Tensorflow,Python）

# 手写数字识别 ----卷积神经网络模型
import os import tensorflow as tf #部分注释来源于 # http://www.cnblogs.com/rgvb178/p/6052541.html

from tensorflow.examples.tutorials.mnist import input_data data = input_data.read_data_sets("/tmp/data/", one_hot=True) '''获取程序集'''

# Multilayer Convolutional Network 多层卷积网络
def convolutional(x, keep_prob): # 卷积过程
    def conv2d(x, W): ''' tf.nn.conv2d(input,filter,strides,padding,use_cudnn_on_gpu=True,data_format='NHWC',dilations=[1, 1, 1, 1], name=None) 计算给定的4-D input和filter张量的2-D卷积。 给定形状为[batch, in_height, in_width, in_channels]的输入张量和形状为[filter_height, filter_width, in_channels, out_channels]的滤波器/内核张量，此操做执行如下操做： 将滤镜展平为具备形状[filter_height * filter_width * in_channels, output_channels]的二维矩阵。 从输入张量中提取图像补丁，以造成形状为[batch, out_height, out_width, filter_height * filter_width * in_channels]的虚拟张量。 对于每一个补丁，右对乘滤波器矩阵和图像补丁矢量。 参数： input：一个Tensor，必须是下列类型之一：half，bfloat16，float32，float64；一个4-D张量，维度顺序根据data_format值进行解释，详见下文。 filter：一个Tensor，必须与input相同，形状为[filter_height, filter_width, in_channels, out_channels]的4-D张量。 strides：ints列表，长度为4的1-D张量，input的每一个维度的滑动窗口的步幅；维度顺序由data_format值肯定，详见下文。 padding：string，能够是："SAME", "VALID"，要使用的填充算法的类型。 use_cudnn_on_gpu：bool，默认为True。 data_format：string，能够是"NHWC", "NCHW"，默认为"NHWC"；指定输入和输出数据的数据格式；使用默认格式“NHWC”，数据按如下顺序存储：[batch, height, width, channels]；或者，格式能够是“NCHW”，数据存储顺序为：[batch, channels, height, width]。 dilations：ints的可选列表，默认为[1, 1, 1, 1]，长度为4的1-D张量，input的每一个维度的扩张系数；若是设置为k> 1，则该维度上的每一个滤镜元素之间将有k-1个跳过的单元格；维度顺序由data_format值肯定，详见上文；批次和深度尺寸的扩张必须为1。 name：操做的名称（可选）。 返回：一个Tensor，与input具备相同的类型。 :return: '''
        return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') # 池化过程
    def max_pool_2x2(x): ''' tf.nn.max_pool(value, ksize, strides, padding, name=None) 参数是四个，和卷积很相似： 第一个参数value：须要池化的输入，通常池化层接在卷积层后面，因此输入一般是feature map，依然是[batch, height, width, channels]这样的shape 第二个参数ksize：池化窗口的大小，取一个四维向量，通常是[1, height, width, 1]，由于咱们不想在batch和channels上作池化，因此这两个维度设为了1 第三个参数strides：和卷积相似，窗口在每个维度上滑动的步长，通常也是[1, stride,stride, 1] 第四个参数padding：和卷积相似，能够取'VALID' 或者'SAME' 返回一个Tensor，类型不变，shape仍然是[batch, height, width, channels]这种形式 :param x: :return: '''
        return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') # 初始化权重
    def weight_variable(shape): ''' tf.truncated_normal(shape,mean=0.0, stddev=1.0,dtype=tf.float32,seed=None,name=None) 从截断的正态分布中输出随机值。 生成的值遵循具备指定平均值和标准误差的正态分布，不一样之处在于其平均值大于 2 个标准差的值将被丢弃并从新选择。 函数参数： shape：一维整数张量或 Python 数组，输出张量的形状。 mean：dtype 类型的 0-D 张量或 Python 值，截断正态分布的均值。 stddev：dtype 类型的 0-D 张量或 Python 值，截断前正态分布的标准误差。 dtype：输出的类型。 seed：一个 Python 整数。用于为分发建立随机种子。查看tf.set_random_seed行为。 name：操做的名称（可选）。 函数返回值： tf.truncated_normal函数返回指定形状的张量填充随机截断的正常值。 :param shape: :return: ''' initial = tf.truncated_normal(shape, stddev=0.1) return tf.Variable(initial) # 初始化偏置项
    def bias_variable(shape): ''' tf.constant(value,dtype=None,shape=None,name=’Const’) 建立一个常量tensor，按照给出value来赋值，能够用shape来指定其形状。value能够是一个数，也能够是一个list。 若是是一个数，那么这个常亮中全部值的按该数来赋值。 若是是list,那么len(value)必定要小于等于shape展开后的长度。赋值时，先将value中的值逐个存入。不够的部分，则所有存入value的最后一个值。 :param shape: :return: ''' initial = tf.constant(0.1, shape=shape) return tf.Variable(initial) # First Convolutional Layer 第一次卷积层
    #首先在每一个5x5网格中，提取出32张特征图。其中weight_variable中前两维是指网格的大小，第三维的1是指输入通道数目，第四维的32是指输出通道数目（也能够理解为使用的卷积核个数、获得的特征图张数）。每一个输出通道都有一个偏置项，所以偏置项个数为32
    x_image = tf.reshape(x, [-1, 28, 28, 1])  #为了使之能用于计算，咱们使用reshape将其转换为四维的tensor，其中第一维的－1是指咱们能够先不指定，第二三维是指图像的大小，第四维对应颜色通道数目，灰度图对应1，rgb图对应3.
    W_conv1 = weight_variable([5, 5, 1, 32]) b_conv1 = bias_variable([32]) h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)  #利用ReLU激活函数，对其进行第一次卷积。
    h_pool1 = max_pool_2x2(h_conv1) #第一次池化
    # Second Convolutional Layer 第二个回旋的层
    # (32 # 14x14->64 #14x14->64 #7x7)
    # 与第一层卷积、第一次池化相似的过程。
    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) # Densely Connected Layer 紧密链接层
    # 此时，图片是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
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) # keep_prob = tf.placeholder("float")
    # h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
    # 这是一个比较新的也很是好用的防止过拟合的方法，想出这个方法的人基本属于很是crazy的存在。在Udacity - Deep
    # Learning的课程中有提到这个方法——彻底随机选取通过神经网络流一半的数据来训练，在每次训练过程当中用0来替代被丢掉的激活值，其它激活值合理缩放。

    # Readout Layer 读出层
    W_fc2 = weight_variable([1024, 10]) b_fc2 = bias_variable([10]) y = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2) return y, [W_conv1, b_conv1, W_conv2, b_conv2, W_fc1, b_fc1, W_fc2, b_fc2] # 变量做用域 variable_scope # model
with tf.variable_scope("convolutional"): x = tf.placeholder(tf.float32, [None, 784]) keep_prob = tf.placeholder(tf.float32) y, variables = convolutional(x, keep_prob) # train
y_ = tf.placeholder(tf.float32, [None, 10]) # 计算交叉熵的代价函数
cross_entropy = -tf.reduce_sum(y_ * tf.log(y)) ''' reduce_sum （input_tensor ， axis = None ， keep_dims = False ， name = None ， reduction_indices = None） 此函数计算一个张量的各个维度上元素的总和。 函数中的input_tensor是按照axis中已经给定的维度来减小的；除非 keep_dims 是true，不然张量的秩将在axis的每一个条目中减小1；若是keep_dims为true，则减少的维度将保留为长度1。 若是axis没有条目，则缩小全部维度，并返回具备单个元素的张量。 参数： input_tensor：要减小的张量。应该有数字类型。 axis：要减少的尺寸。若是为None（默认），则缩小全部尺寸。必须在范围[-rank(input_tensor), rank(input_tensor))内。 keep_dims：若是为true，则保留长度为1的缩小尺寸。 name：操做的名称（可选）。 reduction_indices：axis的废弃的名称。 返回： 该函数返回减小的张量。 numpy兼容性 至关于np.sum '''

# 使用优化算法使得代价函数最小化
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) ''' class tf.train.AdamOptimizer __init__(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, use_locking=False, name='Adam') 此函数是Adam优化算法：是一个寻找全局最优势的优化算法，引入了二次方梯度校订。 相比于基础SGD算法，1.不容易陷于局部优势。2.速度更快！ '''

# 找出预测正确的标签
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) ''' tf.equal(A, B)是对比这两个矩阵或者向量的相等的元素，若是是相等的那就返回True，反正返回False，返回的值的矩阵维度和A是同样的 A = [[1,3,4,5,6]] B = [[1,3,4,3,2]] with tf.Session() as sess: print(sess.run(tf.equal(A, B))) [[ True True True False False]] 该函数将返回一个 bool 类型的张量。 '''

# 得出经过正确个数除以总数得出准确率
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) ''' cast(x, dtype, name=None) 将x的数据格式转化成dtype.例如，原来x的数据格式是bool， 那么将其转化成float之后，就可以将其转化成0和1的序列。反之也能够 a = tf.Variable([1,0,0,1,1]) b = tf.cast(a,dtype=tf.bool) sess = tf.Session() sess.run(tf.initialize_all_variables()) print(sess.run(b)) #[ True False False True True] '''
''' 求最大值tf.reduce_max(input_tensor, reduction_indices=None, keep_dims=False, name=None) 求平均值tf.reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None) 参数1--input_tensor:待求值的tensor。 参数2--reduction_indices:在哪一维上求解。 参数（3）（4）可忽略 举例说明： # 'x' is [[1., 2.] # [3., 4.]] x是一个2维数组，分别调用reduce_*函数以下： 首先求平均值： tf.reduce_mean(x) ==> 2.5 #若是不指定第二个参数，那么就在全部的元素中取平均值 tf.reduce_mean(x, 0) ==> [2., 3.] #指定第二个参数为0，则第一维的元素取平均值，即每一列求平均值 tf.reduce_mean(x, 1) ==> [1.5, 3.5] #指定第二个参数为1，则第二维的元素取平均值，即每一行求平均值 ''' saver = tf.train.Saver(variables) with tf.Session() as sess: # tf.global_variables_initializer() 初始化模型的参数
 sess.run(tf.global_variables_initializer()) for i in range(20000):  # 每100次迭代输出一第二天志，共迭代20000次
        batch = data.train.next_batch(50) 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)) sess.run(train_step, feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) print(sess.run(accuracy, feed_dict={x: data.test.images, y_: data.test.labels, keep_prob: 1.0})) # os.path.join(os.path.dirname(__file__), 'data', 'convolutional.ckpt') //绝对路径包含中文字符可能致使路径不可用 相对路径：'mnist/data/regression.ckpt'
    path = saver.save( sess,  'mnist/data/regression.ckpt',write_meta_graph=False, write_state=False) print("Saved:", path)