關於TensorFlow實現卷積神經網絡的一些記錄

看了吳恩達的深度學習視頻，跟着課後作業編寫了一個卷積神經網絡用來識別手勢數字

關於卷積神經網絡的概念以及算法就不多贅述了，主要梳理一下變成過程中的主要思路

0x01 要編寫的神經網絡的結構

X -> conv2d(卷積一次) ->Relu(非線性函數) ->Max_pool(最大池化) -> conv2d -> Relu -> Max_pool -> 一維化轉換 -> FC(全連接層) -> softmax  -> y_hat

從輸入x到最終輸出y_hat， 中間使用兩次卷積、Relu以及最大池化，經過一維轉換後進行全連接，因爲是多分類，最終使用softmax輸出

0x02 TensorFlow編程實現

TensorFlow主要涉及到了幾個步驟：

1. 讀取數據集，並做相關預處理

2. 創建佔位符，用於存儲處理好的數據集

3. 根據網絡結構實現向前傳播，計算代價

4. 向後傳播最小化代價

5. 創建神經網絡模型

6. 多次迭代，計算訓練集以及測試集精確度

0x03 創建神經網絡模型步驟

創建的神經網絡模型主要分爲以下幾個步驟：
1. 初始化所有要用到的參數，包括學習率（learning_rate）、迭代次數（epoch_num）、每次迭代代價（costs）、分塊大小（minibatch_size）、隨機種子（seed）、分塊數量(minibatch_num)、圖片大小(m,n_H0,n_W0, n_C0), 匹配數量(n_y) 具體代碼如下：

def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, 
          num_epochs=100, minibach_size=64, print_cost=True, isPlot=True):
    ops.reset_default_graph()
    tf.set_random_seed(1)
    seed = 3
    (m, n_H0, n_W0, n_C0) = X_train.shape
    n_y = Y_train.shape[1]
    costs = []

2.創建網絡結構 ：佔位符 初始化參數 向前傳播 計算代價 向後傳播最小化代價 

X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)

parameters = initialize_parameters()

Z3 = forward_propagation(X, parameters)

cost = compute_cost(Z3, Y)

optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

 3. 創建Session任務

     初始化所有變量 -》實現每次迭代 -》計算總代價 -》畫圖 -》計算精確度

     每次迭代：

     1. 計算minibatch大小，隨機劃分minibatch， 計算minibatch_num

     2. 逐個minibatch計算代價 累加所有的代價

     

with tf.Session() as sess:
    sess.run(init)

    for epoch in range(num_epochs):
        seed = seed + 1
        minibach_cost = 0
        minibach_num = int(m / minibach_size)
        minibaches = cnn_utils.random_mini_batches(X_train, Y_train, minibach_size, seed)

        for minibach in minibaches:
            (minibach_X, minibach_Y) = minibach

            _, temp_cost = sess.run([optimizer, cost], feed_dict={X: minibach_X, Y: minibach_Y})

            minibach_cost += temp_cost / minibach_num

        if print_cost:
            if epoch % 5 == 0:
                print("當前是第 " + str(epoch) + " 代，成本值爲：" + str(minibach_cost))

        if epoch % 1 == 0:
            costs.append(minibach_cost)

    if isPlot:
        plt.plot(np.squeeze(costs))
        plt.ylabel('cost')
        plt.xlabel('iterations (per tens)')
        plt.title("Learning rate =" + str(learning_rate))
        plt.show()

    predict_op = tf.arg_max(Z3, 1)
    correct_prediction = tf.equal(predict_op, tf.arg_max(Y, 1))

    accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
    print('current predict_accuracy =' + str(accuracy))

    train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
    test_accuary = accuracy.eval({X: X_test, Y: Y_test})

    print("訓練集準確度：" + str(train_accuracy))
    print("測試集準確度：" + str(test_accuary))

0x04 結果以及源代碼

150次迭代結果如下：

總代價下降過程如下：

源代碼如下

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.python.framework import ops
import tf_utils

import cnn_utils


def create_placeholders(n_H0, n_W0, n_C0, n_y):
    X = tf.placeholder(tf.float32, [None, n_H0, n_W0, n_C0])
    Y = tf.placeholder(tf.float32, [None, n_y])

    return X, Y


def initialize_parameters():
    tf.set_random_seed(1)

    W1 = tf.get_variable("W1", [4, 4, 3, 8], initializer=tf.contrib.layers.xavier_initializer(seed=0))
    W2 = tf.get_variable("W2", [2, 2, 8, 16], initializer=tf.contrib.layers.xavier_initializer(seed=0))

    parameters = {"W1": W1,
                  "W2": W2}

    return parameters


def forward_propagation(X, parameters):

    W1 = parameters['W1']
    W2 = parameters['W2']

    Z1 = tf.nn.conv2d(X, W1, strides=[1, 1, 1, 1], padding='SAME')
    A1 = tf.nn.relu(Z1)
    P1 = tf.nn.max_pool(A1, ksize=[1, 8, 8, 1], strides=[1, 8, 8, 1], padding='SAME')

    Z2 = tf.nn.conv2d(P1, W2, strides=[1, 1, 1, 1], padding='SAME')
    A2 = tf.nn.relu(Z2)
    P2 = tf.nn.max_pool(A2, ksize=[1, 4, 4, 1], strides=[1, 4, 4, 1], padding='SAME')

    P = tf.contrib.layers.flatten(P2)

    Z3 = tf.contrib.layers.fully_connected(P, 6, activation_fn=None)

    return Z3


def compute_cost(Z3, Y):
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z3, labels=Y))

    return cost


def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=100, minibach_size=64, print_cost=True, isPlot=True):
    ops.reset_default_graph()
    tf.set_random_seed(1)
    seed = 3
    (m, n_H0, n_W0, n_C0) = X_train.shape
    n_y = Y_train.shape[1]
    costs = []

    X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)

    parameters = initialize_parameters()

    Z3 = forward_propagation(X, parameters)

    cost = compute_cost(Z3, Y)

    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

    init = tf.global_variables_initializer()

    with tf.Session() as sess:
        sess.run(init)

        for epoch in range(num_epochs):
            seed = seed + 1
            minibach_cost = 0
            minibach_num = int(m / minibach_size)
            minibaches = cnn_utils.random_mini_batches(X_train, Y_train, minibach_size, seed)

            for minibach in minibaches:
                (minibach_X, minibach_Y) = minibach

                _, temp_cost = sess.run([optimizer, cost], feed_dict={X: minibach_X, Y: minibach_Y})

                minibach_cost += temp_cost / minibach_num

            if print_cost:
                if epoch % 5 == 0:
                    print("當前是第 " + str(epoch) + " 代，成本值爲：" + str(minibach_cost))

            if epoch % 1 == 0:
                costs.append(minibach_cost)

        if isPlot:
            plt.plot(np.squeeze(costs))
            plt.ylabel('cost')
            plt.xlabel('iterations (per tens)')
            plt.title("Learning rate =" + str(learning_rate))
            plt.show()

        predict_op = tf.arg_max(Z3, 1)
        correct_prediction = tf.equal(predict_op, tf.arg_max(Y, 1))

        accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
        print('current predict_accuracy =' + str(accuracy))

        train_accuracy = accuracy.eval({X: X_train, Y: Y_train})
        test_accuary = accuracy.eval({X: X_test, Y: Y_test})

        print("訓練集準確度：" + str(train_accuracy))
        print("測試集準確度：" + str(test_accuary))

        return train_accuracy, test_accuary, parameters


def main():
    X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = tf_utils.load_dataset()
    X_train = X_train_orig / 255.
    X_test = X_test_orig / 255.
    Y_train = cnn_utils.convert_to_one_hot(Y_train_orig, 6).T
    Y_test = cnn_utils.convert_to_one_hot(Y_test_orig, 6).T
    # X, Y = create_placeholders(64, 64, 3, 6)
    # print(str(X), str(Y))
    _, _, parameters = model(X_train, Y_train, X_test, Y_test, num_epochs=150)

    '''
    tf.reset_default_graph()
    np.random.seed(1)

    with tf.Session() as sess:
        X, Y = create_placeholders(64, 64, 3, 6)
        parameters = initialize_parameters()
        Z3 = forward_propagation(X, parameters)
        cost = compute_cost(Z3, Y)

        init = tf.global_variables_initializer()
        sess.run(init)

        a = sess.run(cost, {X: np.random.randn(2, 64, 64, 3), Y: np.random.randn(2, 6)})
        print(str(a))
        sess.close()
    '''


if __name__ == '__main__':
    np.random.seed(1)
    main()