tensorflow利用LeNet-5 训练自己的数据集
书上跟网络上的大部分实例都是使用已经封装好的 mnist 数据集来训练卷积神经网络。但是我想利用神经来训练自己的数据集，这时，问题就出现了，如何将自己的数据集导入到神经网络？
把问题清晰的写下来，整个困难就已经解决了一半了。解决问题的思路如下：
- 将自己的数据集转换为 tensorflow 支持的神经网络输入格式 tfrecord
- 重建 LeNet-5 卷积神经网络
- 对神经网络进行训练
适用于 Windows 以及 pycharm ，python 3.5 环境。不知为何，python3.6以及 python 3.7 不能很好的兼容 tensorflow 所以我选择使用python3.5. 可能现在已经解决这个问题了。
目录
一、制作自己的数据集
1.1、更改代码，以适应自己的数据集
1.2、生成tfrecord以及tfrecord的读取
二、定义神经网络结构
三、训练神经网络模型
一、制作自己的数据集
关于Tensorflow读取数据，官网给出了三种方法：
- 供给数据(Feeding)： 在TensorFlow程序运行的每一步， 让Python代码来供给数据。
- 从文件读取数据： 在TensorFlow图的起始， 让一个输入管线从文件中读取数据。
- 预加载数据： 在TensorFlow图中定义常量或变量来保存所有数据(仅适用于数据量比较小的情况)。
对于数据量较小而言，可能一般选择直接将数据加载进内存，然后再分batch输入网络进行训练（tip:使用这种方法时，结合yield 使用更为简洁，大家自己尝试一下吧，我就不赘述了）。但是，如果数据量较大，这样的方法就不适用了，因为太耗内存，所以这时最好使用tensorflow提供的队列queue，也就是第二种方法 从文件读取数据。对于一些特定的读取，比如csv文件格式，官网有相关的描述，在这儿我介绍一种比较通用，高效的读取方法（官网介绍的少），即使用tensorflow内定标准格式——TFRecords （from ：ycszen URL：TensorFlow高效读取数据的方法）
我们采用 tfrecord 即pipeline 的方式将数据流入神经网络。但是 Google 今后的工作重心正从 pipeline 转移到 DataSet 上面，使用 DataSet API 比pipeline 更加高效，但是我目前仅掌握使用 pipeline 方式。在训练时会出现 WARNING:xxxxxxxxxxxx 以及 Instructions for updating:
To construct input pipelines, use the `tf.data` module. 这是正常的，因为pipeline 以后将会被移除，但是现在依然可用
1.1、更改代码，以适应自己的数据集
只需要将代码里面的 data_path 更换为你的 数据集所在的目录即可（这个目录下还包含两个子文件夹：peach，strawberry）
data_path = "F://soft_exercise//data//" # 数据所在目录位置下面是我定义的两个类，也是 data_path 目录下面的两个子文件夹，如果你想要训练的数据集包含：猫，狗，鱼，那么你仅仅需要将它改成 classess={ ' cat ' , ' dog ' , ' fish ' } 即可
classes = {'peach', 'strawberry'} # 预先自己定义的类别，根据自己的需要修改,我定义了两类：桃子，草莓做完上面的两个更改之后，你就可以使用 LeNet-5 来训练你自己的数据集了
1.2、生成tfrecord以及tfrecord的读取
import os
import tensorflow as tf
from PIL import Image # 高版本python 已不支持PIL 库，所以在安装的时候安装 pillow，但是调用方法一样
#import matplotlib.pyplot as plt
def creat_tfrecord():
sess = tf.InteractiveSession()
data_path = "F://soft_exercise//data//" # 数据所在目录位置
classes = {'peach', 'strawberry'} # 预先自己定义的类别，根据自己的需要修改,我定义了两类：桃子，草莓
writer = tf.python_io.TFRecordWriter("F://soft_exercise//data//train.tfrecords") # 表示转成的tfrecords数据格式的存储路径
for index, name in enumerate(classes):
class_path = data_path + name + "//"
for img_name in os.listdir(class_path):
img_path = class_path + img_name
img = Image.open(img_path)
img = img.resize((28, 28)) # 图像reshape大小设置，根据自己的需要修改
img_raw = img.tobytes()
example = tf.train.Example(features=tf.train.Features(feature={
"label": tf.train.Feature(int64_list=tf.train.Int64List(value=[index])),
'img_raw': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw]))
}))
writer.write(example.SerializeToString())
writer.close()
# 读取文件
def read_and_decode():
creat_tfrecord()
# 根据文件名生成一个队列
filename_queue = tf.train.string_input_producer(["F://soft_exercise//data//train.tfrecords"])
reader = tf.TFRecordReader()
_, serialized_example = reader.read(filename_queue) # 返回文件名和文件
features = tf.parse_single_example(serialized_example,
features={
'label': tf.FixedLenFeature([], tf.int64),
'img_raw': tf.FixedLenFeature([], tf.string),
})
img = tf.decode_raw(features['img_raw'], tf.uint8)
img = tf.reshape(img, [28, 28, 3]) # 图像归一化大小
# img = tf.cast(img, tf.float32) * (1. / 255) - 0.5 #图像减去均值处理，根据自己的需要决定要不要加上
label = tf.cast(features['label'], tf.int64)
# 特殊处理，去数据的batch，如果不要对数据做batch处理，也可以把下面这部分不放在函数里
img_batch, label_batch = tf.train.shuffle_batch([img, label],
batch_size=4,
num_threads=64,
capacity=200,
min_after_dequeue=150)
img_batch = tf.cast(img_batch,tf.float32)
return img_batch, label_batch
上面的代码是生成 tfrecord ，下面的 read_and_decode() 是读取tfrecord 的代码。
二、定义神经网络结构
定义的是 LeNet-5 的结构，需要注意的地方，都已经在代码里面写明了
保存为 input_data.py 文件
# -*- coding: utf-8 -*-
import tensorflow as tf
# 配置神经网络的参数
INPUT_NODE = 784
OUTPUT_NODE = 2
IMAGE_SIZE = 28
NUM_CHANNELS = 3
NUM_LABELS = 2
# 第一层卷积层的尺寸和深度
CONV1_DEEP = 6
CONV1_SIZE = 5
# 第三层卷积层的尺寸和深度
CONV2_DEEP = 16
CONV2_SIZE = 5
# 第五层卷积层的尺寸和深度
CONV3_DEEP = 120
CONV3_SIZE = 5
# 全连接层的节点个数
FC_SIZE = 84
# 定义卷积神经网络的前向传播过程。这里添加一个新的参数train，用于区分训练过程和测试过程。在这个程序中将用到Ddropout方法，dropout可以进一步提升模型可靠性
# 并防止过拟合，dropout过程只在训练时使用。
def inference(input_tensor, train, regularizer):
# 声明第一层卷积层的变量并实现前向传播过程。通过使用不同的命名空间来隔离不同层的变量，这可以让每一层中的变量命名只需要考虑
# 在当前层的作用，而不需要担心重名的问题。和标准的LeNet-5模型不太一样，这里定义的卷积层输入为28x28x1的原始MNIST图片像素。
# 因为卷积层中使用了全0填充，所以输出为28x28x6的矩阵。
with tf.variable_scope('layer1-conv1'):
conv1_weights = tf.get_variable("weight", [CONV1_SIZE, CONV1_SIZE, NUM_CHANNELS, CONV1_DEEP],
initializer=tf.truncated_normal_initializer(stddev=0.1))
conv1_biases = tf.get_variable("bias", [CONV1_DEEP], initializer=tf.constant_initializer(0.0))
# 使用边长为5，深度为6的过滤器，过滤器移动的步长为1，且使用全0填充。
conv1 = tf.nn.conv2d(input_tensor, conv1_weights, strides=[1, 1, 1, 1], padding='SAME')
relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_biases))
# 实现第二层池化层的前向传播过程。这里选用最大池化层，池化层过滤器的边长为2，使用全0填充且移动的步长为2.这一层的输入为上一层的输出
# 也就是28x28x6的矩阵。输出为14x14x6的矩阵。
with tf.name_scope('layer2-pool1'):
pool1 = tf.nn.max_pool(relu1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
# 声明第三层卷积层的变量并实现前向传播过程。这一层输入为14x14x6的矩阵，因为卷积层没有使用全0填充，所以输出为10x10x16的矩阵
with tf.variable_scope('layer3-conv2'):
conv2_weights = tf.get_variable("weight", [CONV2_SIZE, CONV2_SIZE, CONV1_DEEP, CONV2_DEEP],
initializer=tf.truncated_normal_initializer(stddev=0.1))
conv2_biases = tf.get_variable("bias", [CONV2_DEEP], initializer=tf.constant_initializer(0.0))
# 使用边长为5，深度为16的过滤器，过滤器移动的步长为1，不使用全0填充
conv2 = tf.nn.conv2d(pool1, conv2_weights, strides=[1, 1, 1, 1], padding='VALID')
relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases))
# 实现第四层池化层的前向传播过程。这一层和第二层的结构是一样的。这一层的输入为10x10x16的矩阵，输出为5x5x16的矩阵
with tf.name_scope('layer4-pool2'):
pool2 = tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='VALID')
# 声明第五层全连接层（实际上是卷积层）的变量并实现前向传播过程。这一层输入是5x5x16的矩阵，因为没有使用全0填充，
# 所以输出为1x1x120的矩阵
with tf.name_scope('layer5-conv3'):
conv3_weights = tf.get_variable("weights", [CONV3_SIZE, CONV3_SIZE, CONV2_DEEP, CONV3_DEEP],
initializer=tf.truncated_normal_initializer(stddev=0.1))
conv3_biases = tf.get_variable("bias", [CONV3_DEEP], initializer=tf.constant_initializer(0.0))
# 使用边长为5，深度为120的过滤器，过滤器移动的步长为1，不使用全0填充
conv3 = tf.nn.conv2d(pool2, conv3_weights, strides=[1, 1, 1, 1], padding='VALID')
relu3 = tf.nn.relu(tf.nn.bias_add(conv3, conv3_biases))
# 将第五层卷积层的输出转化为第六层全连接层的输入格式。第五层的输出为1x1x120的矩阵，然而第六层全连接层需要的输入格式为向量，
# 所以在这里需要将这个1x1x120的矩阵拉直成一个向量。relu3.get_shape函数可以得到第五层输出矩阵的维度而不需要手工计算。注意因为
# 每一层神经网络的输入输出都为一个batch的矩阵，所以这里得到的维度也包含了一个batch中数据的个数。
pool_shape = relu3.get_shape().as_list()
# 计算将矩阵拉直成向量之后的长度，这个长度就是矩阵长度及深度的乘积。注意这里pool_shape[0]为一个batch中数据的个数。
nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]
# 通过tf.reshape函数将第五层的输出变成一个batch的向量。
reshaped = tf.reshape(relu3, [pool_shape[0], nodes])
# 声明第六层全连接层的变量并实现前向传播过程。这一层的输入时拉直之后的一组向量，向量长度为120，输出是一组长度为84的向量
# 这一层和之前在第五章中介绍的基本一致，唯一的区别就是引入了dropout的概念。dropout在训练时会随机将部分节点的输出为改为0.
# dropout可以避免过拟合问题，从而使得模型在测试数据上的效果更好。dropout一般只在全连接层而不是卷积层或者池化层使用。
with tf.variable_scope('layer6-fc1'):
fc1_weights = tf.get_variable("weight", [nodes, FC_SIZE],
initializer=tf.truncated_normal_initializer(stddev=0.1))
# 只有全连接层的权重需要加入正则化
if regularizer != None:
tf.add_to_collection('losses', regularizer(fc1_weights))
fc1_biases = tf.get_variable("bias", [FC_SIZE], initializer=tf.constant_initializer(0.1))
fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_weights) + fc1_biases)
if train:
fc1 = tf.nn.dropout(fc1, 0.5)
# 声明第七层全连接层的变量并实现前向传播过程。这一层的输入为一组长度为84的向量，输出为一组长度为10的向量。这一层的输出通过
# softmax之后就得到了最后的分类结果。
with tf.variable_scope('layer7-fc2'):
fc2_weights = tf.get_variable("weight", [FC_SIZE, NUM_LABELS],
initializer=tf.truncated_normal_initializer(stddev=0.1))
if regularizer != None:
tf.add_to_collection('losses', regularizer(fc2_weights))
fc2_biases = tf.get_variable("bias", [NUM_LABELS], initializer=tf.constant_initializer(0.1))
logit = tf.matmul(fc1, fc2_weights) + fc2_biases
# 返回第七层的输出
return logit三、训练神经网络模型
保存为 train.py 文件
# -*- coding: utf-8 -*-
import os
import tensorflow as tf
import numpy as np
# 加载cat_dog_inference.py中定义的常量和前向传播函数
import selfdata_inference
import input_data
# 配置神经网络的参数
BATCH_SIZE = 4
LEARNING_RATE_BASE = 0.001
LEARNING_RATE_DECAY = 0.99
REGULARAZTION_RATE = 0.0001
TRAINING_STEPS = 30000
MOVING_AVERAGE_DECAY = 0.99
# 模型保存的路径和文件名。
MODEL_SAVE_PATH = "/model/"
MODEL_NAME = "model1.ckpt"
# TFRecord文件存储地址
file_dir = "F://soft_exercise//data//train.tfrecords"
# 定义训练过程
def train():
# 从TFRecord文件中读取图片和标签数据，组合成batch数据
xs, ys = input_data.read_and_decode()
regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
# 直接使用mnist_interence.py中定义的前向传播过程
y = selfdata_inference.inference(xs, True, regularizer)
global_step = tf.Variable(0, trainable=False)
# 定义滑动平均类和滑动平均操作
variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
variables_averages_op = variable_averages.apply(tf.trainable_variables())
# 定义交叉熵损失
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=ys)
cross_entropy_mean = tf.reduce_mean(cross_entropy)
# 定义总损失(交叉熵损失+正则化损失)
loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))
# 定义学习率
learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, 55000 / BATCH_SIZE, LEARNING_RATE_DECAY)
# 定义反向传播算法更新神经网络的参数，同时更新每一个参数的滑动平均值
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
with tf.control_dependencies([train_step, variables_averages_op]):
train_op = tf.no_op(name='train')
# 检验使用了滑动平均模型的神经网络前向传播的结果是否正确。tf.argmax(average_y,1)计算每一个样例的预测答案。其中average_y是一个
# batch_size*10 的二维数组，每一行表示一个样例的前向传播结果。tf.argmax的第二个参数“1“表示选取最大值的操作尽在第一个维度中进行
# 也就是说，只在每一行选取最大值对应的下标。于是得到的结果是一个长度为batch的一维数组，这个一维数组中的值就表示了每一个样例对应的数字识别结果
# tf.equal判断两个张量的每一维是否相等，如果相等返回True，否则返回False。
correct_prediction = tf.equal(tf.argmax(y, 1), ys)
# 这个运算首先将一个布尔型的数字转换成实数型，然后计算平均值。这个平均值就是模型在这一组数据上的正确率。
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 初始化Tensorflow持久化类
saver = tf.train.Saver()
with tf.Session() as sess:
# 变量初始化
tf.global_variables_initializer().run()
# 由于train.match_filenames_once()返回的文件列表作为临时变量并没有保存到checkpoint，所以并不会作为全局变量被global_variables_initializer()函数初始化，
# 所以要进行局部变量初始化，不然会报错
tf.local_variables_initializer().run()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
try:
for i in range(TRAINING_STEPS):
# while not coord.should_stop():
if coord.should_stop():
break
_, loss_value, accu, step = sess.run([train_op, loss, accuracy, global_step])
# 每迭代训练1000次，输出总损失和在训练样本上的分类正确率
if i % 1000 == 0:
print("Afetr %d training step(s),loss on training batch is %g,accuracy is %g." % (
step, loss_value, accu))
# 保存训练结束后的神经网络模型，在测试或者离线时，直接加载模型
# saver.save(sess,os.path.join(MODEL_SAVE_PATH,MODEL_NAME),global_step=global_step)
except tf.errors.OutOfRangeError:
print('done!')
finally:
coord.request_stop()
coord.join(threads)
# 主程序入口
def main(argv=None):
# 声明处理MNIST数据集的类，这个类在初始化时会自动下载数据
# mnist=input_data.read_data_sets("/tmp/data/",one_hot=True)
train()
# Tensorflow提供的一个主程序入口，tf.app.run会调用上面定义的main函数。
if __name__ == '__main__':
tf.app.run()
导入 selfdata_inference.py 跟input_data.py 时，会出现下面情形，这是没有问题的，可以直接运行
