tensorflow：4)实现'进击'的卷积网络-CIFAR数据集

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

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

进入python命令行，使用库里面的提供的函数下载数据

import cifar10, cifar10_inputcifar10.maybe_download_and_extract()

PS:数据集默认下载的路径为”/tmp/cifar10_data/”，居然使用绝对路径，完全不考虑windowns的感受，而且国外的资源下载速度有点慢，这里提供一个百度云的下载

3.卷积神经网络的代码实现
这里我们先载入一些常用的库，比如Numpy和time,并载入tensorflow中下载和读取CIFAR-10数据的库

from __future__ import divisionimport cifar10, cifar10_inputimport tensorflow as tfimport numpy as npimport time

设置迭代的最大步数为3000，数据解压后的地址，训练时的batch大小

data_dir = 'F:\git\cifar10_data\cifar-10-batches-bin'max_steps = 3000batch_size = 128

定义初始化weight的函数，并增加L2正则项，通过筛选出最有效的特征，减少特征的权重防止过拟合，add_to_collection和L2正则化可以参考上节内容

def variable_with_weight_loss(shape, stddev, w1):    print('weight function runned')    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

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

images_train, labels_train = cifar10_input.distorted_inputs(data_dir=data_dir, batch_size=batch_size)images_train, labels_train = cifar10_input.distorted_inputs(data_dir=data_dir, batch_size=batch_size)images_test, labels_test = cifar10_input.inputs(eval_data=True, data_dir=data_dir, batch_size=batch_size)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)

卷积层的最后，使用一个LRN层，它是在AlexNet中提出的，其模仿了生物神经系统的”侧抑制”机制，对局部神经元的活动创建竞争环境，使得影响较大的值变得更大，并抑制了其他反馈较小的神经元

创建第二个卷积层

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].valueweight3 = 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')

注意这里直接使用tf.nn.sparse_softmax_cross_entropy_with_logits，其把softmax和交替熵整合优化在一起。

选择优化器Adam,学习率设为1e-3，使用tf.nn.in_top_k函数求输出结果中top k 的准确率，默认使用top 1，也就是输出分数最高的那一类的准确率。

loss = loss(logits, label_holder)train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)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()

开始训练模型，每各10个批次打印下loss和花费的时间，说好的0.066s一个批次，因为Lz穷买不起N卡，一个批次大概0.22s

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 = 10000import mathnum_iter = int(math.ceil(num_examples / batch_size))true_count = 0total_sample_count = num_iter * batch_size# print total_sample_countstep = 0while 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_countprint('precision @ 1 = %.3f' % precision)

测试的准确度只有 0.711，姿势不对？