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

最新推荐文章于 2023-09-26 17:24:04 发布

Heart_Sea

最新推荐文章于 2023-09-26 17:24:04 发布

阅读量592

点赞数

分类专栏：深度学习

本文链接：https://blog.csdn.net/heart_sea/article/details/102502019

版权

深度学习专栏收录该内容

0 篇文章 0 订阅

订阅专栏

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

学习链接
CIFAR10模型及数据集介绍
CIFAR10代码

学习链接

https://github.com/tensorflow/models/tree/master/tutorials/image/cifar10
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/53008840
http://blog.csdn.net/barry_j/article/details/79158017
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)。
在这里插入图片描述
可以看到，同已经成熟的人脸识别相比，普适物体识别挑战巨大，数据中含有大量特征、噪声，识别物体比例不一。因而，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

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

CIFAR10数据集介绍

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

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

CIFAR10模型与tensorflow官方开源的很多图像分类模型如Mnist等一并放在了GitHub的tensorflow官方地址中。
（1）下载CIFAR10模型
https://github.com/tensorflow/models/tree/master/tutorials/image/cifar10
文件说明
在这里插入图片描述
下载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中
在这里插入图片描述
或者按照此方法统一下载
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数据集介绍
二进制版本包含文件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.")

在这里插入图片描述

CIFAR10模型

在这里插入图片描述

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)