深度学习（五）基于tensorflow实现简单卷积神经网络Lenet５

原文作者：aircraft

原文地址：https://www.cnblogs.com/DOMLX/p/8954892.html

深度学习教程目录如下，还在继续更新完善中

深度学习系列教程目录

参考博客：https://blog.csdn.net/u012871279/article/details/78037984

https://blog.csdn.net/u014380165/article/details/77284921

目前人工智能神经网络已经成为非常火的一门技术，今天就用tensorflow来实现神经网络的第一块敲门砖。

首先先分模块解释代码。

１．先导入模块，若没有tensorflow还需去网上下载，这里使用mnist训练集来训练，进行手写数字的识别。

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf 

#导入数据，创建一个session对象　，之后的运算都会跑在这个session里
mnist = input_data.read_data_sets("MNIST/",one_hot=True)
sess = tf.InteractiveSession()

２．为了方便，定义后来要反复用到函数

#定义一个函数，用于初始化所有的权值 W,这里我们给权重添加了一个截断的正态分布噪声　标准差为0.1
def weight_variable(shape):
    initial = tf.truncated_normal(shape,stddev=0.1)
    return tf.Variable(initial)

#定义一个函数，用于初始化所有的偏置项 b，这里给偏置加了一个正值0.1来避免死亡节点
def bias_variable(shape):
    inital = tf.constant(0.1,shape=shape)
    return tf.Variable(inital)

#定义一个函数，用于构建卷积层，这里strides都是１　代表不遗漏的划过图像的每一个点
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')

主要的函数说明：

卷积层：
tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, data_format=None, name=None)

参数说明：

• data_format：表示输入的格式，有两种分别为：“NHWC”和“NCHW”，默认为“NHWC”

• input：输入是一个4维格式的（图像）数据，数据的 shape 由 data_format 决定：当 data_format 为“NHWC”输入数据的shape表示为[batch, in_height, in_width, in_channels]，分别表示训练时一个batch的图片数量、图片高度、 图片宽度、 图像通道数。当 data_format 为“NHWC”输入数据的shape表示为[batch, in_channels， in_height, in_width]

• filter：卷积核是一个4维格式的数据：shape表示为：[height,width,in_channels, out_channels]，分别表示卷积核的高、宽、深度（与输入的in_channels应相同）、输出 feature map的个数（即卷积核的个数）。

• strides：表示步长：一个长度为4的一维列表，每个元素跟data_format互相对应，表示在data_format每一维上的移动步长。当输入的默认格式为：“NHWC”，则 strides = [batch , in_height , in_width, in_channels]。其中 batch 和 in_channels 要求一定为1，即只能在一个样本的一个通道上的特征图上进行移动，in_height , in_width表示卷积核在特征图的高度和宽度上移动的布长，即 。

• padding：表示填充方式：“SAME”表示采用填充的方式，简单地理解为以0填充边缘，当stride为1时，输入和输出的维度相同；“VALID”表示采用不填充的方式，多余地进行丢弃。具体公式：

  “SAME”:

  “VALID”:

池化层：
tf.nn.max_pool( value, ksize,strides,padding,data_format=’NHWC’,name=None)
或者
tf.nn.avg_pool(…)

参数说明：

• value：表示池化的输入：一个4维格式的数据，数据的 shape 由 data_format 决定，默认情况下shape 为[batch, height, width, channels]

• 其他参数与 tf.nn.cov2d 类型

• ksize：表示池化窗口的大小：一个长度为4的一维列表，一般为[1, height, width, 1]，因不想在batch和channels上做池化，则将其值设为1。

#placceholder 基本都是用于占位符　后面用到先定义
x = tf.placeholder(tf.float32,[None,784])
y_ = tf.placeholder(tf.float32,[None,10])
x_image = tf.reshape(x,[-1,28,28,1])                                #将数据reshape成适合的维度来进行后续的计算

#第一个卷积层的定义
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)                                        #2x2 的max pooling 

#第二个卷积层的定义
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)

#第一个全连接层的定义
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　随机丢掉一些神经元不参与运算
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)

#第二个全连接层　分为十类数据　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)

上面用到了ｓｏｆｔｍａｘ函数来计算loss。

那softmax loss是什么意思呢?如下：

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv),reduction_indices=[1]))        #交叉熵
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)                                #这里用Ａdam优化器　优化　也可以使用随机梯度下降

correct_predition = tf.equal(tf.argmax(y_conv,1),tf.argmax(y_,1))　　　　　　　　　　　　　　　　　　　
accuracy = tf.reduce_mean(tf.cast(correct_predition,tf.float32))                                #准确率

tf.initialize_all_variables().run()                                                                #使用全局参数初始化器　并调用run方法　来进行参数初始化

tf.initialize_all_variables() 接口是老的接口　也许你们的tensorflow　已经用不了 　　　　现在tf.initialize_all_variables()已经被tf.global_variables_initializer()函数代替

下面是使用大小为５０的mini-batch　来进行迭代训练　　每一百次　勘察一下准确率　　　训练完毕　　　　　就可以直接进行数据的测试了

for i in range(20000):
    batch = mnist.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)

    train_step.run(feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})                            #batch[0]   [1]　分别指数据维度　和标记维度　将数据传入定义好的优化器进行训练


print "test accuracy %g"%accuracy.eval(feed_dict={x:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0})    #开始测试数据　

同学们大概应该直到这个过程了，如果不理解神经网络Ｌenet　建议先百度看看他的原理

下面是完整代码。

# -*- coding: utf-8 -*-
"""
Created on XU JING HUI  4-26-2018

@author: root
"""
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf 

#导入数据，创建一个session对象　，之后的运算都会跑在这个session里
mnist = input_data.read_data_sets("MNIST/",one_hot=True)
sess = tf.InteractiveSession()

#定义一个函数，用于初始化所有的权值 W,这里我们给权重添加了一个截断的正态分布噪声　标准差为0.1
def weight_variable(shape):
    initial = tf.truncated_normal(shape,stddev=0.1)
    return tf.Variable(initial)

#定义一个函数，用于初始化所有的偏置项 b，这里给偏置加了一个正值0.1来避免死亡节点
def bias_variable(shape):
    inital = tf.constant(0.1,shape=shape)
    return tf.Variable(inital)

#定义一个函数，用于构建卷积层，这里strides都是１　代表不遗漏的划过图像的每一个点
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')


#placceholder 基本都是用于占位符　后面用到先定义
x = tf.placeholder(tf.float32,[None,784])
y_ = tf.placeholder(tf.float32,[None,10])
x_image = tf.reshape(x,[-1,28,28,1])                                #将数据reshape成适合的维度来进行后续的计算

#第一个卷积层的定义
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)                                        #2x2 的max pooling 

#第二个卷积层的定义
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)

#第一个全连接层的定义
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　随机丢掉一些神经元不参与运算
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)

#第二个全连接层　分为十类数据　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)
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv),reduction_indices=[1]))        #交叉熵
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)                                #这里用Ａdam优化器　优化　也可以使用随机梯度下降

correct_predition = tf.equal(tf.argmax(y_conv,1),tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_predition,tf.float32))                                #准确率

tf.initialize_all_variables().run()                                                                #使用全局参数初始化器　并调用run方法　来进行参数初始化

for i in range(20000):
    batch = mnist.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)

    train_step.run(feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})                            #batch[0]   [1]　分别指数据维度　和标记维度　将数据传入定义好的优化器进行训练


print "test accuracy %g"%accuracy.eval(feed_dict={x:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0})    #开始测试数据