2018/12/29

TensorFlow Neural Network (神經網路)

21 TensorFlow Neural Network (神經網路)

神經網路是組成深度學習的主要架構,此網路主要的演算法是利用Backpropagation (後向傳播)不斷地調整權重係數,以達成回歸或分類的功能。我們已在09 Artificial Neural Networks單元詳細討論如何利用誤失函數、作動函數對每一權重的偏分並利用後向傳播來求調整權重係數。在tf中,我們並不需考慮如此繁瑣的工作,我們只要設定誤失函數、作動函數及佳化器等係統模型參數,tf 會自動完成權重係數的調整。

在 tf 裡一般我們是利用數學模型的宣告來完成神經元的功能,一般是用矩陣相乘求輸入端各特徵和權重係數結合的結果,並把所求的量交由作動函數求輸出,而上一級的輸出再交由下一級的輸入來實現深度學習的神經網路。

🔶 模擬一個Neuron 的運作
假設要用 Neuron 模擬一個Neuron 的運算功能,求$f(x)=ax+b$,當輸入一個$x$值我們想得到一個特定的$f(x)$值,而$a$ 和 $b$是可調整的係數,若有很多不同的$x$值輸入,而每一個$x$分別對應一個$f(x)$,這便是使用一個神經元來達成回歸的功能。建立TF neuro 的步驟
    • 宣告Variables (weights)
    • 宣告placeholder (放輸入值)
    • 設定model
    • 定義 loss,常用的 miminize square或 cross entropy
    • 定義佳化器及learning rate
    • 定義train的對向為佳化器的實例minimize方法,並以 loss 為參數
    • 啟始變數,代入數值執行train session
    • 得結果並輸出
    假設上例中我們只輸入一個$x$,要求tf 調整參數a,b使得$f(x)$趨近於50,以下是建立neuro並執行學習的例子
    import tensorflow as tf
    sess = tf.Session()
    a = tf.Variable(tf.constant(0.5))
    b = tf.Variable(tf.constant(0.5))
    x_val = 5.
    x_data = tf.placeholder(dtype=tf.float32)
    two_gate = tf.add(tf.multiply(a, x_data), b)
    loss = tf.square(tf.subtract(two_gate, 50.))
    init = tf.global_variables_initializer()
    sess.run(init)
    my_opt = tf.train.GradientDescentOptimizer(0.01)
    train_step = my_opt.minimize(loss)
    print('\nOptimizing Two Gate Output to 50.')
    for i in range(10):
        sess.run(train_step, feed_dict={x_data: x_val})
        a_val, b_val = (sess.run(a), sess.run(b))
        two_gate_output = sess.run(two_gate, feed_dict={x_data: x_val})
        print(str(a_val) + ' * ' + str(x_val) + ' + ' + 
              str(b_val) + ' = ' + str(two_gate_output))
    
    Optimizing T wo Gate Output to 50.
    5.2 * 5.0 + 1.44 = 27.44
    7.4559994 * 5.0 + 1.8912001 = 39.1712
    8.538879 * 5.0 + 2.1077762 = 44.802174
    9.058662 * 5.0 + 2.2117326 = 47.505043
    9.308158 * 5.0 + 2.2616317 = 48.80242
    9.427916 * 5.0 + 2.2855833 = 49.425163
    9.485399 * 5.0 + 2.29708 = 49.724075
    9.512992 * 5.0 + 2.3025985 = 49.867558
    9.526237 * 5.0 + 2.3052473 = 49.93643
    9.532594 * 5.0 + 2.3065186 = 49.969486
    可見程式中迭代了10次輸出就很接近0了。第3,4行宣告Variables (weights),第6行宣告placeholder (放輸入值), 第7行設定model, 第8行定義 loss, 第11行定義佳化器及learning rate, 第12行定義train的對向, 第13行迴圈代入數值執行train session。

    🔶 Neuron 與作動函數 (activation functions)
    我們之前已討論過sigmoid function,這是個很常用的activate function,另外有一個叫Relu (Rectified linear unit),定義成 $\max (0,x)$ 也很常用,下列程式使用 tf 內建的函數畫出這兩個函數圖形
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    sess = tf.InteractiveSession()
    %matplotlib inline
    x_value = np.linspace(-5., 5., 101)
    y_value1 = tf.sigmoid(x_value)
    y_value2 = tf.nn.relu(x_value)
    y1 = y_value1.eval()
    y2 = y_value2.eval()
    plt.plot(x_value, y1, 'r',label='Sigmoid')
    plt.plot(x_value, y2, 'b',label='Relu')
    plt.ylabel('y values',size=12)
    plt.xlabel('x value',size=12)
    plt.legend(loc='upper left')
    plt.grid()
    sess.close()
    sigmoid and relu
    後續我們來看這兩個函數當成Neuro 的作動函數的情形。先前的例子是固定一個$x$,經10次調整係數使得輸出逼近50。接下來的例子是利用不同的$x$ ,讓$f(x_i)=ax_i+b$逼近0.75,其中的$x_i$是隨機產生的值。
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    tf.reset_default_graph()
    sess = tf.Session()
    tf.set_random_seed(5)
    np.random.seed(42)
    batch_size = 50
    a1 = tf.Variable(tf.random_normal(shape=[1, 1]))
    b1 = tf.Variable(tf.random_uniform(shape=[1, 1]))
    a2 = tf.Variable(tf.random_normal(shape=[1, 1]))
    b2 = tf.Variable(tf.random_uniform(shape=[1, 1]))
    x = np.random.normal(2, 0.1, 500)
    x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
    sigmoid_activation = tf.sigmoid(tf.add(tf.matmul(x_data, a1), b1))
    relu_activation = tf.nn.relu(tf.add(tf.matmul(x_data, a2), b2))
    loss1 = tf.reduce_mean(tf.square(tf.subtract(sigmoid_activation, 0.75)))
    loss2 = tf.reduce_mean(tf.square(tf.subtract(relu_activation, 0.75)))
    init = tf.global_variables_initializer()
    sess.run(init)
    my_opt = tf.train.GradientDescentOptimizer(0.01)
    train_step_sigmoid = my_opt.minimize(loss1)
    train_step_relu = my_opt.minimize(loss2)
    loss_vec_sigmoid = []
    loss_vec_relu = []
    for i in range(500):
        rand_indices = np.random.choice(len(x), size=batch_size)
        x_vals = np.transpose([x[rand_indices]])
        sess.run(train_step_sigmoid, feed_dict={x_data: x_vals})
        sess.run(train_step_relu, feed_dict={x_data: x_vals})
        loss_vec_sigmoid.append(sess.run(loss1, feed_dict={x_data: x_vals}))
        loss_vec_relu.append(sess.run(loss2, feed_dict={x_data: x_vals}))    
        sigmoid_output = np.mean(sess.run(sigmoid_activation, 
                 feed_dict={x_data: x_vals}))
        relu_output = np.mean(sess.run(relu_activation, feed_dict={x_data: x_vals}))    
    plt.plot(loss_vec_sigmoid, 'k-', label='Sigmoid Activation')
    plt.plot(loss_vec_relu, 'r--', label='Relu Activation')
    plt.ylim([0, 1.0])
    plt.title('Loss per Generation')
    plt.xlabel('Generation')
    plt.ylabel('Loss')
    plt.legend(loc='upper right')
    plt.show()
    作動函數比較
    輸出的結果顯示Relu一開始的loss很大,但很快就收斂,Sigmoid 一開始較小,但收斂很慢,因而作動函數對系統的影響甚鉅,必需妥善選用。第9-11行使用tf.matmul(), 參數必需是2維的矩陣,所以若變數必需設成 [1,1],如果使用一維的tensor則不能和2維的tensor相乘,但是允許一維的tensor和2維的tensor相加。第27行 random.choice() 是每次隨機從樣本中耳出batch_size數量的樣本。

    🔶 含隱藏層的神經網路
     一個神經網路如果只有輸入層接至輸出層,那太簡單,功能有限,一般在輸入與輸出間會有很多隱藏層。我們參考文獻裡的例子來探討含隱藏層的神經網路。此例是利用我們曾在單元15 Dimensionality Reduction with PCA 討論過的Iris 鳶尾花資料集,此集含150個樣本實例,每樣本有4個feature 和一個亞種的target。
    import numpy as np
    from sklearn import datasets
    iris = datasets.load_iris()
    print(iris.DESCR)
    
    ..........

    **Data Set Characteristics:**

        :Number of Instances: 150 (50 in each of three classes)
        :Number of Attributes: 4 numeric, predictive attributes and the class
        :Attribute Information:
            - sepal length in cm
            - sepal width in cm
            - petal length in cm
            - petal width in cm
            - class:
                    - Iris-Setosa
                    - Iris-Versicolour
                    - Iris-Virginica
    ..........................
    以sepal (花萼)之長(第 0 行)、寬(1) 和petal(花瓣)之長 (2) 為特徵來預測花瓣之寬(3)。下圖是此神經網路的架構圖
    神經網路的架構圖
    由圖可看出有三個特徵輸入,隱藏層有5個神經元,一輸出單元,每一特徵到每一隱藏層之神經元均有一權重係數相連,另隱藏層有五個偏置係數以及五個權重係數接至輸出層,外加輸出層的一個偏置係數,所以共有26個變數,這變數因是要靠學習調整大小以都必需設成Variable。程式如下
    import matplotlib.pyplot as plt
    import numpy as np
    import tensorflow as tf
    from sklearn import datasets
    tf.reset_default_graph()
    def normalize_cols(m):
        col_max = m.max(axis=0)
        col_min = m.min(axis=0)
        return (m-col_min) / (col_max - col_min)
    iris = datasets.load_iris()
    x_vals = np.array([x[0:3] for x in iris.data])
    y_vals = np.array([x[3] for x in iris.data])
    sess = tf.Session()
    seed = 101
    tf.set_random_seed(seed)
    np.random.seed(seed)  
    train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False)
    test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))
    x_vals_train = x_vals[train_indices]
    x_vals_test = x_vals[test_indices]
    y_vals_train = y_vals[train_indices]
    y_vals_test = y_vals[test_indices]
    x_vals_train = np.nan_to_num(normalize_cols(x_vals_train))
    x_vals_test = np.nan_to_num(normalize_cols(x_vals_test))
    batch_size = 50
    x_data = tf.placeholder(shape=[None, 3], dtype=tf.float32)
    y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
    hidden_layer_nodes = 5
    A1 = tf.Variable(tf.random_normal(shape=[3, hidden_layer_nodes])) 
    b1 = tf.Variable(tf.random_normal(shape=[hidden_layer_nodes])) 
    A2 = tf.Variable(tf.random_normal(shape=[hidden_layer_nodes, 1])) 
    b2 = tf.Variable(tf.random_normal(shape=[1]))   # 1 bias for the output
    hidden_output = tf.nn.relu(tf.add(tf.matmul(x_data, A1), b1))
    final_output = tf.nn.relu(tf.add(tf.matmul(hidden_output, A2), b2))
    loss = tf.reduce_mean(tf.square(y_target - final_output))
    my_opt = tf.train.GradientDescentOptimizer(0.005)
    train_step = my_opt.minimize(loss)
    init = tf.global_variables_initializer()
    sess.run(init)
    loss_vec = []
    test_loss = []
    for i in range(500):
        rand_index = np.random.choice(len(x_vals_train), size=batch_size)
        rand_x = x_vals_train[rand_index]
        rand_y = np.transpose([y_vals_train[rand_index]])
        sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y})
        temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y})
        loss_vec.append(np.sqrt(temp_loss))
        test_temp_loss = sess.run(loss, feed_dict=
                        {x_data: x_vals_test, y_target: np.transpose([y_vals_test])})
        test_loss.append(np.sqrt(test_temp_loss))
    
    plt.plot(loss_vec, 'k-', label='Train Loss')
    plt.plot(test_loss, 'r--', label='Test Loss')
    plt.title('Loss (MSE) per Generation')
    plt.legend(loc='upper right')
    plt.xlabel('Generation')
    plt.ylabel('Loss')
    plt.show())
    輸出
    可見test 的loss 比train的loss 大很多,可能原因是本例中的訓練集及測試集的樣本都不是很多,資料本身的數值偏差會造成無法預測的很準,相當於是一個overfitted的情形。程式第6行的 normalize_cols() 定義正規化依特徵的變化範圍調整數值大小,第11,12行分別取出特徵及target,第17,18行隨機取出訓練集及測試集,第23,24行執行正規化。

     參考文獻
    Nick McClure, TensorFlow Machine Learning Cookbook, Packt Publishing, 2017

    沒有留言:

    張貼留言