參考：Python實現常見機器學習演算法
一、線性迴歸

• 1、代價函式

• 2、梯度下降演算法

• 3、均值歸一化

• 4、最終執行結果

• 5、使用scikit-learn庫中的線性模型實現

二、邏輯迴歸

• 1、代價函式

• 2、梯度

• 3、正則化

• 4、S型函式

• 5、對映為多項式

• 6、使用的優化方法

• 7、執行結果

• 8、使用scikit-learn庫中的邏輯迴歸模型實現

• 邏輯迴歸_手寫數字識別_OneVsAll

• 1、隨機顯示100個數字

• 2、OneVsAll

• 3、手寫數字識別

• 4、預測

• 5、執行結果

• 6、使用scikit-learn庫中的邏輯迴歸模型實現

三、BP神經網路

• 1、神經網路model

• 2、代價函式

• 3、正則化

• 4、反向傳播BP

• 5、BP可以求梯度的原因

• 6、梯度檢查

• 7、權重的隨機初始化

• 8、預測

• 9、輸出結果

四、SVM支援向量機

• 1、代價函式

• 2、Large Margin

• 3、SVM Kernel（核函式）

• 4、使用中的模型程式碼

• 5、執行結果

正文

1、代價函式

其中：

。

下面就是要求出theta，使代價最小，即代表我們擬合出來的方程距離真實值最近

共有m條資料，其中

代表我們要擬合出來的方程到真實值距離的平方，平方的原因是因為可能有負值，

有係數2的原因是下面求梯度是對每個變數求偏導，2可以消去

實現程式碼：

 # 計算代價函式
 
 def computerCost(X,y,theta):
 
     m = len(y)
 
     J = 0
 
     J = (np.transpose(X*theta-y))*(X*theta-y)/(2*m) #計算代價J
 
     return J

注意這裡的X是真實資料前加了一列1，因為有theta(0)

2、梯度下降演算法

代價函式對

求偏導得到：

所以對theta的更新可以寫為：

其中

為學習速率，控制梯度下降的速度，一般取0.01,0.03,0.1,0.3.....

為什麼梯度下降可以逐步減小代價函式？

假設函式f(x)的

泰勒展開：f(x+x)=f(x)+f'(x)*x+o(x)，

令：x=-α*f'(x) ,即負梯度方向乘以一個很小的步長α，

將x代入泰勒展開式中：

f(x+x)=f(x)-α[f'(x)]²+o(x)*

可以看出，α是取得很小的正數，[f'(x)]²也是正數，所以可以得出：f(x+x)<=f(x)，

所以沿著負梯度放下，函式在減小，多維情況一樣。

梯度下降演算法

 def gradientDescent(X,y,theta,alpha,num_iters):

     m = len(y)      
     n = len(theta)
 
     temp = np.matrix(np.zeros((n,num_iters)))   # 暫存每次迭代計算的theta，轉化為矩陣形式
 
     J_history = np.zeros((num_iters,1)) #記錄每次迭代計算的代價值
 
     for i in range(num_iters):  # 遍歷迭代次數    
 
         h = np.dot(X,theta)     # 計算內積，matrix可以直接乘
         temp[:,i] = theta - ((alpha/m)*(np.dot(np.transpose(X),h-y)))   
         #梯度的計算 
         theta = temp[:,i]
         J_history[i] = computerCost(X,y,theta)      #呼叫計算代價函式

   print '.',      

 return theta,J_history

3、均值歸一化

目的是使資料都縮放到一個範圍內，便於使用梯度下降演算法

其中

為所有此feture資料的平均值，

可以是最大值-最小值，也可以是這個feature對應的資料的標準差

實現程式碼：

歸一化feature

def featureNormaliza(X):

 X_norm = np.array(X)            #將X轉化為numpy陣列物件，才可以進行矩陣的運算

 #定義所需變數

 mu = np.zeros((1,X.shape[1]))   

 sigma = np.zeros((1,X.shape[1]))

 mu = np.mean(X_norm,0)          # 求每一列的平均值（0指定為列，1代表行）

 sigma = np.std(X_norm,0)        # 求每一列的標準差

 for i in range(X.shape[1]):     # 遍歷列

     X_norm[:,i] = (X_norm[:,i]-mu[i])/sigma[i]  # 歸一化

 return X_norm,mu,sigma

注意預測的時候也需要均值歸一化資料

4、最終執行結果

代價隨迭代次數的變化

5、使用scikit-learn庫中的線性模型實現

https://github.com/lawlite19/MachineLearning_Python/blob/master/LinearRegression/LinearRegression_scikit-learn.py

匯入包

 from sklearn import linear_model 
 
 from sklearn.preprocessing import StandardScaler    #引入縮放的包

歸一化

  #歸一化操作    
 
 scaler = StandardScaler()        
 
 scaler.fit(X)     
 
 x_train = scaler.transform(X)     
 
 x_test = scaler.transform(np.array([1650,3]))

線性模型擬合

 # 線性模型擬合     
 model = linear_model.LinearRegression()     
 model.fit(x_train, y)

預測

 #預測結果     
 result = model.predict(x_test)

二、邏輯迴歸

程式碼

全部程式碼

1、代價函式

可以綜合起來為：

其中：

為什麼不用線性迴歸的代價函式表示，因為線性迴歸的代價函式可能是非凸的，對於分類問題，使用梯度下降很難得到最小值，上面的代價函式是凸函式

的影象如下，即y=1時：

可以看出，當

趨於1，y=1,與預測值一致，此時付出的代價cost趨於0，若

趨於0，y=1,此時的代價cost值非常大，我們最終的目的是最小化代價值，

同理

的影象如下（y=0）：

2、梯度

同樣對代價函式求偏導：

可以看出與線性迴歸的偏導數一致

推導過程

3、正則化

目的是為了防止過擬合。

在代價函式中加上一項

注意j是重1開始的，因為theta(0)為一個常數項，X中最前面一列會加上1列1，所以乘積還是theta(0),feature沒有關係，沒有必要正則化

正則化後的代價：

 # 代價函式
 
 def costFunction(initial_theta,X,y,inital_lambda):
 
     m = len(y)
 
     J = 0
 
     h = sigmoid(np.dot(X,initial_theta))    # 計算h(z)
 
     theta1 = initial_theta.copy()           # 因為正則化j=1從1開始，不包含0，所以複製一份，前theta(0)值為0 
 
     theta1[0] = 0   
 
     temp = np.dot(np.transpose(theta1),theta1)
 
     J = (-np.dot(np.transpose(y),np.log(h))-np.dot(np.transpose(1-y),np.log(1-h))+temp*inital_lambda/2)/m   # 正則化的代價方程
 
     return J

正則化後的代價的梯度

 # 計算梯度

 def gradient(initial_theta,X,y,inital_lambda):
 
     m = len(y)
 
     grad = np.zeros((initial_theta.shape[0]))
 
     h = sigmoid(np.dot(X,initial_theta))# 計算h(z)
 
     theta1 = initial_theta.copy()
 
     theta1[0] = 0
 
     grad = np.dot(np.transpose(X),h-y)/m+inital_lambda/m*theta1
     #正則化的梯度
 
     return grad

4、S型函式

實現程式碼：

 # S型函式
 
 def sigmoid(z):
 
     h = np.zeros((len(z),1))    # 初始化，與z的長度一置
 
     h = 1.0/(1.0+np.exp(-z))     return h

5、對映為多項式

因為資料的feture可能很少，導致偏差大，所以創造出一些feture結合

eg:對映為2次方的形式:

實現程式碼：

 # 對映為多項式 
 
 def mapFeature(X1,X2):
 
     degree = 3;                     # 對映的最高次方
 
     out = np.ones((X1.shape[0],1))  # 對映後的結果陣列（取代X）
 
     '''
 
     這裡以degree=2為例，對映為1,x1,x2,x1^2,x1,x2,x2^2
 
     '''
 
     for i in np.arange(1,degree+1): 
 
         for j in range(i+1):

             temp = X1**(i-j)*(X2**j)    #矩陣直接乘相當於matlab中的點乘.*
 
             out = np.hstack((out, temp.reshape(-1,1)))
 
     return out

6、使用scipy的優化方法

梯度下降使用scipy中optimize中的fmin_bfgs函式

呼叫scipy中的優化演算法fmin_bfgs（擬牛頓法Broyden-Fletcher-Goldfarb-Shanno)
costFunction: 是自己實現的一個求代價的函式，

initial_theta: 表示初始化的值,

fprime指定costFunction的梯度

args是其餘測引數，以元組的形式傳入，最後會將最小化costFunction的theta返回

 result = optimize.fmin_bfgs(costFunction, initial_theta, 
                            fprime=gradient, args=(X,y,initial_lambda))

7、執行結果

data1決策邊界和準確度

data2決策邊界和準確度

8、使用scikit-learn庫中的邏輯迴歸模型實現

程式碼

匯入包

 from sklearn.linear_model import LogisticRegression 
 
 from sklearn.preprocessing import StandardScaler 
 
 from sklearn.cross_validation import train_test_split 
 
 import numpy as np

劃分訓練集和測試集

 # 劃分為訓練集和測試集     
 
 x_train,x_test,y_train,y_test = train_test_split(X,y,test_size=0.2)

歸一化

 # 歸一化     
 
 scaler = StandardScaler()     
 
 scaler.fit(x_train)     
 
 x_train = scaler.fit_transform(x_train)     
 
 x_test = scaler.fit_transform(x_test)

邏輯迴歸

 #邏輯迴歸     
 
 model = LogisticRegression()     
 
 model.fit(x_train,y_train)

預測

 # 預測     
 
 predict = model.predict(x_test)    
 
 right = sum(predict == y_test) 
         
 # 將預測值和真實值放在一塊，好觀察
 predict = np.hstack((predict.reshape(-1,1),y_test.reshape(-1,1)))   
      
 print predict  
   
 #計算在測試集上的準確度
 print ('測試集準確率：%f%%'%(right*100.0/predict.shape[0]))       

邏輯迴歸_手寫數字識別_OneVsAll

程式碼

全部程式碼

1、隨機顯示100個數字

我沒有使用scikit-learn中的資料集，畫素是20*20px，彩色圖如下

灰度圖：

實現程式碼：

 # 顯示100個數字
 
 def display_data(imgData):
 
     sum = 0
 
     '''
 
     顯示100個數（若是一個一個繪製將會非常慢，可以將要畫的數字整理好，放到一個矩陣中，顯示這個矩陣即可）
 
     - 初始化一個二維陣列
 
     - 將每行的資料調整成影象的矩陣，放進二維陣列
 
     - 顯示即可
 
     '''
 
     pad = 1
 
     display_array = -np.ones((pad+10*(20+pad),pad+10*(20+pad)))
 
     for i in range(10):
 
         for j in range(10):
              # order=F指定以列優先，在matlab中是這樣的，python中需要指定，預設以行
             display_array[pad+i*(20+pad):pad+i*(20+pad)+20,pad+j*(20+pad):pad+j*(20+pad)+20] 
               = (imgData[sum,:].reshape(20,20,order="F"))   
 
             sum += 1
 
     plt.imshow(display_array,cmap='gray')   #顯示灰度影象
 
     plt.axis('off')
 
     plt.show()

2、OneVsAll

如何利用邏輯迴歸解決多分類的問題，OneVsAll就是把當前某一類看成一類，其他所有類別看作一類，這樣有成了二分類的問題了。

如下圖，把途中的資料分成三類，先把紅色的看成一類，把其他的看作另外一類，進行邏輯迴歸，然後把藍色的看成一類，其他的再看成一類，以此類推...

可以看出大於2類的情況下，有多少類就要進行多少次的邏輯迴歸分類

3、手寫數字識別

共有0-9，10個數字，需要10次分類

由於資料集y給出的是0,1,2...9的數字，而進行邏輯迴歸需要0/1的label標記，所以需要對y處理

說一下資料集，前500個是0,500-1000是1,...,所以如下圖，處理後的y，**前500行的第一列是1，其餘都是0,500-1000行第二列是1，其餘都是0.... **

然後呼叫梯度下降演算法求解theta

實現程式碼：

 # 求每個分類的theta，最後返回所有的all_theta    
 
 def oneVsAll(X,y,num_labels,Lambda):
 
     # 初始化變數
 
     m,n = X.shape
 
     all_theta = np.zeros((n+1,num_labels))  # 每一列對應相應分類的theta,共10列
 
     X = np.hstack((np.ones((m,1)),X))       # X前補上一列1的偏置bias
 
     class_y = np.zeros((m,num_labels))      # 資料的y對應0-9，需要對映為0/1的關係
 
     initial_theta = np.zeros((n+1,1))       # 初始化一個分類的theta
 
     # 對映y
 
     for i in range(num_labels):
 
         class_y[:,i] = np.int32(y==i).reshape(1,-1) # 注意reshape(1,-1)才可以賦值
 
     #np.savetxt("class_y.csv", class_y[0:600,:], delimiter=',')    
 
     '''遍歷每個分類，計算對應的theta值'''
 
     for i in range(num_labels):
          # 呼叫梯度下降的優化方法
          result = optimize.fmin_bfgs(costFunction, initial_theta,  
                      fprime=gradient, args=(X,class_y[:,i],Lambda)) 
 
         all_theta[:,i] = result.reshape(1,-1)   # 放入all_theta中
 
     all_theta = np.transpose(all_theta) 
 
     return all_theta

4、預測

之前說過，預測的結果是一個概率值，利用學習出來的theta代入預測的S型函式中，每行的最大值就是是某個數字的最大概率，所在的列號就是預測的數字的真實值,因為在分類時，所有為0的將y對映在第一列，為1的對映在第二列，依次類推

實現程式碼：

 # 預測
 
 def predict_oneVsAll(all_theta,X):
 
     m = X.shape[0]
 
     num_labels = all_theta.shape[0]
 
     p = np.zeros((m,1))
 
     X = np.hstack((np.ones((m,1)),X))   #在X最前面加一列1
 
     h = sigmoid(np.dot(X,np.transpose(all_theta)))  #預測
 
     '''
 
     返回h中每一行最大值所在的列號
 
     - np.max(h, axis=1)返回h中每一行的最大值（是某個數字的最大概率）
 
     - 最後where找到的最大概率所在的列號（列號即是對應的數字）
 
     '''
 
     p = np.array(np.where(h[0,:] == np.max(h, axis=1)[0]))  
 
     for i in np.arange(1, m):
 
         t = np.array(np.where(h[i,:] == np.max(h, axis=1)[i]))
 
         p = np.vstack((p,t))
 
     return p

5、執行結果

10次分類，在訓練集上的準確度：

6、使用scikit-learn庫中的邏輯迴歸模型實現

程式碼

1、匯入包

 from scipy import io as spio 
 
 import numpy as np 
 
 from sklearn import svm 
 
 from sklearn.linear_model import LogisticRegression

2、載入資料

 data = loadmat_data("data_digits.mat")      
 
 X = data['X']   # 獲取X資料，每一行對應一個數字20x20px     
 
 y = data['y']   # 這裡讀取mat檔案y的shape=(5000, 1)     
 
 y = np.ravel(y) # 呼叫sklearn需要轉化成一維的(5000,)

3、擬合模型

 model = LogisticRegression()     
 
 model.fit(X, y) # 擬合

4、預測

 predict = model.predict(X) #預測          
 
 print u"預測準確度為：%f%%"%np.mean(np.float64(predict == y)*100)

5、輸出結果（在訓練集上的準確度）

三、BP神經網路

全部程式碼

1、神經網路model

先介紹個三層的神經網路，如下圖所示

輸入層（input layer）有三個units（

為補上的bias，通常設為1）

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

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

所以可以得到：

隱含層：

輸出層

，

其中，S型函式

，也成為激勵函式

可以看出

為3x4的矩陣，

為1x4的矩陣

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

2、代價函式

假設最後輸出的

，即代表輸出層有K個單元

，

其中，

代表第i個單元輸出

與邏輯迴歸的代價函式

差不多，就是

累加上每個輸出（共有K個輸出）

3、正則化

L: 所有層的個數

表示第L層unit的個數

正則化後的代價函式為

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

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

> # 代價函式
> 
> def nnCostFunction(nn_params,input_layer_size,hidden_layer_size,num_labels,X,y,Lambda):
> 
>     length = nn_params.shape[0] # theta的中長度
> 
>     # 還原theta1和theta2
> 
>     Theta1 = nn_params[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1)
> 
>     Theta2 = nn_params[hidden_layer_size*(input_layer_size+1):length].reshape(num_labels,hidden_layer_size+1)
> 
>     # np.savetxt("Theta1.csv",Theta1,delimiter=',')
> 
>     m = X.shape[0]
> 
>     class_y = np.zeros((m,num_labels))      # 資料的y對應0-9，需要對映為0/1的關係
> 
>     # 對映y
> 
>     for i in range(num_labels):
> 
>         class_y[:,i] = np.int32(y==i).reshape(1,-1) # 注意reshape(1,-1)才可以賦值
> 
>     '''去掉theta1和theta2的第一列，因為正則化時從1開始'''    
> 
>     Theta1_colCount = Theta1.shape[1]    
> 
>     Theta1_x = Theta1[:,1:Theta1_colCount]
> 
>     Theta2_colCount = Theta2.shape[1]    
> 
>     Theta2_x = Theta2[:,1:Theta2_colCount]
> 
>     # 正則化向theta^2
> 
>     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))))
> 
>     '''正向傳播,每次需要補上一列1的偏置bias'''
> 
>     a1 = np.hstack((np.ones((m,1)),X))      
> 
>     z2 = np.dot(a1,np.transpose(Theta1))    
> 
>     a2 = sigmoid(z2)
> 
>     a2 = np.hstack((np.ones((m,1)),a2))
> 
>     z3 = np.dot(a2,np.transpose(Theta2))
> 
>     h  = sigmoid(z3)    
> 
>     '''代價'''    
> 
>     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   
> 
>     return np.ravel(J)

4、反向傳播BP

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

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

假設4層的神經網路,

記為-->l層第j個單元的誤差

《===》

（向量化）

沒有

，因為對於輸入沒有誤差

因為S型函式

的倒數為：

，

所以上面的

和

可以在前向傳播中計算出來

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

for i=1-m:-

-正向傳播計算

（l=2,3,4...L）

-反向計算

最後

，即得到代價函式的梯度

實現程式碼：

> # 梯度
> 
> def nnGradient(nn_params,input_layer_size,hidden_layer_size,num_labels,X,y,Lambda):
> 
>     length = nn_params.shape[0]
> 
>     Theta1 = nn_params[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1)
> 
>     Theta2 = nn_params[hidden_layer_size*(input_layer_size+1):length].reshape(num_labels,hidden_layer_size+1)
> 
>     m = X.shape[0]
> 
>     class_y = np.zeros((m,num_labels))      # 資料的y對應0-9，需要對映為0/1的關係    
> 
>     # 對映y
> 
>     for i in range(num_labels):
> 
>         class_y[:,i] = np.int32(y==i).reshape(1,-1) # 注意reshape(1,-1)才可以賦值
> 
>     '''去掉theta1和theta2的第一列，因為正則化時從1開始'''
> 
>     Theta1_colCount = Theta1.shape[1]    
> 
>     Theta1_x = Theta1[:,1:Theta1_colCount]
> 
>     Theta2_colCount = Theta2.shape[1]    
> 
>     Theta2_x = Theta2[:,1:Theta2_colCount]
> 
>     Theta1_grad = np.zeros((Theta1.shape))  #第一層到第二層的權重
> 
>     Theta2_grad = np.zeros((Theta2.shape))  #第二層到第三層的權重
> 
>     Theta1[:,0] = 0;
> 
>     Theta2[:,0] = 0;
> 
>     '''正向傳播，每次需要補上一列1的偏置bias'''
> 
>     a1 = np.hstack((np.ones((m,1)),X))
> 
>     z2 = np.dot(a1,np.transpose(Theta1))
> 
>     a2 = sigmoid(z2)
> 
>     a2 = np.hstack((np.ones((m,1)),a2))
> 
>     z3 = np.dot(a2,np.transpose(Theta2))
> 
>     h  = sigmoid(z3)
> 
>     '''反向傳播，delta為誤差，'''
> 
>     delta3 = np.zeros((m,num_labels))
> 
>     delta2 = np.zeros((m,hidden_layer_size))
> 
>     for i in range(m):
> 
>         delta3[i,:] = h[i,:]-class_y[i,:]
> 
>         Theta2_grad = Theta2_grad+np.dot(np.transpose(delta3[i,:].reshape(1,-1)),a2[i,:].reshape(1,-1))
> 
>         delta2[i,:] = np.dot(delta3[i,:].reshape(1,-1),Theta2_x)*sigmoidGradient(z2[i,:])
> 
>         Theta1_grad = Theta1_grad+np.dot(np.transpose(delta2[i,:].reshape(1,-1)),a1[i,:].reshape(1,-1))
> 
>     '''梯度'''
> 
>     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
> 
>     return np.ravel(grad)

5、BP可以求梯度的原因

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

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

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

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

6、梯度檢查

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

利用導數的定義驗證：

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

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

實現程式碼：

> # 檢驗梯度是否計算正確
> 
> # 檢驗梯度是否計算正確
> 
> def checkGradient(Lambda = 0):
> 
>     '''構造一個小型的神經網路驗證，因為數值法計算梯度很浪費時間，而且驗證正確後之後就不再需要驗證了'''
> 
>     input_layer_size = 3
> 
>     hidden_layer_size = 5
> 
>     num_labels = 3
> 
>     m = 5
> 
>     initial_Theta1 = debugInitializeWeights(input_layer_size,hidden_layer_size); 
> 
>     initial_Theta2 = debugInitializeWeights(hidden_layer_size,num_labels)
> 
>     X = debugInitializeWeights(input_layer_size-1,m)
> 
>     y = 1+np.transpose(np.mod(np.arange(1,m+1), num_labels))# 初始化y
> 
>     y = y.reshape(-1,1)
> 
>     nn_params = np.vstack((initial_Theta1.reshape(-1,1),initial_Theta2.reshape(-1,1)))  #展開theta 
> 
>     '''BP求出梯度'''
> 
>     grad = nnGradient(nn_params, input_layer_size, hidden_layer_size, 
> 
>                      num_labels, X, y, Lambda)  
> 
>     '''使用數值法計算梯度'''
> 
>     num_grad = np.zeros((nn_params.shape[0]))
> 
>     step = np.zeros((nn_params.shape[0]))
> 
>     e = 1e-4
> 
>     for i in range(nn_params.shape[0]):
> 
>         step[i] = e
> 
>         loss1 = nnCostFunction(nn_params-step.reshape(-1,1), input_layer_size, hidden_layer_size, 
> 
>                               num_labels, X, y, 
> 
>                               Lambda)
> 
>         loss2 = nnCostFunction(nn_params+step.reshape(-1,1), input_layer_size, hidden_layer_size, 
> 
>                               num_labels, X, y, 
> 
>                               Lambda)
> 
>         num_grad[i] = (loss2-loss1)/(2*e)
> 
>         step[i]=0
> 
>     # 顯示兩列比較
> 
>     res = np.hstack((num_grad.reshape(-1,1),grad.reshape(-1,1)))
> 
>     print res

7、權重的隨機初始化

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

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

實現程式碼

> # 隨機初始化權重theta
> 
> def randInitializeWeights(L_in,L_out):
> 
>     W = np.zeros((L_out,1+L_in))    # 對應theta的權重
> 
>     epsilon_init = (6.0/(L_out+L_in))**0.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)大小的隨機矩陣
> 
>     return W

8、預測

正向傳播預測結果

實現程式碼

> # 預測
> 
> def predict(Theta1,Theta2,X):
> 
>     m = X.shape[0]
> 
>     num_labels = Theta2.shape[0]
> 
>     #p = np.zeros((m,1))
> 
>     '''正向傳播，預測結果'''
> 
>     X = np.hstack((np.ones((m,1)),X))
> 
>     h1 = sigmoid(np.dot(X,np.transpose(Theta1)))
> 
>     h1 = np.hstack((np.ones((m,1)),h1))
> 
>     h2 = sigmoid(np.dot(h1,np.transpose(Theta2)))
> 
>     '''
> 
>     返回h中每一行最大值所在的列號
> 
>     - np.max(h, axis=1)返回h中每一行的最大值（是某個數字的最大概率）
> 
>     - 最後where找到的最大概率所在的列號（列號即是對應的數字）
> 
>     '''
> 
>     #np.savetxt("h2.csv",h2,delimiter=',')
> 
>     p = np.array(np.where(h2[0,:] == np.max(h2, axis=1)[0]))  
> 
>     for i in np.arange(1, m):
> 
>         t = np.array(np.where(h2[i,:] == np.max(h2, axis=1)[i]))
> 
>         p = np.vstack((p,t))
> 
>     return p

9、輸出結果

梯度檢查：

隨機顯示100個手寫數字

顯示theta1權重

訓練集預測準確度

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

四、SVM支援向量機

1、代價函式

在邏輯迴歸中，我們的代價為：

其中：

如圖所示，如果y=1，cost代價函式如圖所示

我們想讓

，即z>>0，這樣的話cost代價函式才會趨於最小（這是我們想要的），所以用途中紅色的函式

代替邏輯迴歸中的cost

當y=0時同樣，用

代替

最終得到的代價函式為：

最後我們想要

之前我們邏輯迴歸中的代價函式為：

可以認為這裡的

，只是表達形式問題，這裡C的值越大，SVM的決策邊界的margin也越大，下面會說明

2、Large Margin

如下圖所示,SVM分類會使用最大的margin將其分開

先說一下向量內積

表示u的歐幾里得範數（歐式範數），

向量V在向量u上的投影的長度記為p，則：向量內積：

根據向量夾角公式推導一下即可，

前面說過，當C越大時，margin也就越大，我們的目的是最小化代價函式J(θ),當margin最大時，C的乘積項

要很小，所以近似為：

我們最後的目的就是求使代價最小的θ

由

可以得到：

p即為x在θ上的投影

如下圖所示，假設決策邊界如圖，找其中的一個點，到θ上的投影為p,則

或者

，若是p很小，則需要

很大，這與我們要求的θ使

最小相違背，所以最後求的是large margin

3、SVM Kernel（核函式）

對於線性可分的問題，使用線性核函式即可

對於線性不可分的問題，在邏輯迴歸中，我們是將feature對映為使用多項式的形式

，SVM中也有多項式核函式，但是更常用的是高斯核函式，也稱為RBF核

高斯核函式為：

假設如圖幾個點，

令：

可以看出，若是x與

距離較近，==》

，（即相似度較大），若是x與

距離較遠，==》

，（即相似度較低）

高斯核函式的σ越小，f下降的越快

如何選擇初始的

訓練集：

選擇：

對於給出的x，計算f,令：

，

所以：

最小化J求出θ，

如果

，==》預測y=1

4、使用scikit-learn中的SVM模型程式碼

全部程式碼

線性可分的,指定核函式為linear：

> '''data1——線性分類'''
> 
> data1 = spio.loadmat('data1.mat')
> 
> X = data1['X']
> 
> y = data1['y']
> 
> y = np.ravel(y)
> 
> plot_data(X,y)
> 
> model = svm.SVC(C=1.0,kernel='linear').fit(X,y) # 指定核函式為線性核函式

非線性可分的，預設核函式為rbf

> '''data2——非線性分類'''
> 
> data2 = spio.loadmat('data2.mat')
> 
> X = data2['X']
> 
> y = data2['y']
> 
> y = np.ravel(y)
> 
> plt = plot_data(X,y)
> 
> plt.show()
> 
> model = svm.SVC(gamma=100).fit(X,y)     # gamma為核函式的係數，值越大擬合的越好

5、執行結果

線性可分的決策邊界：

線性不可分的決策邊界：

下篇-Python實現常見機器學習演算法(下)