根據《機器學習》（周志華）第五章內容，用Python實現標準BP算法

BP神經網絡由一層輸入層、任意隱層（一般爲1）、一層輸出層組成。假定輸入向量爲n維向量，即輸入神經元數量爲n，隱層的層數爲num,每一層隱層的神經元數量爲eachCount,輸出向量爲yCount維向量，即輸出神經元的數量爲yCount,則BP算法要訓練的參數有：

1.輸入層到第一層隱層的n * eachCount個連接權值以及eachCount個閾值；

2.隱層與隱層之間的(num - 1) * eachCount * eachCount個連接權值以及(num -1) * eachCount個閾值；

3.最後一層隱層到輸出層的eachCount * yCount個連接權值以及輸出層的yCount個閾值。

其中，閾值可看作一個固定輸入爲-1.0的“啞結點”，因此權重和閾值的學習可以統一爲權重的學習。

BP算法包括標註BP算法以及累積BP算法，前者每次更新只針對單個樣例，參數更新得非常頻繁，而且對不同樣例進行更新的效果可能出現“抵消”現象。而累積BP算法直接針對累積誤差最小化，它正在讀取整個訓練集D一遍後纔對參數進行更新，其參數更新的頻率低得多。這裏我們使用Python來實現標準BP算法。

神經元使用Sigmoid函數作爲激活函數，其公式爲：

                                                                        

實現代碼爲：

def sigmoid(inX):
    return 1.0/(1+exp(-inX))

然後給出標準BP算法的Python實現，引用了numpy庫進行矩陣計算，python版本爲2.7，註釋很詳細:

'''
標準bp算法
每次更新都只針對單個樣例，參數更新得很頻繁s
dataSet 訓練數據集
labels 訓練數據集對應的標籤
標籤採用one-hot編碼(一位有效編碼)，例如類別0對應標籤爲[1,0],類別1對應標籤爲[0,1]
alpha 學習率
num 隱層數，默認爲1層
eachCount 每一層隱層的神經元數目
repeat 最大迭代次數
算法終止條件：達到最大迭代次數或者相鄰一百次迭代的累計誤差的差值不超過0.001
'''
def bp(dataSet, labels, alpha = 0.01, num = 1, eachCount = 10, repeat = 500):
    dataSet = mat(dataSet)
    m,n = shape(dataSet)
    if len(labels) == 0:
        print 'no train data! '
        return
    yCount = shape(labels[0])[1]     # 輸出神經元的數目
    firstWMat = mat(random.sample((n + 1, eachCount)))   # 輸入層到第一層隱層的w值和閾值，每列第一個爲閾值
    hideWArr = random.sample((num - 1, eachCount + 1, eachCount))  # 隱藏間的w值和閾值，每列第一個爲閾值
    lastWMat = mat(random.sample((eachCount + 1, yCount)))  # 最後一個隱層到輸出神經元的w值和閾值，每列第一個爲閾值
    hideInputs = mat(zeros((num, eachCount)))  # 隱層的輸入
    hideOutputs = mat(zeros((num, eachCount + 1)))    # 隱層的輸出
    hideOutputs[:, 0] = -1.0    # 初始化隱層輸出的每列第一個值爲-1，即下一層功能神經元的閾值對應的輸入恆爲-1
    hideEh = mat(zeros((num, eachCount)))     # 隱層的梯度項
    yInputs = mat(zeros((1, yCount)))   # 輸出層的輸入
    i = 0   # 迭代次數
    old_ey = 0  # 前一次迭代的累積誤差
    sn = 0 # 相鄰迭代的累計誤差的差值不超過0.001的次數
    while i < repeat:
        for r in range(len(dataSet)):
            line = dataSet[r]
            # 根據輸入樣本計算隱層的輸入和輸出
            xMat = mat(insert(line, 0, values=-1.0, axis=1))
            hideInputs[0, :] = xMat * firstWMat
            hideOutputs[0, 1:] = sigmoid(hideInputs[0, :])
            for j in range(1, len(hideInputs)):
                hideInputs[j, :] = hideOutputs[j - 1, :] * mat(hideWArr[j - 1, :, :])
                hideOutputs[j, 1:] = sigmoid(hideInputs[j, :])
            # 根據與輸出層連接的隱層的輸出值計算輸出層神經元的輸入
            yInputs[0, :] = hideOutputs[len(hideInputs) - 1, :] * lastWMat
            # 計算近似輸出
            yHead = sigmoid(yInputs)
            # 獲取真實類別
            yReal = labels[r]
            # 計算輸出層神經元的梯度項
            gj = array(yHead) * array(1 - yHead) * array((yReal - yHead))
            #計算隱層的梯度項
            lastSumWGj = lastWMat[1:, :] * mat(gj).T
            bMb = multiply(hideOutputs[num - 1, 1:], 1 - hideOutputs[num - 1, 1:])
            hideEh[num - 1, :] = multiply(bMb, lastSumWGj.T)
            for q in range(num - 1):
                index = num - 2 - q
                hideSumWEh = mat(hideWArr[index])[1:, :] * hideEh[index + 1].T
                bMb = multiply(hideOutputs[index, 1:], 1 - hideOutputs[index, 1:])
                hideEh[index, :] = multiply(bMb, hideSumWEh.T)
            # 更新各層神經元的連接權和閾值
            lastWMat[:,:] = lastWMat[:,:] + alpha * hideOutputs[num - 1].T * mat(gj)
            firstWMat[:,:] = firstWMat[:,:] + alpha * xMat[0, :].T * mat(hideEh[0, :])
            for p in range(num - 1):
                hideWArrMat = mat(hideWArr[p])
                hideWArrMat[:, :] = hideWArrMat[:, :] + alpha * hideOutputs[p].T * mat(hideEh[p + 1, :])
                hideWArr[p] = array(hideWArrMat)
        print 'repeat: %d' % i
        # 計算迭代累積誤差
        ey = (yHead - yReal) * (yHead - yReal).T
        # 判斷是否達到迭代終止條件
        if abs(ey - old_ey) < 0.001:
            sn = sn + 1
            old_ey = ey
            if sn >= 100:
                break
        else:
            sn = 0
            old_ey = ey
        i = i + 1
    return firstWMat, hideWArr,lastWMat, old_ey

獲取到了訓練參數後，我們就可以使用以下代碼對輸入向量進行類別預測：

'''
獲取y的近似輸出
'''
def getYHead(inX, yCount, firstWMat, hideWArr, lastWMat):
    num = len(hideWArr) + 1 # 隱層數目
    eachCount = shape(hideWArr)[2] # 每一層隱層的神經元數目
    hideInputs = mat(zeros((num, eachCount)))  # 隱層的輸入
    hideOutputs = mat(zeros((num, eachCount + 1)))  # 隱層的輸出
    hideOutputs[:, 0] = -1.0 ## 初始化隱層輸出的每列第一個值爲-1，即下一層功能神經元的閾值對應的輸入恆爲-1
    yInputs = mat(zeros((1, yCount)))  # 輸出層的輸入
    # 計算隱層的輸入
    xMat = mat(insert(inX, 0, values=-1.0, axis=1))
    hideInputs[0, :] = xMat * firstWMat
    hideOutputs[0, 1:] = sigmoid(hideInputs[0, :])
    for j in range(1, len(hideInputs)):
        hideInputs[j, :] = hideOutputs[j - 1, :] * mat(hideWArr[j - 1, :, :])
        hideOutputs[j, 1:] = sigmoid(hideInputs[j, :])

    # 計算輸出層的輸入
    yInputs[0, :] = hideOutputs[len(hideInputs) - 1, :] * lastWMat

    # 計算近似輸出
    yHead = sigmoid(yInputs)
    return yHead

需要注意的是，不管是訓練數據中的類別數據，還是上面的分類函數給出的分類結果，採用的都是one-hot（一位有效）編碼，例如對於手寫識別系統，如果分類結果是10，則輸出的類別會是一個10維的向量，每一維代表了類別爲對應下標的概率大小。因爲這裏被沒有對其進行正則化處理，因此總和不一定爲1.0.

下面使用一份《機器學習與實戰》圖書邏輯迴歸一章附帶的一份數據集來對上述分類算法進行訓練和測試，數據集如下：

-0.017612	14.053064	0
-1.395634	4.662541	1
-0.752157	6.538620	0
-1.322371	7.152853	0
0.423363	11.054677	0
0.406704	7.067335	1
0.667394	12.741452	0
-2.460150	6.866805	1
0.569411	9.548755	0
-0.026632	10.427743	0
0.850433	6.920334	1
1.347183	13.175500	0
1.176813	3.167020	1
-1.781871	9.097953	0
-0.566606	5.749003	1
0.931635	1.589505	1
-0.024205	6.151823	1
-0.036453	2.690988	1
-0.196949	0.444165	1
1.014459	5.754399	1
1.985298	3.230619	1
-1.693453	-0.557540	1
-0.576525	11.778922	0
-0.346811	-1.678730	1
-2.124484	2.672471	1
1.217916	9.597015	0
-0.733928	9.098687	0
-3.642001	-1.618087	1
0.315985	3.523953	1
1.416614	9.619232	0
-0.386323	3.989286	1
0.556921	8.294984	1
1.224863	11.587360	0
-1.347803	-2.406051	1
1.196604	4.951851	1
0.275221	9.543647	0
0.470575	9.332488	0
-1.889567	9.542662	0
-1.527893	12.150579	0
-1.185247	11.309318	0
-0.445678	3.297303	1
1.042222	6.105155	1
-0.618787	10.320986	0
1.152083	0.548467	1
0.828534	2.676045	1
-1.237728	10.549033	0
-0.683565	-2.166125	1
0.229456	5.921938	1
-0.959885	11.555336	0
0.492911	10.993324	0
0.184992	8.721488	0
-0.355715	10.325976	0
-0.397822	8.058397	0
0.824839	13.730343	0
1.507278	5.027866	1
0.099671	6.835839	1
-0.344008	10.717485	0
1.785928	7.718645	1
-0.918801	11.560217	0
-0.364009	4.747300	1
-0.841722	4.119083	1
0.490426	1.960539	1
-0.007194	9.075792	0
0.356107	12.447863	0
0.342578	12.281162	0
-0.810823	-1.466018	1
2.530777	6.476801	1
1.296683	11.607559	0
0.475487	12.040035	0
-0.783277	11.009725	0
0.074798	11.023650	0
-1.337472	0.468339	1
-0.102781	13.763651	0
-0.147324	2.874846	1
0.518389	9.887035	0
1.015399	7.571882	0
-1.658086	-0.027255	1
1.319944	2.171228	1
2.056216	5.019981	1
-0.851633	4.375691	1
-1.510047	6.061992	0
-1.076637	-3.181888	1
1.821096	10.283990	0
3.010150	8.401766	1
-1.099458	1.688274	1
-0.834872	-1.733869	1
-0.846637	3.849075	1
1.400102	12.628781	0
1.752842	5.468166	1
0.078557	0.059736	1
0.089392	-0.715300	1
1.825662	12.693808	0
0.197445	9.744638	0
0.126117	0.922311	1
-0.679797	1.220530	1
0.677983	2.556666	1
0.761349	10.693862	0
-2.168791	0.143632	1
1.388610	9.341997	0
0.317029	14.739025	0

這是一個二分類問題，包含了100個樣本，每個樣本包含兩個特徵的取值以及一個類別標籤。

以下代碼將從文本文件中讀取上述數據集並轉化爲我們所需的格式：

def loadDataSet(fileName):
    dataMat = []
    labelMat = []
    with open(fileName, 'r') as fr:
        for line in fr.readlines():
            lineArr = line.strip().split()
            dataMat.append([float(lineArr[0]), float(lineArr[1])])
            if int(lineArr[2]) == 0:
                labelMat.append([1.0, 0.0])
            else:
                labelMat.append([0.0, 1.0])
    return mat(dataMat), mat(labelMat)

訓練和測試的代碼爲：

def test():
    dataSet, labels = loadDataSet('testSet.txt')
    firstWMat, hideWArr, lastWMat,ey = bp(dataSet, labels)
    labelsHead = []
    for line in dataSet:
        yHead = getYHead(line, 2, firstWMat, hideWArr, lastWMat)
        labelsHead.append(yHead)
    errorCount = 0
    for i in range(len(labels)):
        if labels[i, 0] == 1:
            yReal = 0
        else:
            yReal = 1
        if labelsHead[i][0, 0] > labelsHead[i][0, 1]:
            yEs = 0
        else:
            yEs = 1
        if yReal != yEs:
            print 'error when test: [%f, %f], real: %d, error: %d' %(dataSet[i][0, 0], dataSet[i][0, 1], yReal, yEs)
            errorCount = errorCount + 1
    print 'error rate: %f' %(float(errorCount) /  len(dataSet))
    return labelsHead

爲了簡單，以上代碼把同一份數據集既當作了訓練數據，也當作了測試數據，最後的正確率大概在97%。