行業專家分享：深度學習筆記之Tensorflow入門！

從前面的學習筆記中，筆者和大家一起使用了  numpy  一步一步從感知機開始到兩層網路以及最後實現了深度神經網路的演算法搭建。而後我們又討論了改善深度神經網路的基本方法，包括神經網路的正則化、引數最佳化和調參等問題。這一切工作我們都是基於numpy 完成的，沒有呼叫任何深度學習框架。在學習深度學習的時候，一開始不讓大家直接上手框架可謂良苦用心，旨在讓大家能夠跟筆者一樣，一步一步透過 numpy 搭建神經網路的過程就是要讓你能夠更加深入的理解神經網路的架構、基本原理和工作機制，而不是黑箱以視之。

但學習到這個階段，你已充分理解了神經網路的工作機制，馬上就要接觸更深層次的卷積神經網路（CNN）和遞迴神經網路（RNN)，依靠純手工去搭建這些複雜的神經網路恐怕並不現實。這時候就該深度學習框架出場了。針對深度學習，目前有很多優秀的學習框架，比如說筆者馬上要講的 Tensorflow，微軟的 CNTK，伯克利視覺中心開發的 caffe，以及別具一格的 PyTorch 和友好易用的 keras，本系列深度學習筆記打算從 Tensorflow 開始，對三大主流易用的深度學習框架 Tensorflow、PyTorch 和 keras 進行學習和講解。選擇這三個框架的原因在於其簡單易用、方便程式設計和執行速度相對較快。

作為谷歌的深度學習框架， Tensorflow  在深度學習領域可謂風頭無二。其中 Tensor 可以理解為類似於 numpy 的 N 維陣列，名為張量； flow 則意味著 N 維陣列的流計算，而 Tensor 的資料流計算形式則為一個計算圖的形式進行計算。這裡重點提一下，如果大學本科期間的線性代數忘記了的話，我勸你趕緊回去翻一翻，線性代數和矩陣論是深度學習的基礎，希望你能熟練掌握。

先看個簡單的例子。

import tensorflow as tf# Define y_hat constant. Set to 36.y_hat = tf.constant(36, name='y_hat') 
# Define y. Set to 39           y = tf.constant(39, name='y')                    # Create a variable for the lossloss = tf.Variable((y - y_hat)**2, name='loss')   # When init is run later (session.run(init)), the loss variable will be initialized and ready to be computedinit = tf.global_variables_initializer()        # Create a session and print the outputwith tf.Session() as session:  
    # Initializes the variables                  
    session.run(init)  
    # Prints the loss                         
    print(session.run(loss))

9

在上述程式碼中，我們首先定義了兩個常量，然後定義了一個 loss Tensor（變數），之後對變數進行初始化，建立計算會話，最後執行會話計算並列印結果。所以我們可以看到執行 Tensorflow 的基本機制：
建立一些尚未被執行的張量——定義這些張量之間的運算操作——初始化這些張量——建立會話——執行會話

需要注意的一點是，建立會話後一定要執行這個會話，且看下面示例：

a = tf.constant(2)
b = tf.constant(10)
c = tf.multiply(a,b)
print(c)

Tensor("Mul:0", shape=(), dtype=int32)

在上面的示例中，我們建立了兩個 Tensor 和 Tensor 之間的乘積運算，但直接列印的結果卻不是我們想要看到的 20. 原因則在於這裡我們沒有建立會話並執行，只是列印了兩個張量運算之後的張量。建立會話並執行操作如下：

sess = tf.Session()
print(sess.run(c))

20

除了直接定義變數之外，我們還可以透過建立佔位符變數來稍後為之賦值，然後在執行會話中傳入一個 feed_dict ，示例如下：

x = tf.placeholder(tf.int64, name = 'x')
print(sess.run(2 * x, feed_dict = {x: 3}))
sess.close()

6

相信你已經大致明白了基於張量運算的 Tensorflow 的底層執行機制了。總結而言就是：建立張量、初始化張量、建立會話並執行。

下面展示幾個 Tensorflow 的神經網路計算的基礎函式示例。

線性函式

def linear_function():    
    """
    Implements a linear function: 
            Initializes W to be a random tensor of shape (4,3)
            Initializes X to be a random tensor of shape (3,1)
            Initializes b to be a random tensor of shape (4,1)
    Returns: 
    result -- runs the session for Y = WX + b 
    """
    np.random.seed(1)
    X = tf.constant(np.random.randn(3,1), name='X')
    W = tf.constant(np.random.randn(4,3), name='W')
    b = tf.constant(np.random.randn(4,1), name='b')
    Y = tf.add(tf.matmul(W, X), b)    # Create the session using tf.Session() and run it with sess.run(...) on the variable you want to calculate
    init = tf.global_variables_initializer() 
    sess = tf.Session()
    sess.run(init)
    result = sess.run(Y)    # close the session 
    sess.close()    
    return result

計算sigmoid函式

def sigmoid(z):    
    """
    Computes the sigmoid of z
    Arguments:
    z -- input value, scalar or vector
    Returns: 
    results -- the sigmoid of z
    """
    x = tf.placeholder(tf.float32, name='x')
    sigmoid = tf.sigmoid(x)    
    with tf.Session() as sess:
        result = sess.run(sigmoid, feed_dict={x: z})    
    return result

計算損失函式

def cost(logits, labels):    
    """
    Computes the cost using the sigmoid cross entropy
    Arguments:
    logits -- vector containing z, output of the last linear unit (before the final sigmoid activation)
    labels -- vector of labels y (1 or 0) 
    Note: What we've been calling "z" and "y" in this class are respectively called "logits" and "labels" 
    in the TensorFlow documentation. So logits will feed into z, and labels into y. 
    Returns:
    cost -- runs the session of the cost (formula (2))
    """
    # Create the placeholders for "logits" (z) and "labels" (y) (approx. 2 lines)
    z = tf.placeholder(tf.float32, name='z')
    y = tf.placeholder(tf.float32, name='y')    # Use the loss function (approx. 1 line)
    cost = tf.nn.sigmoid_cross_entropy_with_logits(logits=z, labels=y)    # Create a session (approx. 1 line). See method 1 above.
    sess = tf.Session()    # Run the session (approx. 1 line).
    sess.run(cost, feed_dict={z: logits, y: labels})    # Close the session (approx. 1 line). See method 1 above.
    sess.close()    
    return cost

one hot 編碼

def one_hot_matrix(labels, C):   
    """
    Creates a matrix where the i-th row corresponds to the ith class number and the jth column
                     corresponds to the jth training example. So if example j had a label i. Then entry (i,j) 
                     will be 1. 
    Arguments:
    labels -- vector containing the labels 
    C -- number of classes, the depth of the one hot dimension
    Returns: 
    one_hot -- one hot matrix
    """
    # Create a tf.constant equal to C (depth), name it 'C'. (approx. 1 line)
    C = tf.constant(C)    # Use tf.one_hot, be careful with the axis (approx. 1 line)
    one_hot_matrix = tf.one_hot(labels, C, axis=0)    # Create the session (approx. 1 line)
    sess = tf.Session()
    one_hot = sess.run(one_hot_matrix)    # Close the session (approx. 1 line). See method 1 above.
    sess.close()    
    return one_hot

引數初始化

def ones(shape):    """
    Creates an array of ones of dimension shape
    Arguments:
    shape -- shape of the array you want to create
    Returns: 
    ones -- array containing only ones
    """
    # Create "ones" tensor using tf.ones(...). (approx. 1 line)
    ones = tf.ones(shape)    # Create the session (approx. 1 line)
    sess = tf.Session()    # Run the session to compute 'ones' (approx. 1 line)
    ones = sess.run(ones)    # Close the session (approx. 1 line). See method 1 above.
    sess.close()    
    return ones

一頓操作之後，我們已經將神經網路的一些基礎運算利用 Tensorflow 定義好了。在下一期筆記中，我們將學習如何使用 Tensorflow 搭建神經網路。

參考資料：

【本文轉載自微信公眾號： 】