标题
概述
对CIFAR-10 数据集的分类是机器学习中一个公开的基准测试问题，本教程代码通过解决CIFAR-10数据分类任务，介绍了Tensorflow的一些高阶用法，演示了构建大型复杂模型的一些重要技巧，着重于建立一个规范的网络组织结构，训练并进行评估，为建立更大规模更加复杂的模型提供一个范例，可以作为学习Tensorflow的一个经典示例。本文章对每行代码做了详细注释，以便对其他学习的朋友有所帮助，并欢迎读者对不恰当处提出意见，以帮助完善。
CIFAR-10数据介绍
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字节。
每个图片数据格式为：
- 第一个字节为0-9的数字，为10个类别的标签，对应的类别名称在batches.meta.txt文件中存储，batches.meta.txt包含10行数据，类别标签i对应第i行的名称；
- 每张图片为32*32=1024个像素，第2-1025字节为每个像素的red值，第1026-2049字节为每个像素的green值，第2050-3073字节为每个像素的blue值。
- 由于数据是按照行主序排列，所以2-33为图片的第一行像素的red值，以此类推。
更多信息请参考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模型的预测性能。 |
- cifar10_input.py
# 绝对引入，忽略目录下相同命名的包，引用系统标准的包
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)
- cifar_train.py
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()
- cifar_eval.py
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<num_iter and not coord.should_stop():
# 调用top_k_op=tf.nn.in_top_k执行预测，返回bool值
predictions=sess.run([top_k_op])
# 对预测结果中的真值进行累加
true_count+=np.sum(predictions)
# 循环的步数自动加1
step+=1
# 预测真值的数量除以总的样本数量得到预测的精度
precision=true_count/total_sample_count
# 打印系统当前的时间和预测的精度
print('%s: precision @ 1 = %.3f' % (datetime.now(),predictions))
# 定义tf.Summary()的对象，将训练过程中的信息，包括预测信息写入到FLAGS.eval_dir下的图文件，支持后续tensorboard打印
summary=tf.Summary()
summary.ParseFromString(sess.run(summary_op))
summary.value.add(tag='Precision @ 1', simple_value=predictions)
summary_writer.add_summary(summary,global_step)
except Exception as e:
# 如果程序运行出错，多线程协调器coord停止其他线程，并把错误报告给coord
coord.request_stop(e)
# 多线程协调器coord停止其他线程
coord.request_stop()
# 多线程协调器coord等待所有的线程终止，并给出10秒的宽限期
# 如果超过10秒还有线程存在且ignore_live_threads参数为False，会报RuntimeError
# 如果request_stop()被传入Exception信息，则会替代RuntimeError，报Exception信息
coord.join(threads,stop_grace_period_secs=10)
def evaluate():
# 使用系统默认图作为计算图
with tf.Graph().as_default() as g:
# 设置变量eval_data为'test'
eval_data=FLAGS.eval_data=='test'
# 调用cifar10.inputs函数对测试数据进行处理，得到评估使用的图像和标签数据
images,labels=cifar10.inputs(eval_data=eval_data)
# 使用cifar10.inference函数构建的深度学习模型对测试数据进行评估
# 返回预测的分类数据logits，logits为预测为各个类别的概率
logits=cifar10.inference(images)
# tf.nn.in_top_k按照logtis中的元素从大到小的顺序对元素坐标排序，再按照labels中的元素从大到小的顺序对坐标排序，
# 然后取第一位进行比较，如果相同返回true，否则返回false
# logits中的元素为预测的各个类别的概率，最大概率也就是预测的类别，labels中正确的类别对应的元素为1，否则为0
# 所以logits最大元素的坐标如果和labels中最大元素的坐标一致，说明预测正确
top_k_op=tf.nn.in_top_k(logits,labels,1)
# 设置移动平均模型，设置参数decay=cifar10.MOVING_AVERAGE_DECA
# 因为训练的时候使用了移动平均模型，评估的时候也需要使用
variable_averages=tf.train.ExponentialMovingAverage(cifar10.MOVING_AVERAGE_DECAY)
# 使用variables_to_restore函数在加载模型的时候将影子变量直接映射到变量的本身，
# 所以在获取变量的滑动平均值的时候只需要获取到变量的本身值而不需要去获取影子变量
# 参考文章https://blog.csdn.net/sinat_29957455/article/details/78508793
variable_to_restore=variable_averages.variables_to_restore()
# 定义saver向checkpoint保存和读取变量
saver=tf.train.Saver(variable_to_restore)
# 定义操作对象，合并操作点，将所有训练时的summary信息保存到磁盘，以便tensorboard显示
summary_op=tf.summary.merge_all()
# 定义操作对象，将计算图的信息保存到文件存储在FLAGS.eval_dir定义的路径，以备tensorboard打印时使用
summary_writer=tf.summary.FileWriter(FLAGS.eval_dir,g)
while True:
# 循环调用函数单次评估函数eval_once做数据评估
eval_once(saver=saver,summary_writer=summary_writer,top_k_op=top_k_op,summary_op=summary_op)
# 如果FLAGS.run_once设置为True，也即是只运行一次评估函数
if FLAGS.run_once:
# 退出循环
break
# eval_once每FLAGS.eval_interval_secs==5分钟运行一次
time.sleep(FLAGS.eval_interval_secs)
def main(argv=None):
# 下载并解压cifar10的数据，防止没有数据可评估
cifar10.maybe_download_and_extract()
# 创建目录存储Log文件，存储评估的结果，供tensorboard打印使用
# 如果目录存在，说明有历史数据，删除重新创建，存储最新的评估结果
if tf.gfile.Exists(FLAGS.eval_dir):
tf.gfile.DeleteRecursively(FLAGS.eval_dir)
tf.gfile.MakeDirs(FLAGS.eval_dir)
# 评估训练结果
evaluate()
if __name__ == '__main__':
# 处理FLAGS参数解析，运行main()函数
tf.app.run()
代码下载地址
https://github.com/tensorflow/models/tree/master/tutorials/image/cifar10