对CIFAR-10 数据集的分类是机器学习中一个公开的基准测试问题,本教程代码通过解决CIFAR-10数据分类任务,介绍了Tensorflow的一些高阶用法,演示了构建大型复杂模型的一些重要技巧,着重于建立一个规范的网络组织结构,训练并进行评估,为建立更大规模更加复杂的模型提供一个范例,可以作为学习Tensorflow的一个经典示例。本文章对每行代码做了详细注释,以便对其他学习的朋友有所帮助,并欢迎读者对不恰当处提出意见,以帮助完善。
CIFAR-10数据集是一组大小为32x32的RGB图像,这些图像涵盖了10个类别:飞机, 汽车, 鸟, 猫, 鹿, 狗, 青蛙, 马, 船以及卡车。
数据集总共包含60000张图片,每个类别6000张。其中,训练集包含50000张图片,测试集包含10000万张图片。数据集被分为5个训练batch和一个测试batch,每个batch包含10000张图片。从每个类别的图片中随机选出1000张图片共10000张图片作为测试的batch,将剩余图片按照随机排序组成测试batch,每个训练batch中各个类别的图片数量不一定相等,某些类别可能会多一些,某些类别可能会少一些,但是所有训练batch加一起,每个类别的图片数量为5000。各个类别的图片是互斥的,不存在一张图片属于两个或两个以上类别的情况。
数据集的数据类型分Python versions、Matlab versions和Binary version三种,本文代码使用Binary version,故主要介绍这个类型的数据格式。Binary version的数据下载解压后包括data_batch_1.bin、data_batch_2.bin、data_batch_3.bin、data_batch_4.bin data_batch_5.bin和test_batch.bin五个文件,每个文件包含10000个图片数据,每个图片数据包含3073字节,由于每个图片数据之间没有分隔符,所以每个文件共30730000字节。
每个图片数据格式为:
更多信息请参考CIFAR-10 page
代码文件包括:
文件 | 作用 |
---|---|
cifar10_input.py | 读取本地CIFAR-10的二进制文件格式的内容。 |
cifar10.py | 建立CIFAR-10的模型。 |
ccifar10_train.py | 读在CPU或GPU上训练CIFAR-10的模型。 |
cifar10_multi_gpu_train.py | 在多GPU上训练CIFAR-10的模型。 |
cifar10_eval.py | 评估CIFAR-10模型的预测性能。 |
# 绝对引入,忽略目录下相同命名的包,引用系统标准的包
from __future__ import absolute_import
# 导入精确除法
from __future__ import division
# 使用python 3.x的print函数
from __future__ import print_function
import os
# xrange返回类,每次遍历返回一个值,range返回列表,一次计算返回所有值,xrange效率要高些
from six.moves import xrange
import tensorflow as tf
IMAGE_SIZE = 24
# CIFAR10的数据分类数为10
NUM_CLASSES = 10
# CIFAR10的训练集有50000个图片
NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN = 50000
# CIFAR10的测试集有10000个图片
NUM_EXAMPLES_PER_EPOCH_FOR_EVAL = 10000
def read_cifar10(filename_queue):
# 创建空类,方便数据结构化存储
class CIFAR10Record(object):
pass
result = CIFAR10Record()
# 1 for cifar-10;2 for cifar-100
label_bytes = 1
# cifar10的图片包含32*32个像素,每个像素包含三个RGB值
result.height = 32
result.width = 32
result.depth = 3
# 计算每幅图片特征向量的字节数
image_bytes = result.height * result.width * result.depth
# 计算每条记录的字节数=标签字节数+每幅图片特征向量的字节数
record_bytes = label_bytes + image_bytes
# 读取固定长度字节数信息,可以参看文章https://blog.csdn.net/fegang2002/article/details/83046584
reader = tf.FixedLengthRecordReader(record_bytes=record_bytes)
result.key, value = reader.read(filename_queue)
# CIFAR10数据通过Reader读取后通过Record传输变为字符串类型,既value为字符串类型
# 但是要使用的话,需要还原为CIFAR10原始数据格式tf.uint8(8位无符号整形)类型,可以通过tf.decode_raw函数实现
record_bytes = tf.decode_raw(value, tf.uint8)
# 从读取的数据记录中截取出标签值
result.label = tf.cast(tf.strided_slice(record_bytes, [0], [label_bytes]), tf.int32)
# 从读取的数据记录中截取出图片数据,并且转换为【深,高,宽】的形状[3,32,32]
depth_major = tf.reshape(
tf.strided_slice(record_bytes, [label_bytes], [label_bytes + image_bytes]),
[result.depth, result.height, result.width],
)
# 转换depth_major的维度,将第一个维度放在最后,既更新为【高,宽,深】的形状[32,32,3]
result.uint8image = tf.transpose(depth_major, [1, 2, 0])
return result
def _generate_image_and_label_batch(
image, label, min_queue_examples, batch_size, shuffle
):
# 设置入列的线程?
num_preprocess_threads = 16
if shuffle:
# 把输入的图片像素数据和标签数据随机打乱后,按照批次生成输出的图片像素数据和标签数据
images, label_batch = tf.train.shuffle_batch(
[image, label],
batch_size=batch_size,
num_threads=num_preprocess_threads,
capacity=min_queue_examples + 3 * batch_size,
# 出列后,队列中要保持的最小元素数?
min_after_dequeue=min_queue_examples,
)
else:
# 把输入的图片像素数据和标签数据按照原顺序、按照批次生成输出的图片像素数据和标签数据
images, label_batch = tf.train.batch(
[image, label],
batch_size=batch_size,
num_threads=num_preprocess_threads,
capacity=min_queue_examples + 3 * batch_size,
)
# 将输入的图像数据记录到缓存中,为后续展示准备
tf.summary.image("image", image)
return images, tf.reshape(label_batch, [batch_size])
def destorted_inputs(data_dir, batch_size):
# 设置CIFAR10数据文件的位置和名称
filename = [os.path.join(data_dir, "data_batch_%d.bin" % i) for i in xrange(1, 6)]
# 如果设置的CIFAR10数据文件不存在,报错退出
for f in filename:
if not tf.gfile.Exists(f):
raise ValueError("Failed to find file: " + f)
# 将filename中包含的文件打包生成一个先入先出队列(FIFOQueue)
# 并且在计算图的QUEUE_RUNNER集合中添加一个QueueRunner(QueueRunner包含一个队列的一系列的入列操作)
# 默认shuffle=True时,会对文件名进行随机打乱处理
filename_queue = tf.train.string_input_producer(filename)
with tf.name_scope("data_augmentation"):
# 调用read_cifar10函数,将队列filename_queue进行处理,返回值赋予read_input
read_input = read_cifar10(filename_queue)
# 将图片像素数据read_input.uint8image转化为tf.float32类型,赋予reshaped_image
reshaped_image = tf.cast(read_input.uint8image, tf.float32)
height = IMAGE_SIZE
width = IMAGE_SIZE
# 对图片进行随机切割,转化尺寸为[24,24,3]
distorted_image = tf.random_crop(reshaped_image, [height, width, 3])
# 对切割后图片沿width方向随机翻转,有可能的结果就是从左往右,从左往左等于没有翻转
distorted_image = tf.image.random_flip_left_right(distorted_image)
# 对切割翻转后的图片随机调整亮度,实际上是在原图的基础上随机加上一个值(如果加上的是正值则增亮否则增暗),
# 此值取自[-max_delta,max_delta),要求max_delta>=0。
distorted_image = tf.image.random_brightness(distorted_image, max_delta=63)
# 对切割、翻转和随机调整亮度的图片随机调整对比度,对比度调整值取自[lower,upper]
distorted_image = tf.image.random_contrast(
distorted_image, lower=0.2, upper=1.8
)
# 对切割、翻转、随机调整亮度和对比度的图片进行标准化处理,将RGB像素的值限定在一个范围,可以加速神经网络的训练
# 标准化处理可以使得不同的特征具有相同的尺度(Scale)。这样,在使用梯度下降法学习参数的时候,不同特征对参数的影响程度就一样了。
float_image = tf.image.per_image_standardization(distorted_image)
# 设置切割、翻转、随机调整亮度、对比度和标准化后的图片数据设置尺寸为[24,24,3]
float_image.set_shape([height, width, 3])
# 设置标签数据的形状尺寸为[1]
read_input.label.set_shape([1])
# 设置队列中最少样本数为每轮样本的40%?
min_fraction_of_examples_in_queue = 0.4
min_queue_examples = int(
NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN * min_fraction_of_examples_in_queue
)
print(
"Filling queue with %d CIFAR images before starting to train. "
"This will take a few minutes." % min_queue_examples
)
return _generate_image_and_label_batch(
float_image, read_input.label, min_queue_examples, batch_size, shuffle=True
)
def inputs(eval_data, data_dir, batch_size):
if not eval_data:
# 如果不是测试数据,就从训练数据文件中读取数据
filenames = [
os.path.join(data_dir, "data_batch_%d.bin" % i) for i in xrange(1, 6)
]
# 设置每轮样本数为训练数据每轮样本数
num_examples_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN
else:
# 如果是测试数据,就从测试数据文件中读取数据
filenames = [os.path.join(data_dir, "test_batch.bin")]
# 设置每轮样本数为测试数据每轮样本数
num_examples_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_EVAL
# 检验文件是否存在
for f in filenames:
if not tf.gfile.Exists(f):
raise ValueError("Failed to find file:" + f)
with tf.name_scope("input"):
# 将filename中包含的文件打包生成一个先入先出队列
filename_queue = tf.train.string_input_producer(filenames)
# 调用read_cifar10函数,将数据文件处理成结构化的类对象CIFAR10Record,并返回给read_input
read_input = read_cifar10(filename_queue=filename_queue)
# 将read_input中的图片像素数据转换为tf.float32类型以便后续处理
reshaped_image = tf.cast(read_input.uint8image, tf.float32)
height = IMAGE_SIZE
width = IMAGE_SIZE
# 将reshaped_image图片数据修剪为宽24,高24的尺寸
resized_image = tf.image.resize_image_with_crop_or_pad(
reshaped_image, height, width
)
# 标准化处理resized_image图片数据返回给float_image
float_image = tf.image.per_image_standardization(resized_image)
# 设置float_image尺寸为[24,24,3]
float_image.set_shape([height, width, 3])
# 设置标签数据尺寸为[1]
read_input.label.set_shape([1])
# 设置队列中最少样本数为每轮样本的40%?
min_fraction_of_examples_in_queue = 0.4
min_queue_examples = int(
num_examples_per_epoch * min_fraction_of_examples_in_queue
)
# 调用_generate_image_and_label_batch处理float_image数据
return _generate_image_and_label_batch(
float_image,
read_input.label,
min_queue_examples=min_queue_examples,
batch_size=batch_size,
shuffle=False,
)
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import re
import sys
import tarfile
from six.moves import urllib
import tensorflow as tf
import cifar10_input
# 创建命令行参数
FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_integer(
"batch_size", 128, """Number of images to process in a batch."""
)
tf.app.flags.DEFINE_string(
"data_dir",
os.path.join(os.getcwd(), "cifar10_train_data"),
"""Path to the CIFAR-10 data directory.""",
)
tf.app.flags.DEFINE_boolean("use_fp16", False, """Train the model using fp16.""")
# 设置全局变量
IMAGE_SIZE = cifar10_input.IMAGE_SIZE
NUM_CLASSES = cifar10_input.NUM_CLASSES
NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN = cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN
NUM_EXAMPLES_PER_EPOCH_FOR_EVAL = cifar10_input.NUM_EXAMPLES_PER_EPOCH_FOR_EVAL
MOVING_AVERAGE_DECAY = 0.9999 # The decay to use for the moving average.
NUM_EPOCHS_PER_DECAY = 350.0 # Epochs after which learning rate decays.
LEARNING_RATE_DECAY_FACTOR = 0.1 # Learning rate decay factor.
INITIAL_LEARNING_RATE = 0.1 # Initial learning rate.
TOWER_NAME = "tower"
DATA_URL = "https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz"
def _activation_summary(x):
# 设置tensor_name,如果输入的tensor的名称里,包含'tower_'+数字+'/'的字符串,将其替换成''
tensor_name = re.sub("%s_[0-9]*/" % TOWER_NAME, "", x.op.name)
# 为输入的tensor创建直方图,节点命名为tensor_name + "/activations",可以在tensorboard中显示
tf.summary.histogram(tensor_name + "/activations", x)
# 因为relu激活函数有可能造成大量参数为0,所以使用tf.nn.zero_fraction计算输入tensor x中0元素个数在所有元素个数中的比例
# 在tensorboar中打印,节点命名为tensor_name + "/sparsity"
# 参考https://blog.csdn.net/fegang2002/article/details/83539768
tf.summary.scalar(tensor_name + "/sparsity", tf.nn.zero_fraction(x))
def _variable_on_cpu(name, shape, initializer):
# 创建变量运行在CPU中
with tf.device("/cpu:0"):
# 根据参数FLAGS.use_fp16,设置变量的类型
dtype = tf.float16 if FLAGS.use_fp16 else tf.float32
# 初始化变量
var = tf.get_variable(
name=name, shape=shape, initializer=initializer, dtype=dtype
)
return var
def _variable_with_weight_decay(name, shape, stddev, wd):
# 根据参数FLAGS.use_fp16设置确定变量的类型
dtype = tf.float16 if FLAGS.use_fp16 else tf.float32
# 使用函数_variable_on_cpu创建变量,使用tf.truncated_normal随机生成数据
# 在tf.truncated_normal中如果x的取值在区间(μ-2σ,μ+2σ)之外则重新进行选择
# 横轴区间(μ-2σ,μ+2σ)内的面积为95.449974%,这样保证了生成的值都在均值附近。
var = _variable_on_cpu(
name=name,
shape=shape,
initializer=tf.truncated_normal(stddev=stddev, dtype=dtype),
)
if wd is not None:
# 如果wd参数有值的话,将张量var的各个元素的平方和除以2,
# 然后与wd点乘,命名为weight_loss
weight_decay = tf.multiply(tf.nn.l2_loss(var), wd, name="weight_loss")
# 将weight_decay加入losses集合
tf.add_to_collection("losses", weight_decay)
return var
def distorted_inputs():
# 如果FLAGS.data_dir为空,报错提示
if not FLAGS.data_dir:
raise ValueError("Please supply a data_dir")
# cifar10的数据解压后保存在data_dir
data_dir = os.path.join(FLAGS.data_dir, "cifar-10-batches-bin")
# 对cifar10的数据做切割、翻转、随机调整亮度、对比度和标准化处理,并按照FLAGS.batch_size参数生成批次数据
images, labels = cifar10_input.distorted_inputs(
data_dir=data_dir, batch_size=FLAGS.batch_size
)
# 如果FLAGS.use_fp16设置为真,将images,labels的类型转换为tf.float16
if FLAGS.use_fp16:
images = tf.cast(images, tf.float16)
labels = tf.cast(labels, tf.float16)
return images, labels
def inputs(eval_data):
# 如果FLAGS.data_dir为空,报错提示
if not FLAGS.data_dir:
raise ValueError("Please supply a data_dir")
# cifar10的数据解压后保存在data_dir
data_dir = os.path.join(FLAGS.data_dir, "cifar-10-batches-bin")
# 调用cifar10_input.inputs函数对cifar10数据进行处理
images, labels = cifar10_input.inputs(
eval_data=eval_data, data_dir=data_dir, batch_size=FLAGS.batch_size
)
# 如果FLAGS.use_fp16设置为真,将images,labels的类型转换为tf.float16
if FLAGS.use_fp16:
images = tf.cast(images, tf.float16)
labels = tf.cast(labels, tf.float16)
return images, labels
def inference(images):
# 定义卷积层,变量的作用域为conv1
with tf.variable_scope("conv1") as scope:
# 创建变量kernel作为卷积核,命名为'weights',
# 卷积核高为5,宽为5,输入通道也即是图片的通道为3,输出通道也即是卷积核的数量为64
# 按照标准差为5e-2的正态分布随机生成数据,抛弃均值左右2倍标准差外的数据
# 不设置调整参数wd
kernel = _variable_with_weight_decay(
"weights", shape=[5, 5, 3, 64], stddev=5e-2, wd=None
)
# 创建卷积层,输入为images[image_batch,image_height,image_width,image_channel]
# 卷积核为kernel[kernel_height,kernel_width,image_channel,kernel_channel],kernel_channel为卷积核的数量
# 步长strides为[1, 1, 1, 1],为卷积核分别在images的四个维度[image_batch,image_height,image_width,image_channel]上的步长,
# padding: string类型,值为“SAME” 和 “VALID”,表示的是卷积的形式,是否考虑边界。
# "SAME"是考虑边界,不足的时候用0去填充周围,"VALID"则不考虑
conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding="SAME")
# 设置偏置,命名为'biases',长度为64的一维向量,所有元素都为0
biases = _variable_on_cpu("biases", [64], tf.constant_initializer(0.0))
# 将卷积层和偏置加到一起
pre_activation = tf.nn.bias_add(conv, biases)
# 卷积层和偏置加在一起后添加relu的激活函数,得到第一层卷积,命名为'conv1',relu激活函数可能会造成大量参数为0
conv1 = tf.nn.relu(pre_activation, name=scope.name)
# 在tensorboad中打印conv1的分布和0元素占比,0元素占比可以反映此层对于训练的作用,占比高作用小,占比低作用大
_activation_summary(conv1)
# 设置最大池化层对conv1层做最大池化处理,命名为"pool1"
# 池化窗口的大小设置为[1, 3, 3, 1],分别对应conv1的四个维度[batch,height,width,channel]
# 步长为[1, 2, 2, 1],分别对应conv1的四个维度[batch,height,width,channel]
# padding设置"SAME",当滑动到边界尺寸不足时用'0'填充
pool1 = tf.nn.max_pool(
conv1,
ksize=[1, 3, 3, 1],
strides=[1, 2, 2, 1],
padding="SAME",
name="pool1",
)
# 对池化后的结果pool1做局部相应标准化处理,类似于dropout,防止过拟合
norm1 = tf.nn.lrn(
pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name="norm1"
)
# 定义卷积层,变量的作用域为conv2
with tf.variable_scope("conv2") as scope:
# 创建变量kernel作为卷积核,命名为'weights',
# 卷积核高为5,宽为5,输入通道也即是图片的通道为64,输出通道也即是卷积核的数量为64
# 按照标准差为5e-2的正态分布随机生成数据,抛弃均值左右2倍标准差外的数据
# 不设置调整参数wd
kernel = _variable_with_weight_decay(
"weights", shape=[5, 5, 64, 64], stddev=5e-2, wd=None
)
# 创建卷积层,输入为norm1,卷积核为kernel,步长strides为[1, 1, 1, 1]
# padding:"SAME"是考虑边界,不足的时候用0去填充周围
conv = tf.nn.conv2d(norm1, kernel, [1, 1, 1, 1], padding="SAME")
# 设置偏置,命名为'biases',长度为64的一维向量,所有元素都为0.1
biases = _variable_on_cpu("biases", [64], tf.constant_initializer(0.1))
# 将卷积层和偏置加到一起
pre_activation = tf.nn.bias_add(conv, biases)
# 卷积层和偏置加在一起后添加relu的激活函数,得到第二层卷积,命名为'conv2',relu激活函数可能会造成大量参数为0
conv2 = tf.nn.relu(pre_activation, name=scope.name)
# 在tensorboad中打印conv2的分布和0元素占比,0元素占比可以反映此层对于训练的作用,占比高作用小,占比低作用大
_activation_summary(conv2)
# 对卷积后的结果conv2做局部相应标准化处理,类似于dropout,防止过拟合
norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name="norm2")
# 设置最大池化层对norm2层做最大池化处理,命名为"pool2"
# 池化窗口的大小设置为[1, 3, 3, 1],分别对应pool2的四个维度[batch,height,width,channel]
# 步长为[1, 2, 2, 1],分别对应pool2的四个维度[batch,height,width,channel]
# padding设置"SAME",当滑动到边界尺寸不足时用'0'填充
pool2 = tf.nn.max_pool(
norm2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding="SAME", name="pool2"
)
# 定义全连接层,变量的作用域为local3
with tf.variable_scope("local3") as scope:
# Move everything into depth so we can perform a single matrix multiply.
# 将pool2转化为二维张量,第一维的尺寸为image的第一维的尺寸,其余的元素自动换算为第二维的尺寸,返回张量reshape
reshape = tf.reshape(pool2, [images.get_shape().as_list()[0], -1])
# 获取reshape张量的第二维的尺寸
dim = reshape.get_shape()[1].value
# 创建权重变量weights为二维张量,第一维的尺寸为张量reshape的第二维尺寸,第二维的尺寸为384
# 按照标准差为0.04的正态分布随机生成数据,抛弃均值左右2倍标准差外的数据
# 设置调整参数wd=0.004
weights = _variable_with_weight_decay(
"weights", shape=[dim, 384], stddev=0.04, wd=0.004
)
# 设置偏置,命名为'biases',长度为64的一维向量,所有元素都为0.1
biases = _variable_on_cpu("biases", [384], tf.constant_initializer(0.1))
# 设置local3为reshape和weights相乘再与biases相加,再添加激活函数relu,relu激活函数可能会造成大量参数为0
local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
# 在tensorboad中打印local3的分布和0元素占比,0元素占比可以反映此层对于训练的作用,占比高作用小,占比低作用大
_activation_summary(local3)
# 定义全连接层,变量的作用域为local4
with tf.variable_scope("local4") as scope:
# 创建权重变量weights为二维张量,第一维的尺寸为384,第二维的尺寸为192
# 按照标准差为0.04的正态分布随机生成数据,抛弃均值左右2倍标准差外的数据
# 设置调整参数wd=0.004
weights = _variable_with_weight_decay(
"weights", shape=[384, 192], stddev=0.04, wd=0.004
)
# 设置偏置,命名为'biases',长度为192的一维向量,所有元素都为0.1
biases = _variable_on_cpu("biases", [192], tf.constant_initializer(0.1))
# 设置local4为local3和weights相乘再与biases相加,再添加激活函数relu,relu激活函数可能会造成大量参数为0
local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name=scope.name)
# 在tensorboad中打印local4的分布和0元素占比,0元素占比可以反映此层对于训练的作用,占比高作用小,占比低作用大
_activation_summary(local4)
# 定义全连接层,变量的作用域为softmax_linear
with tf.variable_scope("softmax_linear") as scope:
# 创建权重变量weights为二维张量,第一维的尺寸为192,第二维的尺寸为图片的分类数
# 按照标准差为1/192.0的正态分布随机生成数据,抛弃均值左右2倍标准差外的数据
# 不设置调整参数wd
weights = _variable_with_weight_decay(
"weights", [192, NUM_CLASSES], stddev=1 / 192.0, wd=None
)
# 设置偏置,命名为'biases',长度为图片分类数的一维向量,所有元素都为0
biases = _variable_on_cpu("biases", [NUM_CLASSES], tf.constant_initializer(0.0))
# 设置softmax_linear为local4和weights相乘再与biases相加
softmax_linear = tf.add(tf.matmul(local4, weights), biases, name=scope.name)
# 在tensorboad中打印softmax_linear的分布和0元素占比,0元素占比可以反映此层对于训练的作用,占比高作用小,占比低作用大
_activation_summary(softmax_linear)
# 张量softmax_linear作为函数输出
return softmax_linear
def loss(logits, labels):
# 将labels的类型转化为tf.int64
labels = tf.cast(labels, tf.int64)
# 求logits和labels之间的交叉熵,命名"cross_entropy_per_example"
# tf.nn.sparse_softmax_cross_entropy_with_logits()比tf.nn.softmax_cross_entropy_with_logits多了一步将labels稀疏化
# 此例用非稀疏的标签,所以用tf.nn.sparse_softmax_cross_entropy_with_logits()
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=labels, logits=logits, name="cross_entropy_per_example"
)
# 对logits和labels之间的交叉熵cross_entropy求均值返回给cross_entropy_mean,命名"cross_entropy"
cross_entropy_mean = tf.reduce_mean(cross_entropy, name="cross_entropy")
# 将cross_entropy_mean存入losses集合
tf.add_to_collection("losses", cross_entropy_mean)
# 将集合中的元素相加作为函数的返回值
return tf.add_n(tf.get_collection("losses"), name="total_loss")
def _add_loss_summaries(total_loss):
# 设置移动平均模型,设置参数decay=0.9
# 参考https://blog.csdn.net/qq_14845119/article/details/78767544
loss_averages = tf.train.ExponentialMovingAverage(0.9, name="avg")
# 从集合Losses中取出损失函数的值
losses = tf.get_collection("losses")
# 将从集合Losses中取出损失函数的值losses和输入的total_loss作和,然后做移动平均,作为函数的返回值
loss_averages_op = loss_averages.apply(losses + [total_loss])
for l in losses + [total_loss]:
# Name each loss as '(raw)' and name the moving average version of the loss
# as the original loss name.
# 在tensorboard中打印所有的lose的值
tf.summary.scalar(l.op.name + " (raw)", l)
# 在tensorboard中打印所有的lose移动平均之后的值?
tf.summary.scalar(l.op.name, loss_averages.average(l))
return loss_averages_op
def train(total_loss, global_step):
# 设置每个epoch训练的batch数
num_batches_per_epoch = NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN / FLAGS.batch_size
# 设置每个epoch中learning rate的衰减次数
decay_steps = int(num_batches_per_epoch * NUM_EPOCHS_PER_DECAY)
# 初始化学习率INITIAL_LEARNING_RATE后,训练过程中按照LEARNING_RATE_DECAY_FACTOR比例衰减学习率,以免学习率过大造成震荡
# staircase为True,每decay_steps步数后,更新learning_rate=learning_rate*(decay_rate**decay_steps)
# staircase为False,每一步更新learning_rate=learning_rate*decay_rate
# global_step为学习步数
lr = tf.train.exponential_decay(
INITIAL_LEARNING_RATE,
global_step,
decay_steps,
LEARNING_RATE_DECAY_FACTOR,
staircase=True,
)
# 在tensorboard中打印Learning rate
tf.summary.scalar("learning_rate", lr)
# 将从集合Losses中取出损失函数的值losses和输入的total_loss作和,然后做移动平均
loss_averages_op = _add_loss_summaries(total_loss)
# 上下文管理器,控制计算流图,指定计算顺序,优先执行loss_averages_op
with tf.control_dependencies([loss_averages_op]):
# 设置梯度下降优化算法,学习率lr为随着学习的步数逐渐衰减
opt = tf.train.GradientDescentOptimizer(lr)
# 计算total_loss的梯度
grads = opt.compute_gradients(total_loss)
# 执行梯度下降,执行之前根据上下文管理器先操作loss_averages_op对total_loss做移动平均
# 然后再对total_loss做梯度下降优化
apply_gradient_op = opt.apply_gradients(grads, global_step=global_step)
# 在tensorboard中打印所有的可训练变量
for var in tf.trainable_variables():
tf.summary.histogram(var.op.name, var)
# 在tensorboard中打印所有梯度优化过程中更新的梯度
for grad, var in grads:
if grad is not None:
tf.summary.histogram(var.op.name + "/gradients", grad)
# 设置移动平均模型,设置参数decay=MOVING_AVERAGE_DECAY,num_updates=global_step?
variable_averages = tf.train.ExponentialMovingAverage(
MOVING_AVERAGE_DECAY, global_step
)
# 上下文管理器,控制计算流图,指定计算顺序,优先执行apply_gradient_op
with tf.control_dependencies([apply_gradient_op]):
# 先执行apply_gradient_op,更新tf.trainable_variables()
# 然后再对tf.trainable_variables()做移动平均
variables_averages_op = variable_averages.apply(tf.trainable_variables())
# 返回根据梯度下降优化且经过移动平均的参数变量
return variables_averages_op
def maybe_download_and_extract():
# 下载cifar10的样本数据,并解压
# 设置cifar10样本数据存储的文件夹,如果文件夹不存在,系统自动创建
dest_directory = FLAGS.data_dir
if not os.path.exists(dest_directory):
os.makedirs(dest_directory)
# 将cifar10的样本数据的下载链接DATA_URL按照'/'截取后取最后一个元素,其为文件名称
filename = DATA_URL.split("/")[-1]
# 组合cifar10的样本数据的完整路径
filepath = os.path.join(dest_directory, filename)
if not os.path.exists(filepath):
# 如果cifar10的样本数据在系统中不存在,下载
# 定义_progress回调函数,显示下载的进度
def _progress(count, block_size, total_size):
# 打印下载进度
sys.stdout.write(
"\r>> Downloading %s %.1f%%"
% (filename, float(count * block_size) / float(total_size) * 100.0)
)
# linux系统下系统刷新输出,每秒输出一个结果,windows系统不需要,总是每秒输出一个结果
sys.stdout.flush()
# 从DATA_URL下载cifar10的样本数据,保存为filepath
# 使用回到函数_progress显示下载进度
# urlretrieve每下载一部分数据块后将下载的数据块数量count、数据库大小block_size和
# 下载文件的总大小total_size传给回调函数_progress处理,打印下载进度
filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)
print()
# 获取cifar10样本数据的系统状态信息
statinfo = os.stat(filepath)
# 打印cifar10样本数据下载成功信息,显示下载后的文件路径、名称和大小
print("Successfully downloaded", filename, statinfo.st_size, "bytes.")
# cifar10样本数据解压后会生成文件夹cifar-10-batches-bin
extracted_dir_path = os.path.join(dest_directory, "cifar-10-batches-bin")
if not os.path.exists(extracted_dir_path):
# 如果extracted_dir_path在系统中不存在,说明cifar10样本数据还未解压
# 将cifar10样本数据解压后保存到dest_directory
tarfile.open(filepath, "r:gz").extractall(dest_directory)
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from datetime import datetime
import time
import tensorflow as tf
import cifar10
# 设置输入参数
FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string(
"train_dir",
"/cifar10_train_check",
"""Directory where to write event logs and checkpoint.""",
)
tf.app.flags.DEFINE_integer("max_steps", 100000, """Number of batches to run.""")
tf.app.flags.DEFINE_boolean(
"log_device_placement", False, """Whether to log device placement."""
)
tf.app.flags.DEFINE_integer(
"log_frequency", 10, """How often to log results to the console."""
)
def train():
# 创建上下文管理器,使用默认计算图
with tf.Graph().as_default():
# 从默认计算图中创建并返回glob step变量,初始化后为0
global_step = tf.train.get_or_create_global_step()
# 设置运行在cpu下
with tf.device("/cup:0"):
# 对cifar10的数据做切割、翻转、随机调整亮度、对比度和标准化处理,并按照FLAGS.batch_size参数生成批次数据
images, labels = cifar10.distorted_inputs()
# 通过cifar10.inference定义的深层学习框架(2层卷积,3层全链接)对cifar10.distorted_inputs()处理的图片数据进行学习
# 得到各个分类的特征值
logits = cifar10.inference(images)
# 将各个分类的特征值和标签数据通过cifar10.loss得到损失值
loss = cifar10.loss(logits, labels)
# 通过cifar10.train对损失值进行训练,训练的总步数为global_step
train_op = cifar10.train(loss, global_step)
# 创建类_LoggerHook,是继承tf.train.SessionRunHook的子类,生成钩子程序,用来监视训练过程
class _LoggerHook(tf.train.SessionRunHook):
# 创建会话之前调用,调用begin()时,default graph会被创建,
def begin(self):
# 初始化训练的起始步数
self._step = -1
# 获取当前时间的时间戳(1970纪元后经过的浮点秒数)初始化会话的起始时间
self._start_time = time.time()
# 每个sess.run()执行之前调用,返回tf.train.SessRunArgs(op/tensor),在即将运行的会话中加入op/tensor loss
# 加入的loss会和sess.run()中已定义的op/tensor合并,然后一起执行
def before_run(self, run_context):
# 叠加训练的步数,第一次训练从步数0开始
self._step += 1
# 返回SessionRunArgs对象,作为即将运行的会话的参数,将loss添加到会话中
return tf.train.SessionRunArgs(loss)
# 每个sess.run()执行之后调用,run_values是befor_run()中的op/tensor loss的返回值
# 可以调用run_context.qeruest_stop()用于停止迭代,sess.run抛出任何异常after_run不会被调用
def after_run(
# tf.train.SessRunContext提供会话运行所需的信息,tf.train.SessRunValues保存会话运行的结果
self, run_context, run_values # pylint: disable=unused-argument
):
# 判断迭代步数是否为FLAGS.log_frequency=10的整数倍
if self._step % FLAGS.log_frequency == 0:
# 获取当前时间的时间戳(1970纪元后经过的浮点秒数)
current_time = time.time()
# 获取每10个会话运行的持续时间
duration = current_time - self._start_time
# 更新会话的起始时间
self._start_time = current_time
# 获取before_run中加入的操作loss的返回值
loss_value = run_values.results
# 计算每秒钟处理的样本数
examples_per_sec = FLAGS.log_frequency * FLAGS.batch_size / duration
# 计算每个会话的运行时间,单位为秒
sec_per_batch = float(duration / FLAGS.log_frequency)
# 打印当前系统时间,当前步数下的loss的值(标示:每秒处理的样本数和每个批次样本处理所需要的时间)
format_str = (
"%s: step %d, loss = %.2f (%.1f examples/sec; %.3f sec/batch)"
)
print(
format_str
% (
datetime.now(),
self._step,
loss_value,
examples_per_sec,
sec_per_batch,
)
)
with tf.train.MonitoredTrainingSession(
# 设置恢复变量的文件路径为FLAGS.train_dir
checkpoint_dir=FLAGS.train_dir,
hooks=[
# 设置HOOK程序在FLAGS.max_steps=100000后停止
tf.train.StopAtStepHook(last_step=FLAGS.max_steps),
# 设置如果loss的值为Nan,停止训练
tf.train.NanTensorHook(loss),
# 调用自己定义的_LoggerHook() HOOK类
_LoggerHook(),
],
# 对会话进行设置,log_device_placement为True时,会在终端打印出各项操作是在哪个设备上运行的
config=tf.ConfigProto(log_device_placement=FLAGS.log_device_placement),
) as mon_sess:
# 创建循环在没有符合程序退出条件的情况下,运行train_op训练数据
while not mon_sess.should_stop():
mon_sess.run(train_op)
def main(argv=None):
# 下载并解压cifar10的数据,防止没有数据可训练
cifar10.maybe_download_and_extract()
# 创建目录存储Log和checkpoint文件,如果目录存在,删除重新创建,以保证保存最新的训练信息
if tf.gfile.Exists(FLAGS.train_dir):
tf.gfile.DeleteRecursively(FLAGS.train_dir)
tf.gfile.MakeDirs(FLAGS.train_dir)
# 训练数据
train()
if __name__ == "__main__":
# 处理FLAGS参数解析,运行main()函数
tf.app.run()
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from datetime import datetime
import math
import time
import numpy as np
import tensorflow as tf
import cifar10
# 定义参数变量
FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string('eval_dir', '/cifar10_eval',
"""Directory where to write event logs.""")
tf.app.flags.DEFINE_string('eval_data', 'test',
"""Either 'test' or 'train_eval'.""")
tf.app.flags.DEFINE_string('checkpoint_dir', '/cifar10_train_check',
"""Directory where to read model checkpoints.""")
tf.app.flags.DEFINE_integer('eval_interval_secs', 60 * 5,
"""How often to run the eval.""")
tf.app.flags.DEFINE_integer('num_examples', 10000,
"""Number of examples to run.""")
tf.app.flags.DEFINE_boolean('run_once', False,
"""Whether to run eval only once.""")
def eval_once(saver,summary_writer,top_k_op,summary_op):
# 创建上下文管理器,定义会话sess
with tf.Session() as sess:
# 获取保存的模型,模型路径由FLAGS.checkpoint_dir定义
ckpt=tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
# 如果ckpt和ckpt.model_checkpoint_path非空
if ckpt and ckpt.model_checkpoint_path:
# 从chekpoint中恢复参数
saver.restore(sess, ckpt.model_checkpoint_path)
# 获取训练的总步数,模型文件的名称为'model.ckpt-总步数'
global_step=ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
else:
# 如果ckpt和ckpt.model_checkpoint_path为空,打印提示,退出函数
print('No checkpoint file found')
return
# 开启一个多线程协调器,协调线程间的关系
coord=tf.train.Coordinator()
try:
# 定义数组存储线程
threads=[]
# 所有队列管理器被默认加入图的tf.GraphKeys.QUEUE_RUNNERS集合中
for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):
# 队列创建线程来做入列操作,并将创建的线程存入threads数组
threads.extend(qr.create_threads(sess=sess,coord=coord,daemon=True,start=True))
# 总样本数除以每个批次的样本数量向上取整,获取总的批次数量也即是迭代次数
num_iter=int(math.ceil(FLAGS.num_examples/FLAGS.batch_size))
# 预测结果的真值数量初始化为0
true_count=0
# 迭代次数乘以每个批次的样本数量得到总的样本数量
total_sample_count=num_iter*FLAGS.batch_size
# 循环的步数初始化为0
step=0
while step
https://github.com/tensorflow/models/tree/master/tutorials/image/cifar10