tensorflow用CNN实现CIFAR-10图像分类（cpu贼慢）

代码及注释

import cifar10,cifar10_input
import tensorflow as tf
import numpy as np
import time
import os
​
# 各种参数和CIFAR-10的默认下载路径
max_steps = 3000
batch_size = 128
data_dir = './cifar-10-batches-bin'
​
def variable_with_weight_loss(shape, stddev, wl):
    # 用的也是阶段正态分布，初始化权重
    var = tf.Variable(tf.truncated_normal(shape, stddev=stddev))
    if wl is not None:
        # 给权重做一个正则化处理，特征过多会导致过拟合，不知道该惩罚哪些，正则化就来帮忙了
        # L1正则太强了，会导致稀疏，无用的权重都会被置为0，而L2能让其比较平均
        # wl控制L2 loss的大小
        # add_to_collection把weight loss统一存到一个collection中，并命名为losses
        weight_loss = tf.multiply(tf.nn.l2_loss(var),wl,name='weight_loss')
        tf.add_to_collection('losses',weight_loss)
    return var
​
# 用cifar10类下载数据集，解压展开到默认位置
# 然而我却下载失败了，只能去官网下载
# http://www.cs.toronto.edu/~kriz/cifar.html
# cifar10.maybe_download_and_extract()
​
# 对图像做一定处理，进行数据增强，生成训练数据
# 返回的是已经封装好的tensor，每次执行都会生产一个batch_size数量的样本
# 这里的增强是再distorted_inputs里面完成的，如水平翻转，随机剪切24*24，随机亮度
# 这里的图像也会被标准化
images_train, labels_train = cifar10_input.distorted_inputs(data_dir = data_dir,batch_size=batch_size)
# 剪裁正中间24*24大小的区块，对图像进行标准化操作，生成测试数据
# 因为训练集已经随机成24*24，这里也跟风么，反正不用乱搞就行了
images_test,labels_test = cifar10_input.inputs(eval_data=True,data_dir=data_dir,batch_size = batch_size)
​
Filling queue with 20000 CIFAR images before starting to train. This will take a few minutes.
# 特征和label得占位符，这里的batch必须要是事先设定，而不能是None
image_holder = tf.placeholder(tf.float32, [batch_size,24,24,3])
label_holder = tf.placeholder(tf.int32,[batch_size])
​
# 第一个卷积层
# 没有进行L2
weight1 = variable_with_weight_loss(shape=[5,5,3,64],stddev = 5e-2,wl=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))
# 池化层3*3步长2*2
pool1 = tf.nn.max_pool(conv1,ksize=[1,3,3,1],strides=[1,2,2,1],padding='SAME')
# 这里的LRN可以理解为一种标准化，增强泛化能力
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,wl=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')
​
# 全连接
# 先全部展开，第一维是batch大小，第二维不管，填满为之
reshape = tf.reshape(pool2,[batch_size,-1])
dim = reshape.get_shape()[1].value
# 隐藏节点384，这个权重初始化层万能
# 全连接层不要过拟合，所以弄了一个L2系数，所以这一层的所有参数都会受到L2的制裁
weight3 = variable_with_weight_loss(shape=[dim,384],stddev=0.04,wl=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,wl=0.004)
bias4 = tf.Variable(tf.constant(0.1,shape=[192]))
local4 = tf.nn.relu(tf.matmul(local3,weight4)+bias4)
​
# 这个是最后一层，不需要用softmax
weight5 = variable_with_weight_loss(shape = [192,10],stddev = 1/192.0,wl=0.0)
bias5 = tf.Variable(tf.constant(0.0,shape=[10]))
logits = tf.add(tf.matmul(local4,weight5),bias5)
​
# 计算loss，这里softmax和loss结合了
def loss(logits,labels):
    labels = tf.cast(labels,tf.int64)
    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')
    # 这里把所有得loss甩到collection(losses)里了
    tf.add_to_collection('losses',cross_entropy_mean)
    # 通过求和，得到最后的loss，其中包含cross_entropy_loss和后两个全连接层中weight的L2 loss
    return tf.add_n(tf.get_collection('losses'),name='total_loss')
​
# 将logits节点和label占位符传入，得到最终loss
loss = loss(logits,label_holder)
​
# 优化器adam，学习率为1e-3
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)
​
# 这个是输出top k的准确率，默认使用top1，也就是分数最高的那一类准确率
top_k_op = tf.nn.in_top_k(logits,label_holder,1)
​
# 初始化全部参数
sess = tf.InteractiveSession()
tf.global_variables_initializer().run()
​
# 这一步是启动前面提到的图片增强线程队列
# 一共使用了16个线程来加速
tf.train.start_queue_runners()

for step in range(max_steps):
    # 记录一下开始的时间
    start_time = time.time()
    # 用session的run来执行训练，得到一个batch的训练数据
    image_batch,label_batch = sess.run([images_train,labels_train])
    # 再将这个batch传入到train_op和loss计算
    _,loss_value = sess.run([train_op,loss],feed_dict={image_holder:image_batch,label_holder:label_batch})
    # 看看练了多久
    # 用GTX，每秒钟大概能训练1800个样本（我就100个，呵呵），每个batch大约需要0.066s
    # loss最后会到1.0左右
    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))

step 0 ,loss=6.87 (93.3 examples/sec;1.371 sec/batch)
step 10 ,loss=5.08 (110.8 examples/sec;1.155 sec/batch)
step 20 ,loss=3.99 (105.6 examples/sec;1.212 sec/batch)
step 30 ,loss=3.23 (106.9 examples/sec;1.198 sec/batch)
step 40 ,loss=2.84 (110.4 examples/sec;1.159 sec/batch)
step 50 ,loss=2.51 (105.7 examples/sec;1.211 sec/batch)
step 60 ,loss=2.23 (107.6 examples/sec;1.190 sec/batch)
step 70 ,loss=2.08 (105.6 examples/sec;1.212 sec/batch)
step 80 ,loss=2.06 (107.8 examples/sec;1.187 sec/batch)
step 90 ,loss=1.93 (104.0 examples/sec;1.230 sec/batch)
step 100 ,loss=2.10 (105.3 examples/sec;1.216 sec/batch)
step 110 ,loss=1.98 (93.8 examples/sec;1.364 sec/batch)
step 120 ,loss=2.11 (99.4 examples/sec;1.288 sec/batch)
step 130 ,loss=1.89 (67.0 examples/sec;1.910 sec/batch)
step 140 ,loss=1.80 (107.4 examples/sec;1.192 sec/batch)
step 150 ,loss=1.83 (95.1 examples/sec;1.346 sec/batch)
step 160 ,loss=2.12 (105.0 examples/sec;1.219 sec/batch)
step 170 ,loss=1.69 (108.3 examples/sec;1.182 sec/batch)
step 180 ,loss=1.89 (101.4 examples/sec;1.263 sec/batch)
step 190 ,loss=1.93 (109.2 examples/sec;1.172 sec/batch)
step 200 ,loss=1.66 (107.0 examples/sec;1.197 sec/batch)
step 210 ,loss=1.77 (107.9 examples/sec;1.186 sec/batch)
step 220 ,loss=1.71 (110.9 examples/sec;1.154 sec/batch)
step 230 ,loss=1.55 (108.0 examples/sec;1.185 sec/batch)
step 240 ,loss=1.54 (104.9 examples/sec;1.220 sec/batch)
step 250 ,loss=1.53 (106.9 examples/sec;1.197 sec/batch)
step 260 ,loss=1.73 (105.2 examples/sec;1.217 sec/batch)
step 270 ,loss=1.66 (111.3 examples/