C++实现BP算法_单隐层_异或(可模拟各种函数并验证)

最新推荐文章于 2024-04-28 20:12:43 发布
最新推荐文章于 2024-04-28 20:12:43 发布
阅读量1.7k 收藏 25
点赞数 1
分类专栏： 编程_C++ VS2012_C++ 智能计算 文章标签： BP 单隐层
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanshuning/article/details/41913043
版权

报告：

1、            题目：

建立一个含单隐层的双输入单输出网络，实现异或问题：

                 x1(1)=0                   x2(1)=1                 d(1)=1

                 x1(2)=1                   x2(2)=0                 d(2)=1

                 x1(3)=1                   x2(3)=1                 d(3)=0

                 x1(4)=0                   x2(4)=0                 d(4)=0  

    训练出相应的网络权值矩阵W。

2、            实现步骤：

①初始化：设定wji(0), wkj(0)  ，函数采用Sigmoid（）函数, y=1/(1+exp(-x))， y在（0，1）之间.设计一个“合理的网络结构”，隐层数为1 ，隐层节点为2；

②对每个输入样本进行如下计算：

    a 前向信号传播

    b 反向误差传播

③n=n+1, 转入下一个计算周期。

3、            核心代码及说明：

参数说明：

innode  //输入结点数   

hidenode //隐含结点数   

 outnode  //输出结点数   

trainsample //BP训练样本数

double w[innode][hidenode];//隐含结点权值   

    double w1[hidenode][outnode];//输出结点权值  

    double rate_w; //权值学习率（输入层-隐含层)   

    double rate_w1;//权值学习率 (隐含层-输出层) 

    double e;//误差计算   

    double error;//允许的最大误差  

double pp[hidenode];//隐含结点的校正误差   

    double qq[outnode];//希望输出值与实际输出值的偏差   

    double yd[outnode];//希望输出值   

   

    double x[innode];//输入向量   

    double x1[hidenode];//隐含结点状态值   

    double x2[outnode];//输出结点状态值 

//输入样本 

double X[trainsample][innode]= {   

    {-1,0,1},{-1,1,0},{-1,1,1},{-1,0,0}   };   

//期望输出样本   

double Y[trainsample][outnode]={   

    {1},{1},{0},{0}     };

训练部分：

    for(int isamp=0;isamp<trainsample;isamp++)//循环训练一次样品   

    {  

        /输入层到隐层 

        for(int j=0;j<hidenode;j++)   

        {   

            o1[j]=0.0;   

            for(int i=0;i<innode;i++)   

                o1[j]=o1[j]+w[i][j]*x[i];//隐含层各单元输入激活值   

           x1[j]=1.0/(1+exp(-o1[j]));//x1[j]=1.0/(1+exp(-o1[j]-b1[j]));//隐含层各单元的输出  

  

        }   

    /隐层到输出层 

        for(int k=0;k<outnode;k++)   

        {   

            o2[k]=0.0;   

            for(int j=0;j<hidenode;j++)   

                o2[k]=o2[k]+w1[j][k]*x1[j]; //输出层各单元输入激活值   

           x2[k]=1.0/(1.0+exp(-o2[k]));  //输出层各单元输出      

        }   

    //计算偏差并调整权值

        for(int k=0;k<outnode;k++)   

        {   

           qq[k]=(yd[k]-x2[k])*x2[k]*(1-x2[k]); //希望输出与实际输出的偏差   

            for(int j=0;j<hidenode;j++)   

               w1[j][k]+=rate_w1*qq[k]*x1[j];  //下一次的隐含层和输出层之间的权值   

        }   

        for(int j=0;j<hidenode;j++)   

        {   

            pp[j]=0.0;   

            for(int k=0;k<outnode;k++)   

               pp[j]=pp[j]+qq[k]*w1[j][k];   

            pp[j]=pp[j]*x1[j]*(1-x1[j]); //隐含层的校正误差  

            for(int i=0;i<innode;i++)   

                w[i][j]+=rate_w*pp[j]*x[i]; //下一次的输入层和隐含层之间的新连接权值  

        }  

        for(int k=0;k<outnode;k++)   

        {   

           e+=fabs(yd[k]-x2[k])*fabs(yd[k]-x2[k]); //计算均方差   

        }   

        error=e/2.0;   

    }   

}

4、            运算结果：

（1）隐层节点数为2，满足允许误差0.01的运行结果，得到了矩阵w1和w，及迭代次数和误差，并经行验证，验证结果正确。运算次数较多，误差较小。

 

（2）隐层节点数为2，满足允许误差0.1的运行结果，运算次数减少，误差变大。

#include<iostream>  
#include<cmath>  
using namespace std;  
  
#define  innode 2  //输入结点数  
#define  hidenode 3//隐含结点数  
#define  outnode 1 //输出结点数  
#define  trainsample 4//BP训练样本数  
class BpNet  
{  
public:  
    void train(double p[trainsample][innode ],double t[trainsample][outnode]);//Bp训练  
    double p[trainsample][innode];     //输入的样本  
    double t[trainsample][outnode];    //样本要输出的  
  
    double *recognize(double *p);//Bp识别  
  
    void writetrain(); //写训练完的权值  
    void readtrain(); //读训练好的权值，这使的不用每次去训练了，只要把训练最好的权值存下来就OK  
  
    BpNet();  
    virtual ~BpNet();  
  
public:  
    void init();  
    double w[innode][hidenode];//隐含结点权值  
    double w1[hidenode][outnode];//输出结点权值  
    
  
    double rate_w; //权值学习率（输入层-隐含层)  
    double rate_w1;//权值学习率 (隐含层-输出层)  
   
  
    double e;//误差计算  
    double error;//允许的最大误差  
    double result[outnode];// Bp输出  
};  
  
BpNet::BpNet()  
{  
    error=0.1;  
    e=0.0;  
  
    rate_w=0.9;  //权值学习率（输入层--隐含层)  
    rate_w1=0.9; //权值学习率 (隐含层--输出层)  
    
}  
  
BpNet::~BpNet()  
{  
  
}  
  
void winit(double w[],int n) //权值初始化  
{  
  for(int i=0;i<n;i++)  
    w[i]= (rand()%10)*0.1-0.5;
}  
  
void BpNet::init()  
{  
    winit((double*)w,innode*hidenode);  
    winit((double*)w1,hidenode*outnode);  
  
}  
  
void BpNet::train(double p[trainsample][innode],double t[trainsample][outnode])  
{  
    double pp[hidenode];//隐含结点的校正误差  
    double qq[outnode];//希望输出值与实际输出值的偏差  
    double yd[outnode];//希望输出值  
  
    double x[innode]; //输入向量  
    double x1[hidenode];//隐含结点状态值  
    double x2[outnode];//输出结点状态值  
    double o1[hidenode];//隐含层激活值  
    double o2[outnode];//输出层激活值  
  
    for(int isamp=0;isamp<trainsample;isamp++)//循环训练一次样品  
    {  
        for(int i=0;i<innode;i++)  
            x[i]=p[isamp][i]; //输入的样本  
        for(int i=0;i<outnode;i++)  
            yd[i]=t[isamp][i]; //期望输出的样本  
  
        //构造每个样品的输入和输出标准  
		//输入层到隐层
        for(int j=0;j<hidenode;j++)  
        {  
            o1[j]=0.0;  
            for(int i=0;i<innode;i++)  
                o1[j]=o1[j]+w[i][j]*x[i];//隐含层各单元输入激活值  
           x1[j]=1.0/(1+exp(-o1[j]));// x1[j]=1.0/(1+exp(-o1[j]-b1[j]));//隐含层各单元的输出  
            //    if(o1[j]+b1[j]>0) x1[j]=1;  
            //else x1[j]=0;  
        }  
    //隐层到输出层
        for(int k=0;k<outnode;k++)  
        {  
            o2[k]=0.0;  
            for(int j=0;j<hidenode;j++)  
                o2[k]=o2[k]+w1[j][k]*x1[j]; //输出层各单元输入激活值  
           x2[k]=1.0/(1.0+exp(-o2[k]));  //输出层各单元输出  
            
        }  
  



        for(int k=0;k<outnode;k++)  
        {  
            qq[k]=(yd[k]-x2[k])*x2[k]*(1-x2[k]); //希望输出与实际输出的偏差  
            for(int j=0;j<hidenode;j++)  
                w1[j][k]+=rate_w1*qq[k]*x1[j];  //下一次的隐含层和输出层之间的新连接权  
        }  
  
        for(int j=0;j<hidenode;j++)  
        {  
            pp[j]=0.0;  
            for(int k=0;k<outnode;k++)  
                pp[j]=pp[j]+qq[k]*w1[j][k];  
            pp[j]=pp[j]*x1[j]*(1-x1[j]); //隐含层的校正误差  
  
            for(int i=0;i<innode;i++)  
                w[i][j]+=rate_w*pp[j]*x[i]; //下一次的输入层和隐含层之间的新连接权  
        }  
  
        for(int k=0;k<outnode;k++)  
        {  
            e+=fabs(yd[k]-x2[k])*fabs(yd[k]-x2[k]); //计算均方差  
        }  
        error=e/2.0;  
  
       
    }  
}  
  
double *BpNet::recognize(double *p)  
{  
    double x[innode]; //输入向量  
    double x1[hidenode]; //隐含结点状态值  
    double x2[outnode]; //输出结点状态值  
    double o1[hidenode]; //隐含层激活值  
    double o2[hidenode]; //输出层激活值  
  
    for(int i=0;i<innode;i++)  
        x[i]=p[i];  
  
    for(int j=0;j<hidenode;j++)  
    {  
        o1[j]=0.0;  
        for(int i=0;i<innode;i++)  
            o1[j]=o1[j]+w[i][j]*x[i]; //隐含层各单元激活值  
        x1[j]=1.0/(1+exp(-o1[j]));//x1[j]=1.0/(1.0+exp(-o1[j]-b1[j])); //隐含层各单元输出  
       
    }  
  
    for(int k=0;k<outnode;k++)  
    {  
        o2[k]=0.0;  
        for(int j=0;j<hidenode;j++)  
            o2[k]=o2[k]+w1[j][k]*x1[j];//输出层各单元激活值  
       x2[k]=1.0/(1.0+exp(-o2[k])); //  x2[k]=1.0/(1.0+exp(-o2[k]-b2[k]));//输出层各单元输出  
     
    }  
  
    for(int k=0;k<outnode;k++)  
    {  
        result[k]=x2[k];  
    }  
    return result;  
}  
  
void BpNet::writetrain()  
{  
    FILE *stream0;  
    FILE *stream1;  
    
    int i,j;  
    //隐含结点权值写入  
    if(( stream0 = fopen("w.txt", "w+" ))==NULL)  
    {  
        cout<<"创建文件失败!";  
        exit(1);  
    }  
    for(i=0;i<innode;i++)  
    {  
        for(j=0;j<hidenode;j++)  
        {  
            fprintf(stream0, "%f\n", w[i][j]);  
        }  
    }  
    fclose(stream0);  
  
    //输出结点权值写入  
    if(( stream1 = fopen("w1.txt", "w+" ))==NULL)  
    {  
        cout<<"创建文件失败!";  
        exit(1);  
    }  
    for(i=0;i<hidenode;i++)  
    {  
        for(j=0;j<outnode;j++)  
        {  
            fprintf(stream1, "%f\n",w1[i][j]);  
        }  
    }  
    fclose(stream1);  
  
}  
  
void BpNet::readtrain()  
{  
    FILE *stream0;  
    FILE *stream1;  
   
    int i,j;  
  
    //隐含结点权值读出  
    if(( stream0 = fopen("w.txt", "r" ))==NULL)  
    {  
        cout<<"打开文件失败!";  
        exit(1);  
    }  
    float  wx[innode][hidenode];  
    for(i=0;i<innode;i++)  
    {  
        for(j=0;j<hidenode;j++)  
        {  
            fscanf(stream0, "%f", &wx[i][j]);  
            w[i][j]=wx[i][j];  
        }  
    }  
    fclose(stream0);  
  
    //输出结点权值读出  
    if(( stream1 = fopen("w1.txt", "r" ))==NULL)  
    {  
        cout<<"打开文件失败!";  
        exit(1);  
    }  
    float  wx1[hidenode][outnode];  
    for(i=0;i<hidenode;i++)  
    {  
        for(j=0;j<outnode;j++)  
        {  
            fscanf(stream1, "%f", &wx1[i][j]);  
            w1[i][j]=wx1[i][j];  
        }  
    }  
    fclose(stream1);  
  }
//输入样本  可改变，以实现不同函数的模拟
double X[trainsample][innode]= {  
    {0,1},{1,0},{1,1,},{0,0} 
    };  
//期望输出样本  
double Y[trainsample][outnode]={  
    {1},{1},{0},{0}  
    };  
  
int main()  
{  
    BpNet bp;  
    bp.init();  
    int times=0;  
    while(bp.error>0.01)  
    {  
        bp.e=0.0;  
        times++;  
        bp.train(X,Y);  
        cout<<"Times="<<times<<" error="<<bp.error<<endl;  
    }  
    cout<<"trainning complete..."<<endl;  
	bp.writetrain();
	bp.readtrain();
    double m[innode]={1,1};  
    double *r=bp.recognize(m); 
	 for(int i=0;i<innode;++i)  
       cout<<m[i]; 
	 cout<<"的训练结果为";
    for(int i=0;i<outnode;++i)  
       cout<<bp.result[i]<<" ";  
    double cha[trainsample][outnode];  
    double mi=100;  
    double index;  
    for(int i=0;i<trainsample;i++)  
    {  
        for(int j=0;j<outnode;j++)  
        {  
            //找差值最小的那个样本  
            cha[i][j]=(double)(fabs(Y[i][j]-bp.result[j]));  
            if(cha[i][j]<mi)  
            {  
                mi=cha[i][j];  
                index=Y[i][j];  //得到对应的期望输出
            }  
        }  
    }  
    
    cout<<" 期望输出为 "<<index<<endl;  
    cout<<endl;  
    return 0;  
}

光子乘羽
关注
  • 1
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
BP神经网络算法实现 C++
lin的博客
09-17 2702
BP神经网络基本原理： 误差逆传播(back propagation, BP)算法是一种计算单个权值变化引起网络性能变化的较为简单的方法。由于BP算法过程包含从输出节点开始，反向地向第一隐含层(即最接近输入层的隐含层)传播由总误差引起的权值修正，所以称为“反向传播”。 BP神经网络是有教师指导训练方式的多层前馈网络，其基本思想是：从网络输入节点输入的样本信号向前传播，经隐含层节点和输出层节点处...
基于C++的BP算法
06-14
自己写的用C++实现的BP模型，自己也还是不太明白，有兴趣的可以看看。。
简单BP神经网络 - 异或问题分类(C++实现+详细助解)
du98看灯夜的博客
03-06 914
神经网络概念及基础：https://www.cnblogs.com/maybe2030/p/5597716.html 本例具体公式使用按步推导参照：https://www.cnblogs.com/charlotte77/p/5629865.html 激活函数（激励函数）理解与总结：https://blog.csdn.net/tyhj_sf/article/details/79932893 废话不多说上代码！（代码来源参考至：https://www.cnblogs.com/semen/p/6883.
BP神经网络c++代码实现
最新发布
waitingforone的博客
04-28 791
BP神经网络c++代码实现
基于C++编程的BP神经网络实现异或问题
01-14
利用C++语言设计BP神经网络来解决非线性的异或问题
感知机和单隐藏层网络的模拟“异或运算”（XOR）
qq_41918762的博客
08-21 1780
文章目录感知机和单隐藏层网络的模拟“异或运算”（XOR）1、感知机模型2、异或运算3、基于tf的Perception模型和单隐藏层nn实现3.1、Perception 模型3.2、单隐藏层的nn模型 感知机和单隐藏层网络的模拟“异或运算”（XOR） 异或，英文为exclusive OR，缩写成xor。异或（xor）是一个数学运算符 1、感知机模型 感知机模型可以简单的理解为单层的神经网络。感知机接...
BP神经网络解决异或问题
01-17
一个比较典型的神经元网络，方便学习.一定可以使用
使用带隐藏层的神经网络拟合异或操作
实践求真知
05-05 2750
一 介绍多层神经网络非常好理解，就是在输入和输出中间多加些神经元，每一层可以加多个，也可加很多层。下面通过一个例子将异或数据进行分类。二 实例描述通过构建异或规律的数据集作为模拟样本，构建一个简单的多层神经网络来拟合其样本特征完成分类任务。1 异或规则当两个数相同时，输出为0，不相同时输出为1，这就是异或规则。表示为两类数据：（0,0）和（1,1）为一类（0,1）和（1,0）为一类2 网络模型介绍...
人工神经网络之异或分类器
11-26
自己用vc++6.0编的异或分类器，运行结果正确
BP神经网络异或分类VC++6.0实现
05-20
VC++6.0环境下实现BP神经网络异或分类 自己写的程序，可以运行，分享~~
神经网络与深度学习(二)cpp-c++BP神经网络
Mr_W1997的博客
02-03 1189
读到作者用JAVA实现的神经网络解决异或等问题 以下为c++实现版本 接口略有不同 具体关键的更新的证明详见机器学习或大牛博客 有一个关键的地方是 权值的初始化 原本是都初始化0 但是楼主也意识到 这样无论怎样更新 隐层不同神经元对应输入层同一神经元的权值都相同 相当于 仍然用一个线性函数划分 不可线性划分的区域 思考良久就初始化为随机数了 然而不行 后来看了别人的初始化 发现了这个
C++实现BP算法
10-17
实现BP算法，非常实用方便
BP算法的C++实现
11-04
使用面向对象的C++实现了BP神经网络，压缩包中一共6个文件，在vs2008中调试通过。程序运行的数据从文本文件中数输入。代码中有详细解释。
C++实现的BP神经网络（代码与详解）
热门推荐
菜鸡也有大佬梦
08-28 4万+
描述部分 什么是BP神经网络 这个百度比较多就不赘述了 在看到我的文章前一定也看了不少了! 开篇先说几点 本文是基于博客"https://blog.csdn.net/ironyoung/article/details/49455343"补充与拓展 本文努力去通俗的阐述bp神经网络原理 与结合实际bp网络图重构其代码 尤其核心算法部分 让bp算法使用更清晰明了 并且下面贴的代码注释非常全 保证每...
BP神经网络求解异或算法
weixin_44980490的博客
08-24 3541
BP神经网络求解异或算法 目录BP神经网络求解异或算法一、BP神经网络二、激活函数三、异或求解 一、BP神经网络 BP算法包括信号的前向传播和误差的反向传播两个过程。即计算误差输出时按从输入到输出的方向进行，而调整权值和阈值则从输出到输入的方向进行。 正向传播时，输入信号通过隐含层作用于输出节点，经过非线性变换，产生输出信号，若实际输出与期望输出不相符，则转入误差的反向传播过程。 误差反传是将输出误差通过隐含层向输入层逐层反传，并将误差分摊给各层所有单元，以从各层获得的误差信号作为调整各单元权值的依据。通过
C/C++数据结构练习题[2023-05-08]
code helper
05-08 1万+
目的：字符串是一种基础且广泛使用的数据结构，与字符串相关的题目既可 以考察基本程序设计能力和技巧，也可以考查算法设计能力。 题目：求字符串之间距离 要求：设有字符串 X，称在 X 的头尾及中间插入任意多个空格后构成的新 字符串为 X 的扩展串，如字符串 X 为“abcbcd”，则字符串“abcb□cd”，“□a□bcbcd□” 和“abcb□cd□”都是 X 的扩展串，这里“□”代表空格字符。如果 A1 是字符串 A 的 扩展串，B1 是字符串 B 的扩展串，A1 与 B1 具有相同的长度，那么定义字符串
实验二 单隐层神经网络
书启鸿蒙知秋枫
12-22 1310
为了避免过拟合的现象，保证足够高的网络性能和泛化能力，在满足精度要求的前提下取尽可能紧凑的结构，即取尽可能少的隐层节点数。隐藏层节点数不仅与输入输出层的节点数有关，更与需要解决的问题的复杂度和转换函数的模型以及样本数据的特性等因素有关。权值的增长意味着对应的空间的维数越高，过高的维数易导致训练后期的过拟合。从上图可以看出,隐藏节点数的增加,可以降低网络误差,提高精准度,但是也会使得网络复杂化,从而增加了网络的训练时间和出现”过拟合”的倾向。W2为隐层到输出层的权重数组，b2为隐层到输出层的偏置数组。
c++实现BP算法
m15274977937的博客
07-11 1850
c++实现BP算法   2010-01-08 23:56:38|  分类： 默认分类|举报|字号 订阅        下载LOFTER我的照片书  | 在朋友的帮助下终于成功了，用C++实现BP算法，编写程序1小时，调试逻辑错误2天，汗 #inclu
BP算法C++实现
波大菜菜
11-01 1131
//BackPropagation.h #ifndef BackPropagation_H #define BackPropagation_H #include #include #include #include #include class backPro { public: ~backPro(); backPro(int n1, int *sz, double
python bp神经网络 异或_BP神经网络求解异或问题(Python实现)
05-21
好的，下面是 Python 实现的 BP 神经网络解决异或问题的代码： ```python import numpy as np # 定义 sigmoid 函数 def sigmoid(x): return 1 / (1 + np.exp(-x)) # 定义 sigmoid 函数的导数 def sigmoid_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值