4--tensorflow CNN 卷积神经网络

1.什么是卷积神经网络
人工神经网络的一种结构，最常见应用于图片识别，已可以用于其他方面。
卷积也就是说神经网络不再是对每个像素的输入信息做处理了,而是图片上每一小块像素区域进行处理, 这种做法加强了图片信息的连续性.
在每一次卷积的时候, 神经层可能会无意地丢失一些信息. 这时, 池化 (pooling) 就可以很好地解决这一问题. 而且池化是一个筛选过滤的过程, 能将 layer 中有用的信息筛选出来, 给下一个层分析. 同时也减轻了神经网络的计算负担。

2.CNN介绍
cnn是怎么处理信息的：
每一个像素点有RGB三个值，图片的厚度是3，每一次卷积，就是抽取一个大小为Stride的部分，然后每一次抽取会隔一个步长，跨度就是Patch，每次取出的小块图片厚度变厚，但是大小很小，结合到一块就是，长，宽压缩了，厚度变厚了：


这就是valid Padding
另一种抽出来汇集起来之后长宽是与原来一样的，叫做same Padding
pooling也有两种方式：max pooling ，average pooling

3.开始实践
我们之前的手写数字识别实践，用的算法，只能保证最后87%的正确率，参考
这是非常低的，如果使用CNN，正确率可以达到96%

首先定义weights，biase，conv，pooling这四个函数：

#初始化权重函数
def weight_variable(shape):
    initial = tf.truncated_normal(shape,stddev = 0.1)#产生截断正态分布随机数
    return tf.Variable(initial)

#初始化偏置
def bias_variable(shape):
    initial = tf.constant(0.1,shape = shape)#定义初始值是0.1
    return tf.Variable(initial)

#定义卷积神经网络层
def conv2d(x,W):#定义一个2维的CNN
    #stride[1,x_movement,y_movement,1]步长，每隔多少抽取信息
    #第一个和第四个数必须是1
    return tf.nn.conv2d(x,W,strides = [1,1,1,1],padding = 'SAME')#跨度是1，抽取信息
    
#定义2*2的最大池化   
def max_pool_2x2(x):#池化
    return tf.nn.max_pool(x,ksize = [1,2,2,1],strides = [1,2,2,1],padding = 'SAME')
    #ksize池化窗口的大小

整个结构图如下：

接下来来写conv1 layer，conv2 layer，func1 layer和func2 layer：

###conv1 layer###第一层卷积
W_conv1 = weight_variable([5,5,1,32])#[filter_height,filter_width,in_channels,out_channels]
#patch 5*5,insize 1,指的是输入灰度图像，只有一通道outsize 32
#过滤器每次取出的小片图片大小是5*5，但是输出的是1个单位的结果，且高度变成了32
b_conv1 = bias_variable([32])#初始化偏置项
#进行卷积，并且用relu激活
h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1) #类比于y = x*w + b
#h_conv1之后size是28*28*32
h_pool1 = max_pool_2x2(h_conv1)#池化,14*14*32


###conv2 layer###第二层卷积
w_conv2 = weight_variable([5,5,32,64])#初始化第二层神经层的权重
#patch 5*5,insize 32,outsize 64
b_conv2 = bias_variable([64])#初始化偏置
#将第一层卷积池化后的结果作为第二层卷积的输入
h_conv2 = tf.nn.relu(conv2d(h_pool1,w_conv2) + b_conv2)#14*14*64
h_pool2 = max_pool_2x2(h_conv2)#池化,7*7*64


###func1 layer###全链接层
W_fc1 = weight_variable([7*7*64,1024])
b_fc1 = bias_variable([1024])
# h_pool2这个三维的值，转化为二维的
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
#把[n_samples,7*7*64]变成[h_pool2,[-1,7*7*64]]
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1) + b_fc1)
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)


###func2 layer###输出层
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2) + b_fc2)
#输出层用softmax进行classification处理，算概率

完整程序：

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

mnist = input_data.read_data_sets('MNIST_data',one_hot = True)


def compute_accuracy(v_xs,v_ys):
    global prediction
    y_pre = sess.run(prediction,feed_dict = {xs:v_xs,keep_prob:1})
    correct_prediction = tf.equal(tf.argmax(y_pre,1),tf.argmax(v_ys,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
    result = sess.run(accuracy,feed_dict = {xs:v_xs,ys:v_ys,keep_prob:1})
    return result

#初始化权重函数
def weight_variable(shape):
    initial = tf.truncated_normal(shape,stddev = 0.1)#产生截断正态分布随机数
    return tf.Variable(initial)

#初始化偏置
def bias_variable(shape):
    initial = tf.constant(0.1,shape = shape)#定义初始值是0.1
    return tf.Variable(initial)

#定义卷积神经网络层
def conv2d(x,W):#定义一个2维的CNN
    #stride[1,x_movement,y_movement,1]步长，每隔多少抽取信息
    #第一个和第四个数必须是1
    return tf.nn.conv2d(x,W,strides = [1,1,1,1],padding = 'SAME')#跨度是1，抽取信息
    
#定义2*2的最大池化   
def max_pool_2x2(x):#池化
    return tf.nn.max_pool(x,ksize = [1,2,2,1],strides = [1,2,2,1],padding = 'SAME')
    #ksize池化窗口的大小

#define placeholder for inputs to network
xs = tf.placeholder(tf.float32,[None,784])#28*28
ys = tf.placeholder(tf.float32,[None,10])
keep_prob = tf.placeholder(tf.float32)
x_image = tf.reshape(xs,[-1,28,28,1])
#将输入的xs转成一个4D向量，第2、3维对应图片的宽高，最后一维代表图片的颜色通道数
# 输入的图像为灰度图，所以通道数为1，如果是RGB图，通道数为3
# tf.reshape(xs,[-1,28,28,1])的意思是将xs自动转换成28*28*1的数组
# -1的意思是代表不知道x的shape，它会按照后面的设置进行转换
#print(x_image.shape)#[n_samples,28,28,1]



###conv1 layer###第一层卷积
W_conv1 = weight_variable([5,5,1,32])#[filter_height,filter_width,in_channels,out_channels]
#patch 5*5,insize 1,指的是输入灰度图像，只有一通道outsize 32
#过滤器每次取出的小片图片大小是5*5，但是输出的是1个单位的结果，且高度变成了32
b_conv1 = bias_variable([32])#初始化偏置项
#进行卷积，并且用relu激活
h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1) #类比于y = x*w + b
#h_conv1之后size是28*28*32
h_pool1 = max_pool_2x2(h_conv1)#池化,14*14*32


###conv2 layer###第二层卷积
w_conv2 = weight_variable([5,5,32,64])#初始化第二层神经层的权重
#patch 5*5,insize 32,outsize 64
b_conv2 = bias_variable([64])#初始化偏置
#将第一层卷积池化后的结果作为第二层卷积的输入
h_conv2 = tf.nn.relu(conv2d(h_pool1,w_conv2) + b_conv2)#14*14*64
h_pool2 = max_pool_2x2(h_conv2)#池化,7*7*64


###func1 layer###全链接层
W_fc1 = weight_variable([7*7*64,1024])
b_fc1 = bias_variable([1024])
# h_pool2这个三维的值，转化为二维的
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
#把[n_samples,7*7*64]变成[h_pool2,[-1,7*7*64]]
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1) + b_fc1)
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)


###func2 layer###输出层
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2) + b_fc2)
#输出层用softmax进行classification处理，算概率


#the error between prediction and real data
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),reduction_indices = [1]))#loss
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#对于大的系统，用AdamOptimizer比较好，AdamOptimizer的学习步长应该更小


sess = tf.Session() #important step

sess.run(tf.initialize_all_variables())



for i in range(1000):
    batch_xs,batch_ys = mnist.train.next_batch(100)
    #batch_xs.shape = (100,784);batch_ys.shape = (100,10)
    #从下载好的MNIST_data中提取出训练数据中的100个
    #不学习整个data，而是每100个学习一下，就效率比较高
    sess.run(train_step,feed_dict = {xs:batch_xs,ys:batch_ys,keep_prob:1.0})
    if i % 50 == 0:
        #计算准确度的函数compute_accuracy
        print(compute_accuracy(mnist.test.images,mnist.test.labels))
        #mnist里面包含了test_data和train_data,用test_data的labels与预测值对比，算准确值，测试功能

整个过程需要一段时间：

打印出精度一步步提高，能达到97%

参考