jiading

TensorFlow 训练模型流程解读(含源码)

Tensorflow的Object Detection的API是基于config文件调用的,但是真正的Tensorflow模型和训练过程是基于python代码的,本文是一个很好的例子,非常完整地演示了使用Tensorflow从制作数据集开始的全过程,有非常强的借鉴性

使用 TensorFlow 编写了一个对四种花分类的代码,其中涉及到读取数据,搭建模型,测试图片。在编写代码中有些 API 用的不是很熟练,因此写下此文章记录,方便日后回忆。

第一部分:读取数据和标签

一般我们训练模型,需要大量的数据,一般有数据集,但是一些特殊行业,需要自己手动收集数据。我们把数据分类放好,如图:

img

四种花的图片分门别类放好。我们就可以写代码读取,并标签 0 1 2 3

代码如下:

train_dir = \'D:/download/flower_world-master/flower_world-master/input_data\'  # 训练样本的读入路径
logs_train_dir = \'D:/download/flower_world-master/flower_world-master/log\'  # logs存储路径
 
# train, train_label = input_data.get_files(train_dir)
train, train_label, val, val_label = input_data.get_files(train_dir, 0.3)
# 训练数据及标签
train_batch, train_label_batch = input_data.get_batch(train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
# 测试数据及标签
val_batch, val_label_batch = input_data.get_batch(val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
# step1:获取所有的图片路径名,存放到
# 对应的列表中,同时贴上标签,存放到label列表中。
def get_files(file_dir, ratio):
    for file in os.listdir(file_dir + \'/roses\'):
        roses.append(file_dir + \'/roses\' + \'/\' + file)
        label_roses.append(0)
    for file in os.listdir(file_dir + \'/tulips\'):
        tulips.append(file_dir + \'/tulips\' + \'/\' + file)
        label_tulips.append(1)
    for file in os.listdir(file_dir + \'/dandelion\'):
        dandelion.append(file_dir + \'/dandelion\' + \'/\' + file)
        label_dandelion.append(2)
    for file in os.listdir(file_dir + \'/sunflowers\'):
        sunflowers.append(file_dir + \'/sunflowers\' + \'/\' + file)
        label_sunflowers.append(3)
 
    # step2:对生成的图片路径和标签List合并成一个大数组
    image_list = np.hstack((roses, tulips, dandelion, sunflowers))
    label_list = np.hstack((label_roses, label_tulips, label_dandelion, label_sunflowers))
 
    # 利用shuffle打乱顺序
    temp = np.array([image_list, label_list])
    temp = temp.transpose()
    np.random.shuffle(temp)
 
    # 从打乱的temp中再取出list(img和lab)
    # image_list = list(temp[:, 0])
    # label_list = list(temp[:, 1])
    # label_list = [int(i) for i in label_list]
    # return image_list, label_list
 
    # 将所有的img和lab转换成list
    all_image_list = list(temp[:, 0])
    all_label_list = list(temp[:, 1])
 
    # 将所得List分为两部分,一部分用来训练tra,一部分用来测试val
    # ratio是测试集的比例
    n_sample = len(all_label_list)
    n_val = int(math.ceil(n_sample * ratio))  # 测试样本数
    n_train = n_sample - n_val  # 训练样本数
 
    tra_images = all_image_list[0:n_train]
    tra_labels = all_label_list[0:n_train]
    tra_labels = [int(float(i)) for i in tra_labels]
    val_images = all_image_list[n_train:-1]
    val_labels = all_label_list[n_train:-1]
    val_labels = [int(float(i)) for i in val_labels]
 
    return tra_images, tra_labels, val_images, val_labels
 
 
# ---------------------------------------------------------------------------
# --------------------生成Batch----------------------------------------------
 
# step1:将上面生成的List传入get_batch() ,转换类型,产生一个输入队列queue,因为img和lab
# 是分开的,所以使用tf.train.slice_input_producer(),然后用tf.read_file()从队列中读取图像
#   image_W, image_H, :设置好固定的图像高度和宽度
#   设置batch_size:每个batch要放多少张图片
#   capacity:一个队列最大多少
def get_batch(image, label, image_W, image_H, batch_size, capacity):
    # 转换类型
    image = tf.cast(image, tf.string)
    label = tf.cast(label, tf.int32)
 
    # 从tensor列表中随机抽取一个tensor
    input_queue = tf.train.slice_input_producer([image, label])
 
    label = input_queue[1]
    image_contents = tf.read_file(input_queue[0])  # read img from a queue
 
    # step2:将图像解码,不同类型的图像不能混在一起,要么只用jpeg,要么只用png等。
    #decode a jpeg image to uint8 tensor shape is [h,w ,channel]
    image = tf.image.decode_jpeg(image_contents, channels=3)
 
    # step3:数据预处理,对图像进行旋转、缩放、裁剪、归一化等操作,让计算出的模型更健壮。
 
    image = tf.image.resize_image_with_crop_or_pad(image, image_W, image_H)
    image = tf.image.per_image_standardization(image)
 
    # step4:生成batch
    # image_batch: 4D tensor [batch_size, width, height, 3],dtype=tf.float32
    # label_batch: 1D tensor [batch_size], dtype=tf.int32
    image_batch, label_batch = tf.train.batch([image, label],
                                              batch_size=batch_size,
                                              num_threads=32,
                                              capacity=capacity)
    # 重新排列label,行数为[batch_size]
    label_batch = tf.reshape(label_batch, [batch_size])
    #转换精度
    image_batch = tf.cast(image_batch, tf.float32)
    return image_batch, label_batch

主要有两个函数组成:get_files(train_dir, 测试样本占比) get_batch(list1,list 2,list3 ,list4)

get_files 主要是读取路径下的图片,分别存放到列表中,同时生成标签。需要注意的一点是要先使用 numpy 生成一个四维数组,即

[[a,b,c] [[a 1]

​ [b 2]

[1,2,3] 的形式在经过 arrary.transpose() 编程 [c 3]] 的形式。即图片名和标签一一对应 (其实这些步骤不是必须的,只是为了增加样本的随机性),再将数组转化为队列返回。

get_batch() 这个函数比较复杂。主要使用文件队列的方式进行数据的读取。他的参数是上面生成的四个 list. 进入函数后,首先对图片和标签两个 list 转换类型。tf.cast() 转换成张量。便于接下来的计算。tf.train.slice_input_producer 是一个 tensor 生成器,作用是按照设定,每次从一个 tensor 列表中按顺序或者随机抽取出一个 tensor 放入文件名队列。也可以指定样本放入文件名队列的方式,包括迭代次数,是否乱序等,但是要真正将文件放入文件名队列,还需要调用 tf.train.start_queue_runners 函数来启动执行文件名队列填充的线程,之后计算单元才可以把数据读出来,否则文件名队列为空的,计算单元就会处于一直等待状态,导致系统阻塞

f.train.batch 是一个 tensor 队列生成器,作用是按照给定的 tensor 顺序,把 batch_size 个 tensor 推送到文件队列,作为训练一个 batch 的数据,等待 tensor 出队执行计算。

也就是说,这个模块会根据你提供 的 batch_size,从 tensor 列表中入队多少个 tensor 到文件名列表中。然后在读。

参考链接:https://www.cnblogs.com/shixisheng/p/9560617.html

https://86rev0.smartapps.cn/pages/blog/article-detail?userName=yeler082&articleId=90371452

第二部分:搭建模型

准备好数据后,就可以准备模型了,有两种方法,一种是训练别人训练好的模型,另外一种就是从零搭建自己的模型,我们在从头搭建模型的时候,有很多变量很多层都会用到,可以使用全局变量,但是对模块的封装性不好,tf 为我们提供了一种更简便的变量域的方法。

tf.variable_scope(\'变量域名称\')

tf.Variable() # 创建变量 不过最好使用 get_Variable()

# 训练操作定义
#前向计算,获取回归值
train_logits = model.inference(train_batch, BATCH_SIZE, N_CLASSES)
#计算获得损失值
train_loss = model.losses(train_logits, train_label_batch)
#根据损失值进行优化
train_op = model.trainning(train_loss, learning_rate)
#计算准确率
train_acc = model.evaluation(train_logits, train_label_batch)
 
# 测试操作定义
test_logits = model.inference(val_batch, BATCH_SIZE, N_CLASSES)
test_loss = model.losses(test_logits, val_label_batch)
test_acc = model.evaluation(test_logits, val_label_batch)
#调用的函数如下
def inference(images, batch_size, n_classes):
    # 一个简单的卷积神经网络,卷积+池化层x2,全连接层x2,最后一个softmax层做分类。
    # 卷积层1
    # 64个3x3的卷积核(3通道),padding=’SAME’,表示padding后卷积的图与原图尺寸一致,激活函数relu()
 
    with tf.variable_scope(\'conv1\') as scope:
        weights = tf.Variable(tf.truncated_normal(shape=[3, 3, 3, 64], stddev=1.0, dtype=tf.float32),
                              name=\'weights\', dtype=tf.float32)
 
        biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[64]),
                             name=\'biases\', dtype=tf.float32)
 
        conv = tf.nn.conv2d(images, weights, strides=[1, 1, 1, 1], padding=\'SAME\')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv1 = tf.nn.relu(pre_activation, name=scope.name)
 
    # 池化层1
    # 3x3最大池化,步长strides为2,池化后执行lrn()操作,局部响应归一化,对训练有利。
    with tf.variable_scope(\'pooling1_lrn\') as scope:
        pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding=\'SAME\', name=\'pooling1\')
        norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name=\'norm1\')
 
    # 卷积层2
    # 16个3x3的卷积核(16通道),padding=’SAME’,表示padding后卷积的图与原图尺寸一致,激活函数relu()
    with tf.variable_scope(\'conv2\') as scope:
        weights = tf.Variable(tf.truncated_normal(shape=[3, 3, 64, 16], stddev=0.1, dtype=tf.float32),
                              name=\'weights\', dtype=tf.float32)
 
        biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[16]),
                             name=\'biases\', dtype=tf.float32)
 
        conv = tf.nn.conv2d(norm1, weights, strides=[1, 1, 1, 1], padding=\'SAME\')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv2 = tf.nn.relu(pre_activation, name=\'conv2\')
 
    # 池化层2
    # 3x3最大池化,步长strides为2,池化后执行lrn()操作,
    # pool2 and norm2
    with tf.variable_scope(\'pooling2_lrn\') as scope:
        norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001 / 9.0, beta=0.75, name=\'norm2\')
        pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 1, 1, 1], padding=\'SAME\', name=\'pooling2\')
 
    # 全连接层3
    # 128个神经元,将之前pool层的输出reshape成一行,激活函数relu()
    with tf.variable_scope(\'local3\') as scope:
        reshape = tf.reshape(pool2, shape=[batch_size, -1])
        dim = reshape.get_shape()[1].value
        weights = tf.Variable(tf.truncated_normal(shape=[dim, 128], stddev=0.005, dtype=tf.float32),
                              name=\'weights\', dtype=tf.float32)
 
        biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[128]),
                             name=\'biases\', dtype=tf.float32)
 
        local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
 
    # 全连接层4
    # 128个神经元,激活函数relu()
    with tf.variable_scope(\'local4\') as scope:
        weights = tf.Variable(tf.truncated_normal(shape=[128, 128], stddev=0.005, dtype=tf.float32),
                              name=\'weights\', dtype=tf.float32)
 
        biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[128]),
                             name=\'biases\', dtype=tf.float32)
 
        local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name=\'local4\')
 
    # dropout层
    #    with tf.variable_scope(\'dropout\') as scope:
    #        drop_out = tf.nn.dropout(local4, 0.8)
 
    # Softmax回归层
    # 将前面的FC层输出,做一个线性回归,计算出每一类的得分
    with tf.variable_scope(\'softmax_linear\') as scope:
        weights = tf.Variable(tf.truncated_normal(shape=[128, n_classes], stddev=0.005, dtype=tf.float32),
                              name=\'softmax_linear\', dtype=tf.float32)
 
        biases = tf.Variable(tf.constant(value=0.1, dtype=tf.float32, shape=[n_classes]),
                             name=\'biases\', dtype=tf.float32)
 
        softmax_linear = tf.add(tf.matmul(local4, weights), biases, name=\'softmax_linear\')
 
    return softmax_linear
 
 
# -----------------------------------------------------------------------------
# loss计算
# 传入参数:logits,网络计算输出值。labels,真实值,在这里是0或者1
# 返回参数:loss,损失值
def losses(logits, labels):
    with tf.variable_scope(\'loss\') as scope:
        cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=labels,
                                                                       name=\'xentropy_per_example\')
        loss = tf.reduce_mean(cross_entropy, name=\'loss\')
        tf.summary.scalar(scope.name + \'/loss\', loss)
    return loss
 
 
# --------------------------------------------------------------------------
# loss损失值优化
# 输入参数:loss。learning_rate,学习速率。
# 返回参数:train_op,训练op,这个参数要输入sess.run中让模型去训练。
def trainning(loss, learning_rate):
    with tf.name_scope(\'optimizer\'):
        optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
        global_step = tf.Variable(0, name=\'global_step\', trainable=False)
        train_op = optimizer.minimize(loss, global_step=global_step)
    return train_op
 
 
# -----------------------------------------------------------------------
# 评价/准确率计算
# 输入参数:logits,网络计算值。labels,标签,也就是真实值,在这里是0或者1。
# 返回参数:accuracy,当前step的平均准确率,也就是在这些batch中多少张图片被正确分类了。
def evaluation(logits, labels):
    with tf.variable_scope(\'accuracy\') as scope:
        correct = tf.nn.in_top_k(logits, labels, 1)
        correct = tf.cast(correct, tf.float16)
        accuracy = tf.reduce_mean(correct)
        tf.summary.scalar(scope.name + \'/accuracy\', accuracy)
    return accuracy

第三部分:开始训练

主要是创建一个会话,从文件队列读取一个 batch 数据。并保存训练好的模型

summary_op = tf.summary.merge_all()
 
# 产生一个会话
sess = tf.Session()
# 产生一个writer来写log文件
train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
 
# 产生一个saver来存储训练好的模型
saver = tf.train.Saver()
# 所有节点初始化
sess.run(tf.global_variables_initializer())
# 队列监控
coord = tf.train.Coordinator()
#一般情况下,系统有多少个核就有能启动多少个入队线程
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
 
# 进行batch的训练
try:
    # 执行MAX_STEP步的训练,一步一个batch
    for step in np.arange(MAX_STEP):
        if coord.should_stop():
            break
        _, tra_loss, tra_acc = sess.run([train_op, train_loss, train_acc])
 
        # 每隔50步打印一次当前的loss以及acc,同时记录log,写入writer
        if step % 10 == 0:
            print(\'Step %d, train loss = %.2f, train accuracy = %.2f%%\' % (step, tra_loss, tra_acc * 100.0))
            summary_str = sess.run(summary_op)
            train_writer.add_summary(summary_str, step)
        # 每隔100步,保存一次训练好的模型
        if (step + 1) == MAX_STEP:
            checkpoint_path = os.path.join(logs_train_dir, \'model.ckpt\')
            saver.save(sess, checkpoint_path, global_step=step)
 
except tf.errors.OutOfRangeError:
    print(\'Done training -- epoch limit reached\')
 
finally:
    coord.request_stop()

第四部分:测试训练好的模型

第三部分使用 save 类保存 cleckpoint 文件(二进制文件,把变量名映射到对应的 tensor 值)

#from Pillow import Image
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import model
from input_data import get_files
from PIL import Image  #install pillow
 
# 获取一张图片
def get_one_image(train):
    # 输入参数:train,训练图片的路径
    # 返回参数:image,从训练图片中随机抽取一张图片
    n = len(train)
    ind = np.random.randint(0, n)
    img_dir = train[ind]  # 随机选择测试的图片
 
    img = Image.open(img_dir)
    plt.imshow(img)
    plt.show()
    image = np.array(img)
    return image
 
 
# 测试图片
def evaluate_one_image(image_array):
   #新生成的图作为tensorflow运行环境默认图。只要图你才能作画(节点和数据)
    with tf.Graph().as_default():
        BATCH_SIZE = 1
        N_CLASSES = 4
 
        image = tf.cast(image_array, tf.float32)
        image = tf.image.per_image_standardization(image)
        image = tf.reshape(image, [1, 64, 64, 3])
 
        logit = model.inference(image, BATCH_SIZE, N_CLASSES)
 
        logit = tf.nn.softmax(logit)
 
        x = tf.placeholder(tf.float32, shape=[64, 64, 3])
 
        # you need to change the directories to yours.
        logs_train_dir = \'D:/download/flower_world-master/flower_world-master/log\'
 
        saver = tf.train.Saver()
 
        with tf.Session() as sess:
 
            print("Reading checkpoints...")
            ckpt = tf.train.get_checkpoint_state(logs_train_dir)
            if ckpt and ckpt.model_checkpoint_path:
                global_step = ckpt.model_checkpoint_path.split(\'/\')[-1].split(\'-\')[-1]
                saver.restore(sess, ckpt.model_checkpoint_path)
                print(\'Loading success, global_step is %s\' % global_step)
            else:
                print(\'No checkpoint file found\')
 
            prediction = sess.run(logit, feed_dict={x: image_array})
            max_index = np.argmax(prediction)
            print(max_index)
            if max_index == 0:
                print(\'这是玫瑰花的可能性为: %.6f\' % prediction[:, 0])
            elif max_index == 1:
                print(\'这是郁金香的可能性为: %.6f\' % prediction[:, 1])
            elif max_index == 2:
                print(\'这是蒲公英的可能性为: %.6f\' % prediction[:, 2])
            else:
                 print(\'这是这是向日葵的可能性为: %.6f\' % prediction[:, 3])
            #return result
 
 
# ------------------------------------------------------------------------
 
if __name__ == \'__main__\':
    img = Image.open(\'D:/download/3.jpg\')
   # plt.imshow(img)
   # plt.show()
    imag = img.resize([64, 64])
    image = np.array(imag)
    evaluate_one_image(image)

分类:

技术点:

相关文章: