2. 程式人生 > >人工智慧實踐：TensorFlow筆記學習（四）—— 神經網路優化

人工智慧實踐：TensorFlow筆記學習（四）—— 神經網路優化

阿新 • • 發佈：2019-01-07

神經網路優化 

大綱

4.1 損失函式

4.2 學習率

4.3 滑動平均

4.4 正則化

4.5 神經網路搭建八股

目標

掌握神經網路優化方法

4.1 損失函式

神經元模型：用數學公式表示為：，f為啟用函式。

神經網路是以神經元為基本單元構成的。

啟用函式：引入非線性啟用因素，提高模型的表達力。

常用的啟用函式有relu、sigmoid、tanh等。

① 啟用函式relu: 在Tensorflow中，用tf.nn.relu()表示

          

            relu()數學表示式                      relu()數學圖形

② 啟用函式sigmoid：在Tensorflow中，用tf.nn.sigmoid()表示

                 

     sigmoid ()數學表示式                     sigmoid()數學圖形

③ 啟用函式tanh：在Tensorflow中，用tf.nn.tanh()表示

                   

       tanh()數學表示式                     tanh()數學圖形

神經網路的複雜度：可用神經網路的層數和神經網路中待優化引數個數表示

神經網路的層數：一般不計入輸入層，層數 = n個隱藏層 + 1個輸出層 

神經網路待優化的引數：神經網路中所有引數w的個數 + 所有引數b的個數

例如：

 

輸入層   隱藏層   輸出層

在該神經網路中，包含1個輸入層、1個隱藏層和1個輸出層，該神經網路的層數為2層。 在該神經網路中，引數的個數是所有引數w的個數加上所有引數b的總數，第一層引數用三行四列的二階張量表示（即12個線上的權重w）再加上4個偏置b；第二層引數是四行兩列的二階張量（即8個線上的權重w）再加上2個偏置b。總引數 = 3*4+4 + 4*2+2 = 26。

損失函式（loss）：用來表示預測值（y）與已知答案（y_）的差距。在訓練神經網路時，通過不斷改變神經網路中所有引數，使損失函式不斷減小，從而訓練出更高準確率的神經網路模型。

常用的損失函式有均方誤差、自定義和交叉熵等。

均方誤差mse：n個樣本的預測值y與已知

答案y_之差的平方和，再求平均值。 


在Tensorflow中用loss_mse = tf.reduce_mean(tf.square(y_ - y))

例如：預測酸奶日銷量 y，x1和 x2 是影響日銷量的兩個因素。應提前採集的資料有：一段時間內，每日的 x1 因素、x2因素和銷量 y_。採集的資料儘量多。在本例中用銷量預測產量，最優的產量應該等於銷量。由於目前沒有資料集，所以擬造了一套資料集。利用 Tensorflow 中函式隨機生成 x1、 x2，製造標準答案y_= x1 + x2，為了更真實，求和後還加了正負 0.05 的隨機噪聲。 我們把這套自制的資料集喂入神經網路，構建一個一層的神經網路，擬合預測酸奶日銷量的函式。

示例程式碼：

#coding:utf-8
#預測多或預測少的影響一樣
#0匯入模組，生成資料集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455

rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)
Y_ = [[x1+x2+(rdm.rand()/10.0-0.05)] for (x1, x2) in X]

#1定義神經網路的輸入、引數和輸出，定義前向傳播過程。
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
w1= tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)

#2定義損失函式及反向傳播方法。
#定義損失函式為MSE,反向傳播方法為梯度下降。
loss_mse = tf.reduce_mean(tf.square(y_ - y))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
#train_step = tf.train.MomentumOptimizer(0.001,0.9).minimize(loss_mse)  
#train_step = tf.train.AdamOptimizer(0.001).minimize(loss_mse)

#3生成會話，訓練STEPS輪
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 20000
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32
        end = (i*BATCH_SIZE) % 32 + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y_[start:end]})
        if i % 500 == 0:
            print "After %d training steps, w1 is: " % (i)
            print sess.run(w1), "\n"
    print "Final w1 is: \n", sess.run(w1)
#在本程式碼#2中嘗試其他反向傳播方法，看對收斂速度的影響

執行結果如下：

由上述程式碼可知，本例中神經網路預測模型為y = w1*x1 +w2*x2，損失函式採用均方誤差。通過使損失函式值（loss）不斷降低，神經網路模型得到最終引數w1=0.98，w2=1.02，銷量預測結果為y =0.98*x1 +1.02*x2。由於在生成資料集時，標準答案為y = x1+ x2，因此，銷量預測結果和標準答案已非常接近，說明該神經網路預測酸奶日銷量正確。

自定義損失函式：根據問題的實際情況，定製合理的損失函式。

例如：

對於預測酸奶日銷量問題，如果預測銷量大於實際銷量則會損失成本；如果預測銷量小於實際銷量則會損失利潤。在實際生活中，往往製造一盒酸奶的成本和銷售一盒酸奶的利潤是不等價的。因此，需要使用符合該問題的自定義損失函式。

自定義損失函式為：

其中，損失定義成分段函式：

損失函式表示，若預測結果 y 小於標準答案 y_，損失函式為利潤乘以預測結果y 與標準答案 y_之差；若預測結果 y大於標準答案 y_，損失函式為成本乘以預測結果 y 與標準答案 y_之差。

用 Tensorflow 函式表示為：

loss =tf.reduce_sum(tf.where(tf.greater(y,y_),COST(y-y_),PROFIT(y_-y))) 

① 若酸奶成本為1元，酸奶銷售利潤為9元，則製造成本小於酸奶利潤，因此希望預測的結果y多一些。採用上述的自定義損失函式，訓練神經網路模型。

示例程式碼：

#coding:utf-8
#酸奶成本1元， 酸奶利潤9元
#預測少了損失大，故不要預測少，故生成的模型會多預測一些
#0匯入模組，生成資料集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455
COST = 1
PROFIT = 9

rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)
Y = [[x1+x2+(rdm.rand()/10.0-0.05)] for (x1, x2) in X]

#1定義神經網路的輸入、引數和輸出，定義前向傳播過程。
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
w1= tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)

#2定義損失函式及反向傳播方法。
# 定義損失函式使得預測少了的損失大，於是模型應該偏向多的方向預測。
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_)*COST, (y_ - y)*PROFIT))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)

#3生成會話，訓練STEPS輪。
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 3000
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32
        end = (i*BATCH_SIZE) % 32 + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})
        if i % 500 == 0:
            print "After %d training steps, w1 is: " % (i)
            print sess.run(w1), "\n"
    print "Final w1 is: \n", sess.run(w1)

執行結果如下：


由程式碼執行結果可知，神經網路最終引數為 w1=1.03， w2=1.05，銷量預測結果為 y =1.03*x1 + 1.05*x2。由此可見，採用自定義損失函式預測的結果大於採用均方誤差預測的結果，更符合實際需求。

②若酸奶成本為 9元，酸奶銷售利潤為 1 元，則製造成本大於酸奶利潤，因此希望預測結果 y 小一些。採用上述的自定義損失函式，訓練神經網路模型。

 示例程式碼：

#coding:utf-8
#酸奶成本9元， 酸奶利潤1元
#預測多了損失大，故不要預測多，故生成的模型會少預測一些
#0匯入模組，生成資料集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455
COST = 9
PROFIT = 1

rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)
Y = [[x1+x2+(rdm.rand()/10.0-0.05)] for (x1, x2) in X]

#1定義神經網路的輸入、引數和輸出，定義前向傳播過程。
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
w1= tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)

#2定義損失函式及反向傳播方法。
#重新定義損失函式，使得預測多了的損失大，於是模型應該偏向少的方向預測。
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_)*COST, (y_ - y)*PROFIT))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)

#3生成會話，訓練STEPS輪。
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 3000
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32
        end = (i*BATCH_SIZE) % 32 + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})
        if i % 500 == 0:
            print "After %d training steps, w1 is: " % (i)
            print sess.run(w1), "\n"
    print "Final w1 is: \n", sess.run(w1)

執行結果如下：


由執行結果可知，神經網路最終引數為w1=0.96，w2=0.97，銷量預測結果為y =0.96*x1 + 0.97*x2。因此，採用自定義損失函式預測的結果小於採用均方誤差預測的結果，更符合實際需求。

交叉熵(Cross Entropy)：表示兩個概率分佈之間的距離。交叉熵越大，兩個概率分佈距離越遠，兩個概率分佈越相異；交叉熵越小，兩個概率分佈距離越近，兩個概率分佈越相似。

交叉熵計算公式：

用Tensorflow函式表示為ce= -tf.reduce_mean(y_* tf.log(tf.clip_by_value(y,1e-12, 1.0))) 

例如： 兩個神經網路模型解決二分類問題中，已知標準答案為 y_ = (1, 0)，第一個神經網路模型預測結果為 y1=(0.6,0.4)，第二個神經網路模型預測結果為 y2=(0.8, 0.2)，判斷哪個神經網路模型預測的結果更接近標準答案。根據交叉熵的計算公式得：

H1((1,0),(0.6,0.4)) = -(1*log0.6 + 0*log0.4) ≈ -(-0.222 + 0) = 0.222

H2((1,0),(0.8,0.2)) = -(1*log0.8 + 0*log0.2) ≈ -(-0.097 + 0) = 0.097

由於 0.222>0.097，所以預測結果 y2 與標準答案 y_更接近，y2預測更準確。

softmax 函式：將 n 分類的 n 個輸出（y1,y2…yn）變為滿足以下概率分佈要求的函式。

 

softmax函式表示為： 

softmax 函式應用：在 n 分類中，模型會有 n 個輸出，即 y1,y2…yn，其中yi 表示第 i 種情況出現的可能性大小。將 n 個輸出經過 softmax 函式，可得到符合概率分佈的分類結果。

在 Tensorflow 中，一般讓模型的輸出經過 sofemax 函式，以獲得輸出分類的概率分佈，再與標準答案對比，求出交叉熵，得到損失函式，用如下函式實現：

ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_,1)) 
cem = tf.reduce_mean(ce)

4.2 學習率

學習率 learning_rate：表示了每次引數更新的幅度大小。學習率過大，會導致待優化的引數在最

小值附近波動，不收斂；學習率過小，會導致待優化的引數收斂緩慢。 在訓練過程中，引數的更新向著損失函式梯度下降的方向。引數的更新公式為：


假設損失函式為loss = (w + 1)2。梯度是損失函式loss的導數為 ∇=2w+2。如引數初值為5，學習率為0.2，則引數和損失函式更新如下： 

1次       引數w：5           5 - 0.2 * (2 * 5 +2) = 2.6

2次       引數w：2.6        2.6 - 0.2 * (2 *2.6 + 2) = 1.16

3次       引數w：1.16      1.16 – 0.2 * (2 *1.16 + 2) = 0.296

4次       引數w：0.296    損失函式loss = (w + 1)2的影象為：

 

由圖可知，損失函式loss的最小值會在(-1,0)處得到，此時損失函式的導數為0,得到最終引數w =-1。

示例程式碼： 

#coding:utf-8
#設損失函式 loss=(w+1)^2, 令w初值是常數5。反向傳播就是求最優w，即求最小loss對應的w值
import tensorflow as tf
#定義待優化引數w初值賦5
w = tf.Variable(tf.constant(5, dtype=tf.float32))
#定義損失函式loss
loss = tf.square(w+1)
#定義反向傳播方法
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
#生成會話，訓練40輪
with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    for i in range(40):
        sess.run(train_step)
        w_val = sess.run(w)
        loss_val = sess.run(loss)
        print "After %s steps: w is %f,   loss is %f." % (i, w_val,loss_val)
執行結果如下：

由結果可知，隨著損失函式值的減小，w無限趨近於-1，模型計算推測出最優引數w = -1。

學習率的設定學習率過大，會導致待優化的引數在最小值附近波動，不收斂；學習率過小，會導致待優化的引數收斂緩慢。

例如：

① 對於上例的損失函式loss= (w + 1)2。則將上述程式碼中學習率修改為 1，其餘內容不變。

實驗結果如下：


由執行結果可知，損失函式 loss 值並沒有收斂，而是在 5 和-7 之間波動。

②對於上例的損失函式loss = (w + 1)2。則將上述程式碼中學習率修改為0.0001，其餘內容不變。 

實驗結果如下：  

由執行結果可知，損失函式 loss 值緩慢下降，w值也在小幅度變化，收斂緩慢。

指數衰減學習率：學習率隨著訓練輪數變化而動態更新學習率計算公式如下：

Learning_rate=LEARNING_RATE_BASE*LEARNING_RATE_DECAY* 

用 Tensorflow 的函式表示為：

global_step = tf.Variable(0,trainable=False) 
learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE, 
global_step, 
LEARNING_RATE_STEP,LEARNING_RATE_DECAY, staircase=True/False)

其中，LEARNING_RATE_BASE為學習率初始值，LEARNING_RATE_DECAY為學習率衰減率,global_step記錄了當前訓練輪數，為不可訓練型引數。學習率 learning_rate更新頻率為輸入資料集總樣本數除以每次喂入樣本數。若staircase設定為True時，表示global_step/learning rate step取整數，學習率階梯型衰減；若staircase設定為false時，學習率會是一條平滑下降的曲線。 例如： 在本例中，模型訓練過程不設定固定的學習率，使用指數衰減學習率進行訓練。其中，學習率初值設置為0.1，學習率衰減率設定為0.99，BATCH_SIZE設定為1。 

示例程式碼：

#coding:utf-8
#設損失函式 loss=(w+1)^2, 令w初值是常數10。反向傳播就是求最優w，即求最小loss對應的w值
#使用指數衰減的學習率，在迭代初期得到較高的下降速度，可以在較小的訓練輪數下取得更有收斂度。
import tensorflow as tf

LEARNING_RATE_BASE = 0.1 #最初學習率
LEARNING_RATE_DECAY = 0.99 #學習率衰減率
LEARNING_RATE_STEP = 1  #喂入多少輪BATCH_SIZE後，更新一次學習率，一般設為：總樣本數/BATCH_SIZE

#運行了幾輪BATCH_SIZE的計數器，初值給0, 設為不被訓練
global_step = tf.Variable(0, trainable=False)
#定義指數下降學習率
learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, LEARNING_RATE_STEP, LEARNING_RATE_DECAY, staircase=True)
#定義待優化引數，初值給10
w = tf.Variable(tf.constant(5, dtype=tf.float32))
#定義損失函式loss
loss = tf.square(w+1)
#定義反向傳播方法
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
#生成會話，訓練40輪
with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    for i in range(40):
        sess.run(train_step)
        learning_rate_val = sess.run(learning_rate)
        global_step_val = sess.run(global_step)
        w_val = sess.run(w)
        loss_val = sess.run(loss)
        print "After %s steps: global_step is %f, w is %f, learning rate is %f, loss is %f" % (i, global_step_val, w_val, learning_rate_val, loss_val)

執行結果如下：

由結果可以看出，隨著訓練輪數增加學習率在不斷減小。

4.3 滑動平均

滑動平均：記錄了一段時間內模型中所有引數w和b各自的平均值。利用滑動平均值可以增強模型的泛化能力。

滑動平均值（影子）計算公式：

影子 = 衰減率 * 影子 +（1 - 衰減率）* 引數

其中，衰減率，影子初值=引數初值

用Tesnsorflow函式表示為：

ema =tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY，global_step) 

其中，MOVING_AVERAGE_DECAY表示滑動平均衰減率，一般會賦接近1的值，global_step表示當前訓練了多少輪。

ema_op =ema.apply(tf.trainable_variables())

其中，ema.apply()函式實現對括號內參數求滑動平均，tf.trainable_variables()函式實現把所有待訓練引數彙總為列表。

with tf.control_dependencies([train_step,ema_op]):
     train_op = tf.no_op(name='train')

其中，該函式實現將滑動平均和訓練過程同步執行。

檢視模型中引數的平均值，可以用ema.average()函式。 例如：

在神經網路模型中，將MOVING_AVERAGE_DECAY設定為0.99，引數w1設定為0，w1的滑動平均值設定為0。

①開始時，輪數global_step設定為0，引數w1更新為1，則w1的滑動平均值為：

w1滑動平均值=min(0.99,1/10)*0+(1–min(0.99,1/10)*1 = 0.9

②當輪數global_step設定為100時，引數w1更新為10，則滑動平均值變為：

w1滑動平均值=min(0.99,101/110)*0.9+(1–min(0.99,101/110)*10 = 0.826+0.818=1.644

③再次執行，引數w1更新為1.644，則滑動平均值變為：

w1滑動平均值=min(0.99,101/110)*1.644+(1–min(0.99,101/110)*10 = 2.328

④再次執行，引數w1更新為2.328，則滑動平均值：

w1滑動平均值=2.956

示例程式碼： 

#coding:utf-8
import tensorflow as tf

#1. 定義變數及滑動平均類
#定義一個32位浮點變數，初始值為0.0  這個程式碼就是不斷更新w1引數，優化w1引數，滑動平均做了個w1的影子
w1 = tf.Variable(0, dtype=tf.float32)
#定義num_updates（NN的迭代輪數）,初始值為0，不可被優化（訓練），這個引數不訓練
global_step = tf.Variable(0, trainable=False)
#例項化滑動平均類，給衰減率為0.99，當前輪數global_step
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
#ema.apply後的括號裡是更新列表，每次執行sess.run（ema_op）時，對更新列表中的元素求滑動平均值。
#在實際應用中會使用tf.trainable_variables()自動將所有待訓練的引數彙總為列表
#ema_op = ema.apply([w1])
ema_op = ema.apply(tf.trainable_variables())

#2. 檢視不同迭代中變數取值的變化。
with tf.Session() as sess:
    # 初始化
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
	#用ema.average(w1)獲取w1滑動平均值 （要執行多個節點，作為列表中的元素列出，寫在sess.run中）
	#打印出當前引數w1和w1滑動平均值
    print "current global_step:", sess.run(global_step)
    print "current w1", sess.run([w1, ema.average(w1)]) 
    
    # 引數w1的值賦為1
    sess.run(tf.assign(w1, 1))
    sess.run(ema_op)
    print "current global_step:", sess.run(global_step)
    print "current w1", sess.run([w1, ema.average(w1)]) 
    
    # 更新global_step和w1的值,模擬出輪數為100時，引數w1變為10, 以下程式碼global_step保持為100，每次執行滑動平均操作，影子值會更新 
    sess.run(tf.assign(global_step, 100))  
    sess.run(tf.assign(w1, 10))
    sess.run(ema_op)
    print "current global_step:", sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])       
    
    # 每次sess.run會更新一次w1的滑動平均值
    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

#更改MOVING_AVERAGE_DECAY 為 0.1  看影子追隨速度

執行結果如下：


從執行結果可知，最初引數w1和滑動平均值都是0；引數w1設定為1後，滑動平均值變為0.9；當迭代輪數更新為100輪時，引數w1更新為10後，滑動平均值變為1.644。隨後每執行一次，引數 w1的滑動平均值都向引數w1靠近。可見，滑動平均追隨引數的變化而變化。 

4.4 正則化

過擬合：神經網路模型在訓練資料集上的準確率較高，在新的資料進行預測或分類時準確率較低，說明模型的泛化能力差。

正則化：在損失函式中給每個引數w加上權重，引入模型複雜度指標，從而抑制模型噪聲，減小過擬合。

使用正則化後，損失函式loss變為兩項之和：

loss = loss(y與y_)+ REGULARIZER*loss(w)

其中，第一項是預測結果與標準答案之間的差距，如之前講過的交叉熵、均方誤差等；第二項是正則化計算結果。

正則化計算方法：

① L1正則化：  

用Tesnsorflow函式表示:loss(w)= tf.contrib.layers.l1_regularizer(REGULARIZER)(w)

② L2正則化：  

用Tesnsorflow函式表示:loss(w)= tf.contrib.layers.l2_regularizer(REGULARIZER)(w)

用Tesnsorflow函式實現正則化：

tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w) loss = cem +tf.add_n(tf.get_collection('losses'))

cem的計算已在4.1節中給出。

例如：

用300個符合正態分佈的點X[x0, x1]作為資料集，根據點X[x0, x1]計算生成標註Y_，將資料集標註為紅色點和藍色點。

標註規則為：當x02 + x12 < 2 時，y_=1，標註為紅色；當x02 + x122 時，y_=0，標註為藍色。

我們分別用無正則化和有正則化兩種方法，擬合曲線，把紅色點和藍色點分開。在實際分類時，如果前向傳播輸出的預測值y接近1則為紅色點概率越大，接近0則為藍色點概率越大，輸出的預測值y為0.5是紅藍點概率分界線。  

在本例子中，我們使用了之前未用過的模組與函式：

matplotlib模組：Python中的視覺化工具模組，實現函式視覺化

終端安裝指令：

sudo apt install python-tk

sudo pip install matplotlib

函式plt.scatter()：利用指定顏色實現點(x,y)的視覺化

plt.scatter (x座標, y座標, c=”顏色”) 

plt.show()

收集規定區域內所有的網格座標點：

xx, yy = np.mgrid[起:止:步長, 起:止:步長] #找到規定區域以步長為解析度的行列網格座標點

grid = np.c_[xx.ravel(), yy.ravel()]  #收集規定區域內所有的網格座標點

plt.contour()函式：告知x、y座標和各點高度，用levels指定高度的點描上顏色

plt.contour (x軸座標值, y軸座標值, 該點的高度,levels=[等高線的高度]) plt.show()

示例程式碼如：

#coding:utf-8
#0匯入模組 ，生成模擬資料集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
BATCH_SIZE = 30 
seed = 2 
#基於seed產生隨機數
rdm = np.random.RandomState(seed)
#隨機數返回300行2列的矩陣，表示300組座標點（x0,x1）作為輸入資料集
X = rdm.randn(300,2)
#從X這個300行2列的矩陣中取出一行,判斷如果兩個座標的平方和小於2，給Y賦值1，其餘賦值0
#作為輸入資料集的標籤（正確答案）
Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
#遍歷Y中的每個元素，1賦值'red'其餘賦值'blue'，這樣視覺化顯示時人可以直觀區分
Y_c = [['red' if y else 'blue'] for y in Y_]
#對資料集X和標籤Y進行shape整理，第一個元素為-1表示，隨第二個引數計算得到，第二個元素表示多少列，把X整理為n行2列，把Y整理為n行1列
X = np.vstack(X).reshape(-1,2)
Y_ = np.vstack(Y_).reshape(-1,1)
print X
print Y_
print Y_c
#用plt.scatter畫出資料集X各行中第0列元素和第1列元素的點即各行的（x0，x1），用各行Y_c對應的值表示顏色（c是color的縮寫） 
plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
plt.show()


#定義神經網路的輸入、引數和輸出，定義前向傳播過程 
def get_weight(shape, regularizer):
	w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
	tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
	return w

def get_bias(shape):  
    b = tf.Variable(tf.constant(0.01, shape=shape)) 
    return b
	
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))

w1 = get_weight([2,11], 0.01)	
b1 = get_bias([11])
y1 = tf.nn.relu(tf.matmul(x, w1)+b1)

w2 = get_weight([11,1], 0.01)
b2 = get_bias([1])
y = tf.matmul(y1, w2)+b2 

#定義損失函式
loss_mse = tf.reduce_mean(tf.square(y-y_))
loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))

#定義反向傳播方法：不含正則化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_mse)

with tf.Session() as sess:
	init_op = tf.global_variables_initializer()
	sess.run(init_op)
	STEPS = 40000
	for i in range(STEPS):
		start = (i*BATCH_SIZE) % 300
		end = start + BATCH_SIZE
		sess.run(train_step, feed_dict={x:X[start:end], y_:Y_[start:end]})
		if i % 2000 == 0:
			loss_mse_v = sess.run(loss_mse, feed_dict={x:X, y_:Y_})
			print("After %d steps, loss is: %f" %(i, loss_mse_v))
    #xx在-3到3之間以步長為0.01，yy在-3到3之間以步長0.01,生成二維網格座標點
	xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
	#將xx , yy拉直，併合併成一個2列的矩陣，得到一個網格座標點的集合
	grid = np.c_[xx.ravel(), yy.ravel()]
	#將網格座標點喂入神經網路 ，probs為輸出
	probs = sess.run(y, feed_dict={x:grid})
	#probs的shape調整成xx的樣子
	probs = probs.reshape(xx.shape)
	print "w1:\n",sess.run(w1)
	print "b1:\n",sess.run(b1)
	print "w2:\n",sess.run(w2)	
	print "b2:\n",sess.run(b2)

plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()


#定義反向傳播方法：包含正則化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_total)

with tf.Session() as sess:
	init_op = tf.global_variables_initializer()
	sess.run(init_op)
	STEPS = 40000
	for i in range(STEPS):
		start = (i*BATCH_SIZE) % 300
		end = start + BATCH_SIZE
		sess.run(train_step, feed_dict={x: X[start:end], y_:Y_[start:end]})
		if i % 2000 == 0:
			loss_v = sess.run(loss_total, feed_dict={x:X,y_:Y_})
			print("After %d steps, loss is: %f" %(i, loss_v))

	xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
	grid = np.c_[xx.ravel(), yy.ravel()]
	probs = sess.run(y, feed_dict={x:grid})
	probs = probs.reshape(xx.shape)
	print "w1:\n",sess.run(w1)
	print "b1:\n",sess.run(b1)
	print "w2:\n",sess.run(w2)
	print "b2:\n",sess.run(b2)

plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
plt.contour(xx, yy, probs, levels=[.5])
plt.show()

執行程式碼，效果如下：

首先，資料集實現視覺化，x02 + x12 < 2的點顯示紅色， x02 + x122 的點顯示藍色，如圖所示：


接著，執行無正則化的訓練過程，把紅色的點和藍色的點分開，生成曲線如下圖所示： 


最後，執行有正則化的訓練過程，把紅色的點和藍色的點分開，生成曲線如下圖所示：

對比無正則化與有正則化模型的訓練結果，可看出有正則化模型的擬合曲線平滑，模型具有更好的泛化能力。

4.5 神經網路搭建八股

前向傳播：由輸入到輸出，搭建完整的網路結構描述前向傳播的過程需要定義三個函式：

def forward(x, regularizer):

w=

b= 

y= 

return y

第一個函式 forward()完成網路結構的設計，從輸入到輸出搭建完整的網路結構，實現前向傳播過程。該函式中，引數x為輸入，regularizer為正則化權重，返回值為預測或分類結果y。 

def get_weight(shape, regularizer):           
w = tf.Variable() 
tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))  
return w

第二個函式get_weight()對引數w設定。該函式中，引數shape表示引數w的形狀，regularizer 表示正則化權重，返回值為引數w。其中，tf.variable()給w賦初值，tf.add_to_collection()表示將引數w正則化損失加到總損失losses中。

defget_bias(shape):       

b =tf.Variable(    )      

return b

第三個函式get_bias()對引數b進行設定。該函式中，引數shape表示引數b的形狀,返回值為引數b。其中，tf.variable()表示給w賦初值。

反向傳播：訓練網路，優化網路引數，提高模型準確性。

def backward(  ):

x= tf.placeholder(    )

y_ = tf.placeholder(    ) 

y =forward.forward(x, REGULARIZER)

global_step = tf.Variable(0,trainable=False)   

loss =   

函式 backward()中，placeholder()實現對資料集x和標準答案y_佔位，forward.forward()實現前向傳播的網路結構，引數global_step表示訓練輪數，設定為不可訓練型引數。在訓練網路模型時，常將正則化、指數衰減學習率和滑動平均這三個方法作為模型優化方法。

在Tensorflow中，正則化表示為：首先，計算預測結果與標準答案的損失值

①MSE：   y 與 y_的差距(loss_mse) =tf.reduce_mean(tf.square(y-y_)) 

②交叉熵：ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_, 1))    

y與 y_的差距(cem) = tf.reduce_mean(ce)    

③自定義：y 與 y_的差距

其次，總損失值為預測結果與標準答案的損失值加上正則化項

loss = y 與 y_的差距 +tf.add_n(tf.get_collection('losses'))     

在Tensorflow中，指數衰減學習率表示為：

learning_rate= tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, 
                            資料集總樣本數 / BATCH_SIZE,
                            LEARNING_RATE_DECAY,staircase=True)
train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)

在Tensorflow中，滑動平均表示為：

ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)  
ema_op =ema.apply(tf.trainable_variables())
with tf.control_dependencies([train_step, ema_op]):          
train_op = tf.no_op(name='train')

其中，滑動平均和指數衰減學習率中的global_step為同一個引數。

用with結構初始化所有引數  

with tf.Session() as sess:        
 init_op =tf.global_variables_initializer()       
    sess.run(init_op)  for i inrange(STEPS):
     sess.run(train_step, feed_dict={x:   , y_:  })            
        if i % 輪數 == 0:
          print

其中，with結構用於初始化所有引數資訊以及實現呼叫訓練過程，並打印出loss值。

判斷python執行檔案是否為主檔案

if __name__=='__main__':

backward()

該部分用來判斷python執行的檔案是否為主檔案。若是主檔案，則執行backword()函式。 例如： 用300個符合正態分佈的點X[x0, x1]作為資料集，根據點X[x0, x1]的不同進行標註Y_，將資料集標註為紅色和藍色。標註規則為：當x02 + x12 < 2 時，y_=1，點X標註為紅色；當x02 + x12 2 時，y_=0，點X標註為藍色。我們加入指數衰減學習率優化效率，加入正則化提高泛化性，並使用模組化設計方法，把紅色點和藍色點分開。

程式碼總共分為三個模組：生成資料集(generateds.py)、前向傳播(forward.py)、反向傳播(backward.py)。 

①生成資料集的模組(generateds.py) 

#coding:utf-8
#0匯入模組 ，生成模擬資料集
import numpy as np
import matplotlib.pyplot as plt
seed = 2 
def generateds():
	#基於seed產生隨機數
	rdm = np.random.RandomState(seed)
	#隨機數返回300行2列的矩陣，表示300組座標點（x0,x1）作為輸入資料集
	X = rdm.randn(300,2)
	#從X這個300行2列的矩陣中取出一行,判斷如果兩個座標的平方和小於2，給Y賦值1，其餘賦值0
	#作為輸入資料集的標籤（正確答案）
	Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
	#遍歷Y中的每個元素，1賦值'red'其餘賦值'blue'，這樣視覺化顯示時人可以直觀區分
	Y_c = [['red' if y else 'blue'] for y in Y_]
	#對資料集X和標籤Y進行形狀整理，第一個元素為-1表示跟隨第二列計算，第二個元素表示多少列，可見X為兩列，Y為1列
	X = np.vstack(X).reshape(-1,2)
	Y_ = np.vstack(Y_).reshape(-1,1)
	return X, Y_, Y_c	
#print X
#print Y_
#print Y_c
#用plt.scatter畫出資料集X各行中第0列元素和第1列元素的點即各行的（x0，x1），用各行Y_c對應的值表示顏色（c是color的縮寫） 
#plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
#plt.show()

②前向傳播模組(forward.py)

#coding:utf-8
#0匯入模組 ，生成模擬資料集
import tensorflow as tf

#定義神經網路的輸入、引數和輸出，定義前向傳播過程 
def get_weight(shape, regularizer):
	w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
	tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
	return w

def get_bias(shape):  
    b = tf.Variable(tf.constant(0.01, shape=shape)) 
    return b
	
def forward(x, regularizer):
	
	w1 = get_weight([2,11], regularizer)	
	b1 = get_bias([11])
	y1 = tf.nn.relu(tf.matmul(x, w1) + b1)

	w2 = get_weight([11,1], regularizer)
	b2 = get_bias([1])
	y = tf.matmul(y1, w2) + b2 
	
	return y

③反向傳播模組(backward.py) 

#coding:utf-8
#0匯入模組 ，生成模擬資料集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import opt4_8_generateds
import opt4_8_forward

STEPS = 40000
BATCH_SIZE = 30 
LEARNING_RATE_BASE = 0.001
LEARNING_RATE_DECAY = 0.999
REGULARIZER = 0.01

def backward():
	x = tf.placeholder(tf.float32, shape=(None, 2))
	y_ = tf.placeholder(tf.float32, shape=(None, 1))

	X, Y_, Y_c = opt4_8_generateds.generateds()

	y = opt4_8_forward.forward(x, REGULARIZER)
	
	global_step = tf.Variable(0,trainable=False)	

	learning_rate = tf.train.exponential_decay(
		LEARNING_RATE_BASE,
		global_step,
		300/BATCH_SIZE,
		LEARNING_RATE_DECAY,
		staircase=True)


	#定義損失函式
	loss_mse = tf.reduce_mean(tf.square(y-y_))
	loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))
	
	#定義反向傳播方法：包含正則化
	train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss_total)

	with tf.Session() as sess:
		init_op = tf.global_variables_initializer()
		sess.run(init_op)
		for i in range(STEPS):
			start = (i*BATCH_SIZE) % 300
			end = start + BATCH_SIZE
			sess.run(train_step, feed_dict={x: X[start:end], y_:Y_[start:end]})
			if i % 2000 == 0:
				loss_v = sess.run(loss_total, feed_dict={x:X,y_:Y_})
				print("After %d steps, loss is: %f" %(i, loss_v))

		xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
		grid = np.c_[xx.ravel(), yy.ravel()]
		probs = sess.run(y, feed_dict={x:grid})
		probs = probs.reshape(xx.shape)
	
	plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
	plt.contour(xx, yy, probs, levels=[.5])
	plt.show()
	
if __name__=='__main__':
	backward()

執行結果如下：


由執行結果可見，程式使用模組化設計方法，加入指數衰減學習率，使用正則化後，紅色點和藍色點的分割曲線相對平滑，效果變好。

致謝

感謝曹老師的辛勤付出，來源曹健，人工智慧實踐：TensorFlow筆記，北京大學

相關推薦

人工智慧實踐：TensorFlow筆記學習（四）—— 神經網路優化

神經網路優化 大綱4.1 損失函式4.2 學習率4.3 滑動平均4.4 正則化4.5 神經網路搭建八股目標掌握神經網路優化方法4.1 損失函式神經元模型：用數學公式表示為：，f為啟用函式。神經網路是以神經元為基本單元構成的。啟用函式：引入非線性啟用因素，提高模型的表達力。常用

人工智慧實踐：TensorFlow筆記學習（七）—— 卷積神經網路基礎

大綱7.1 卷積神經網路7.2  lenet5程式碼講解目標掌握卷積神經網路的搭建方法7.1 卷積神經網路全連線 NN：每個神經元與前後相鄰層的每一個神經元都有連線關係，輸入是特徵，輸出為預測的結果。引數個數：（前層X後層+後層）  一張解析度僅僅是28x28的黑白影象，就有

人工智慧實踐：TensorFlow筆記學習（五）—— 全連線網路基礎

MNIST資料集輸出手寫數字識別準確率大綱5.1 MNIST資料集5.2 模組化搭建神經網路5.3 手寫數字識別準確率輸出目標利用MNIST資料集鞏固模組化搭建神經網路的八股，實踐前向傳播和反向傳播過程，編寫測試程式輸出手寫數字識別準確率。5.1 MNIST資料集MNIST資

人工智慧實踐：Tensorflow筆記（完整版）

  入門課程,比較基礎   第一講 帶著大家梳理人工智慧領域的基本概念：比如什麼是人工智慧、什麼機器學習、什麼是深度學習，他們的發展歷史是什麼，能用他們做什麼。課後，助教會帶領大家安裝Ubuntu系統、Python直譯器 和 Tensorflow環境，把同學們的電腦進行改造

[ MOOC課程學習 ] 人工智慧實踐：Tensorflow筆記_CH7_2 Lenet-5程式碼講解

Lenet-5程式碼講解 Lenet 神經網路是 Yann LeCun 等人在 1998 年提出的,該神經網路充分考慮影象的相關性。 1. Lenet 神經網路結構為: 1.輸入為 32*32*1 的圖片大小,為單通道的輸入; 2.進行卷積,卷積核大

[ MOOC課程學習 ] 人工智慧實踐：Tensorflow筆記_CH6_2 製作資料集

製作資料集 tfrecords 檔案： (1) tfrecords: 是一種二進位制檔案,可先將圖片和標籤製作成該格式的檔案。使用 tfrecords 進行資料讀取,會提高記憶體利用率。 (2) tf.train.Example: 用來儲存訓練資料。訓練

中國大學MOOC-人工智慧實踐：Tensorflow筆記-課程筆記 Chapter5

學習課程時的個人筆記記錄。具體課程情況可以點選連結檢視。（這裡推一波中國大學MOOC，很好的學習平臺，質量高，種類全，想要學習的話很有用的）** 本篇是第五章的學習筆記,第四章的可以點選我閱讀. 前三章的可以點選我閱讀. Chapter 5 全連線網路基礎

人工智慧實踐：Tensorflow筆記(一)

import tensorflow as tf a=tf.constant([1.0,2.0]) b=tf.constant([3.0,4.0]) result=a+b print(result) #Tensor("add:0", shape=(2,), dtype=floa

深度學習筆記（四）——神經網路和深度學習（淺層神經網路）

1.神經網路概覽 神經網路的結構與邏輯迴歸類似，只是神經網路的層數比邏輯迴歸多一層，多出來的中間那層稱為隱藏層或中間層。從計算上來說，神經網路的正向傳播和反向傳播過程只是比邏輯迴歸多了一次重複的計算。正向傳播過程分成兩層，第一層是輸入層到隱藏層，用上標[1]來表示；第二層是隱藏層到輸出層，用上標

機器學習（西瓜書）學習筆記（四）---------神經網路

1. 神經元模型 神經網路/人工神經網路：由具有適應性的簡單單元組成的廣泛並行互連的網路。 神經網路學習：機器學習和神經網路兩個學科交叉的部分。 Neural Networks中的基本單元：神經元。 從電腦科學的角度，NN就是一個包含了大量引數的數學模型，該模型由若干個函式相互代入而

Python教程：進擊機器學習（四）--Matplotlib

介紹 Matplotlib是Python庫中最經常用來繪製圖的，它可以快速的視覺化你的資料，並且匯出不同的格式。用Matplotlib繪製的圖可以達到出版書籍和論文的質量要求。我們開始探索在處理一些常見的資料時應用Matplotlib。 pyplo

羅斯基白話：TensorFlow+實戰系列（四）變數管理

白話TensorFlow +實戰系列（一）變數管理        這篇文章主要記錄常用的兩種管理變數的方法。個人感覺變數管理是比較重要的，特別是當建立一個複雜的神經網路的時候，變數一旦增多，如果不

吳恩達《神經網路與深度學習》課程筆記歸納（二）-- 神經網路基礎之邏輯迴歸

上節課我們主要對深度學習（Deep Learning）的概念做了簡要的概述。我們先從房價預測的例子出發，建立了標準的神經網路（Neural Network）模型結構。然後從監督式學習入手，介紹了Standard NN，CNN和RNN三種不同的神經網路模型。接著介紹了兩種不

吳恩達《神經網路與深度學習》課程筆記歸納（三）-- 神經網路基礎之Python與向量化

上節課我們主要介紹了邏輯迴歸，以輸出概率的形式來處理二分類問題。我們介紹了邏輯迴歸的Cost function表示式，並使用梯度下降演算法來計算最小化Cost function時對應的引數w和b。通過計算圖的方式來講述了神經網路的正向傳播和反向傳播兩個過程。本節課我們將來

2017CS231n李飛飛深度視覺識別筆記（四）——神經網路

第四講 神經網路課時1 反向傳播    目前，我們已經講了怎麼定義一個分類器、怎麼定義一個損失函式以及它的正則化，也討論了用梯度下降的方法找到最小化的損失函式。    接下來，將討論如何計算任意複雜函式

TensorFlow學習（四）：優化器Optimizer

更新時間： 2017.5.9 簡化了很多不需要的內容，關注重點。 反正是要學一些API的，不如直接從例子裡面學習怎麼使用API，這樣同時可以複習一下一些基本的機器學習知識。但是一開始開始和以前一樣，先直接講類和常用函式用法，然後舉例子。 這裡

python學習筆記字典（四）

python字典是python中唯一的映射類型，采用鍵值對（key-value）的形式存儲數據。python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數字、字符串、元組。字典(dictionary)是除

Redis學習筆記--String（四）

沒有 增加 blog 數字 ali mil 1.2 ger 1.5 Redis的第一個數據類型string 1.命令 1.1賦值 語法：SET key value Set key value; 127.0.0.1:6379> set test 123 OK 1.2

Scala筆記整理（四）：Scala面向對象—類詳解2（繼承相關）

大數據 Scala [TOC] 單例 希望某個類只存在一個使用的對象，而不管有多少個調用者在使用它，就是單例的概念。 Java中的單例 package cn.xpleaf.single; /** * 單例模式-餓漢式（在屬性中先創建好對象，不管是否調用getInstance方法） * @auth

20180929 北京大學 人工智能實踐：Tensorflow筆記

智能 ima 16px class 技術 flow spa get ont 北京大學 人工智能實踐：Tensorflow筆記 https://www.bilibili.com/video/av22530538/?p=13