BP神经网络的C++实现

最新推荐文章于 2024-07-29 19:36:57 发布
最新推荐文章于 2024-07-29 19:36:57 发布
阅读量3.3k 收藏 15
点赞数 2
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/han6771306/article/details/25476301
版权

单隐层的BP神经网络的C++实现，激励函数选择了Sigmoid函数 1 / ( 1.0 + exp( - x - d ) )，x为每一层的输入，d为神经元的阈值。因为sigmoid函数输出在[0,1]之间，所以要对数据进行归一化处理，归一化处理的函数选择了线性归一化函数 x = ( x - min ) / ( max - min )。

#pragma once
#include<cassert>
#include<string>
using std::string;

enum Params
{
	InLayerNodesNum=1,//输入层节点数
	MidLayerNodesNum=8,//隐层节点数
	OutLayerNodesNum=1
};

/**
*  BP神经网络train的目的是找出这样的一组权值	_m_weight[Params::MidLayerNodesNum];//隐含层权值
*												_o_weight[Params::MidLayerNodesNum];//网络层权值
*  使输出与训练样本的真实输出间的误差小于阈值   _err
*  如果训练过程中迭代次数超出阈值 _it_nums 则认为训练失败 
*/

class BPNet
{
public:
	BPNet(){init();}
	~BPNet(){}
	
	int train(const double(*p)[Params::InLayerNodesNum],const double (*t)[Params::OutLayerNodesNum],int size);//
	int sim(const double(*p)[Params::InLayerNodesNum],double(*t)[Params::OutLayerNodesNum],int size);//
	bool save(){return save("data.b");}
	bool load(){return load("data.b");}
	bool save(const string& file);
	bool load(const string& file);

private:
	void init();
	void normalize(double **t,int size);//归一化处理
	void unnormalize(double **t,int size);//反归一化处理
private:
	
	double _m_w_rate;//输入层-隐含层权值学习率
	double _o_w_rate;//隐含层-网络层权学习率
	double _m_t_rate;//输入层-隐含层阈值学习率
	double _o_t_rate;//隐含层-网络层阈值学习率

	int _it_nums;//迭代次数
	double _err;//误差限

	double _mint,_maxt;
	
	double _m_threshold[Params::MidLayerNodesNum];//输入层-隐含层阈值
	double _o_threshold[Params::OutLayerNodesNum];//隐含层-网络层阈值
	double _m_weight[Params::InLayerNodesNum][Params::MidLayerNodesNum];//输入层-隐含层权值
	double _o_weight[Params::MidLayerNodesNum][Params::OutLayerNodesNum];//隐含层-网络层权值
};

#include "BPNet.h"

#include<cstdlib>
#include<ctime>
#include<cmath>

#include<fstream>
#include<iostream>

using std::ifstream;
using std::ofstream;


int BPNet::train(const double(*p)[Params::InLayerNodesNum],const double (*t)[Params::OutLayerNodesNum],int size)
{//
	double o1[Params::MidLayerNodesNum];
	double o2[Params::OutLayerNodesNum];
	double error1[Params::MidLayerNodesNum];
	double error2[Params::OutLayerNodesNum];
	double max_error=0;//记录最大误差

	double *perr=new double[size];

	double** t_temp=new double*[size];//保存t的数据，这里的设计很糟糕
	for(int i=0;i<size;++i)
	{
		t_temp[i]=new double[Params::OutLayerNodesNum];
		for(int j=0;j<Params::OutLayerNodesNum;++j)
			t_temp[i][j]=t[i][j];
	}

	normalize(t_temp,size);//归一化处理

	int i=0;
	for(;i<_it_nums;++i)
	{
		for(int j=0;j<size;++j)
		{
			//正向传播
				//计算隐含层输出
			for(int k=0;k<Params::MidLayerNodesNum;++k)
			{
				o1[k]=_m_weight[0][k]*p[j][0];
				for(int m=1;m<Params::InLayerNodesNum;++m)
					o1[k]+=_m_weight[m][k]*p[j][m];
				//激励函数
				o1[k]=1.0/(1+exp(-o1[k]-_m_threshold[k]));//隐含层各单元的输出
			}
				//计算输出层输出
			for(int k=0;k<Params::OutLayerNodesNum;++k)
			{
				o2[k]=_o_weight[0][k]*o1[0];
				for(int m=1;m<Params::MidLayerNodesNum;++m)
					o2[k]+=_o_weight[m][k]*o1[m];
				//激励函数
				o2[k]=1.0/(1+exp(-o2[k]-_o_threshold[k]));//隐含层各单元的输出 
			}

			//反向传播
			for(int k=0;k<Params::OutLayerNodesNum;++k)
			{
				//计算输出层误差
				error2[k]=(t_temp[j][k]-o2[k])*o2[k]*(1-o2[k]);
				//调整权值
				for(int m=0;m<Params::MidLayerNodesNum;++m)
					_o_weight[m][k]+=_o_w_rate*error2[k]*o1[m];
			}
				
			for(int k=0;k<Params::MidLayerNodesNum;++k)
			{
				//计算隐含层误差
				double d=0;
				for(int m=0;m<Params::OutLayerNodesNum;++m)
					d+=error2[m]*_o_weight[k][m];
				//调整权值
				error1[k]=d*o1[k]*(1-o1[k]);

				for(int m=0;m<Params::InLayerNodesNum;++m)
					_m_weight[m][k]+=_m_w_rate*error1[k]*p[j][m];
			}

			double e=0;
			for(int k=0;k<Params::OutLayerNodesNum;++k)
				e+=fabs(t_temp[j][k]-o2[k])*fabs(t_temp[j][k]-o2[k]);
			
			perr[j]=e/2;
			//更新阈值
			for(int k=0;k<OutLayerNodesNum;k++)  
				_o_threshold[k]+=_o_t_rate*error2[k]; //下一次的隐含层和输出层之间的新阈值  
			for(int k=0;k<MidLayerNodesNum;k++)  
				_m_threshold[k]+=_m_t_rate*error1[k]; //下一次的输入层和隐含层之间的新阈值  
		}

		max_error=perr[0];
		for(int j=1;j<size;++j)
			if(perr[j]>max_error)
				max_error=perr[j];
		if(max_error<_err)
			break;
	}

	delete[] perr;

	for(int i=0;i<size;++i)
		delete[] t_temp[i];
	delete[] t_temp;

	if(i>=_it_nums)
		return 0;
	return 1;
}

int BPNet::sim(const double(*p)[Params::InLayerNodesNum],double(*t)[Params::OutLayerNodesNum],int size)
{//
	double maxt,mint;

	double o1[Params::MidLayerNodesNum];

	double** t_temp=new double*[size];//保存t的数据，这里的设计很糟糕
	for(int i=0;i<size;++i)
		t_temp[i]=new double[Params::OutLayerNodesNum];

	for(int i=0;i<size;++i)
	{
		//正向传播
			//计算隐含层输出
		for(int k=0;k<Params::MidLayerNodesNum;++k)
		{
			o1[k]=_m_weight[0][k]*p[i][0];
			for(int m=1;m<Params::InLayerNodesNum;++m)
				o1[k]+=_m_weight[m][k]*p[i][m];
			o1[k]=1.0/(1.0+exp(-o1[k]-_m_threshold[k]));//隐含层各单元的输出 
		}
			//计算输出层输出
		for(int k=0;k<Params::OutLayerNodesNum;++k)
		{
			t_temp[i][k]=_o_weight[0][k]*o1[0];
			for(int m=1;m<Params::MidLayerNodesNum;++m)
				t_temp[i][k]+=_o_weight[m][k]*o1[m];
			t_temp[i][k]=1.0/(1.0+exp(-t_temp[i][k]-_o_threshold[k]));//隐含层各单元的输出 
		}
	}

	unnormalize(t_temp,size);//反归一化
	for(int i=0;i<size;++i)
		for(int j=0;j<Params::OutLayerNodesNum;++j)
			t[i][j]=t_temp[i][j];

	for(int i=0;i<size;++i)
		delete[] t_temp[i];
	delete[] t_temp;

	return 1;
}

void BPNet::init()
{
	_m_w_rate=0.9;//输入层-隐含层权值学习率
	_o_w_rate=0.9;//隐含层-网络层权值学习率
	_m_t_rate=0.9;//输入层-隐含层权值学习率
	_o_t_rate=0.9;//隐含层-网络层权值学习率

	_it_nums=1000;//迭代次数
	_err=0.00001;//误差限
	
	//初始化成随机数
	srand(time(0));
	for(int i=0;i<Params::InLayerNodesNum;++i)
	{
		for(int j=0;j<Params::MidLayerNodesNum;++j)
			_m_weight[i][j]=(2.0*(double)rand()/RAND_MAX)-1;
	}

	for(int i=0;i<Params::MidLayerNodesNum;++i)
	{
		for(int j=0;j<Params::OutLayerNodesNum;++j)
			_o_weight[i][j]=(2.0*(double)rand()/RAND_MAX)-1;
	}
	for(int i=0;i<Params::MidLayerNodesNum;++i)
		_m_threshold[i]=(2.0*(double)rand()/RAND_MAX)-1;
	for(int i=0;i<Params::OutLayerNodesNum;++i)
		_o_threshold[i]=(2.0*(double)rand()/RAND_MAX)-1;
}

bool BPNet::save(const string& file)
{
	ofstream ofile(file);
	for(int i=0;i<Params::InLayerNodesNum;++i)//保存输入层-隐含层权值
	{
		for(int j=0;j<Params::MidLayerNodesNum;++j)
			ofile<<_m_weight[i][j]<<' ';
		ofile<<'\n';
	}

	for(int i=0;i<Params::MidLayerNodesNum;++i)//保存隐含层-网络层权值
	{
		for(int j=0;j<Params::OutLayerNodesNum;++j)
			ofile<<_o_weight[i][j]<<' ';
		ofile<<'\n';
	}
	for(int i=0;i<Params::MidLayerNodesNum;++i)//保存输入层-隐含层阈值
		ofile<<_m_threshold[i]<<" ";
	ofile<<'\n';

	for(int i=0;i<Params::OutLayerNodesNum;++i)//保存隐含层-网络层阈值
		ofile<<_o_threshold[i]<<" ";
	ofile.close();
	return true;
}

bool BPNet::load(const string& file)
{
	ifstream ifile(file);
	char endLine;
	for(int i=0;i<Params::InLayerNodesNum;++i)//加载输入层-隐含层权值
	{
		for(int j=0;j<Params::MidLayerNodesNum;++j)
			ifile>>_m_weight[i][j];
	}

	for(int i=0;i<Params::MidLayerNodesNum;++i)//加载隐含层-网络层权值
	{
		for(int j=0;j<Params::OutLayerNodesNum;++j)
			ifile>>_o_weight[i][j];
	}
	for(int i=0;i<Params::MidLayerNodesNum;++i)//加载输入层-隐含层阈值
		ifile>>_m_threshold[i];

	for(int i=0;i<Params::OutLayerNodesNum;++i)//加载隐含层-网络层阈值
		ifile>>_o_threshold[i];

	ifile.close();
	return true;
}

void BPNet::normalize(double **t,int size)
{//归一化处理
	_mint=0x7FFFFFFF;//这里利用了“魔数”进行处理，不是最好的方法
	_maxt=-0x7FFFFFFF;

	//找到最大和最小值
	for(int i=0;i<size;++i)
	{
		for(int j=0;j<Params::OutLayerNodesNum;++j)
		{
			if(_mint>t[i][j])
				_mint=t[i][j];
			if(_maxt<t[i][j])
				_maxt=t[i][j];
		}
	}

	if(_mint==_maxt)
		_mint=0;

	double range=_maxt-_mint;

	//归一化
	//找到最大和最小值
	for(int i=0;i<size;++i)
	{
		for(int j=0;j<Params::OutLayerNodesNum;++j)
			t[i][j]=(t[i][j]-_mint)/range;
	}
}

void BPNet::unnormalize(double **t,int size)
{//反归一化处理
	double range=_maxt-_mint;

	//归一化
	//找到最大和最小值
	for(int i=0;i<size;++i)
	{
		for(int j=0;j<Params::OutLayerNodesNum;++j)
			t[i][j]=t[i][j]*range+_mint;
	}
}

#include"BPNet.h"
#include<cstdlib>
#include<ctime>
#include<iostream>
using std::cout;
using std::cin;
using std::endl;




int main()
{
	BPNet bpNet;
	const int N=50; 
	const double Pi=3.1415926;

	srand(time(0));

	double a[N][Params::InLayerNodesNum];
	double a2[N][Params::InLayerNodesNum];
	double b[N][Params::OutLayerNodesNum];
	double b2[N][Params::OutLayerNodesNum];
	double b3[N][Params::OutLayerNodesNum];

	for(int i=0;i<N;++i)
	{
		a[i][0]=((2.0*(double)rand()/RAND_MAX)-1)*(Pi/2-1)+1;
		a2[i][0]=((2.0*(double)rand()/RAND_MAX)-1)*(Pi/2-1)+1;

		b[i][0]=2*sin(a[i][0])-0.7;
		b2[i][0]=2*sin(a2[i][0])-0.7;
	}

	bpNet.train(a,b,N);
	bpNet.save();
	bpNet.load();
	bpNet.sim(a,b3,N);

	for(int i=0;i<N;++i)
		cout<<b[i][0]<<" -> "<<b3[i][0]<<endl;

	return 0;
}


hanshaojun1990
关注
专栏目录
C++ BP人工神经网络预测算法
10-09
BP人工神经网络进行预测的算法，简单易懂
C++实现的神经网络
09-14
虽然用C++实现神经网络会比较麻烦，不过如果注意到以下下的trick, 在用C++实现神经网络时会舒服很多，代码也会非常简明，核心代码在百行左右也不是问题。 C++没有内置的向量,矩阵库，可以自己先轮几个Vector, Matrix类以及各种数学运算操作，最好搞成链式操作。 不要用index form来推导和实现BP算法，个人比较喜欢matrix form, 公式会非常紧凑，实现起来也不太容易出错 顶层框架设计，比如先设计几个基类Model类，数据库类，定义几个通用的接口。实现具体的算法时，只要实现特定接口即可。 我最近实现了一把基本的神经网络，包括LR和多层NN模型, 使用C++11， Visual Studio 2017开发
C++从零实现深度神经网络之壹——Net类的设计和神经网络的初始化
星沉阁
12-15 7276
闲言少叙，直接开始。 既然是要用C++来实现，那么我们自然而然的想到设计一个神经网络类来表示神经网络，这里我称之为Net类。由于这个类名太过普遍，很有可能跟其他人写的程序冲突，所以我的所有程序都包含在namespace liu中，由此不难想到我姓刘。在之前的博客反向传播算法资源整理中，我列举了几个比较不错的资源。对于理论不熟悉而且学习精神的同学可以出门左转去看看这篇文章的资源。这里假设读者对于神经
BP神经网络c/c++代码实现
最新发布
生活需要深度
07-29 395
第 j 个输出神经元的输入： y ^ j = f ( β j − θ j ) 其中 θ j 为输出层的阈值 第j个输出神经元的输入：\hat{y}_{j}=f(\beta _{j}-\theta _{j}) 其中\theta _{j}为输出层的阈值。第 h 个隐层神经元的输出： b h = f ( α h − γ h ) 其中 γ h 为隐藏层的阈值 第h个隐层神经元的输出：b_{h}=f(\alpha _{h}-\gamma _{h})其中\gamma _{h}为隐藏层的阈值。
C++实现神经网络
weixin_30502965的博客
10-15 1023
原文地址BP神经网络原理及C++代码实现 头文件ANN.h #ifndef _ANN_H_ #define _ANN_H_ #include<assert.h> #include<stdlib.h> #include<iostream> #include<string> #include&l...
c++从零实现神经网络
一千世界
02-03 1745
C++从零实现神经网络（收藏版：两万字长文） AI科技大本营2018-01-09 00:00:0012280收藏75 作者 | 冰不语 本文转自微信公众号CVPy 01 Net类的设计与神经网络初始化 闲言少叙，直接开始 既然是要用C++来实现，那么我们自然而然的想到设计一个神经网络类来表示神经网络，这里我称之为Net类。由于这个类名太过普遍，很有可能跟其他人写的程序冲突，所以我的所有程序都包含在namespace liu中，由此不难想到我姓刘...
BP神经网络C++实现与详细讲解 代码部分注释详细，对每个用到的数学公式都有注释说明，资源包含数据集，可以直接运行
06-07
BP神经网络C++实现与详细讲解。代码部分注释详细，对每个用到的数学公式都有注释说明，资源包含数据集，可以直接运行。 在正向传播获取值时：在遍历当前层节点时 遍历上一层节点（从隐藏层开始） 在反向传播获修改...
BP神经网络C++实现——简单模式识别
12-29
4. **BP神经网络C++实现** - **数据预处理**：输入数据需要进行标准化或归一化，以便在网络中进行有效的计算。 - **网络初始化**：设置神经元数量、层数、初始权重等参数。 - **前向传播**：根据输入数据计算各层...
bp神经网络 c++实现bp算法 实现二进制数 和十进制数的识别.zip
01-11
这个压缩包文件包含了一个C++实现的BP神经网络，用于识别二进制数和十进制数。以下是关于BP神经网络及其C++实现的详细知识： 1. **BP神经网络基本原理**： - BP神经网络由输入层、隐藏层和输出层组成，其中隐藏层...
c++版神经网络实现
06-19
c++版神经网络的实现，内部实现了矩阵运算，前向传播，反向传播的基本逻辑，使用的是交叉熵损失函数，二分类问题，数据集是64*64*3的猫的图片，已被展成12288向量存于txt文件中，由于数据量大训练时间可能较长
基于C++版本的Bp神经网络，数据拟合，预测
03-19
C++版本的Bp神经网络，工程代码双击直接运行。可用于数据拟合、数据预测，N维输入，1输出。
神经网络的C++实现
10-13
神经网络的搭建与实现 径向基函数神经网络RBF
BP神经网络 c++完整实现代码
01-08
BP神经网络 c++完整实现代码,加了非常详细的注释，代码可以直接运行
神经网络经典算法，C++实现
06-02
神经网络经典算法，C++实现 神经网络经典算法，C++实现 神经网络经典算法，C++实现
C++实现神经BP神经网络
12-17
本文实例为大家分享了C++实现神经BP神经网络的具体代码，供大家参考，具体内容如下 BP.h #pragma once #include<vector> #include<stdlib> #include<time> #include<cmath> #include<iostream> using std::vector; using std::exp; using std::cout; using std::endl; class BP { private: int studyNum;//允许学习次数 double h;//学习率 double allowError;//允许
c++实现多层神经网络
10-22
c++实现多层神经网络模型，工程用vs2008生成。 参考了网上多篇c++神经网络代码，修改多处bug，最终生成无bug版本的代码 测试例子为自己构造：将3位二进制转为10进制
【深度学习系列（二）】：基于c++实现一个简单的神经网络（1）
wxplol的博客
01-31 5789
      学习深度学习首先得知道反向传播，这是神经网络能够学习得重要原因，也是深度学习得基石。所以，本系列以此为开篇，着重介绍神经网络得正向/反向传播得流程。哈哈，肯定有人会问为什么用C++实现，python不是更好吗？哈哈，本人严重C++控，好吧后续得一些文章大多是基于c++实现的，所以，最好有一定的c++基础。本文代码得配置要求： C++ OpenCV3.4 完整的代码工程可以访问我的g...
【深度学习系列（二）】：基于c++实现一个简单的神经网络（2）
wxplol的博客
02-01 1475
2、模型的搭建及初始化       在我们读取数据集时我们已经知道输入的神经元个数，在构造NN类时我们需要设置分类数，也就是说我们已经知道输入和输出的神经元个数，所以只要知道隐藏层的层数及每层的神经元个数，那么整个神经网络也就搭建完成了。本程序中通过容器保存插入每层隐藏层神经元个数来确定隐藏层的层数和个数。搭建整个网络，其实就是依次创建每一层的权重和偏置的矩阵，并分别保存到存储权重和偏置的容器中...
【深度学习系列（二）】：基于c++实现一个简单的神经网络（3）
wxplol的博客
04-25 1946
3、前向和反向传播 1. 单个神经元的前向和反向计算 众所周知，神经网络是由一系列的神经元组成，那具体长什么样呢？可以看下面的图。 所以，对于一个神经元来说，其前向计算公式如下： 其中...
C++实现BP神经网络程序详解
"BP神经网络的C++程序实现" BP神经网络（Backpropagation Neural Network）是一种常用的多层前馈神经网络，用于训练复杂函数的近似。在本C++程序中，BP神经网络的结构被定义为`bp_nn`结构体，包含了网络的输入层、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值