這篇結合一個三層神經網路完成多分類的例子來講解tensorflow

建立圖

首先建立神經網路中需要多次傳入值的，X和Y，建立placeholder，由於不能確切知道一次minibatch傳入的樣本數多少，於是在矩陣大小定義時，第二維度為None。

def create_placeholders(n_x, n_y):
    X = tf.placeholder(tf.float32, [n_x, None])
    Y = tf.placeholder(tf.float32, [n_y, None])   
    return X, Y

初始化我們的引數

在上一篇中，我們是使用tf.Variable()來進行初始化的，而這裡我們運用到的是tf.get_variable()。get_variable()建立的我們叫做共享變數，即這一套變數是不能被重複定義的，重複定義就會報錯，除非在VarScope中進行reuse，而Variable()，就可以進行重複定義，系統會自動處理衝突。
這裡我們用到了一個高階初始化API tf.contrib.layers.xavier_initializer()

def initialize_parameters(): 
    tf.set_random_seed(1) 

    W1 = tf.get_variable('W1', [25,12288], initializer = tf.contrib.layers.xavier_initializer(seed = 1
 
))
    b1 = tf.get_variable('b1', [25,1], initializer = tf.zeros_initializer())
    W2 = tf.get_variable('W2', [12,25], initializer = tf.contrib.layers.xavier_initializer(seed = 1))
    b2 = tf.get_variable('b2', [12,1], initializer = tf.zeros_initializer())
    W3 = tf.get_variable('W3', [6,12], initializer = tf.contrib.layers.xavier_initializer(seed = 1
 
))
    b3 = tf.get_variable('b3', [6,1], initializer = tf.zeros_initializer())

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2,
                  "W3": W3,
                  "b3": b3}

    return parameters

定義前向傳播函式

tf.matmul() 等同於 np.dot()
Relu啟用函式，tf.nn.relu()

def forward_propagation(X, parameters):

    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']
    W3 = parameters['W3']
    b3 = parameters['b3']

    Z1 = tf.matmul(W1, X) + b1                                              
    A1 = tf.nn.relu(Z1)                                              
    Z2 = tf.matmul(W2, A1) + b2                                              
    A2 = tf.nn.relu(Z2)                                             
    Z3 = tf.matmul(W3, A2) + b3                                              

    return Z3

定義損失函式

由於是分類問題，我們使用交叉熵，API是
tf.nn.softmax_cross_entropy_with_logits()
https://www.tensorflow.org/api_docs/python/tf/nn/softmax_cross_entropy_with_logits
，然後求取平均值API為
tf.reduce_mean()
https://www.tensorflow.org/api_docs/python/tf/reduce_mean

def compute_cost(Z3, Y):    

    logits = tf.transpose(Z3)
    labels = tf.transpose(Y)

    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = logits, labels = labels))

    return cost

建立，初始化Session，執行Graph

Adam優化演算法API
tf.train.AdamOptimizer()
https://www.tensorflow.org/api_docs/python/tf/train/AdamOptimizer
而minimize() 是所有優化演算法類裡定義的函式，用來最小化cost。

初始化所有全域性變數API
tf.global_variables_initializer()
https://www.tensorflow.org/versions/r1.0/api_docs/python/tf/global_variables_initializer

element-wise判斷是否相同
tf.equal()
https://www.tensorflow.org/api_docs/python/tf/equal

得到最大值的下標，預設按列取。
tf.argmax()
https://www.tensorflow.org/api_docs/python/tf/argmax

資料型別轉換
tf.cast()
https://www.tensorflow.org/api_docs/python/tf/cast

def model(X_train, Y_train, X_test, Y_test, learning_rate = 0.0001,
          num_epochs = 1500, minibatch_size = 32, print_cost = True):


    tf.reset_default_graph()
    tf.set_random_seed(1) 
    seed = 3 
    (n_x, m) = X_train.shape 
    n_y = Y_train.shape[0] 
    costs = [] 

    X, Y = create_placeholders(n_x, 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:       
        # Run the initialization
        sess.run(init)
        # Do the training loop
        for epoch in range(num_epochs):

            epoch_cost = 0. 
            num_minibatches = int(m / minibatch_size) 
            seed = seed + 1
            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)

            for minibatch in minibatches:

                (minibatch_X, minibatch_Y) = minibatch

                _ , minibatch_cost = sess.run([optimizer, cost], feed_dict = {X: minibatch_X, Y: minibatch_Y})


                epoch_cost += minibatch_cost / num_minibatches

            # Print the cost every epoch
            if print_cost == True and epoch % 100 == 0:
                print ("Cost after epoch %i: %f" % (epoch, epoch_cost))
            if print_cost == True and epoch % 5 == 0:
                costs.append(epoch_cost)

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

        # lets save the parameters in a variable
        parameters = sess.run(parameters)
        print ("Parameters have been trained!")

        # Calculate the correct predictions
        correct_prediction = tf.equal(tf.argmax(Z3), tf.argmax(Y))

        # Calculate accuracy on the test set
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

        print ("Train Accuracy:", accuracy.eval({X: X_train, Y: Y_train}))
        print ("Test Accuracy:", accuracy.eval({X: X_test, Y: Y_test}))

        return parameters

小廣告

淘寶choker、耳飾小店 物理禁止
女程式設計師編碼時和編碼之餘 都需要一些美美的choker、耳飾來裝扮自己
男程式設計師更是需要常備一些來送給自己心儀的人
淘寶小店開店不易 希望有緣人多多支援 (O ^ ~ ^ O)
本號是本人 只是發則小廣告 沒有被盜 會持續更新深度學習相關博文和一些翻譯
感謝大家 不要拉黑我 ⊙﹏⊙|||°