TensorFlow实现进阶的神经网络

      很抱歉！本应该昨天就更新的，无奈遇到了比较棘手的问题，好在经过不懈的努力，还算是比较幸运地解决了问题。本次我们要使用的大名鼎鼎的CIFAR-10的数据集，这个集合里面包括十种类别，airplane,automobile,bird,cat,deer,dog,frog,horse,ship,truck，共有6w张32*32的图片，其中训练集5w,测试集1w。TF中是有自带的py文件能够下载这些数据，但是，但是……太慢了！为此我等了一天……然后还下载失败了，很气，下面提供博主最终修改过源码的文件和数据（提醒一下，楼主tf版本为1.2，如果有使用1.0的同学，建议到网上找原始的cifar10_input.py文件），这样能避免在数据上纠结。

链接：http://pan.baidu.com/s/1eSksdnO 密码：kvdq

      里面一个是cifar-10数据，将它解压到某个路径上去，然后将cifar10_input.py放在pycharm的site-packages中或者直接放在我们自己写的py文件的目录下，总之，要能import进去就行，下面是载入数据的代码

import cifar10_input
import tensorflow as tf
import numpy as np
import time

max_steps=10000  #设置训练轮数，在这个程序里，轮数越大,准确度越高，但是……博主用的GPU版本，慢的跟蜗牛一样……
data_dir='/tmp/cifar10_data/cifar-10-batches-bin'#这是tf默认下载数据的路径，我也按照这个来，C盘空间不够的同学可以再选个路径

batch_size=128   #大家应该很熟悉这货了

    接下来定义一个权重随机生成的函数，这里，我们首次使用正则化的概念，它是通过减少特征或者惩罚不重要特征的权重来缓解过拟合问题。（神经网络好矛盾，总在过拟合和缓解过拟合之间徘徊）具体算法的数学过程大家可以去搜搜文章看看，博主大部分机器学习的基础都是从周志华老师的《机器学习》上学得的

def variable_with_weight_loss(shape,stddev,w1): #这里定义了一个w1,用来控制L2正则化loss的大小
    var=tf.Variable(tf.truncated_normal(shape=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
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)
images_holder=tf.placeholder(tf.float32,[batch_size,24,24,3])#图片为RGB模式，有3个颜色通道，尺寸为24*24，在input.py中已经过处理
labels_holder=tf.placeholder(tf.int32,[batch_size])

接下来定义第一个卷积层，这里不同于之前的卷积层，在池化层后，又加了一层LAN层。
weight1=variable_with_weight_loss(shape=[5,5,3,64],stddev=5e-2,w1=0.0)#第一层卷积不做正则化处理，所以令w1=0
kernel1=tf.nn.conv2d(images_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层，该法能对局部神经元的活动创建竞争环境，使得相对大的值变得更大，并抑制较小的神经元

第二层卷积层，与第一层略有不同，在于将LRN层提前到池化层前，并且bias的初始值均设置为0.1

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])#这里使用get_shape函数，获取数据扁平化后的长度
dim=reshape.get_shape()[1].value
weight3=variable_with_weight_loss(shape=[dim,384],stddev=0.04,w1=0.004)#这里设置隐层节点数为384bias3=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/192.0,w1=0.0)#将正态分布的标准差设为上一个隐层的节点数的倒数，且不计入L2正则化
bias5=tf.Variable(tf.constant(0.0,shape=[10]))
logits=tf.add(tf.matmul(local4,weight5),bias5)
这里先不做softmax，我们把它放在计算loss的部分
我们把softmax的计算和cross_entropy合并在了tf.nn.sparse_softmax_cross_entropy_with_logits里面
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')
    tf.add_to_collection('losses',cross_entropy_mean)#将cross_entropy的loss添加到整体的losses的collection中
    return tf.add_n(tf.get_collection('losses'),name='total_loss')

接着将logits节点和label_holder传入loss函数获得最终的loss
loss=loss(logits,labels_holder)
train_op=tf.train.AdagradOptimizer(1e-3).minimize(loss)#依然使用Adam optimizizer优化
top_k_op=tf.nn.in_top_k(logits,labels_holder,1)#输出结果中的top k的准确率，默认使用top 1,也就是输出分数最高的那一类的准确率

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

这里使用16个线程进行加速，如果这里不启动线程，后面的inference以及训练的操作是无法开始的
tf.train.start_queue_runners()
开始训练
for step in range(max_steps):
    start_time=time.time()
    image_batch,labels_batch=sess.run([images_train,labels_train])
    loss_value=sess.run([train_op,loss],feed_dict={images_holder:image_batch,labels_holder:labels_batch})
    duration=time.time()-start_time
    if step%10==0:
        examples_per_sec=batch_size/duration  #每隔10个step会计算并展示当前的loss,每秒能训练的样本数量，以及训练一个batch所花费的时间
        sec_per_batch=float(duration)
        print(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
step=0
while step<num_iter:
    image_batch,labels_batch=sess.run([images_test,labels_test])
    predictions=sess.run([top_k_op],feed_dict={images_holder:image_batch,labels_holder:labels_batch})
    true_count+=np.sum(predictions)
    step+=1
precision=true_count/total_sample_count
print('precision @ 1=%.3f'%precision)

      怎么说呢，这个近一百行代码的程序，看起来也不难，但是作为好奇宝宝，我们总有些疑问，比如，为何第一卷积层和第二卷积层中的池化层和LRN层顺序不一样？为何loss函数和softmax混合在了一起？……这个博主想了好久也没有找到答案。不过学到这里，大家要明确一点的是，往后的准确率的提升，很大一部分都是靠经验来调参……似乎只有上帝能够帮我们了……这个训练轮数我设置为10000次，就花了我电脑一晚上的时间来训练（心疼），言外之意就是，以后我们自己试验的运行的准确率高不了了（通常训练轮数越大，准确率是一定会提高的，博主这一次仅仅达到0.53的准确率）而且，仔细想想，这才是32*32的图片啊，突然就能理解为何google说要实现自动驾驶可能要二三十年后这种话了。目前处理器的制作工艺也快到头了（隧穿效应），基于冯诺依曼制作的计算机的计算能力已经可预见地看到了尽头？看看量子计算机能否引领新潮流?谁知道呢，那么这一篇到这里了。之后我们会尝试地看看一些经典的卷积神经网络，至于基于CPU的TF能否跑起来，那就……额，哈哈哈