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

 

posted @ 2018-12-28 15:30  C#爆破  阅读(885)  评论(0编辑  收藏  举报