TensorFlow 訓練模型流程解讀（含源碼）

Tensorflow的Object Detection的API是基於config文件調用的，但是真正的Tensorflow模型和訓練過程是基於python代碼的，本文是一個很好的例子，非常完整地演示了使用Tensorflow從制作數據集開始的全過程，有非常強的借鑒性

使用 TensorFlow 編寫了一個對四種花分類的代碼，其中涉及到讀取數據，搭建模型，測試圖片。在編寫代碼中有些 API 用的不是很熟練，因此寫下此文章記錄，方便日后回憶。

第一部分：讀取數據和標簽

一般我們訓練模型，需要大量的數據，一般有數據集，但是一些特殊行業，需要自己手動收集數據。我們把數據分類放好，如圖：

四種花的圖片分門別類放好。我們就可以寫代碼讀取，並標簽 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)