准备:
① 下载Tensorflow Models库,,我是直接打开网址,下载放到自己的目录下面,为了方便import下载的module 如 cifar 10.py等,我直接打开下载文件的cifar10目录,然后在里面新建自己的Tensorflow_cifar-10_cnn.py文件,如下:只有最后一个文件 这个是自己新建的,其他文件是下载tutorials自带.
注意下载最后一个二进制版本
开始抄书...
# 导入各种模块和所需文件
import cifar10
import cifar10_input
import tensorflow as tf
import numpy as np
import time
# 定义batch_size, 训练轮数max_steps, 以及下载CIFAR-10数据的默认路径
max_steps = 3000
batch_size = 128
# 存放数据集的目录
data_dir = 'D:/jupyter_notebook/tensorflow_practice/CIFAR-10_ex/cifar-10-binary/cifar-10-batches-bin'
# 定义初始化weight的函数,这里给weight加一个L2的loss,相当于L2正则化处理
def variable_with_weight_loss(shape, stddev, w1):
# 使用截断的正态分布创建变量
var = tf.Variable(tf.truncated_normal(shape, stddev=stddev))
if w1 is not None:
# tf.multiply()元素各自相乘,注意与tf.matmul的区别
# tf.nn.l2_loss(var)计算weight的L2 loss,再使用tf.multiply实现w1控制L2 loss的大小
weight_loss = tf.multiply(tf.nn.l2_loss(var), w1, name='weight_loss')
# add_to_collection(name,value),相当于字典的用法,key:name,value:value(list数据结构),往name添加东西相当于往value的list添加元素
tf.add_to_collection('losses', weight_loss)
return var
# 使用cifar10类下载数据集，并解压、展开到其默认位置
# 我是自己在网站下载的...
# cifar10.maybe_download_and_extract()
# 使用cifar10_input类中的distorted_inputs函数产生训练需要使用的数据,包括特征及其对应的label
# 返回的是已经封装好的tensor，每次执行都会生成一个batch_size的数量样本, 需要注意我们对数据进行了Data Augmentation
# 包括:水平翻转、随机剪切、设置随机的亮度和对比度、以及对数据进行标准化(0均值,1方差)
images_train, labels_train = cifar10_input.distorted_inputs(data_dir=data_dir, batch_size=batch_size)
# 使用cifar10_input.inputs函数来生成测试数据
images_test, labels_test = cifar10_input.inputs(eval_data=True,
data_dir=data_dir,
batch_size=batch_size)
# 创建数据的placeholder,包括特征和label
# 注意之前我们的 x = tf.placeholder(tf.float32,[None,784]) 中都是None,但是在这里不可以这么设置
# 因为batch_size之后的定义网络结构时被用到,所以数据尺寸的第一个值即样本条数需要被预先设定
# 彩色图片数据集3个颜色通道
image_holder = tf.placeholder(tf.float32, [batch_size, 24, 24, 3])
label_holder = tf.placeholder(tf.int32, [batch_size])
# 现在创建第一个卷积层
# 5*5的卷积核,3个颜色通道,64个卷积核,同时设置weight初始化函数的标准为0.05.
# 注意:w1 = 0.0 表示不对这一层权重进行正则化
weight1 = variable_with_weight_loss(shape=[5, 5, 3, 64], stddev=5e-2,
w1=0.0)
# 使用tf.nn.conv2d进行卷积操作
kernel1 = tf.nn.conv2d(image_holder, weight1, strides=[1, 1, 1, 1], padding='SAME')
# 初始化bias1为0
bias1 = tf.Variable(tf.constant(0.0, shape=[64]))
# 使用tf.nn.bias_add加上偏置后使用relu激活函数处理
conv1 = tf.nn.relu(tf.nn.bias_add(kernel1, bias1))
# 池化处理尺寸3*3,步长2*2,注意到尺寸和步长不一致,这样可以增加数据的丰富性
pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
padding='SAME')
# tf.nn.lrn:LRN处理,模仿生物神经系统的'侧抑制'机制,响应大的值更大,响应小的值被抑制,增强模型的泛化能力
# LRN:Local Response Normalization局部响应值归一化
# tf.nn.lrn(input,depth_radius=None,bias=None,alpha=None,beta=None,name=None)
norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75)
# 创建第二个卷积层
# 上一层卷积核个数为64,所以这一次的输入通道变为54
weight2 = variable_with_weight_loss(shape=[5, 5, 64, 64], stddev=5e-2,
w1=0.0)
kernel2 = tf.nn.conv2d(norm1, weight2, strides=[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(tensor,shape,name = None),其中reshape为列表的形式,-1表示自己计算那个维度
# [batch_size, -1]表示有batch_size那么多行,列自动算出,每一行表示一个样本
reshape = tf.reshape(pool2, [batch_size, -1])
# 我们使用get_shape()函数获取扁平化以后的长度
# 更多reshape和get_shape()的用法参考: https://blog.csdn.net/Li_haiyu/article/details/80063842
# 获取reshape后的列
dim = reshape.get_shape()[1].value
# 隐含节点384个,设置一个非零的weight loss值0.04,这一层所有的参数都被L2正则化所约束
weight3 = variable_with_weight_loss(shape=[dim, 384], stddev=0.04, w1=0.004)
bias3 = tf.Variable(tf.constant(0.1, shape=[384]))
# reshape的维度为[batch_size,dim],weight3的维度为[dim,384],维度匹配
# local3 维度[batch_size,384]
local3 = tf.nn.relu(tf.matmul(reshape, weight3) + bias3)
# 定义第二个全连接层
# 这个全连接层隐含节点数下降了一半，192个，其他的超参数保持不变
weight4 = variable_with_weight_loss(shape=[384, 192], stddev=0.04, w1=0.004)
bias4 = tf.Variable(tf.constant(0.1, shape=[192]))
# local4维度[batch_size,193]
local4 = tf.nn.relu(tf.matmul(local3, weight4) + bias4)
# 最后一层，不加入正则化
# 注意:将softmax放在了计算loss部分,因为我们不需要对inference的输出进行softmax处理就可以获得最终的分类结果(直接比较inference输出的各类数值大小即可)
# 计算softmax主要是为了计算loss,因此整合到后面比较合适
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)
# 定义loss函数cross entropy,把softmax函数和cross entropy loss的计算合在一起,即tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits,labels=labels, name='cross_entropy_per_example')
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')
# 这里使用tf.reduce_mean计算cross entropy的均值
cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy')
# 将cross entropy的loss添加到整体的losses的collection中
tf.add_to_collection('losses', cross_entropy_mean)
# 将losses的collection中的全部loss求和,得到最终的loss
return tf.add_n(tf.get_collection('losses'), name='total_loss')
# 获取最终的loss
loss = loss(logits, label_holder)
# 优化器选择Adam Optimizer
train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)
# 使用tf.nn.in_top_k函数求输出结果中top k的准确率，默认使用top 1，也就是输出分数最高的那一类的准确率
top_k_op = tf.nn.in_top_k(logits, label_holder, 1)
# 使用tf.InteractiveSession创建默认的session，接着初始化全部模型参数
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, label_batch = sess.run([images_train, labels_train])
# _也表示一个变量,接收train_op的值
_, loss_value = sess.run([train_op, loss], feed_dict={image_holder: image_batch, label_holder: label_batch})
# 这里计算的就是时间差
duration = time.time() - start_time
# 每10次迭代就输出损失值等
if step % 10 == 0:
example_per_sec = batch_size / duration
sec_per_batch = float(duration)
# %.0f 表示保留小数点后零位,.2f表示保留小数点后2位
format_str = 'step %d, loss=%.2f ,%.1f examples/sec, %.3f sec/batch'
print(format_str % (step, loss_value, example_per_sec, sec_per_batch))
# 在测试集评估模型的准确率
# 测试集一共10000个样本
num_examples = 10000
import math
# 计算迭代次数
# ceil表示向上取整 math.ceil(3.2) = 4
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, label_batch = sess.run([images_test, labels_test])
predictions = sess.run([top_k_op], feed_dict={image_holder: image_batch, label_holder: label_holder})
true_count += np.sum(predictions)
step += 1
# 最后将准确率的评测结果打印出来
precision = true_count / total_sample_count
print('precision @ 1 = %.3f'%precision)
附:卷积神经网络结构表
