手写数字识别 ----卷积神经网络模型官方案例注释（基于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)