实验1 BP神经网络实验

最新推荐文章于 2024-06-06 20:29:46 发布

Blaze Jack

最新推荐文章于 2024-06-06 20:29:46 发布

阅读量1.1w

点赞数 10

分类专栏：计算智能实验&python 文章标签： python bp神经网络

本文链接：https://blog.csdn.net/qq_37325947/article/details/86726913

版权

计算智能实验&python 专栏收录该内容

10 篇文章 28 订阅

订阅专栏

传送门（所有的实验都使用python实现）

实验目的

编程实现BP神经网络算法；
探究BP算法中学习因子算法收敛趋势、收敛速度之间的关系；
修改训练后BP神经网络部分连接权值，分析连接权值修改前和修改后对相同测试样本测试结果，理解神经网络分布存储等特点。

实验要求

按照下面的要求操作，然后分析不同操作后网络输出结果。

可修改学习因子
可任意指定隐单元层数
可任意指定输入层、隐含层、输出层的单元数
可指定最大允许误差ε
可输入学习样本（增加样本）
可存储训练后的网络各神经元之间的连接权值矩阵；
修改训练后的BP神经网络部分连接权值，分析连接权值修改前和修改后对相同测试样本测试结果。

实验原理

明确BP神经网络算法的基本思想如下：
明确BP神经网络算法步骤和流程如下：

四、实验内容和分析

实验时建立三层BP神经网络，输入节点2个，隐含层节点2个，输出节点1个，输入训练样本如下表：

表1 输入训练样本

输入值		输出
0.0	0.0	0.0
0.0	1.0	1.0
1.0	0.0	1.0
1.0	1.0	0.0
0.1	1.0	1.0

学习因子分别为0.9, 最大允许误差0.001。

训练结果：

输入测试样本为

0.05 0.1

0.2 0.9

0.86 0.95

输出测试结果为

成功通过了测试，说明训练过程正确

1.改变学习因子

设置学习因子为0.6，学习因子越小结果越准确，但是也更耗时

2.改变输入层、隐含层、输出层的单元数

当隐含层节点个数为3时，相同训练样本和测试样本，得到测试结果为

隐含层变多之后，网络变复杂了，训练次数增多，但是结果更加准确。

最大允许误差ε控制网络识别精度。

精度取的越小，最后结果更精确，代价是付出更多的时间进行迭代。

以上实验误差均为0.001，本次取误差为0.0001，发现迭代次数上升，但是精度提高。

增加学习样本

在基本实验的基础上，增加一个学习样本0.1 1.0 1.0后

增加一个样本以后，虽然速度变慢，但是结果精度大大提高。

2.改变部分连接权值

为了保证算法能迅速收敛，因此采用的是随机梯度下降法，而非梯度下降法，因此算法是无监督型的，故不推荐修改连接权值。

1.实验过程：

由于BP算法的初始权重和阈值的随机性（为了保证梯度下降法的随机性，这里不使用固定的权重和阈值，可以使实验效果更好），因此实验的收敛次数是分散的，我们采用多次实验，取最小收敛次数作为依据。如图1所示。

图1 部分实验过程

实验过程如图1所示，多次执行算法，通过观察其收敛次数和测试结果的效果来决定是否采集本次数据。

2.实验结果：

本实验中，样本数据如表一所示，默认配置：最大迭代次数为10000，最大误差为0.001，学习因子为0.5，动量为0.9。实验结果在实验内容部分给出。

经过大量实验表明：

（1）一般来说，当算法迭代次数越多时，实验结果越精确，然而也存在特例，即算法陷入局部最小，迭代次数的增加并不带来精确度的提高。

python源码

# -*- coding: UTF-8 -*-
import random
import math
class bp:
    def init_w(self,w,x,y):#初始化偏置值
        for i in range(x):
            for j in range(y):
                w[i][j]=random.random()
                if(w[i][j]<0.5):w[i][j]=-w[i][j];
    def init_se(self,w,x):#初始化权值
        for i in range(x):
            w[i]=random.random()
            if(w[i]<0.5):
                w[i]=-w[i]
        
    def  forward(self,   inp,  outp,w, x, y, se):#向前传播输入
        for j in range(y):
            outp[j]=0
            for i in range(x):
                outp[j]+=inp[i]*w[i][j]
            outp[j] = outp[j]+se[j];
            outp[j] = (1.0)/(1+math.exp(-outp[j]))
    def  reforward(self):#反向误差更新
        self.sumse = 0;
        #计算输出层误差
        for i in range(self.o_size):
            self.eo[i] = self.ouput[i] * (1.0-self.ouput[i]) * (self.ouputex[i]-self.ouput[i]);
            if(self.eo[i]<0.0):
                self.sumse -= self.eo[i];
            else:
                self.sumse += self.eo[i]
        #计算输入层误差  
        for i in range(self.h_size):
            self. eh[i] = 0;
            for j in range(self.o_size):
                self. eh[i]+= self.hidden[i] * (1-self.hidden[i]) * self.who[i][j] * self.eo[j];
    def  updatew(self):
        #更新隐含层与输出层权值
        for i in range(self.h_size):
            for j in range(self.o_size):
                self.upwho[i][j]=(self.L*self.hidden[i]*self.eo[j])+(self.Mom*self.upwho[i][j])
                self.who[i][j]+=self.upwho[i][j]
        #更新输入与隐含层权值
        for i in range(self.i_size):
            for j in range(self.h_size):
                self.upwih[i][j]=(self.L*self.input[i]*self.eh[j])+(self.Mom*self.upwih[i][j])
                self.wih[i][j]+=self.upwih[i][j]   
        #更新阈值
    def  updatefa(self):
        for i in range(self.i_size):
            self.seh[i]+=self.L*self.eh[i]
        for i in range(self.o_size):
            self.seo[i]+=self.L*self.eo[i]
        #训练函数
    def  train(self ,in1,out1):
        self.input=in1
        self.ouputex=out1
        self.forward(self.input, self.hidden, self.wih, self.i_size, self.h_size, self.seh)#向前传播输入
        self.forward(self.hidden, self.ouput, self.who, self.h_size, self.o_size, self.seo)
        self.reforward()#反向误差传播
        self.updatew()#更新网络权重
        self.updatefa()#更新阈值
    #测试函数
    def test(self,init1):
        self.input=init1
        self.forward(self.input, self.hidden, self.wih, self.i_size, self.h_size, self.seh)
        self.forward(self.hidden, self.ouput, self.who, self.h_size, self.o_size, self.seo)
        for i in range(self.o_size):
            print(self.ouput[i])
    #返回阈值
    def get_e(self,w,x):
        self.f=0
        for i in range(self.o_size):
            print(w[i],end="")
            self.f+=1
            if(self.f%2==0):
                print("")    
        print("")
    #返回权值          
    def get_w(self,w,x,y):
        self.f=0;
        for i in range(x):
            for j in range(y):
                print(w[i][j],end="")
                print("     ",end="")
                self.f+=1
                if(self.f%2==0):
                    print("")         
    #类初始化                  
    def __init__(self,size,l,mom):

        self.L=l                        #学习因子                                                                                    
        self.Mom=mom;        #动量
        self.i_size=size[0];          #输入层数量
        self.h_size=size[1];        #隐含层数量
        self.o_size=size[2];          #输出层数量
        self.wih=[[0 for i in range(self.h_size)] for j in range(self.i_size)]    #输入层与隐含层权值
        self.who=[[0 for i in range(self.o_size)] for j in range(self.h_size)]     #隐含层与输出层权值
        self.upwih=[[0 for i in range(self.h_size)] for j in range(self.i_size)]    
        self.upwho=[[0 for i in range(self.o_size)] for j in range(self.h_size)]     # 动量更新
        self.input=[0 for i in range(self.i_size)]                      #输入层  
        self.hidden=[0 for i in range(self.h_size)]                #隐含层
        self.ouput=[0 for i in range(self.o_size)]                   #输出层
        self.ouputex=[0 for i in range(self.o_size)]                #期待输出
        self.seh= [0 for i in range(self.h_size)]                       #隐含层偏置
        self.seo= [0 for i in range(self.o_size)]                       #输出层偏置
        self.eh= [0 for i in range(self.h_size)]                       #隐含层误差
        self.eo= [0 for i in range(self.o_size)]                       #输出层误差
        
        self. init_w(self.wih,self.i_size,self.h_size)          #初始化 输入层到隐含层
        self. init_w(self.who,self.h_size,self.o_size)         #初始化 隐含层到输出层.
         
        self.init_se(self.seh, self.h_size)#初始化隐含层的偏置
        self.init_se(self.seo, self.o_size)#初始化输出层的偏置
    
           
         
size =[2,2,1]
inputData = [[0.0,0.0],[0.0,1.0],[1.0,0.0],[1.0,1.0],[0.1,1.0],[0.1,1.0]]
outputData = [[0.0],[1.0],[1.0],[0.0],[1.0],[1.0]]
testData = [[0.05,0.1],[0.2,0.9],[0.86,0.95]]


t=bp(size,0.5,0.9)

for i in range(10000):
    for j in range(6):
        t.train(inputData[j],outputData[j])
    if(t.sumse<0.001): 
        print("迭代次数:",i)
        break
    
print("误差为:",t.sumse)  
print("输入层与隐含层连接权值为:",end="")
t.get_w(t.wih,t.i_size,t.h_size)
print("隐含层与输出层连接权值为:",end="")
t.get_w(t.who,t.h_size,t.o_size)
print("隐含层神经元阈值为:",end="")
t.get_e(t.seh, t.h_size)
print("输出层神经元阈值为:",end="")
t.get_e(t.seo, t.o_size)
    
for i in range(3):
    print("训练样本为:",testData[i],"        结果为：",end="")
    t.test(testData[i])

Blaze Jack

关注

10
点赞
踩
112

收藏

觉得还不错? 一键收藏
打赏
5
评论
实验1 BP神经网络实验

传送门（所有的实验都使用python实现）实验1 BP神经网络实验实验2 som网实验实验3 hopfield实现八皇后问题实验4 模糊搜索算法预测薄冰厚度实验5 遗传算法求解tsp问题实验6 蚁群算法求解tsp问题实验7 粒子群优化算法求解tsp问题实验8 分布估计算法求解背包问题实验9 模拟退火算法求解背包问题实验10 禁忌搜索算法求解tsp问题...
复制链接

扫一扫