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
    评论
专栏目录
基于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
一个比较典型的神经元网络，方便学习.一定可以使用
广义异或bp算法.rar_bp标准程序_bp算法 c++_符号函数
09-22
本文件为用C语言实现的可实现广义异或问题的bp神经网络算法。该问题是对标准异或问题的推广。在标准异或问题中，输入X1和X2取离散量-1或+1，在广义异或问题中，输入（X1,X2）可以在区间[-1，+1] X [-1, +1]内任意...
BP神经网络解决异或问题_BP算法_
10-03
BP算法的核心在于反向传播误差，通过调整神经元之间的权重来最小化预测输出与实际目标之间的差异。这个过程通常包括前向传播和反向传播两个阶段。在前向传播中，输入信号通过网络逐层传递，直到得到最终的输出。在...
用BP网络解决异或问题(C++语言).rar_BP 异或
09-23
在提供的“用BP网络解决异或问题(C++语言).txt”文件中，可能包含了使用C++实现这一过程的代码。通常，代码会包括权重初始化、前向传播计算、反向传播更新权重以及训练循环等部分。 **C++实现** C++是一种通用的...
NN_Task1.zip_bp 异或_visual c
09-14
本项目“NN_Task1.zip_bp 异或_visual c”聚焦于利用C++编程实现BP（Back Propagation，反向传播）神经网络解决经典的异或问题。 首先，我们要理解什么是异或问题。异或（XOR）逻辑运算符在二进制计算中具有独特...
BP.rar_BP 异或_visual c
09-24
在本案例中，开发者可能使用Visual C++编写了BP神经网络的实现，并解决了异或问题。Visual C++提供了丰富的库支持，包括MFC（Microsoft Foundation Classes）和标准模板库（STL），以及调试工具和性能分析工具，便于...
人工神经网络之异或分类器
11-26
自己用vc++6.0编的异或分类器，运行结果正确
BP神经网络异或分类VC++6.0实现
05-20
VC++6.0环境下实现BP神经网络异或分类 自己写的程序，可以运行，分享~~
C++实现BP算法
10-17
实现BP算法，非常实用方便
BP算法的C++实现
11-04
使用面向对象的C++实现了BP神经网络，压缩包中一共6个文件，在vs2008中调试通过。程序运行的数据从文本文件中数输入。代码中有详细解释。
BP神经网络算法实现 C++
lin的博客
09-17 2702
BP神经网络基本原理： 误差逆传播(back propagation, BP)算法是一种计算单个权值变化引起网络性能变化的较为简单的方法。由于BP算法过程包含从输出节点开始，反向地向第一隐含层(即最接近输入层的隐含层)传播由总误差引起的权值修正，所以称为“反向传播”。 BP神经网络是有教师指导训练方式的多层前馈网络，其基本思想是：从网络输入节点输入的样本信号向前传播，经隐含层节点和输出层节点处...
使用带隐藏层的神经网络拟合异或操作
实践求真知
05-05 2750
一 介绍多层神经网络非常好理解，就是在输入和输出中间多加些神经元，每一层可以加多个，也可加很多层。下面通过一个例子将异或数据进行分类。二 实例描述通过构建异或规律的数据集作为模拟样本，构建一个简单的多层神经网络来拟合其样本特征完成分类任务。1 异或规则当两个数相同时，输出为0，不相同时输出为1，这就是异或规则。表示为两类数据：（0,0）和（1,1）为一类（0,1）和（1,0）为一类2 网络模型介绍...
神经网络与深度学习(二)cpp-c++BP神经网络
Mr_W1997的博客
02-03 1189
读到作者用JAVA实现的神经网络解决异或等问题 以下为c++实现版本 接口略有不同 具体关键的更新的证明详见机器学习或大牛博客 有一个关键的地方是 权值的初始化 原本是都初始化0 但是楼主也意识到 这样无论怎样更新 隐层不同神经元对应输入层同一神经元的权值都相同 相当于 仍然用一个线性函数划分 不可线性划分的区域 思考良久就初始化为随机数了 然而不行 后来看了别人的初始化 发现了这个
C++实现的BP神经网络（代码与详解）
热门推荐
菜鸡也有大佬梦
08-28 4万+
描述部分 什么是BP神经网络 这个百度比较多就不赘述了 在看到我的文章前一定也看了不少了! 开篇先说几点 本文是基于博客"https://blog.csdn.net/ironyoung/article/details/49455343"补充与拓展 本文努力去通俗的阐述bp神经网络原理 与结合实际bp网络图重构其代码 尤其核心算法部分 让bp算法使用更清晰明了 并且下面贴的代码注释非常全 保证每...
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_derivative(x): return x * (1 - x) # 训练 BP 神经网络 def train(X, y, hidden_neurons=3, epochs=10000, alpha=0.1): # 初始化输入层权重和偏置 input_neurons = X.shape[1] w1 = np.random.uniform(size=(input_neurons, hidden_neurons)) b1 = np.random.uniform(size=(1, hidden_neurons)) # 初始化输出层权重和偏置 output_neurons = y.shape[1] w2 = np.random.uniform(size=(hidden_neurons, output_neurons)) b2 = np.random.uniform(size=(1, output_neurons)) # 开始训练 for i in range(epochs): # 前向传播 hidden_layer_input = np.dot(X, w1) + b1 hidden_layer_output = sigmoid(hidden_layer_input) output_layer_input = np.dot(hidden_layer_output, w2) + b2 output_layer_output = sigmoid(output_layer_input) # 反向传播 error = y - output_layer_output d_output = error * sigmoid_derivative(output_layer_output) error_hidden_layer = d_output.dot(w2.T) d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output) # 更新权重和偏置 w2 += hidden_layer_output.T.dot(d_output) * alpha b2 += np.sum(d_output, axis=0, keepdims=True) * alpha w1 += X.T.dot(d_hidden_layer) * alpha b1 += np.sum(d_hidden_layer, axis=0, keepdims=True) * alpha return w1, b1, w2, b2 # 测试 BP 神经网络 def predict(X, w1, b1, w2, b2): # 前向传播 hidden_layer_input = np.dot(X, w1) + b1 hidden_layer_output = sigmoid(hidden_layer_input) output_layer_input = np.dot(hidden_layer_output, w2) + b2 output_layer_output = sigmoid(output_layer_input) return output_layer_output # 定义输入和输出数据 X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) y = np.array([[0], [1], [1], [0]]) # 训练 BP 神经网络 w1, b1, w2, b2 = train(X, y, hidden_neurons=3, epochs=10000, alpha=0.1) # 测试 BP 神经网络 predictions = predict(X, w1, b1, w2, b2) print(predictions) ``` 代码中使用了 sigmoid 函数作为激活函数，并且使用了 sigmoid 函数的导数来计算反向传播的梯度。在训练时，通过随机初始化权重和偏置，使用前向传播和反向传播来更新权重和偏置，最终得到训练好的 BP 神经网络。在测试时，使用训练好的 BP 神经网络来预测输出结果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值