機器學習（四）：BP神經網路_手寫數字識別_Python

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

機器學習演算法Python實現

三、BP神經網路

全部程式碼

1、神經網路model

先介紹個三層的神經網路，如下圖所示
- 輸入層（input layer）有三個units（ ${x_0}$ 為補上的bias，通常設為1）
- $a_i^{(j)}$ 表示第j層的第i個激勵，也稱為為單元unit
- ${\theta ^{(j)}}$ 為第j層到第j+1層對映的權重矩陣，就是每條邊的權重
所以可以得到：
- 隱含層：
  $a_1^{(2)} = g(\theta _{10}^{(1)}{x_0} + \theta _{11}^{(1)}{x_1} + \theta _{12}^{(1)}{x_2} + \theta _{13}^{(1)}{x_3})$
  $a_2^{(2)} = g(\theta _{20}^{(1)}{x_0} + \theta _{21}^{(1)}{x_1} + \theta _{22}^{(1)}{x_2} + \theta _{23}^{(1)}{x_3})$
  $a_3^{(2)} = g(\theta _{30}^{(1)}{x_0} + \theta _{31}^{(1)}{x_1} + \theta _{32}^{(1)}{x_2} + \theta _{33}^{(1)}{x_3})$
- 輸出層
  ${h_\theta }(x) = a_1^{(3)} = g(\theta _{10}^{(2)}a_0^{(2)} + \theta _{11}^{(2)}a_1^{(2)} + \theta _{12}^{(2)}a_2^{(2)} + \theta _{13}^{(2)}a_3^{(2)})$ 其中，S型函式 $g(z) = \frac{1}{{1 + {e^{ - z}}}}$ ，也成為激勵函式
可以看出為3x4的矩陣，為1x4的矩陣
- ${\theta ^{(j)}}$ ==》j+1的單元數x（j層的單元數+1）

2、代價函式

假設最後輸出的 ${h_\Theta }(x) \in {R^K}$ ，即代表輸出層有K個單元
$J(\Theta ) = - \frac{1}{m}\sum\limits_{i = 1}^m {\sum\limits_{k = 1}^K {[y_k^{(i)}\log {{({h_\Theta }({x^{(i)}}))}_k}} } + (1 - y_k^{(i)})\log {(1 - {h_\Theta }({x^{(i)}}))_k}]$ 其中， ${({h_\Theta }(x))_i}$ 代表第i個單元輸出
與邏輯迴歸的代價函式 $J(\theta ) = - \frac{1}{m}\sum\limits_{i = 1}^m {[{y^{(i)}}\log ({h_\theta }({x^{(i)}}) + (1 - } {y^{(i)}})\log (1 - {h_\theta }({x^{(i)}})]$

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

3、正則化

L–>所有層的個數
${S_l}$ –>第l層unit的個數
正則化後的代價函式為
![enter description here][16]
- $\theta$ 共有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個單元的誤差
- $\delta _{\text{j}}^{(4)} = a_j^{(4)} - {y_i}$ 《===》 ${\delta ^{(4)}} = {a^{(4)}} - y$ （向量化）
- ${\delta ^{(3)}} = {({\theta ^{(3)}})^T}{\delta ^{(4)}}.*{g^}({a^{(3)}})$
- ${\delta ^{(2)}} = {({\theta ^{(2)}})^T}{\delta ^{(3)}}.*{g^}({a^{(2)}})$
- 沒有 ${\delta ^{(1)}}$ ，因為對於輸入沒有誤差
因為S型函式 ${\text{g(z)}}$ 的倒數為： ${g^}(z){\text{ = g(z)(1 - g(z))}}$ ，所以上面的 ${g^}({a^{(3)}})$ 和 ${g^}({a^{(2)}})$ 可以在前向傳播中計算出來
反向傳播計算梯度的過程為：
- $\Delta _{ij}^{(l)} = 0$ （ $\Delta$ 是大寫的 $\delta$ ）
- for i=1-m:
  - ${a^{(1)}} = {x^{(i)}}$
  -正向傳播計算 ${a^{(l)}}$ （l=2,3,4…L）
  -反向計算 ${\delta ^{(L)}}$ 、 ${\delta ^{(L - 1)}}$ … ${\delta ^{(2)}}$ ；
  - $\Delta _{ij}^{(l)} = \Delta _{ij}^{(l)} + a_j^{(l)}{\delta ^{(l + 1)}}$
  - $D_{ij}^{(l)} = \frac{1}{m}\Delta _{ij}^{(l)} + \lambda \theta _{ij}^l\begin{array}{c} {}& {(j \ne 0)} \end{array}$
  $D_{ij}^{(l)} = \frac{1}{m}\Delta _{ij}^{(l)} + \lambda \theta _{ij}^lj = 0\begin{array}{c} {}& {j = 0} \end{array}$
最後 $\frac{{\partial J(\Theta )}}{{\partial \Theta _{ij}^{(l)}}} = D_{ij}^{(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求的梯度是否正確
利用導數的定義驗證：
$\frac{{dJ(\theta )}}{{d\theta }} \approx \frac{{J(\theta + \varepsilon ) - J(\theta - \varepsilon )}}{{2\varepsilon }}$
求出來的數值梯度應該與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權重
訓練集預測準確度
歸一化後訓練集預測準確度

機器學習（四）：BP神經網路_手寫數字識別_Python

機器學習演算法Python實現三、BP神經網路全部程式碼 1、神經網路model 先介紹個三層的神經網路，如下圖所示輸入層（input layer）有三個units（為

機器學習與神經網路（四）：BP神經網路的介紹和Python程式碼實現

前言：本篇博文主要介紹BP神經網路的相關知識，採用理論+程式碼實踐的方式，進行BP神經網路的學習。本文首先介紹BP神經網路的模型，然後介紹BP學習演算法，推導相關的數學公式，最後通過Python程式碼實現BP演算法，從而給讀者一個更加直觀的認識。 1.BP網路模型為了將理

【深度學習】基於Numpy實現的神經網路進行手寫數字識別

直接先用前面設定的網路進行識別，即進行推理的過程，而先忽視學習的過程。推理的過程其實就是前向傳播的過程。深度學習也是分成兩步：學習 + 推理。學習就是訓練模型，更新引數；推理就是用學習到的引數來處理新的資料。 from keras.datasets.mnist impor

前置機器學習（四）：一文掌握Pandas用法

> Pandas提供快速，靈活和富於表現力的**資料結構**，是強大的**資料分析**Python庫。本文收錄於[機器學習前置教程系列](https://mp.weixin.qq.com/mp/appmsgalbum?action=getalbum&__biz=MzUxMjU4NjI4MQ=

人工智慧（四）：人工神經網路

在這裡我們只做總結梳理，具體的證明我們並不涉及，只要掌握原理，併為我們所用即可。一、感知器——單個神經元在說明神經網路之前，先介紹一下神經網路的基礎計算單元——神經元，也是一直沿用至今的“M-P神經元模型”。在這個模型中，神經元接收到來自n個其他神經元傳遞過來的輸入訊號，這些輸入訊

深度學習（四）卷積神經網路入門學習(1)

卷積神經網路入門學(1)作者：hjimce卷積神經網路演算法是n年前就有的演算法，只是近年來因為深度學習相關演算法為多層網路的訓練提供了新方法，然後現在電腦的計算能力已非當年的那種計算水平，同時現在的訓練資料很多，於是神經網路的相關演算法又重新火了起來，因此卷積神經網路就又活

深度學習1——深度學習（四）卷積神經網路入門學習(1)

卷積神經網路入門學(1) 轉載自：hjimce的專欄 - 部落格頻道 - CSDN.NET 原文地址：http://blog.csdn.NET/hjimce/article/details/47323463 作者：hjimce 卷積

深度學習（四）卷積神經網路Lenet-5實現

卷積神經網路Lenet-5實現作者：hjimce 卷積神經網路演算法是n年前就有的演算法，只是近年來因為深度學習相關演算法為多層網路的訓練提供了新方法，然後現在電腦的計算能力已非當年的那種計算水平，同時現在的訓練資料很多，於是神經網路的相關演算法

【深度學習】python實現簡單神經網路以及手寫數字識別案例

前言 \quad \qu

利用卷積神經網路進行手寫數字識別詳解

import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data ‘’‘可分別用這兩個函式建立卷積核(kernel)與偏置(bias)’’’ #返回一個給定形狀的變數，並自動以截斷正態分佈

用python的numpy實現神經網路實現手寫數字識別

首先是讀取檔案，train-images-idx3-ubyte等四個檔案是mnist資料集裡的資料。放在MNIST資料夾裡。MNIST資料夾和這個.py檔案放在同一個資料夾裡。 import numpy as np import struct train_images

邏輯迴歸softmax神經網路實現手寫數字識別(cs)

邏輯迴歸softmax神經網路實現手寫數字識別全過程 1 - 匯入模組 import numpy as np import matplotlib.pyplot as plt from ld_mnist import load_digits

卷積神經網路之手寫數字識別應用MNISTCNN

一、TensorFlow環境安裝，及準備（ubuntu 環境）1、安裝python、pip#sudo apt-get install python-pip python-dev2、臨時更換pip源，使用國內源保證下載速度#sudo pip install -i https:/

Deep Learning-TensorFlow (1) CNN卷積神經網路_MNIST手寫數字識別程式碼實現詳解

import tensorflow as tf import tensorflow.examples.tutorials.mnist.input_data as input_data import time # 計算開始時間 start = time.clock()

機器學習總結（七）：基本神經網路、BP演算法、常用啟用函式對比

1. 神經網路（1）為什麼要用神經網路？對於非線性分類問題，如果用多元線性迴歸進行分類，需要構造許多高次項，導致特徵特多學習引數過多，從而複雜度太高。（2）常用的啟用函式及其優缺點階

機器學習與深度學習系列連載：第二部分深度學習（十）卷積神經網路 1 Convolutional Neural Networks

卷積神經網路 Convolutional Neural Networks 卷積神經網路其實早在80年代，就被神經網路泰斗Lecun 提出[LeNet-5, LeCun 1980]，但是由於當時的資料量、計算力等問題，沒有得到廣泛使用。卷積神經網路的靈感來自50年代的諾貝爾生物學獎

演算法工程師修仙之路：吳恩達機器學習（四）

吳恩達機器學習筆記及作業程式碼實現中文版第四章 Logistic迴歸分類在分類問題中，要預測的變數y是離散的值，邏輯迴歸 (Logistic Regression) 演算法是目前最流行使用最廣泛的一種學習演算法。在分類問題中，我們嘗試預測的是結果

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

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

機器學習筆記（四）卷積神經網路CNN

1.前言：卷積神經網路在計算視覺領域的表現十分出色,與普通的BP神經網路一樣，CNN同樣由神經元組成。其實卷積神經網路是卷積+神經網路，基本上由三部分組成：卷積層，pooling層，全連線層。 2.CNN：卷積層卷積是一個訊號領域的概念，我們這裡提

機器學習與深度學習系列連載：第一部分機器學習（四）誤差分析（Bias and Variance）和模型調優

1.誤差分析（Bias and Variance）當我們以非常複雜的模型去進行測試的時候，可能得到的結果並不理想影響結果的主要有兩個因素：Bias 偏差、Variance 方差 Bias 偏差在這裡，我們定義偏差是指與目標結果的偏移量，這個偏

機器學習（四）：BP神經網路_手寫數字識別_Python

機器學習演算法Python實現

三、BP神經網路

1、神經網路model

2、代價函式

3、正則化

4、反向傳播BP

5、BP可以求梯度的原因

6、梯度檢查

7、權重的隨機初始化

8、預測

9、輸出結果

相關推薦