一 BP神經網路的基本結構

在神經網路中，輸入層由資料集的某個向量x和一個偏置b構成，該向量需要乘以同緯度的權重向量w，累加得到下一層神經元的一個輸入標量，該標量乘以啟用函式得到下一層神經元的輸入。

該結構分為以下幾個部分。

二 BP神經網路的訓練過程

1.正向傳播的過程

上式中的w是隔層的權重向量。o是上一次的輸出向量，對於輸入層就是訓練樣本集x。b是閾值，與梯度下降法處理相同，在訓練樣本集x首列加入全為1的列向量。

加入列向量原始碼

    def addcol(self,matrix1,matrix2):
        [m1,n1] = shape(matrix1)
        [m2,n2] = shape(matrix2)
        if
 
 m1 != m2:
            print "different rows,can not merge matrix"
            return;     
        mergMat = zeros((m1,n1+n2))
        mergMat[:,0:n1] = matrix1[:,0:n1]
        mergMat[:,n1:(n1+n2)] = matrix2[:,0:n2]
        return mergMat  

啟用函式

啟用函式原始碼

    def logistic(self,net):
        return
 
 1.0/(1.0+exp(-net))

其中

原始碼實現

hi_input = self.hi_wb*SampIn#隱含層節點輸入
hi_output = self.logistic(hi_input)#隱含層節點輸出
hi2out  = self.addcol(hi_output.T, ones((self.nSampNum,1))).T#加入全為1的列向量b
out_input = self.out_wb*hi2out#輸出層節點輸入
out_output = self.logistic(out_input)#輸出層節點輸出

2.計算期望和實際分類的誤差

計算實際輸出與期望的差，並判斷這個誤差是否低於容限。如果高於容限則進行反向傳播。
誤差向量：

3.計算反向傳播的過程
若正向傳播過程中未能得到期望值的輸出，則逐層計算實際輸出與期望值的誤差值，根據誤差值進行調節權重。

啟用函式的導函式dlogit函式

dlogit程式碼實現

（1）輸出層誤差：計算誤差反向傳播層的梯度和微分，用於更新權重。
輸入層微分形式

兩邊推導，其中左邊推導

右邊推導

將左右結合得到

輸出層節點對最終的誤差需要負的責任為

（2）隱含層誤差：計算誤差反向傳播的隱含層的梯度和微分，用於更新隱含層權重。
隱含層誤差：

左右推導，其中左邊為

右邊為

左右結合在一起得到

隱層節點對最終的誤差需要負的責任為

4.修正各層權值
利用各層神經元的梯度和微分修正連線權值
更新輸出層

更新隱含層

其中N代表當前迭代次數，n是網路設計引數（如動量因子）

三 BP神經網路原始碼

# -*- coding: UTF-8 -*-

from numpy import *
import matplotlib.pyplot as plt 

class BPNet(object):
    def __init__(self):   
        self.eb = 0.01              # 誤差容限 
        self.eta = 0.1             # 學習率
        self.mc = 0.3               # 動量因子 
        self.maxiter = 2000         # 最大迭代次數
        self.errlist = []           # 誤差列表      
        self.dataMat = 0            # 訓練集
        self.classLabels = 0        # 分類標籤集
        self.nSampNum=0             # 樣本行數
        self.nSampDim=0             # 樣本列數
        self.nHidden = 4;           # 隱含層神經元 
        self.nOut = 1;              # 輸出層個數
        self.iterator =0            # 演算法收斂是迭代次數
    # 啟用函式
    def logistic(self,net):
        return 1.0/(1.0+exp(-net))

    # 啟用函式的導函式
    def dlogit(self,net):
        return multiply(net,(1.0-net))

    # 矩陣個元素平方和
    def errorfunc(self,inX):
        return sum(power(inX,2))*0.5

    # 資料標準化
    def normalize(self,dataMat):
        [m,n]=shape(dataMat)
        for i in xrange(n-1):
            dataMat[:,i] = (dataMat[:,i]-mean(dataMat[:,i]))/(std(dataMat[:,i])+1.0e-10)
        return dataMat

    #載入資料
    def loadDataSet(self,filename):
        self.dataMat = []; self.classLabels = []
        fr = open(filename)
        for line in fr.readlines():
            lineArr = line.strip().split()
            self.dataMat.append([float(lineArr[0]), float(lineArr[1]), 1.0])
            self.classLabels.append(int(lineArr[2]))
        self.dataMat = mat(self.dataMat)
        m,n = shape(self.dataMat)
        self.nSampNum = m;    
        self.nSampDim = n-1; 
    # 增加新增列         
    def addcol(self,matrix1,matrix2):
        [m1,n1] = shape(matrix1)
        [m2,n2] = shape(matrix2)
        if m1 != m2:
            print "different rows,can not merge matrix"
            return;     
        mergMat = zeros((m1,n1+n2))
        mergMat[:,0:n1] = matrix1[:,0:n1]
        mergMat[:,n1:(n1+n2)] = matrix2[:,0:n2]
        return mergMat      

    # 隱含層初始化
    def init_hiddenWB(self):
        self.hi_w = 2.0*(random.rand(self.nHidden,self.nSampDim)-0.5)
        self.hi_b = 2.0*(random.rand(self.nHidden,1)-0.5)
        self.hi_wb = mat(self.addcol(mat(self.hi_w),mat(self.hi_b)))
    # 輸出層初始化
    def init_OutputWB(self):
        self.out_w = 2.0*(random.rand(self.nOut,self.nHidden)-0.5)
        self.out_b = 2.0*(random.rand(self.nOut,1)-0.5)
        self.out_wb = mat(self.addcol(mat(self.out_w),mat(self.out_b)))

    # bp網路主程式
    def bpTrain(self):
        SampIn = self.dataMat.T
        expected = mat(self.classLabels)
        self.init_hiddenWB()
        self.init_OutputWB()
        dout_wbOld = 0.0 ; dhi_wbOld = 0.0 

        for i in xrange(self.maxiter):   
            #正向傳播
            hi_input = self.hi_wb*SampIn#隱含層節點輸入
            hi_output = self.logistic(hi_input)#隱含層節點輸出
            hi2out  = self.addcol(hi_output.T, ones((self.nSampNum,1))).T#加入全為1的列向量b
            out_input = self.out_wb*hi2out#輸出層節點輸入
            out_output = self.logistic(out_input)#輸出層節點輸出

            #2.誤差計算  
            err = expected - out_output 
            sse = self.errorfunc(err)
            self.errlist.append(sse);
            if sse <= self.eb:
                self.iterator = i+1
                break;

            #3.反向傳播
            DELTA = multiply(err,self.dlogit(out_output))
            delta =multiply(self.out_wb[:,:-1].T*DELTA,self.dlogit(hi_output)) 
            dout_wb = DELTA*hi2out.T
            dhi_wb = delta*SampIn.T

            if i == 0:
                self.out_wb = self.out_wb + self.eta * dout_wb 
                self.hi_wb = self.hi_wb + self.eta * dhi_wb
            else :
                self.out_wb = self.out_wb + (1.0 - self.mc)*self.eta*dout_wb  + self.mc * dout_wbOld
                self.hi_wb = self.hi_wb + (1.0 - self.mc)*self.eta*dhi_wb + self.mc * dhi_wbOld
            dout_wbOld = dout_wb
            dhi_wbOld = dhi_wb

    # bp網路分類器
    def BPClassfier(self,start,end,steps=30):
        x = linspace(start,end,steps)
        xx = mat(ones((steps,steps)))
        xx[:,0:steps] = x 
        yy = xx.T
        z = ones((len(xx),len(yy))) ;
        for i in xrange(len(xx)):
            for j in xrange(len(yy)):
                xi = []; tauex=[] ; tautemp=[]
                mat(xi.append([xx[i,j],yy[i,j],1])) 
                hi_input = self.hi_wb*(mat(xi).T)
                hi_out = self.logistic(hi_input) 
                taumrow,taucol= shape(hi_out)
                tauex = mat(ones((1,taumrow+1)))
                tauex[:,0:taumrow] = (hi_out.T)[:,0:taumrow]
                out_input = self.out_wb*(mat(tauex).T)
                out = self.logistic(out_input) 
                z[i,j] = out 
        return x,z

# 繪製分類器
    def classfyLine(self,plt,x,z):
        plt.contour(x,x,z,1,colors='black')

# 繪製誤差曲線    
    def TrendLine(self,plt,color='r'):
        X = linspace(0,self.maxiter,self.maxiter)
        Y = log2(self.errlist)      
        plt.plot(X,Y,color)

    # 資料散點圖
    def drawClassScatter(self,plt):
        i=0
        for mydata in self.dataMat:
            if self.classLabels[i]==0:
                plt.scatter(mydata[0,0],mydata[0,1],c='blue',marker='o')
            else:
                plt.scatter(mydata[0,0],mydata[0,1],c='red',marker='s')
            i += 1      

主程式原始碼

from numpy import *
import operator
from bpNet import *
import matplotlib.pyplot as plt 

# 資料集
bpnet = BPNet() 
bpnet.loadDataSet("testSet2.txt")
bpnet.dataMat = bpnet.normalize(bpnet.dataMat)

# 繪製資料集散點圖
bpnet.drawClassScatter(plt)

# BP神經網路進行資料分類
bpnet.bpTrain()

print bpnet.out_wb
print bpnet.hi_wb

# 計算和繪製分類線
x,z = bpnet.BPClassfier(-3.0,3.0)
bpnet.classfyLine(plt,x,z)
plt.show()
# 繪製誤差曲線
bpnet.TrendLine(plt)
plt.show()

四 執行結果