tensirflow实战6：进阶的卷积神经网络训练CIFAR-10数据集

1.CIFAR-10数据集介绍
本节使用的是比较经典的数据集叫CIFAR-10,包含60000张32*32的彩色图像（总算不像MNIST，是灰度图了，灰度图是单通道），因为是彩色图像，所以这个数据集是三通道的，分别是R,G,B三个通道。CIFAR-10,一共有10类图片，每一类图片有6000张，有飞机，鸟，猫，狗等，而且其中没有任何重叠的情况（现实社会中肯定不止那么多类啦）。现在还有一个兄弟版本，CIFAR-100，里面有100类，工程量已经蛮大的了，如果有兴趣，小伙伴们可以尝试一下哦！
这里还要提到一个数据增广的问题，对于数据集比较小，数据量远远不够的情况下，我们可以对图片进行翻转、随机剪切等增加数据，制造出更加多的样本，提高对图片的利用率。

2.数据准备
这个要事先下载Tensorflow Models库，以便使用CIFAR-10数据的类

git clone https://github.com/tensorflow/models.git
cd models/tutorials/image/cifar10

3.卷积神经网络的代码实现
这里我们先载入一些常用的库，比如Numpy和time,并载入tensorflow中下载和读取CIFAR-10数据的类。我这里开头加了from future import division，这是因为在代码最后我的true_count，total_sample_count都是整型，但我要通过这两个数相除，得到准确率，在python2中，如果不添加这个future函数，得出的结果是0，没法得到正确的结果。小伙伴们可以运行代码的时候注释掉这一行试一下，当然如果是python3版本的就不存在这个问题了。

from __future__ import division
import cifar10, cifar10_input
import tensorflow as tf
import numpy as np
import time

设置迭代的最大步数为3000，数据下载默认的地址在/tmp/cifar10_data/，所以我这里定义的地址就是这个位置，这个位置后来是用来读取数据，和对数据进行增广的时候使用的

max_steps = 3000
batch_size = 128
data_dir = '/tmp/cifar10_data/cifar-10-batches-bin'

定义初始化weight的函数，并增加L2正则项，通过筛选出最有效的特征，减少特征的权重防止过拟合。

def variable_with_weight_loss(shape, stddev, w1):
    var = tf.Variable(tf.truncated_normal(shape, stddev = stddev))
    if w1 is not None:
        weight_loss = tf.multiply(tf.nn.l2_loss(var), w1, name = 'weight_loss')
        tf.add_to_collection('losses', weight_loss)
    return var

下载并提取CIFAR-10数据集，并展开到前文所说的位置

cifar10.maybe_download_and_extract()

对数据进行增广

images_train, labels_train = cifar10_input.distorted_inputs(data_dir = data_dir, batch_size = batch_size)

再次利用cifar10_input.inputs函数生成测试数据，这里不需要像训练数据一样对图片进行翻转、随机剪裁等，只需要裁剪图片正中间的24*24大小的区域，并进行数据标准化操作。

images_test, labels_test = cifar10_input.inputs(eval_data = True, data_dir = data_dir, batch_size = batch_size)

设定palceholder的尺寸

image_holder = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])
label_holder = tf.placeholder(tf.int32, [batch_size])

创建第一个卷积层

weight1 = variable_with_weight_loss(shape = [5, 5, 3, 64], stddev = 5e-2, w1 = 0.0)
kernel1 = tf.nn.conv2d(image_holder, weight1, [1, 1, 1, 1], padding = 'SAME')
bias1 = tf.Variable(tf.constant(0.0, shape = [64]))
conv1 = tf.nn.relu(tf.nn.bias_add(kernel1, bias1))
pool1 = tf.nn.max_pool(conv1, ksize = [1, 3, 3, 1], strides = [1, 2, 2, 1], padding = 'SAME')
norm1 = tf.nn.lrn(pool1, 4, bias = 1.0, alpha = 0.001 / 9.0, beta = 0.75)

创建第二个卷积层

weight2 = variable_with_weight_loss(shape = [5, 5, 64, 64], stddev = 5e-2, w1 = 0.0)
kernel2 = tf.nn.conv2d(norm1, weight2, [1, 1, 1, 1], padding = 'SAME')
bias2 = tf.Variable(tf.constant(0.1, shape = [64]))
conv2 = tf.nn.relu(tf.nn.bias_add(kernel2, bias2))
norm2 = tf.nn.lrn(conv2, 4, bias = 1.0, alpha = 0.001 / 9.0, beta = 0.75)
pool2 = tf.nn.max_pool(norm2, ksize = [1, 3, 3, 1], strides = [1, 2, 2, 1], padding = 'SAME')

创建第一个全连接层

reshape = tf.reshape(pool2, [batch_size, -1])
dim = reshape.get_shape()[1].value
weight3 = variable_with_weight_loss(shape = [dim, 384], stddev = 0.04, w1 = 0.004)
bias3 = tf.Variable(tf.constant(0.1, shape = [384]))
local3 = tf.nn.relu(tf.matmul(reshape, weight3) + bias3)

创建第二个全连接层

weight4 = variable_with_weight_loss(shape = [384, 192], stddev = 0.04, w1 = 0.004)
bias4 = tf.Variable(tf.constant(0.1, shape = [192]))
local4 = tf.nn.relu(tf.matmul(local3, weight4) + bias4)

最后一层

weight5 = variable_with_weight_loss(shape = [192, 10], stddev = 1.0 / 192.0, w1 = 0.0)
bias5 = tf.Variable(tf.constant(0.0, shape = [10]))
logits = tf.add(tf.matmul(local4, weight5), bias5)

定义损失函数，注意腰把L2的损失也要加到总的损失中去

def loss(logits, labels):
    labels = tf.cast(labels, tf.int32)
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = logits, labels = labels, name = 'cross_entropy_per_example')
    cross_entropy_mean = tf.reduce_mean(cross_entropy, name = 'cross_entropy')
    tf.add_to_collection('losses', cross_entropy_mean)
    return tf.add_n(tf.get_collection('losses'), name = 'total_loss')

接着将logits节点和label_placeholder传入loss函数获得最终的loss

loss = loss(logits, label_holder)

选择优化器Adam,学习率设为1e-3

train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)

使用tf.nn.in_top_k函数求输出结果中top k 的准确率，默认使用top 1，也就是输出分数最高的那一类的准确率。

top_k_op = tf.nn.in_top_k(logits, label_holder, 1)

初始化模型参数

sess = tf.InteractiveSession()
tf.global_variables_initializer().run()

启动模型线程

tf.train.start_queue_runners()

开始训练，我的GPU是GTX TITAN X训练大概每个batch需要0.08s左右，如果用其它的GPU，可能时间会有长短不太一致。

for step in range(max_steps):
    start_time = time.time()
    image_batch, label_batch = sess.run([images_train, labels_train])
    _, loss_value = sess.run([train_op, loss], feed_dict = {image_holder: image_batch, label_holder: label_batch})
    duration = time.time() - start_time
    if step % 10 == 0:
        examples_per_sec = batch_size / duration
        sec_per_batch = float(duration)

        format_str = ('step %d, loss = %.2f(%.1f examples/sec; %.3f sec/batch)')
        print(format_str % (step, loss_value, examples_per_sec, sec_per_batch))

评测模型在测试集上的准确率

num_examples = 10000
import math
num_iter = int(math.ceil(num_examples / batch_size))
true_count = 0
total_sample_count = num_iter * batch_size
# print total_sample_count
step = 0
while step < num_iter:
    image_batch, label_batch = sess.run([images_test, labels_test])
    predictions = sess.run([top_k_op], feed_dict = {image_holder: image_batch, label_holder: label_batch})

    true_count += np.sum(predictions)
    step += 1
    # print(true_count)

输出准确率的评测结果

precision = true_count / total_sample_count
print('precision @ 1 = %.3f' %precision)

代码好像越写越长，数据集也开始慢慢复杂起来了，但是只要每天进步一点点，就好O(∩_∩)O