Python : bp神经网络

柔情只为你懂 2022-06-15 04:07 367阅读 0赞

经典的BP神经网络通常由三层组成: 输入层， 隐含层与输出层.通常输入层神经元的个数与特征数相关，输出层的个数与类别数相同， 隐含层的层数与神经元数均可以自定义.

参考这篇文章BP神经网络：http://www.cnblogs.com/Finley/p/5946000.html

我们用一个完成训练的神经网络处理回归问题， 每个样本拥有n个输入.相应地，神经网络拥有n个输入神经元和1个输出神经元.  
实际应用中我们通常在输入层额外增加一个偏置神经元， 提供一个可控的输入修正;或者为每个隐含层神经元设置一个偏置参数.我们将n个特征依次送入输入神经元， 隐含层神经元获得输入层的输出并计算自己输出值， 输出层的神经元根据隐含层输出计算出回归值.上述过程一般称为前馈(Feed-Forward)过程， 该过程中神经网络的输入输出与多维函数无异.  
现在我们的问题是如何训练这个神经网络.作为监督学习算法，BP神经网络的训练过程即是根据前馈得到的预测值和参考值比较， 根据误差调整连接权重WijWij的过程.训练过程称为反向传播过程(BackPropagation)， 数据流正好与前馈过程相反.

代码部分：

def test(self):

cases = \[  \[0, 0\],  
             \[0, 1\],  
            \[1, 0\],  
            \[1, 1\], \]

labels = \[\[0\], \[1\], \[1\], \[0\]\] \#训练数据与对应标签

self.setup(2, 5, 1)\# setup(self, ni, nh, no)  输入层2 ，隐含层5 与输出层 1

self.train(cases, labels, 10000, 0.05, 0.1)  \# train(self, cases, labels, limit=10000, learn=0.05, correct=0.1):  训练10000次

for case in cases:\# 用训练好的神经网络进行预测

print(self.predict(case)

**对源代码进行修改，以适应不同的数据的训练**

def test(self):\#653行数据：400行作训练组，153行作测试组  
        dataset = np.loadtxt('cancer.csv', delimiter=",")\#训练数据与对应标签  
        cases = dataset\[:,1:10\]\#训练数据  
        labels = dataset\[:,10\]\#与训练数据对应标签  
        self.setup(8, 20, 1)\# 输入层8，隐含层12 与输出层 1  
        self.train(cases\[:400\], labels, 4000, 0.05, 0.1)\# 训练4000次  
        count = \[0,0\]\# 记录测试组，分类的正确与失败的次数  
        i=0  
        for case in cases\[400:\]:  
            if abs(self.predict(case)\[0\]-labels\[400+i\])<0.1:  
                count\[0\]=count\[0\]+1  
            else:   
                count\[1\]=count\[1\]+1  
            i=i+1  
        print 'result =',count  
        print 'error =',float(count\[1\])/(count\[0\]+count\[1\])\# 计算错误率

cancer.csv数据表如下（部分）：

BPNN训练4000次的错误率下降图：

![20170523175735163][]

0 12.8448262186  
50 4.10844670814  
100 3.58434989815  
150 3.15858867197  
200 2.38735799264  
250 2.04432250324  
300 1.77222199656  
350 1.54374562525  
400 1.3487734907  
450 0.87122153142  
500 0.479622131152  
550 0.307741058766  
600 0.230797986863  
650 0.180755622979  
700 0.143829885446  
750 0.117019273077  
800 0.098005108996  
850 0.0839411256238  
900 0.0729682530637  
950 0.0641603578238  
1000 0.0570006961453  
1050 0.0511074973869  
1100 0.0462032493153  
1150 0.0420821031431  
1200 0.0385856909863  
1250 0.0355910202918  
1300 0.0330025986922  
1350 0.0307461646576  
1400 0.0287636367024  
1450 0.0270091957697  
1500 0.0254463384422  
1550 0.0240456914654  
1600 0.0227833919505  
1650 0.021639877922  
1700 0.0205989754046  
1750 0.0196472015221  
1800 0.0187732271848  
1850 0.0179674598074  
1900 0.0172217183767  
1950 0.0165289817532  
2000 0.0158831973479  
2050 0.0152791414983  
2100 0.0147123245084  
2150 0.0141789315335  
2200 0.0136757851599  
2250 0.0132003090711  
2300 0.012750470325  
2350 0.0123246862648  
2400 0.011921700198  
2450 0.011540447834  
2500 0.0111799424189  
2550 0.0108391978219  
2600 0.010517193265  
2650 0.0102128708912  
2700 0.00992515251293  
2750 0.00965296333207  
2800 0.00939525461526  
2850 0.00915102144641  
2900 0.00891931456527  
2950 0.00869924685799  
3000 0.00848999566806  
3050 0.00829080215643  
3100 0.00810096875842  
3150 0.00791985553624  
3200 0.00774687599169  
3250 0.00758149271488  
3300 0.00742321310487  
3350 0.00727158530025  
3400 0.00712619439176  
3450 0.00698665894723  
3500 0.00685262785274  
3550 0.00672377745871  
3600 0.00659980901154  
3650 0.00648044634727  
3700 0.00636543382303  
3750 0.00625453446233  
3800 0.00614752829156  
3850 0.00604421084709  
3900 0.00594439183413  
3950 0.00584789392052

测试分类效果：

result = \[241, 12\]  
error = 0.0474308300395

修改后源代码：

# -*- coding: utf-8 -*- 
    import math
    import random
    import numpy as np
    import matplotlib.pyplot as plt  
    random.seed(0)
    
    
    def rand(a, b):
        return (b - a) * random.random() + a
    
    
    def make_matrix(m, n, fill=0.0):
        mat = []
        for i in range(m):
            mat.append([fill] * n)
        return mat
    
    
    def sigmoid(x):
        return 1.0 / (1.0 + math.exp(-x))
    
    
    def sigmod_derivate(x):
        return x * (1 - x)
    
    
    class BPNeuralNetwork:
        def __init__(self):
            self.input_n = 0
            self.hidden_n = 0
            self.output_n = 0
            self.input_cells = []
            self.hidden_cells = []
            self.output_cells = []
            self.input_weights = []
            self.output_weights = []
            self.input_correction = []
            self.output_correction = []
    
        def setup(self, ni, nh, no):
            self.input_n = ni + 1
            self.hidden_n = nh
            self.output_n = no
            # init cells
            self.input_cells = [1.0] * self.input_n
            self.hidden_cells = [1.0] * self.hidden_n
            self.output_cells = [1.0] * self.output_n
            # init weights
            self.input_weights = make_matrix(self.input_n, self.hidden_n)
            self.output_weights = make_matrix(self.hidden_n, self.output_n)
            # random activate
            for i in range(self.input_n):
                for h in range(self.hidden_n):
                    self.input_weights[i][h] = rand(-0.2, 0.2)
            for h in range(self.hidden_n):
                for o in range(self.output_n):
                    self.output_weights[h][o] = rand(-2.0, 2.0)
            # init correction matrix
            self.input_correction = make_matrix(self.input_n, self.hidden_n)
            self.output_correction = make_matrix(self.hidden_n, self.output_n)
    
        def predict(self, inputs):
            # activate input layer
            for i in range(self.input_n - 1):
                self.input_cells[i] = inputs[i]
            # activate hidden layer
            for j in range(self.hidden_n):
                total = 0.0
                for i in range(self.input_n):
                    total += self.input_cells[i] * self.input_weights[i][j]
                self.hidden_cells[j] = sigmoid(total)
            # activate output layer
            for k in range(self.output_n):
                total = 0.0
                for j in range(self.hidden_n):
                    total += self.hidden_cells[j] * self.output_weights[j][k]
                self.output_cells[k] = sigmoid(total)
            return self.output_cells[:]
    
        def back_propagate(self, case, label, learn, correct):
            # feed forward
            self.predict(case)
            # get output layer error
            output_deltas = [0.0] * self.output_n
            for o in range(self.output_n):
                error = label - self.output_cells[o]
                output_deltas[o] = sigmod_derivate(self.output_cells[o]) * error
            # get hidden layer error
            hidden_deltas = [0.0] * self.hidden_n
            for h in range(self.hidden_n):
                error = 0.0
                for o in range(self.output_n):
                    error += output_deltas[o] * self.output_weights[h][o]
                hidden_deltas[h] = sigmod_derivate(self.hidden_cells[h]) * error
            # update output weights
            for h in range(self.hidden_n):
                for o in range(self.output_n):
                    change = output_deltas[o] * self.hidden_cells[h]
                    self.output_weights[h][o] += learn * change + correct * self.output_correction[h][o]
                    self.output_correction[h][o] = change
            # update input weights
            for i in range(self.input_n):
                for h in range(self.hidden_n):
                    change = hidden_deltas[h] * self.input_cells[i]
                    self.input_weights[i][h] += learn * change + correct * self.input_correction[i][h]
                    self.input_correction[i][h] = change
            # get global error
            error = 0.0
            # for o in range(len(label)):
            error += 0.5 * (label - self.output_cells[o]) ** 2
            return error
    
        def train(self, cases, labels, limit=10000, learn=0.05, correct=0.1):
            error_results = []
            nums = []
            for j in range(limit):
                error = 0.0
                for i in range(len(cases)):
                    label = labels[i]
                    case = cases[i]
                    error += self.back_propagate(case, label, learn, correct)
                if j%50==0 :
                    print j , error
                    error_results.append(error)
                    nums.append(j)
            #X轴的文字  
            plt.xlabel("Num")  
            #Y轴的文字  
            plt.ylabel("Error")  
            #图表的标题  
            plt.title("BPNN") 
            plt.xlim(0.0, 4000.0)# set axis limits
            plt.ylim(0.0, 20.)
            
            plt.plot(nums, error_results)# use pylab to plot x and y
            plt.show()# show the plot on the screen
    
        def test(self):
            dataset = np.loadtxt('cancer.csv', delimiter=",")
            cases = dataset[:,1:10]
            labels = dataset[:,10]
            self.setup(8, 20, 1)
            self.train(cases[:400], labels, 4000, 0.05, 0.1)
            count = [0,0]
            i=0
            for case in cases[400:]:
    #             print(self.predict(case)[0])
                if abs(self.predict(case)[0]-labels[400+i])<0.1:
                    count[0]=count[0]+1
                else: 
                    count[1]=count[1]+1
                i=i+1
            print 'result =',count
            print 'error =',float(count[1])/(count[0]+count[1])
    if __name__ == '__main__':
        nn = BPNeuralNetwork()
        nn.test()

4层bp神经网络：输入层，2层隐藏层，输出层（4层BP神经网络比3层BP神经网络，分类效果要好一些，但是训练时间会更长些）

def test(self):  
        dataset = np.loadtxt('cancer.csv', delimiter=",")  
        cases = dataset\[:,1:10\]  
        labels = dataset\[:,10\]  
        self.setup(8, 17,5, 1)\# 输入层8，隐藏层17 隐藏层二 5 与输出层 1  
        self.train(cases\[:400\], labels, 4000, 0.05, 0.1)  
        count = \[0,0\]  
        i=0  
        for case in cases\[400:\]:  
\#             print(self.predict(case)\[0\])  
            if abs(self.predict(case)\[0\]-labels\[400+i\])<0.1:  
                count\[0\]=count\[0\]+1  
            else:   
                count\[1\]=count\[1\]+1  
            i=i+1  
        print 'result =',count  
        print 'error =',float(count\[1\])/(count\[0\]+count\[1\])

![20170525095949206][]

0 41.6054825514  
50 3.91000504333  
100 3.27556041234  
150 2.56284450143  
200 2.74873936433  
250 3.43262666799  
300 2.49611030117  
350 2.39107166443  
400 2.93171199528  
450 1.62359194553  
500 1.01085470283  
550 2.05085913097  
600 0.0980108878737  
650 0.0496093557234  
700 0.0318450321566  
750 0.0230617095963  
800 0.0178742991494  
850 0.0144956637248  
900 0.0121591883372  
950 0.0104571923623  
1000 0.0091630111811  
1050 0.00814580012821  
1100 0.00732544350915  
1150 0.00665010649135  
1200 0.00608471267309  
1250 0.00560465298806  
1300 0.00519214324779  
1350 0.00483400896871  
1400 0.00452028239858  
1450 0.00424328326072  
1500 0.00399699879453  
1550 0.00377665509199  
1600 0.00357841417314  
1650 0.00339915575732  
1700 0.00323631732992  
1750 0.00308777511403  
1800 0.00295175424457  
1850 0.00282676011869  
1900 0.00271152532206  
1950 0.00260496816086  
2000 0.00250615994504  
2050 0.00241429894311  
2100 0.00232868947462  
2150 0.00224872499651  
2200 0.00217387432156  
2250 0.00210367031285  
2300 0.00203770055101  
2350 0.00197559958409  
2400 0.00191704245596  
2450 0.00186173927392  
2500 0.00180943062612  
2550 0.00175988369764  
2600 0.00171288896445  
2650 0.0016682573671  
2700 0.00162581788533  
2750 0.00158541544848  
2800 0.00154690912911  
2850 0.00151017057579  
2900 0.0014750826492  
2950 0.00144153823134  
3000 0.00140943918284  
3050 0.00137869542732  
3100 0.0013492241452  
3150 0.00132094906193  
3200 0.00129379981811  
3250 0.00126771141063  
3300 0.00124262369584  
3350 0.00121848094668  
3400 0.00119523145724  
3450 0.00117282718887  
3500 0.00115122345285  
3550 0.00113037862529  
3600 0.00111025389057  
3650 0.00109081300996  
3700 0.00107202211272  
3750 0.00105384950699  
3800 0.00103626550857  
3850 0.00101924228542  
3900 0.00100275371634  
3950 0.00098677526241  
result = \[244, 9\]  
error = 0.0355731225296

[20170523175735163]: /images/20220615/7f853c4cb85649989a5fe1e6b75703e5.png
[20170525095949206]: /images/20220615/7c5670927e074477bb56e73506dea151.png