欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-05-02 22:57:39
# 手写数字识别 ----卷积神经网络模型 import os import tensorflow as tf #部分注释来源于 # http://www.cnblogs.com/rgvb178/p/6052541.html from tensorflow.examples.tutorials.mn... ......
# 手写数字识别  ----卷积神经网络模型
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)