TensorFlow基于cifar10数据集实现进阶的卷积网络

拼搏现实的明天。 2023-06-06 12:02 14阅读 0赞

### TensorFlow基于cifar10数据集实现进阶的卷积网络 ###

*  学习链接
 *  CIFAR10模型及数据集介绍
 *   *  综述
     *  CIFAR10数据集介绍
     *  CIFAR10数据集可视化
     *  CIFAR10模型
 *  CIFAR10代码

# 学习链接 #

[https://github.com/tensorflow/models/tree/master/tutorials/image/cifar10][https_github.com_tensorflow_models_tree_master_tutorials_image_cifar10]  
[http://www.cs.toronto.edu/~kriz/cifar.html][http_www.cs.toronto.edu_kriz_cifar.html]  
[http://blog.csdn.net/diligent\_321/article/details/53130913][http_blog.csdn.net_diligent_321_article_details_53130913]  
[http://blog.csdn.net/diligent\_321/article/details/53008840][http_blog.csdn.net_diligent_321_article_details_53008840]  
[http://blog.csdn.net/barry\_j/article/details/79158017][http_blog.csdn.net_barry_j_article_details_79158017]  
[http://blog.csdn.net/yangdashi888/article/details/77918311][http_blog.csdn.net_yangdashi888_article_details_77918311]

# CIFAR10模型及数据集介绍 #

## 综述 ##

Cifar-10 是由Hinton 的两个大弟子 Alex Krizhevsky、Ilya Sutskever 收集的一个用于普适物体识别的数据集。Cifar 是加拿大政府牵头投资的一个先进科学项目研究所。Hinton、Bengio和他的学生在2004年拿到了 Cifar 投资的少量资金，建立了神经计算和自适应感知项目。这个项目结集了不少计算机科学家、生物学家、电气工程师、神经科学家、物理学家、心理学家，加速推动了 Deep Learning 的进程。从这个阵容来看，DL 已经和 ML 系的数据挖掘分的很远了。Deep Learning 强调的是自适应感知和人工智能，是计算机与神经科学交叉；Data Mining 强调的是高速、大数据、统计数学分析，是计算机和数学的交叉。

CIFAR-10是机器学习分类问题中的一个标尺问题。目标是将RGB 32\*32的图像分成10类：飞机（airplane）,汽车(automobile),鸟(bird),猫(cat),鹿（deer）,狗(dog),青蛙(frog),马(horse),船(ship),卡车(truck)。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70]  
可以看到，同已经成熟的人脸识别相比，普适物体识别挑战巨大，数据中含有大量特征、噪声，识别物体比例不一。因而，Cifar-10 相对于传统图像识别数据集，是相当有挑战的。想了解更多信息请参考CIFAR-10 page，以及 Alex Krizhevsky 的技术报告。

**学习CIFAR-10模型的用处**

*  强调了网络结构、训练和评估的规范组织方式。
 *  提供了构建更大和更精细的模型的模板。

**选择CIFAR-10的原因：**

*  它足够复杂，可以训练TensorFlow的大规模模型的大部分能力；
 *  它足够小，可以快速训练，这对于尝试新想法和实验新技术是理想的。

**CIFAR-10模型在TensorFlow中设计更大和更精细的模型了展示几个重要构想：**  
核心数学元素包括：

*  卷积
 *  激活函数ReLu
 *  池化max-pooling
 *  标准化local response normalization

可视化(visualization)训练过程中的网络激活(network activities)，包含图像输入，损失函数，激活值和梯度的分布。  
计算学习参数的移动平均（moving average），使用移动平均法提升预测效果。  
实现随时间下降的学习率(learning rate)。  
对输入数据预提取队列(queues),让模型从硬盘延迟和图像预处理中独立出来。  
也提供了多GPU版本，暂时忽略。

正则化：防止过拟合，提高泛化能力  
在机器学习中，不管是分类还是回归，都可能因特征过多而产生过拟合，一般可以通过减少特征或者惩罚不重要特征的权重来缓解这个问题，通常我们并不知道该惩罚哪些特征的权重，而正则化就是帮我们惩罚特征权重的，即特征的权重也会成为模型损失函数的一部分。可以理解为，为了使用某个特征，我们需要付出loss的代价。这样我们就可以筛选出最有效的特征，减少特征权重防止过拟合。这也是奥卡姆剃刀法则，越简单的东西越有效。

*  L1正则会制造稀疏的特征，大部分无用特征的权重会被置为0
 *  L2正则会让特征的权重不过大，使得特征的权重比较平均。  
    [https://www.cnblogs.com/jianxinzhou/p/4083921.html][https_www.cnblogs.com_jianxinzhou_p_4083921.html]

[**深度学习的局部响应归一化LRN**][LRN]

## CIFAR10数据集介绍 ##

CIFAR-10数据集包含60000张32\*32的彩色图像，训练集50000张，测试集10000张，共标注10类，每一类有6000张图片。在这个卷积神经网络模型中，我们使用了一些新的技巧：

1.  对weights进行了L2的正则化。
2.  对图片进行了翻转、随机剪切等数据增强，制造了更多样本。
3.  在每个卷积-最大池化层后面使用了LRN层，增强了模型的泛化能力。

CIFAR10模型与tensorflow官方开源的很多图像分类模型如Mnist等一并放在了GitHub的tensorflow官方地址中。  
（1） 下载CIFAR10模型  
[https://github.com/tensorflow/models/tree/master/tutorials/image/cifar10][https_github.com_tensorflow_models_tree_master_tutorials_image_cifar10]  
文件 说明  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 1]  
**下载Tensorflow Models库，以便使用CIFAR-10数据的类**

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

根据上面两行代码下载划线部分的四个文件，raw-ctrlA-ctrlc-test右键new-Python Package-分别命名四个文件（对应下载的四个文件命名），执行cifar10\_train即可。下载的包依旧在c:tmp中  
![在这里插入图片描述][20191011192337122.png]  
或者按照此方法统一下载  
[svn下载github单个目录文件夹][svn_github]

（2） 下载CIFAR10模型数据集  
http://www.cs.toronto.edu/~kriz/cifar.html

这里有三个版本，分别是python版、matlab版和binary版，根据下载的模型选用 数据集版本，这里选用CIFAR-10二进制版本（适用于C语言）  
（如果这里不下载数据集，也可以在运行cifar10\_train.py程序时自动下载）

（3） CIFAR10数据集解析：  
[CIFAR10/CIFAR100数据集介绍][CIFAR10_CIFAR100]  
二进制版本包含文件data\_batch\_1.bin，data\_batch\_2.bin，…，data\_batch\_5.bin以及test\_batch.bin。这些文件中的每一个格式如下：  
<1×标签> <3072×像素>  
…  
<1×标签> <3072×像素>  
换句话说，第一个字节是第一个图像的标签，它是0-9范围内的一个数字。接下来的3072字节是图像像素的值。前1024个字节是红色通道值，下个1024个绿色，最后1024个蓝色。值以行优先顺序存储，所以前32个字节是图像第一行的红色通道值。  
每个文件包含10000个这样的3073个字节的“行”图像，虽然没有任何分隔的行。因此每个文件应该是30730000字节长。  
还有另一个文件叫做batches.meta.txt。这是一个ASCII文件，它将0-9范围内的数字标签映射到有意义的类名。这只是10个类名的列表，每行一个。第i行的类名称对应于数字标签i。  
这里是像素是0-255之间的整数，占两个bytes。

## CIFAR10数据集可视化 ##

"""
        作者：Heart Sea
        功能：实现cifar10数据集的图片可视化
        版本：1.0
        日期：10/12/2019
    
    """
    import numpy as np
    import imageio
    import os
    
    path_train = './训练集图片'
    path_test = './测试集图片'
    if not os.path.exists(path_train):
        os.makedirs(path_train)
    if not os.path.exists(path_test):
        os.makedirs(path_test)
    
    # 生成训练集5个batch图片,训练集5万张32*32*3的图片，每个batch1万张
    # 生成测试集1个batch图片,测试集1万张32*32*3的图片，batch1万张
    for j in range(1, 7):
        if j != 6:
            filename = 'd:/tmp/cifar10_data/cifar-10-batches-bin/data_batch_'+str(j)+'.bin'
        else:
            filename = 'd:/tmp/cifar10_data/cifar-10-batches-bin/test_batch.bin'
    
        bytestream = open(filename, "rb")   # rb 以二进制读模式打开
    
        # 1是占位字节（存放标签），一行（每个图片的记录长度）为32*32*3+1（存放像素）
        # read函数，从文件中读取的所有字节数，返回从字符串中读取的字节
        buf = bytestream.read(10000 * (1 + 32 * 32 * 3))
        bytestream.close()
    
        # numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
        # buffer 任何暴露缓冲区借口的对象
        # dtype 返回数组的数据类型，默认为float
        # count 需要读取的数据数量，默认为-1，读取所有数据
        # offset 需要读取的起始位置，默认为0
        data = np.frombuffer(buf, dtype=np.uint8)    # 带有\n格式的一维数组
    
        data = data.reshape(10000, 1 + 32 * 32 * 3)  # 二维数组
        labels_images = np.hsplit(data, [1])   # 将data分成两个array,一组是data的第一列，另一组是剩下的所有列
        labels = labels_images[0].reshape(10000)             # 第一组为标签
        images = labels_images[1].reshape(10000, 32, 32, 3)  # 第二组为图像
    
        for i in range(0, 5):  # 输出一个batch的前5个图片，可以自行修改
            img = np.reshape(images[i], (3, 32, 32))  # 导出第一幅图
            img = img.transpose(1, 2, 0)
            if j != 6:
                picname = 'train'+str(i+(j-1)*10)+'.jpg'
                imageio.imwrite('训练集图片/' + picname, img)
            else:
                picname = 'test' + str(i + (j - 1) * 10) + '.jpg'
                imageio.imwrite('测试集图片/' + picname, img)
    print("photo loaded.")

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 2]

## CIFAR10模型 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 3]

# CIFAR10代码 #

"""
        作者：Heart Sea
        功能：基于cifar10数据集实现图片的分类
        Model:
            输入层, 数据增强（翻转，剪切24*24，亮度，对比度），标准化
    
            卷积层, 卷积, 激活relu, 最大池化,
            卷积层, 卷积, 激活relu, LRN, 最大池化
    
            全连接, 激活relu，L2正则
            全连接, 激活relu，L2正则
            输出层, （全连接, 不需要l2，直接比较大小）
    
        日期：10/12/2019
    """
    # 图像分类实验
    # 下载Tensorflow Models库，以便使用CIFAR-10数据的类
    # git clone https://github.com/tensorflow/models.git
    # cd models/tutorials/image/cifar10
    
    # 载入numpy和time，并载入CIFAR-10数据的类
    import cifar10, cifar10_input
    import tensorflow as tf
    import numpy as np
    import time
    import math
    
    max_steps = 3000    # 训练轮数
    batch_size = 128
    data_dir = '/tmp/cifar10_data/cifar-10-batches-bin'     # 下载CIAR-10的默认路径
    
    
    def variable_with_weight_loss(shape, stddev, w1):
        """
            对weight施加L2正则化处理，为了防止过拟合，正则化帮助我们惩罚权重特征，即特征的权重也会成为模型损失函数的一部分
            初始化weight函数，但是为了防止因为特征过多而引起的过拟合，给每个weight加一个L2的loss
            L1正则会造成稀疏的特征，大部分无用特征会被置为0。
            L2特征会让权重不过大，是权重比较平均.
            函数中用w1来控制L2 loss的大小
            使用tf.add_to_collection把weight_loss统一存放到一个collection,名字叫loss
        """
        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()
    
    # 使用CIFAR-10类中的distorted_inputs函数产生训练使用的数据，并封装好作为tensor。
    # 同时还进行了数据增强包括水平翻转、随机剪切、设置随机的亮度和对比度，以及对数据进行标准化。
    # 数据增强采用16个线程进行加速,函数内部会产生线程池，需要使用时通过tensorflow queue进行调度
    images_train, labels_train = cifar10_input.distorted_inputs(data_dir=data_dir, batch_size=batch_size)
    
    # 使用CIFAR-10类中的cifar10_input.inputs函数生成测试数据，
    # 不需翻转、修改亮度,只需要剪切图片的中心24*24的大小的区块,标准化图片
    images_test, labels_test = cifar10_input.inputs(eval_data=True, data_dir=data_dir, batch_size=batch_size)
    
    # 创建输入数据的placeholder，由于batch_size在之后定义网络结构会用到，所以数据尺寸中的第一个值即样本条数需要被预先设定，
    # 数据尺寸中的图片尺寸为24*24,是剪切后的大小，通道数为3，代表图片是彩色的有RGB三条通道
    image_holder = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])
    label_holder = tf.placeholder(tf.int32, [batch_size])
    
    """
        构建第一个卷积层
        第一层卷积的权重不进行L2正则化，w1控制L2正则权重,
        利用tf.nn.conv2d对image_holder数据进行训练，
        然后经过relu非线性激活，之后最大池化，最后加入LRN层增加模型的泛化能力
    """
    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')
    
    # 应用局部相应归一化层LRN，使得响应较大的值变得相对更大，并抑制其他反馈较小的神经元,增强了模型的泛化能力
    # LRN对ReLU这种没有上限边界的激活函数比较有用，因为它会从附近的多个卷积核的响应中挑选比较大的反馈
    # 但不适合sigmoid这种有固定边界并且能抑制过大值的激活函数
    norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 /9.0, beta=0.75)
    
    
    """
        构建第二个卷积层，相比于第一层，
        调换了最大池化层与LRN层的顺序，
        bias=0.1，而不是0,
        上一层的卷积核数量为64(即输出64个通道)，所以第三个维度(输入的通道数)为64
    """
    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')
    
    """
        第一个全连接层，先把第二个卷积层的输出结果进行扁平化，然后使所有的参数都被L2正则约束，最后relu激活
        tf.reshape函数将每个样本都变成一维向量，
        get_shape函数获取数据扁平化后的长度
    """
    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)
    
    """
        第2个全连接层，隐含节点下降一半
    """
    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)
    
    """
       最后一层，不计入正则，
       不需要softmax就可以输出分类结果，直接计算模型inferfence输出结果，直接比较数值大小即可
    """
    weight5 = variable_with_weight_loss(shape=[192, 10], stddev=1/192.0, w1=0.0)
    bias5 = tf.Variable(tf.constant(0.0, shape=[10]))
    logits = tf.add(tf.matmul(local4, weight5), bias5)
    # 整个网络结构部分已经完成
    
    
    def loss(logits, labels):
        """
            logits: 输出层的结果
            labels：实际结果
    
            计算CNN的loss，将softmax的计算和cross entropy loss的计算整合到一起
            使用tf.add_to_collection把cross entropy的loss添加到整体losses的collection中，
            使用tf.add_n将整体lossesDE collection中的全部loss求和，得到最终的loss，
            包括cross entropy loss,还有后面两个全连接层weight的L2 loss
        """
        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('loss', cross_entropy_mean)
        return tf.add_n(tf.get_collection('losses'), name='total_loss')
    # 将logits节点和label_holder传入loss函数
    loss = loss(logits, label_holder)
    
    # 优化器选择Adam
    train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)
    
    # 使用tf.nn.in_top_k函数求出top1的准确率，输出分数最高的那一类的准确率
    # 测试集用
    top_k_op = tf.nn.in_top_k(logits, label_holder, 1)
    
    # 创建默认的session，接着初始化全部模型参数
    sess = tf.InteractiveSession()
    tf.global_variables_initializer().run()
    
    # 启动前面图片数据增强的线程队列，共16个线程进行加速
    tf.train.start_queue_runners()
    
    """
        开始正式训练，在每一个step的训练过程中，我们先使用session的run方法执行images_train、label_train的计算，
        获得一个batch的训练数据，再将这个batch的数据传入到train_op和loss的计算
        每隔10个step会计算并展示当前的loss，每秒钟能训练的样本数量，以及训练一个batch数据所花费的时间
    """
    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      # 测试集样本数量
    
    # 返回多少个batch
    num_iter = int(math.ceil(num_examples / batch_size))    # math.ceil函数,返回数字的上入整数
    true_count = 0
    total_sample_count = num_iter * batch_size   # 总样本数
    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
    # 最后将评测结果计算出来
    precision = true_count / total_sample_count
    print('precision @ 1 = %.3f' % precision)

[https_github.com_tensorflow_models_tree_master_tutorials_image_cifar10]: https://github.com/tensorflow/models/tree/master/tutorials/image/cifar10
[http_www.cs.toronto.edu_kriz_cifar.html]: http://www.cs.toronto.edu/~kriz/cifar.html
[http_blog.csdn.net_diligent_321_article_details_53130913]: http://blog.csdn.net/diligent_321/article/details/53130913
[http_blog.csdn.net_diligent_321_article_details_53008840]: http://blog.csdn.net/diligent_321/article/details/53008840
[http_blog.csdn.net_barry_j_article_details_79158017]: http://blog.csdn.net/barry_j/article/details/79158017
[http_blog.csdn.net_yangdashi888_article_details_77918311]: http://blog.csdn.net/yangdashi888/article/details/77918311
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70]: /images/20230601/b456031cc62b4bd18b0ac6dd8e441806.png
[https_www.cnblogs.com_jianxinzhou_p_4083921.html]: https://www.cnblogs.com/jianxinzhou/p/4083921.html
[LRN]: https://blog.csdn.net/yangdashi888/article/details/77918311
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 1]: /images/20230601/45f08ef3a1994ac4b64e65304a6cce96.png
[20191011192337122.png]: /images/20230601/844b977275f04f74825e03ed21558ff5.png
[svn_github]: https://blog.csdn.net/cf8833/article/details/98789632
[CIFAR10_CIFAR100]: https://blog.csdn.net/u013555719/article/details/79343353/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 2]: /images/20230601/fe91df7679c44c009080c6782eadbe6c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 3]: /images/20230601/d1f06e2a646a4ce4bb5967b6a4c5df3a.png