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
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的原因:
CIFAR-10模型在TensorFlow中设计更大和更精细的模型了展示几个重要构想:
核心数学元素包括:
可视化(visualization)训练过程中的网络激活(network activities),包含图像输入,损失函数,激活值和梯度的分布。
计算学习参数的移动平均(moving average),使用移动平均法提升预测效果。
实现随时间下降的学习率(learning rate)。
对输入数据预提取队列(queues),让模型从硬盘延迟和图像预处理中独立出来。
也提供了多GPU版本,暂时忽略。
正则化:防止过拟合,提高泛化能力
在机器学习中,不管是分类还是回归,都可能因特征过多而产生过拟合,一般可以通过减少特征或者惩罚不重要特征的权重来缓解这个问题,通常我们并不知道该惩罚哪些特征的权重,而正则化就是帮我们惩罚特征权重的,即特征的权重也会成为模型损失函数的一部分。可以理解为,为了使用某个特征,我们需要付出loss的代价。这样我们就可以筛选出最有效的特征,减少特征权重防止过拟合。这也是奥卡姆剃刀法则,越简单的东西越有效。
深度学习的局部响应归一化LRN
CIFAR-10数据集包含60000张32*32的彩色图像,训练集50000张,测试集10000张,共标注10类,每一类有6000张图片。在这个卷积神经网络模型中,我们使用了一些新的技巧:
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。
"""
作者: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.")
"""
作者: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)