Cifar-10数据集及Tensorflow代码实现

一.百度网盘Cifar获取地址:

链接:https://pan.baidu.com/s/132yQGedau02Bw47fz75bYQ
        提取码:bnvd
二.Tensorflow代码实现:

该程序部分分为两个文件,分别是:Cifar10_data.py和CNN_Cifar-10.py文件。其中Cifar10_data.py文件的作用是采用文件队列的方式读取目标文件并对读取完毕的图像文件进行图像增强预处理,CNN_Cifar-10.py文件的作用是构造循环神经网络的整体结构,并进行训练和测试(评估)过程。

下面的代码是Cifar10_data.py程序文件:

 1 #该文件负责读取Cifar-10数据并对其进行数据增强预处理
 2 import os
 3 import tensorflow as tf
 4 num_classes=10
 5
 6 #设定用于训练和评估的样本总数
 7 num_examples_pre_epoch_for_train=50000
 8 num_examples_pre_epoch_for_eval=10000
 9
10 #定义一个空类,用于返回读取的Cifar-10的数据
11 class CIFAR10Record(object):
12     pass
13
14
15 #定义一个读取Cifar-10的函数read_cifar10(),这个函数的目的就是读取目标文件里面的内容
16 def read_cifar10(file_queue):
17     result=CIFAR10Record()
18
19     label_bytes=1                                            #如果是Cifar-100数据集,则此处为2
20     result.height=32
21     result.width=32
22     result.depth=3                                           #因为是RGB三通道,所以深度是3
23
24     image_bytes=result.height * result.width * result.depth  #图片样本总元素数量
25     record_bytes=label_bytes + image_bytes                   #因为每一个样本包含图片和标签,所以最终的元素数量还需要图片样本数量加上一个标签值
26
27     reader=tf.FixedLengthRecordReader(record_bytes=record_bytes)  #使用tf.FixedLengthRecordReader()创建一个文件读取类。该类的目的就是读取文件
28     result.key,value=reader.read(file_queue)                 #使用该类的read()函数从文件队列里面读取文件
29
30     record_bytes=tf.decode_raw(value,tf.uint8)               #读取到文件以后,将读取到的文件内容从字符串形式解析为图相对应的像素数组
31
32     result.label=tf.cast(tf.strided_slice(record_bytes,[0],[label_bytes]),tf.int32)   #因为该数组第一个元素是标签,所以我们使用strided_slice()函数将标签提取出来,并且使用tf.cast()函数将这一个标签转换成int32的数值形式
33
34     depth_major=tf.reshape(tf.strided_slice(record_bytes,[label_bytes],[label_bytes + image_bytes]),
35                            [result.depth,result.height,result.width])  #剩下的元素再分割出来,这些就是图片数据,因为这些数据在数据及立面存储的形式是depth * height * width,我们要把这种格式转换成[depth,height,width]
36
37
38     result.uint8image=tf.transpose(depth_major,[1,2,0])   #我们要将之前分割好的图片数据使用tf.transpose()函数转换成为高度信息、宽度信息、深度信息这样的顺序
39
40     return result                                 #返回值是已经把目标文件里面的信息都读取出来
41
42 def inputs(data_dir,batch_size,distorted):                  #这个文件是读取数据并对数据进行预处理,这个函数就是对数据进行预处理---对图像数据是否进行增强进行判断,并作出相应的操作
43     filenames=[os.path.join(data_dir,"data_batch_%d.bin"%i)for i in range(1,6)]   #拼接地址
44
45     file_queue=tf.train.string_input_producer(filenames)     #根据已经有的文件地址创建一个文件队列
46     read_input=read_cifar10(file_queue)                      #根据已经有的文件队列使用已经定义好的文件读取函数read_cifar10()读取队列中的文件
47
48     reshaped_image=tf.cast(read_input.uint8image,tf.float32)   #将已经转换好的图片数据再次转换为float32的形式
49
50     num_examples_per_epoch=num_examples_pre_epoch_for_train
51
52
53     if distorted != None:                         #如果预处理函数中的distorted参数不为空值,就代表要进行图片增强处理
54         cropped_image=tf.random_crop(reshaped_image,[24,24,3])          #首先将预处理好的图片进行剪切,使用tf.random_crop()函数
55
56         flipped_image=tf.image.random_flip_left_right(cropped_image)    #将剪切好的图片进行左右翻转,使用tf.image.random_flip_left_right()函数
57
58         adjusted_brightness=tf.image.random_brightness(flipped_image,max_delta=0.8)   #将左右翻转好的图片进行随机亮度调整,使用tf.image.random_brightness()函数
59
60         adjusted_contrast=tf.image.random_contrast(adjusted_brightness,lower=0.2,upper=1.8)    #将亮度调整好的图片进行随机对比度调整,使用tf.image.random_contrast()函数
61
62         float_image=tf.image.per_image_standardization(adjusted_contrast)          #进行标准化图片操作,tf.image.per_image_standardization()函数是对每一个像素减去平均值并除以像素方差
63
64         float_image.set_shape([24,24,3])                      #设置图片数据及标签的形状
65         read_input.label.set_shape([1])
66
67         min_queue_examples=int(num_examples_pre_epoch_for_eval * 0.4)
68         print("Filling queue with %d CIFAR images before starting to train.    This will take a few minutes."
69               %min_queue_examples)
70
71         images_train,labels_train=tf.train.shuffle_batch([float_image,read_input.label],batch_size=batch_size,
72                                                          num_threads=16,
73                                                          capacity=min_queue_examples + 3 * batch_size,
74                                                          min_after_dequeue=min_queue_examples,
75                                                          )
76                              #使用tf.train.shuffle_batch()函数随机产生一个batch的image和label
77
78         return images_train,tf.reshape(labels_train,[batch_size])
79
80     else:                               #不对图像数据进行数据增强处理
81         resized_image=tf.image.resize_image_with_crop_or_pad(reshaped_image,24,24)   #在这种情况下,使用函数tf.image.resize_image_with_crop_or_pad()对图片数据进行剪切
82
83         float_image=tf.image.per_image_standardization(resized_image)          #剪切完成以后,直接进行图片标准化操作
84
85         float_image.set_shape([24,24,3])
86         read_input.label.set_shape([1])
87
88         min_queue_examples=int(num_examples_per_epoch * 0.4)
89
90         images_test,labels_test=tf.train.batch([float_image,read_input.label],
91                                               batch_size=batch_size,num_threads=16,
92                                               capacity=min_queue_examples + 3 * batch_size)
93                                  #这里使用batch()函数代替tf.train.shuffle_batch()函数
94         return images_test,tf.reshape(labels_test,[batch_size])

下面的代码是CNN_Cifar-10.py程序文件:

  1 #该文件的目的是构造循环神经网络的整体结构,并进行训练和测试(评估)过程
  2 import tensorflow as tf
  3 import numpy as np
  4 import time
  5 import math
  6 import Cifar10_data
  7
  8 max_steps=4000
  9 batch_size=100
 10 num_examples_for_eval=10000
 11 data_dir="C:/Users/muzi/Desktop/Cifar_data/cifar-10-batches-bin"
 12
 13 #创建一个variable_with_weight_loss()函数,该函数的作用是:
 14 #   1.使用参数w1控制L2 loss的大小
 15 #   2.使用函数tf.nn.l2_loss()计算权重L2 loss
 16 #   3.使用函数tf.multiply()计算权重L2 loss与w1的乘积,并赋值给weights_loss
 17 #   4.使用函数tf.add_to_collection()将最终的结果放在名为losses的集合里面,方便后面计算神经网络的总体loss,
 18 def variable_with_weight_loss(shape,stddev,w1):
 19     var=tf.Variable(tf.truncated_normal(shape,stddev=stddev))
 20     if w1 is not None:
 21         weights_loss=tf.multiply(tf.nn.l2_loss(var),w1,name="weights_loss")
 22         tf.add_to_collection("losses",weights_loss)
 23     return var
 24
 25 #使用上一个文件里面已经定义好的文件序列读取函数读取训练数据文件和测试数据从文件,其中训练数据文件进行数据增强处理,测试数据文件不进行数据增强处理
 26 images_train,labels_train=Cifar10_data.inputs(data_dir=data_dir,batch_size=batch_size,distorted=True)
 27 images_test,labels_test=Cifar10_data.inputs(data_dir=data_dir,batch_size=batch_size,distorted=None)
 28
 29 #创建x和y_两个placeholder,用于在训练或评估时提供输入的数据和对应的标签值。要注意的是,由于以后定义全连接网络的时候用到了batch_size,所以x中,第一个参数不应该是None,而应该是batch_size
 30 x=tf.placeholder(tf.float32,[batch_size,24,24,3])
 31 y_=tf.placeholder(tf.int32,[batch_size])
 32
 33 #创建第一个卷积层
 34 kernel1=variable_with_weight_loss(shape=[5,5,3,64],stddev=5e-2,w1=0.0)
 35 conv1=tf.nn.conv2d(x,kernel1,[1,1,1,1],padding="SAME")
 36 bias1=tf.Variable(tf.constant(0.0,shape=[64]))
 37 relu1=tf.nn.relu(tf.nn.bias_add(conv1,bias1))
 38 pool1=tf.nn.max_pool(relu1,ksize=[1,3,3,1],strides=[1,2,2,1],padding="SAME")
 39
 40 #创建第二个卷积层
 41 kernel2=variable_with_weight_loss(shape=[5,5,64,64],stddev=5e-2,w1=0.0)
 42 conv2=tf.nn.conv2d(pool1,kernel2,[1,1,1,1],padding="SAME")
 43 bias2=tf.Variable(tf.constant(0.1,shape=[64]))
 44 relu2=tf.nn.relu(tf.nn.bias_add(conv2,bias2))
 45 pool2=tf.nn.max_pool(relu2,ksize=[1,3,3,1],strides=[1,2,2,1],padding="SAME")
 46
 47 #因为要进行全连接层的操作,所以这里使用tf.reshape()函数将pool2输出变成一维向量,并使用get_shape()函数获取扁平化之后的长度
 48 reshape=tf.reshape(pool2,[batch_size,-1])    #这里面的-1代表将pool2的三维结构拉直为一维结构
 49 dim=reshape.get_shape()[1].value             #get_shape()[1].value表示获取reshape之后的第二个维度的值
 50
 51 #建立第一个全连接层
 52 weight1=variable_with_weight_loss(shape=[dim,384],stddev=0.04,w1=0.004)
 53 fc_bias1=tf.Variable(tf.constant(0.1,shape=[384]))
 54 fc_1=tf.nn.relu(tf.matmul(reshape,weight1)+fc_bias1)
 55
 56 #建立第二个全连接层
 57 weight2=variable_with_weight_loss(shape=[384,192],stddev=0.04,w1=0.004)
 58 fc_bias2=tf.Variable(tf.constant(0.1,shape=[192]))
 59 local4=tf.nn.relu(tf.matmul(fc_1,weight2)+fc_bias2)
 60
 61 #建立第三个全连接层
 62 weight3=variable_with_weight_loss(shape=[192,10],stddev=1 / 192.0,w1=0.0)
 63 fc_bias3=tf.Variable(tf.constant(0.1,shape=[10]))
 64 result=tf.add(tf.matmul(local4,weight3),fc_bias3)
 65
 66 #计算损失,包括全中参数的正则化损失和交叉熵损失
 67 cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=result,labels=tf.cast(y_,tf.int64))
 68
 69 weights_with_l2_loss=tf.add_n(tf.get_collection("losses"))
 70 loss=tf.reduce_mean(cross_entropy)+weights_with_l2_loss
 71
 72 train_op=tf.train.AdamOptimizer(1e-3).minimize(loss)
 73
 74 #函数tf.nn.in_top_k()用来计算输出结果中top k的准确率,函数默认的k值是1,即top 1的准确率,也就是输出分类准确率最高时的数值
 75 top_k_op=tf.nn.in_top_k(result,y_,1)
 76
 77 init_op=tf.global_variables_initializer()
 78 with tf.Session() as sess:
 79     sess.run(init_op)
 80     tf.train.start_queue_runners()      #启动线程操作,这是因为之前数据增强的时候使用train.shuffle_batch()函数的时候通过参数num_threads()配置了16个线程用于组织batch的操作
 81
 82 #每隔100step会计算并展示当前的loss、每秒钟能训练的样本数量、以及训练一个batch数据所花费的时间
 83     for step in range (max_steps):
 84         start_time=time.time()
 85         image_batch,label_batch=sess.run([images_train,labels_train])
 86         _,loss_value=sess.run([train_op,loss],feed_dict={x:image_batch,y_:label_batch})
 87         duration=time.time() - start_time
 88
 89         if step % 100 == 0:
 90             examples_per_sec=batch_size / duration
 91             sec_per_batch=float(duration)
 92             print("step %d,loss=%.2f(%.1f examples/sec;%.3f sec/batch)"%(step,loss_value,examples_per_sec,sec_per_batch))
 93
 94 #计算最终的正确率
 95     num_batch=int(math.ceil(num_examples_for_eval/batch_size))  #math.ceil()函数用于求整
 96     true_count=0
 97     total_sample_count=num_batch * batch_size
 98
 99     #在一个for循环里面统计所有预测正确的样例个数
100     for j in range(num_batch):
101         image_batch,label_batch=sess.run([images_test,labels_test])
102         predictions=sess.run([top_k_op],feed_dict={x:image_batch,y_:label_batch})
103         true_count += np.sum(predictions)
104
105     #打印正确率信息
106     print("accuracy = %.3f%%"%((true_count/total_sample_count) * 100))

最终执行完成以后,执行的结果如下(使用CPU进行训练):

可以看到,最后的正确率在72.190%

原文地址:https://www.cnblogs.com/alex0521/p/11581786.html

时间: 2024-10-11 07:45:15

Cifar-10数据集及Tensorflow代码实现的相关文章

深度学习之卷积神经网络CNN及tensorflow代码实现示例

一.CNN的引入 在人工的全连接神经网络中,每相邻两层之间的每个神经元之间都是有边相连的.当输入层的特征维度变得很高时,这时全连接网络需要训练的参数就会增大很多,计算速度就会变得很慢,例如一张黑白的 28×28 的手写数字图片,输入层的神经元就有784个,如下图所示: 若在中间只使用一层隐藏层,参数 w 就有 784×15=11760 多个:若输入的是28×28 带有颜色的RGB格式的手写数字图片,输入神经元就有28×28×3=2352 个-- .这很容易看出使用全连接神经网络处理图像中的需要训

《神经网络与深度学习》(五) 卷积神经网络CNN及tensorflow代码实现示例

转自:http://blog.csdn.net/cxmscb/article/details/71023576 一.CNN的引入 在人工的全连接神经网络中,每相邻两层之间的每个神经元之间都是有边相连的.当输入层的特征维度变得很高时,这时全连接网络需要训练的参数就会增大很多,计算速度就会变得很慢,例如一张黑白的 28×28 的手写数字图片,输入层的神经元就有784个,如下图所示: 若在中间只使用一层隐藏层,参数 w 就有 784×15=11760 多个:若输入的是28×28 带有颜色的RGB格式的

Windows 10环境安装VIM代码补全插件YouCompleteMe

Windows 10环境安装VIM代码补全插件YouCompleteMe 折腾一周也没搞定Windows下安装VIM代码补全插件YouCompleteMe,今天在家折腾一天总算搞定了.关键问题是在于Python环境:必须确保环境变量Path里只有一个python.exe. ycmd是client-server架构.ycmd本身是server,可以为多种客户端所用,如VIM/YouComplete,emacs/emacs-ycmd等.服务端有不同引擎,如clang补全c-familiy语言,其他引

Transformer解析与tensorflow代码解读

本文是针对谷歌Transformer模型的解读,根据我自己的理解顺序记录的. 另外,针对Kyubyong实现的tensorflow代码进行解读,代码地址https://github.com/Kyubyong/transformer 首先是Layer Normalization部分,和Batch Normalization有点不一样, 原文地址:https://www.cnblogs.com/zhouxiaosong/p/11032431.html

Tensorflow MNIST 数据集測试代码入门

本系列文章由 @yhl_leo 出品,转载请注明出处. 文章链接: http://blog.csdn.net/yhl_leo/article/details/50614444 測试代码已上传至GitHub:yhlleo/mnist 将MNIST数据集,下载后复制到目录Mnist_data中,假设已经配置好tensorflow环境,基本的四个測试代码文件,都能够直接编译执行: mnist_softmax.py: MNIST机器学习入门 mnist_deep.py: 深入MNIST fully_co

Bunch 转换为 HDF5 文件:高效存储 Cifar 等数据集

关于如何将数据集封装为 Bunch 可参考 关于 『AI 专属数据库的定制』的改进. PyTables 是 Python 与 HDF5 数据库/文件标准的结合.它专门为优化 I/O 操作的性能.最大限度地利用可用硬件而设计,并且它还支持压缩功能. 下面的代码均是在 Jupyter NoteBook 下完成的: import sys sys.path.append('E:/xinlib') from base.filez import DataBunch import tables as tb i

RAD Studio 10 自带Demo代码汇总说明

大家好,好多朋友来信咨询Delphi和C++Builder的移动开发.DataSnap架构等问题,希望能有Demo代码学习.其实Delphi和C++Builder本身自带有很多示例代码,已经覆盖了大部分Delphi和C++Builder开发工具的特性和技术.对于开发各种特定的应用,还是需要去在特定方向钻研该方面的技术的,不要指望一套Demo代码就可以代替自己的学习. 为了方便各位 Delphi 和 C++Builder开发者,有针对性的查找RAD Studio自带的示例代码,从而更快更有针对性的

[nRF51822] 10、基础实验代码解析大全 · 实验15 - RTC

一.实验内容: 配置NRF51822 的RTC0 的TICK 频率为8Hz,COMPARE0 匹配事件触发周期为3 秒,并使能了TICK 和COMPARE0 中断. TICK 中断中驱动指示灯D1 翻转状态, 即指示灯D1 以8Hz 的速率翻转状态 COMPARE0 中断中点亮指示灯D2 二.nRF51822的内部RTC结构: NRF51822 有两个RTC 时钟:RTC0,RTC1.两个RTC 均为24 位,使用LFCLK 低频时钟,并带有12 位分频器,可产生TICK.compare 和溢出

Ubuntu16.10 +python3.5+Tensorflow 1.1

1.python版本检查 因为Ubuntu16.10已经默认安装了python2.7 和 3.5,检查python版本, 如果为python2.7,那么就需要我们设置python3.5为默认版本. 查看优先级及选择,执行以下命令: update-alternatives --config python 2.设置优先级命令 $ sudo update-alternatives --install /usr/bin/python python /usr/bin/python2.7 2 # 添加Pyt