深度学习(八)--CNN

1. 全连接神经网络

每个神经元与前后相邻层的神经元都有联系，输入特征值，输出预测值；

存在的问题：在处理图像问题时，待优化的参数过多，容易导致模型过拟合；

实际应用：对原始图像进行特征提取，把提取到的特征喂给全连接层，让全连接层网络计算分类评估值；

2. 卷积

有效提取图像特征的方法；

优点：参数共享；稀疏连接(连接只与卷积核内的数据相关联)；平移不变(图像即使平移后，它最终的特征几乎不变)

一般用一个正方形卷积核遍历图片上的每一个像素点。即图片与卷积核区域内相对应的每一个像素值乘以卷积核内相对应的权重，然后求和，再加上偏置项，最后得到输出图片中的一个像素值。

卷积后图像的大小：输出图片边长=(输入图片边长-卷积核长+1)/步长

3. padding

为什么需要padding？

 a. 图片卷积运算后尺寸不断减小；

 b. 边缘像素采取次数较少，导致信息丢失；

全零填充padding：在图片的周围进行全零填充，这样能够保证输出的图片大小等于输入大小；

输出样本的大小=(输入图片大小-卷积核大小+2*零填充的数量)/步长+1

tensorflow提供的padding：

a. VALID：不填充

b. SAME: 填充保证输出等于输入

4. 池化

根据池化核的大小和移动的步长，对数据提取的特征进行汇总；

exp(最大池化，步长为2，池化核大小为2)：

5. 全连接层

网络层神经元之间都存在连接关系；

池化层无参数，卷积层有少量参数，全连接层参数较多；

6. 经典的CNN网络

每一种网络结构都是以卷积、激活、池化、全连接这四种操作为基础进行拓展；

 Lenet-5、Alenet、VGGNet、GoogleNet 和 ResNet 

7. CNN实现手写数字识别

# coding=utf-8
'''
定义CNN网络，使得手写数字识别准确率>=99%
'''
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#加载数据
mnist = input_data.read_data_sets('data/MNIST_data/',one_hot=True)
#定义批次处理的大小
batch_size = 100;
n_batch = mnist.train.num_examples//batch_size
#初始化权重
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)
    return tf.Variable(initial)
#定义卷积层
def conv2d(x,W):
    #x input tensor of shape `[batch, in_height, in_width, in_channels]`
    #W filter / kernel tensor of shape [filter_height, filter_width, in_channels, out_channels]
    #`strides[0] = strides[3] = 1`. strides[1]代表x方向的步长，strides[2]代表y方向的步长
    #padding: A `string` from: `"SAME", "VALID"`
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
#定义池化层
def max_pool_2x2(x):
    #ksize [1,x,y,1]
    #ksize、strides的第0个位置和第3个位置为1,其他的2,2表示大小为2*2，横向和纵向步长为2
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
#定义两个占位符
x = tf.placeholder(tf.float32,[None,784])
y = tf.placeholder(tf.float32,[None,10])
#改变x的格式转为4D的向量[batch, in_height, in_width, in_channels]`
x_image = tf.reshape(x,[-1,28,28,1])

#初始化第一个卷积层
W_conv1 = weight_variable([5, 5, 1, 32])  # 5*5的采样窗口，32个卷积核从1个平面抽取特征
b_conv1 = bias_variable([32])  # 每一个卷积核一个偏置值
# 把x_image和权值向量进行卷积，再加上偏置值，然后应用于relu激活函数
conv2d_1 = conv2d(x_image, W_conv1) + b_conv1
h_conv1 = tf.nn.relu(conv2d_1)
h_pool1 = max_pool_2x2(h_conv1)  # 进行max-pooling

#第二个卷积层
W_conv2 = weight_variable([5, 5, 32, 64])  # 5*5的采样窗口，64个卷积核从32个平面抽取特征
b_conv2 = bias_variable([64])  # 每一个卷积核一个偏置值
# 把h_pool1和权值向量进行卷积，再加上偏置值，然后应用于relu激活函数
conv2d_2 = conv2d(h_pool1, W_conv2) + b_conv2
h_conv2 = tf.nn.relu(conv2d_2)
h_pool2 = max_pool_2x2(h_conv2)  # 进行max-pooling

#28*28的图片第一次卷积后还是28*28(padding取值为Same)，第一次池化后变为14*14
#第二次卷积后为14*14，第二次池化后变为了7*7(步长为2)
#进过上面操作后得到64张7*7的平面(64个通道)

#初始化第一个全连接层
W_fc1 = weight_variable([7 * 7 * 64, 1024])  # 上一场有7*7*64个神经元，全连接层有1024个神经元
b_fc1 = bias_variable([1024])  # 1024个节点
# 把池化层2的输出扁平化为1维
h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
# 求第一个全连接层的输出
wx_plus_b1 = tf.matmul(h_pool2_flat, W_fc1) + b_fc1
h_fc1 = tf.nn.relu(wx_plus_b1)
# keep_prob用来表示神经元的输出概率
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

#初始化第二个全连接层
#初始化第二个全连接层
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
wx_plus_b2 = tf.matmul(h_fc1_drop,W_fc2) + b_fc2

#计算输出
prediction = tf.nn.softmax(wx_plus_b2)
#计算交叉熵
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=prediction))
#使用AdamOptimizer进行优化
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#求准确率
correct_prediction = tf.equal(tf.argmax(prediction,1),tf.argmax(y,1))#argmax返回一维张量中最大的值所在的位置
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

#开始训练
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for epoch in range(21):
        for batch in range(n_batch):
            batch_xs, batch_ys = mnist.train.next_batch(batch_size)
            sess.run(train_step, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 0.7})
        acc = sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0})
        print("Iter " + str(epoch) + ", Testing Accuracy= " + str(acc))

结果：

Iter 0, Testing Accuracy= 0.952
Iter 1, Testing Accuracy= 0.9701
Iter 2, Testing Accuracy= 0.9781
Iter 3, Testing Accuracy= 0.9803
Iter 4, Testing Accuracy= 0.9822
Iter 5, Testing Accuracy= 0.9842
Iter 6, Testing Accuracy= 0.9865
Iter 7, Testing Accuracy= 0.9869
Iter 8, Testing Accuracy= 0.9868
Iter 9, Testing Accuracy= 0.988
Iter 10, Testing Accuracy= 0.9882
Iter 11, Testing Accuracy= 0.9881
Iter 12, Testing Accuracy= 0.9889
Iter 13, Testing Accuracy= 0.9902
Iter 14, Testing Accuracy= 0.99
Iter 15, Testing Accuracy= 0.9903
Iter 16, Testing Accuracy= 0.9909
Iter 17, Testing Accuracy= 0.9908
Iter 18, Testing Accuracy= 0.991
Iter 19, Testing Accuracy= 0.9909
Iter 20, Testing Accuracy= 0.9912