三、BP神經網絡

1、神經網絡模型

首先介紹三層神經網絡，如下圖

輸入層（input layer）有三個units（為補上的bias，通常設為1）

表示第j層的第i個激勵，也稱為單元unit

為第j層到第j+1層映射的權重矩陣，就是每條邊的權重

所以可以得到：

隱含層：

輸出層：

其中，S型函數，也成為激勵函數

可以看出為3??4的矩陣，為1??4的矩陣

==》j+1的單元數x（j層的單元數+1）

2、代價函數

假設最後輸出的，即代表輸出層有K個單元

其中，代表第i個單元輸出與邏輯回歸的代價函數

差不多，就是累加上每個輸出（共有K個輸出）

3、正則化

L-->所有層的個數

正則化後的代價函數為

共有L-1層，然後是累加對應每一層的theta矩陣，註意不包含加上偏置項對應的theta(0)

正則化後的代價函數實現代碼：

 1 # 代價函數
 2 def nnCostFunction(nn_params,input_layer_size,hidden_layer_size,num_labels,X,y,Lambda):
 3     length = nn_params.shape[0] # theta的中長度
 4     # 還原theta1和theta2
 5     Theta1 = nn_params[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1)
 
 6     Theta2 = nn_params[hidden_layer_size*(input_layer_size+1):length].reshape(num_labels,hidden_layer_size+1)
 7     
 8     # np.savetxt("Theta1.csv",Theta1,delimiter=‘,‘)
 9     
10     m = X.shape[0]
11     class_y = np.zeros((m,num_labels))      # 數據的y對應0-9，需要映射為0/1的關系
12     # 映射y
13     for i in
 
 range(num_labels):
14         class_y[:,i] = np.int32(y==i).reshape(1,-1) # 註意reshape(1,-1)才可以賦值
15      
16     ‘‘‘去掉theta1和theta2的第一列，因為正則化時從1開始‘‘‘    
17     Theta1_colCount = Theta1.shape[1]    
18     Theta1_x = Theta1[:,1:Theta1_colCount]
19     Theta2_colCount = Theta2.shape[1]    
20     Theta2_x = Theta2[:,1:Theta2_colCount]
21     # 正則化向theta^2
22     term = np.dot(np.transpose(np.vstack((Theta1_x.reshape(-1,1),Theta2_x.reshape(-1,1)))),np.vstack((Theta1_x.reshape(-1,1),Theta2_x.reshape(-1,1))))
23     
24     ‘‘‘正向傳播,每次需要補上一列1的偏置bias‘‘‘
25     a1 = np.hstack((np.ones((m,1)),X))      
26     z2 = np.dot(a1,np.transpose(Theta1))    
27     a2 = sigmoid(z2)
28     a2 = np.hstack((np.ones((m,1)),a2))
29     z3 = np.dot(a2,np.transpose(Theta2))
30     h  = sigmoid(z3)    
31     ‘‘‘代價‘‘‘    
32     J = -(np.dot(np.transpose(class_y.reshape(-1,1)),np.log(h.reshape(-1,1)))+np.dot(np.transpose(1-class_y.reshape(-1,1)),np.log(1-h.reshape(-1,1)))-Lambda*term/2)/m   
33     
34     return np.ravel(J)

4、反向傳播BP

上面正向傳播可以計算得到J(θ)，使用梯度下降算法還需要求它的梯度

BP反向傳播的目的就是求代價函數的梯度

假設4層的神經網絡，記為-->l層第j個單元的誤差

沒有，因為對於輸入沒有誤差，因為S型函數的倒數為：

所以上面的和可以在前向傳播中計算出來

反向傳播計算梯度的過程為：

for i=1-m:

正向傳播計算（l=2，3，4...L）

最後，即得到代價函數的梯度

代碼實現：

 1 # 梯度
 2 def nnGradient(nn_params,input_layer_size,hidden_layer_size,num_labels,X,y,Lambda):
 3     length = nn_params.shape[0]
 4     Theta1 = nn_params[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1)
 5     Theta2 = nn_params[hidden_layer_size*(input_layer_size+1):length].reshape(num_labels,hidden_layer_size+1)
 6     m = X.shape[0]
 7     class_y = np.zeros((m,num_labels))      # 數據的y對應0-9，需要映射為0/1的關系    
 8     # 映射y
 9     for i in range(num_labels):
10         class_y[:,i] = np.int32(y==i).reshape(1,-1) # 註意reshape(1,-1)才可以賦值
11      
12     ‘‘‘去掉theta1和theta2的第一列，因為正則化時從1開始‘‘‘
13     Theta1_colCount = Theta1.shape[1]    
14     Theta1_x = Theta1[:,1:Theta1_colCount]
15     Theta2_colCount = Theta2.shape[1]    
16     Theta2_x = Theta2[:,1:Theta2_colCount]
17     
18     Theta1_grad = np.zeros((Theta1.shape))  #第一層到第二層的權重
19     Theta2_grad = np.zeros((Theta2.shape))  #第二層到第三層的權重
20     
21     Theta1[:,0] = 0;
22     Theta2[:,0] = 0;
23     ‘‘‘正向傳播，每次需要補上一列1的偏置bias‘‘‘
24     a1 = np.hstack((np.ones((m,1)),X))
25     z2 = np.dot(a1,np.transpose(Theta1))
26     a2 = sigmoid(z2)
27     a2 = np.hstack((np.ones((m,1)),a2))
28     z3 = np.dot(a2,np.transpose(Theta2))
29     h  = sigmoid(z3)
30     
31     ‘‘‘反向傳播，delta為誤差，‘‘‘
32     delta3 = np.zeros((m,num_labels))
33     delta2 = np.zeros((m,hidden_layer_size))
34     for i in range(m):
35         delta3[i,:] = h[i,:]-class_y[i,:]
36         Theta2_grad = Theta2_grad+np.dot(np.transpose(delta3[i,:].reshape(1,-1)),a2[i,:].reshape(1,-1))
37         delta2[i,:] = np.dot(delta3[i,:].reshape(1,-1),Theta2_x)*sigmoidGradient(z2[i,:])
38         Theta1_grad = Theta1_grad+np.dot(np.transpose(delta2[i,:].reshape(1,-1)),a1[i,:].reshape(1,-1))
39     
40     ‘‘‘梯度‘‘‘
41     grad = (np.vstack((Theta1_grad.reshape(-1,1),Theta2_grad.reshape(-1,1)))+Lambda*np.vstack((Theta1.reshape(-1,1),Theta2.reshape(-1,1))))/m
42     return np.ravel(grad)

5、BP可以求梯度的原因

實際是利用了鏈式求導法則

因為下一層的單元利用上一層的單元作為輸入進行計算

大體的推導過程如下，最終我們是想預測函數與已知的y非常接近，求均方差的梯度沿著此梯度方向可使代價函數最小化。可對照上面求梯度的過程。

求誤差更詳細的推導過程：

6、梯度檢查

檢查利用BP求的梯度是否正確

利用導數的定義驗證：

求出來的數值梯度應該與BP求出的梯度非常接近

驗證BP正確後就不需要再執行驗證梯度的算法了

代碼實現

 1 # 檢驗梯度是否計算正確
 2 # 檢驗梯度是否計算正確
 3 def checkGradient(Lambda = 0):
 4     ‘‘‘構造一個小型的神經網絡驗證，因為數值法計算梯度很浪費時間，而且驗證正確後之後就不再需要驗證了‘‘‘
 5     input_layer_size = 3
 6     hidden_layer_size = 5
 7     num_labels = 3
 8     m = 5
 9     initial_Theta1 = debugInitializeWeights(input_layer_size,hidden_layer_size); 
10     initial_Theta2 = debugInitializeWeights(hidden_layer_size,num_labels)
11     X = debugInitializeWeights(input_layer_size-1,m)
12     y = 1+np.transpose(np.mod(np.arange(1,m+1), num_labels))# 初始化y
13     
14     y = y.reshape(-1,1)
15     nn_params = np.vstack((initial_Theta1.reshape(-1,1),initial_Theta2.reshape(-1,1)))  #展開theta 
16     ‘‘‘BP求出梯度‘‘‘
17     grad = nnGradient(nn_params, input_layer_size, hidden_layer_size, 
18                      num_labels, X, y, Lambda)  
19     ‘‘‘使用數值法計算梯度‘‘‘
20     num_grad = np.zeros((nn_params.shape[0]))
21     step = np.zeros((nn_params.shape[0]))
22     e = 1e-4
23     for i in range(nn_params.shape[0]):
24         step[i] = e
25         loss1 = nnCostFunction(nn_params-step.reshape(-1,1), input_layer_size, hidden_layer_size, 
26                               num_labels, X, y, 
27                               Lambda)
28         loss2 = nnCostFunction(nn_params+step.reshape(-1,1), input_layer_size, hidden_layer_size, 
29                               num_labels, X, y, 
30                               Lambda)
31         num_grad[i] = (loss2-loss1)/(2*e)
32         step[i]=0
33     # 顯示兩列比較
34     res = np.hstack((num_grad.reshape(-1,1),grad.reshape(-1,1)))
35     print res

7、權重的隨機初始化

神經網絡不能像邏輯回歸那樣初始化theta為0，因為若是每條邊的權重都為0，每個神經元都是相同的輸出，在反向傳播中也會得到同樣的梯度，最終只會預測一種結果。

所以應該初始化為接近0的數

代碼實現

1 # 隨機初始化權重theta
2 def randInitializeWeights(L_in,L_out):
3     W = np.zeros((L_out,1+L_in))    # 對應theta的權重
4     epsilon_init = (6.0/(L_out+L_in))**0.5
5     W = np.random.rand(L_out,1+L_in)*2*epsilon_init-epsilon_init # np.random.rand(L_out,1+L_in)產生L_out*(1+L_in)大小的隨機矩陣
6     return W

8、預測

正向傳播預測結果

代碼實現

 1 # 預測
 2 def predict(Theta1,Theta2,X):
 3     m = X.shape[0]
 4     num_labels = Theta2.shape[0]
 5     #p = np.zeros((m,1))
 6     ‘‘‘正向傳播，預測結果‘‘‘
 7     X = np.hstack((np.ones((m,1)),X))
 8     h1 = sigmoid(np.dot(X,np.transpose(Theta1)))
 9     h1 = np.hstack((np.ones((m,1)),h1))
10     h2 = sigmoid(np.dot(h1,np.transpose(Theta2)))
11     
12     ‘‘‘
13     返回h中每一行最大值所在的列號
14     - np.max(h, axis=1)返回h中每一行的最大值（是某個數字的最大概率）
15     - 最後where找到的最大概率所在的列號（列號即是對應的數字）
16     ‘‘‘
17     #np.savetxt("h2.csv",h2,delimiter=‘,‘)
18     p = np.array(np.where(h2[0,:] == np.max(h2, axis=1)[0]))  
19     for i in np.arange(1, m):
20         t = np.array(np.where(h2[i,:] == np.max(h2, axis=1)[i]))
21         p = np.vstack((p,t))
22     return p 

9、輸出結果

梯度檢查

隨機顯示100個手寫數字

顯示theta1權重

訓練集預測準確度

歸一化後訓練集預測準確度

如何用Python實現常見機器學習算法-3