TensorFlow slim(二) 使用TF-slim編程模板(一)

　　TF-slim 模塊是TensorFLow中比較實用的API之一，是一個用於模型構建、訓練、評估復雜模型的輕量化庫。

　　最近，在使用TF-slim API編寫了一些項目模型后，發現TF-slim模塊在搭建網絡模型時具有相同的編寫模式。這個編寫模式主要包含四個部分：

• __init__():
• build_model():
• fit():
• predict():

1. __init__():

　　這部分相當於是一個main()函數，其中包含參數的設置，模型整體的連接等操作。具體來說：

　　a. 設置參數

　　由於是類的構造函數，所以需要在其中設置一些模型網絡結構的參數、模型訓練時的參數等等。例如

• 學習率
• batch_size
• 訓練代數
• 各種文件的存放地址
• ...
• 對於網絡結構復雜的模型，還可以將網絡結構的table以列表的形式進行保存。便於后續建立模型時可以循環獲取每層的超參數。

self.lr = lr
self.batch_size = batch_size
self.epoch = epoch
self.checkpoint_dir_load = checkpoint_dir
self.checkpoint_dir = os.path.join(checkpoint_dir, filename + ".ckpt")
self.logdir = logdir
self.result_dir = result_dir

　　b. 設置輸入、輸出的占位符placeholder

　　由於TF-slim框架仍然采用的是tensorflow的那一套，不像tf.keras可以使用keras.layer.Input()，所以還需要使用占位符。例如

self.input_image = tf.placeholder(tf.float32, shape=[None, 6000])
self.input_image_raw = tf.reshape(self.input_image, shape=[-1, 6000, 1])

self.input_image_label = tf.placeholder(tf.float32, shape=[None, 1, 10])
self.input_label = tf.reshape(self.input_image_label, shape=[-1, 10])

　　c. 初始化網絡結構，生成訓練輸出和測試輸出

　　用於后續損失的計算以及優化器的生成，以及訓練結果和測試結果的調用。

　　此處會涉及到網絡參數的重用，需要使用tf.variable_scope()來管理參數。

with tf.variable_scope("Network_Structure") as scope:
    self.train_digits = self.build_model(is_trained=True)
    scope.reuse_variables()
    self.test_digits = self.build_model(is_trained=False)

　　d. 損失函數和優化器的聲明

　　此處損失聲明使用的是 輸出的占位符和訓練的輸出。例如：

self.loss = slim.losses.softmax_cross_entropy(logits=self.train_digits, onehot_labels=self.input_label, scope="loss")

self.optimizer = tf.train.AdamOptimizer(learning_rate=self.lr).minimize(loss=self.loss)

　　e. 最終訓練輸出結果和測試輸出結果的計算

　　由於網絡輸出的結果不一定是最終的結果。對於多分類問題，需要將one_hot編碼的結果顯示為類值；對於回歸問題，輸出結果可能會需要反歸一化。等等..

　　如下述代碼，多分類問題的one_hot轉化為類標簽，並進行准確率的計算。

# result and accuracy of test
self.predicts = tf.math.argmax(self.test_digits, 1)   # 將one_hot轉化為類標簽
self.test_correction = tf.equal(self.predicts, tf.math.argmax(self.input_label, 1))
self.accuracy = tf.reduce_mean(tf.cast(self.test_correction, "float"))
tf.summary.scalar("test_accuracy", self.accuracy)

# result and accuracy of train
self.train_result = tf.math.argmax(self.train_digits, 1)
self.train_correlation = tf.equal(self.train_result, tf.math.argmax(self.input_label, 1))
self.train_accuracy = tf.reduce_mean(tf.cast(self.train_correlation, "float"))
tf.summary.scalar("train_accuracy", self.accuracy)

2. build_model():【可以是別的名字】

　　這部分是為了使用tf-slim搭建網絡模型結構。有些模型可能一個函數實現不了，需要多個函數。例如具有共享層的Siamese Network，在共享層后還有其他層。

　　這一部分也實現了如同tf.keras搭建的模型"樂高式"堆疊，不需要手動為各層生成權重、偏執等參數。也是代碼瘦身的重要環節。

with slim.arg_scope([slim.conv1d], padding="SAME", stride=2, activation_fn=tf.nn.relu,
                    weights_initializer=tf.truncated_normal_initializer(stddev=0.01),
                    weights_regularizer=slim.l2_regularizer(0.005)
                    ):
    net = slim.conv1d(self.input_image_raw, num_outputs=16, kernel_size=8, padding="VALID", scope='conv_1')
    tf.summary.histogram("conv_1", net)
    net = slim.conv1d(net, num_outputs=16, kernel_size=8, scope='conv_2')
    tf.summary.histogram("conv_2", net)
    def_max_pool = tf.layers.MaxPooling1D(pool_size=2, strides=2, padding="VALID", name="max_pool_3")
    net = def_max_pool(net)
    # net = slim.nn.max_pool1d(net, ksize=2, strides=None, padding="VALID", data_format="NWC", name="max_pool_3")
    tf.summary.histogram("max_pool_3", net)
    net = slim.conv1d(net, num_outputs=64, kernel_size=4, scope="conv_4")
    tf.summary.histogram("conv_4", net)
    net = slim.conv1d(net, num_outputs=64, kernel_size=4, scope="conv_5")
    tf.summary.histogram("conv_5", net)
    def_max_pool = tf.layers.MaxPooling1D(pool_size=2, strides=2, padding="VALID", name="max_pool_6")
    net = def_max_pool(net)
    # net = slim.nn.max_pool1d(net, ksize=2, strides=1, padding="VALID", name="max_pool_6")
    tf.summary.histogram("max_pool_6", net)
    net = slim.conv1d(net, num_outputs=256, kernel_size=4, scope="conv_7")
    tf.summary.histogram("conv_7", net)
    net = slim.conv1d(net, num_outputs=256, kernel_size=4, scope="conv_8")
    tf.summary.histogram("conv_8", net)
    def_max_pool = tf.layers.MaxPooling1D(pool_size=2, strides=2, padding="VALID", name="max_pool_9")
    net = def_max_pool(net)
    # net = slim.nn.max_pool1d(net, ksize=1, strides=1, padding="VALID", name="max_pool_9")
    tf.summary.histogram("max_pool_9", net)
    net = slim.conv1d(net, num_outputs=512, kernel_size=2, stride=1, scope="conv_10")
    tf.summary.histogram("conv_10", net)
    net = slim.conv1d(net, num_outputs=512, kernel_size=2, stride=1, scope="conv_11")
    tf.summary.histogram("conv_11", net)
    def_max_pool = tf.layers.MaxPooling1D(pool_size=2, strides=2, padding="VALID", name="max_pool_12")
    net = def_max_pool(net)
    # net = slim.nn.max_pool1d(net, ksize=1, strides=1, padding="VALID", name="max_pool_12")
    tf.summary.histogram("max_pool_12", net)
    net = tf.reduce_mean(net, axis=1, name="global_max_pool_13")   # 起全局平均池化的作用
    tf.summary.histogram("global_max_pool_13", net)
    net = slim.dropout(net, keep_prob=0.5, scope="dropout")
    tf.summary.histogram("dropout", net)
    digits = slim.fully_connected(net, num_outputs=num_class, activation_fn=tf.nn.softmax, scope="fully_connected_14")
    tf.summary.histogram("fully_connected_14", digits)
return digits

3. fit():

　　看名字就知道這一部分需要完成的是訓練部分的代碼。

　　這一部分需要包含會話的啟動、模型保存器的初始化、循環迭代、batch設置、數據集輸入、輸出數據獲取、喂到網絡中、保存模型、會話關閉等操作。如下述代碼

sess = tf.Session()  # 啟動會話

merge_summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(self.logdir, sess.graph)

saver = tf.train.Saver(max_to_keep=1)  # 生成保存器
sess.run(tf.global_variables_initializer())   # 變量激活

for step in range(self.epoch):    # 迭代
    print("Epoch:%d"%step)
    avg_cost = 0
    acc = 0
    total_batch = int(input_x.shape[0]/self.batch_size)   # 划分batch
    for batch_num in range(total_batch):   # batch迭代
        # 獲取數據
        batch_xs = input_x[batch_num*self.batch_size:(batch_num+1)*self.batch_size, :]
        batch_ys = input_y[batch_num*self.batch_size:(batch_num+1)*self.batch_size, :]
        batch_ys = sess.run(tf.one_hot(batch_ys, depth=10))
        # 喂到損失 優化器等等
        _, loss, acc = sess.run([self.optimizer, self.loss, self.train_accuracy],
                                                        feed_dict={self.input_image: batch_xs,
                                                         self.input_image_label: batch_ys})
        avg_cost += loss / total_batch
        acc += acc /total_batch

        summary_str = sess.run(merge_summary_op, feed_dict={self.input_image: batch_xs,
                                                            self.input_image_label: batch_ys})
        summary_writer.add_summary(summary_str, global_step=step)
        print("Epoch:%d, batch: %d, avg_cost: %g, accuracy: %g" % (step, batch_num, avg_cost, acc))
    # 保存模型
    saver.save(sess, self.checkpoint_dir, global_step=step)
sess.close()   # 會話關閉

4. predict():

　　從函數名可以知道這一部分是實現預測部分的代碼。其相對於訓練的過程要更簡單。主要包括會話的啟動、保存器的生成、權重的導入（模型的恢復）、預測、關閉會話。如下述代碼

sess = tf.Session()   # 會話的啟動

saver = tf.train.Saver()  # 保存器的生成

module_file = tf.train.latest_checkpoint(self.checkpoint_dir_load)
saver.restore(sess, module_file)    # 模型的恢復

input_y = sess.run(tf.one_hot(input_y, depth=10))  # 獲取輸出
# 獲取預測結果和預測精度
predicts, acc_test = sess.run([self.predicts, self.accuracy], feed_dict={self.input_image: input_x,
# 關閉會話                                                                            self.input_image_label: input_y})
sess.close()
# print("test_accuracy: %f" %acc_test)
return predicts, acc_test

　　上述四步完成后，便可以編寫一個main函數來調用這個類，實現需要的功能。.fit()和.predict()主要是在main()函數來調用。