tensorflow利用LeNet-5 训练自己的数据集

书上跟网络上的大部分实例都是使用已经封装好的 mnist 数据集来训练卷积神经网络。但是我想利用神经来训练自己的数据集，这时，问题就出现了，如何将自己的数据集导入到神经网络？

把问题清晰的写下来，整个困难就已经解决了一半了。解决问题的思路如下：

1. 将自己的数据集转换为 tensorflow 支持的神经网络输入格式 tfrecord
2. 重建 LeNet-5 卷积神经网络
3. 对神经网络进行训练

适用于 Windows 以及 pycharm ，python 3.5 环境。不知为何，python3.6以及 python 3.7 不能很好的兼容 tensorflow 所以我选择使用python3.5. 可能现在已经解决这个问题了。

目录

一、制作自己的数据集

1.1、更改代码，以适应自己的数据集

1.2、生成tfrecord以及tfrecord的读取

二、定义神经网络结构

三、训练神经网络模型

---

一、制作自己的数据集

关于Tensorflow读取数据，官网给出了三种方法：

 

1. 供给数据(Feeding)： 在TensorFlow程序运行的每一步， 让Python代码来供给数据。
2. 从文件读取数据： 在TensorFlow图的起始， 让一个输入管线从文件中读取数据。
3. 预加载数据： 在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 时，会出现下面情形，这是没有问题的，可以直接运行