// BP.cpp : Defines the entry point for the console application.
创新互联专注为客户提供全方位的互联网综合服务，包含不限于网站设计、成都做网站、元宝网络推广、成都小程序开发、元宝网络营销、元宝企业策划、元宝品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联为所有大学生创业者提供元宝建站搭建服务，24小时服务热线：18980820575，官方网址：www.cdcxhl.com
//该程序实现神经网络的BP算法，输入节点数，输出节点数，隐层数，隐层节点数任意，由用户决定。
//其中隐层数指的是总共层数包含输出层，比如说异或算法为2层，第一层节点数为2，第二层也即输出层节点数为1，输入点数为2 。
//但是该程序对异或算法实现并不理想，对多层多节点的神经网络有较好的结果
#include "stdafx.h"
#include "iostream.h"
#include time.h
#include stdlib.h
#include fstream
#include math.h
#include "stdio.h "
#define MAXCOUNT 1e5 //迭代训练次数上限 1的10的正5次幂
//精度0.001的随机浮点数,范围在-0.5——0.5
//rand()取0到32767,最大为2147483647. %模运算表示余数为0到1000之间，所以乘上浮点数0。001f就是0-1之间的数，再减去0.5,就是-0.5到+0.5
float randf()
{
return (float)((rand() % 1001) * 0.001f-0.5);
}
//高斯随机数产生函数
//这样生成的高斯分布随机数序列的期望为0.0，方差为1.0。若指定期望为E，方差为V，则只需增加：X = X * V + E;
double gaussrand()
{
static double V1, V2, S;
static int phase = 0;
double X;
if(phase == 0) {
do {
double U1 = (double)rand() / RAND_MAX;
double U2 = (double)rand() / RAND_MAX;
V1 = 2 * U1 - 1;
V2 = 2 * U2 - 1;
S = V1 * V1 + V2 * V2;
} while(S = 1 || S == 0);
X = V1 * sqrt(-2 * log(S) / S);
} else
X = V2 * sqrt(-2 * log(S) / S );
phase = 1 - phase;
return X;
}
//定义一个多层前向BP网络
class BP
{
public:
double ***p;//记录所有的权值
double ***ddp;//记录所有的权值增量
int *pnode;//记录每一层的节点数
double **pnodey;//记录每组每一层的节点的输出值
double **ddlj;//记录每组每一层的节点的ddlj
double **pX; //记录输入样本
double **pY; //记录输入理想输出值
int Sidenum; //隐层数目
int Inputnodenum;
int outputnodenum;
int yangbenzushu;
BP()
{
Sidenum=0;
Inputnodenum=0;
outputnodenum=0;
yangbenzushu=0;
}
~BP()
{
for(int m=0;mSidenum;m++)
{
for(int n=0;npnode[m+1];n++)
{
delete[] p[m][n];
delete[] ddp[m][n];
}
delete[] p[m];
delete[] ddp[m];
}
delete[] p;
delete[] ddp;
p=NULL;
ddp=NULL;
if(p==NULL)
delete [] pnode;
for(int M=0;MSidenum;M++)
{
delete[] pnodey[M];
delete[] ddlj[M];
}
delete[] pnodey;
delete[] ddlj;
pnodey=NULL;
ddlj=NULL;
}
//完成所有权值的初始化
void getW(int sidenum,int inputnodenum,int outputnodenum1,int yangbenzu)
{
Sidenum=sidenum;
yangbenzushu= yangbenzu;//样本组数目
Inputnodenum=inputnodenum;
outputnodenum=outputnodenum1;
p=new double **[sidenum];//记录所有权值
ddp=new double **[sidenum];//权值增量
pnode=new int [sidenum+1];//包含输入层，输出层每一层的节点数.
for(int i=0;isidenum+1;i++)
{
int data=0;
cout"请输入第"i"层节点数"endl;
cindata;
pnode[i]=data;
}
for (int j=0;jsidenum;j++) // 初始化权值, 不包含输入层,但是包含输出层.第0层表示第一个隐层
{
p[j]=new double* [pnode[j+1]]; //首先P[j]层有多少个节点,就有多少个指针,每个指针指向一个权值数组.因为p[j]是二级指针,存放的是某指针的地址,某指针可以指向一维数组.
ddp[j]=new double*[pnode[j+1]];//同上
for (int k=0;kpnode[j+1];k++)
{
ddp[j][k]=new double[pnode[j]+1];//表示第j层的第k个节点指向的是一个数组,这个数组里存的是这个节点的权值.
p[j][k]=new double[pnode[j]+1];
for (int t=0;tpnode[j]+1;t++) //pnode[j]+1 表示第j层的输入点个数.
{
ddp[j][k][t]=0;//每一层的权值初始化为0 表示的是第j层的第k个节点,第t个输入的输入权值.
if(t==0)p[j][k][t]=-fabs(randf());//每一层的阀值初始化 第0个元素.
else p[j][k][t]=randf();//每一层的权值初始化
}
}
}
//为记录每一层的节点的输出值和ddlj的指针开辟内存
pnodey=new double *[Sidenum]; //一共有Sidenum层.
ddlj=new double *[Sidenum];
for(int p=0;pSidenum;p++)
{
pnodey[p] = new double [pnode[p+1]+1];//每层一共有节点数+1个输出
ddlj[p]=new double [pnode[p+1]];// 这个是做什么的？？
pnodey[p][0]=1;//每组每层的首值为1,这个值是为了与阈值相乘,这也是为什么会有上面+1个输出
}
}
/**********************/
//每个节点输出函数
double fas(double s)
{
double t;
t=1.0/(exp(-s)+1);
return t;
}
/************************************************/
//该函数用来记录样本值和理想输出值
void INPUT(int yangbenzushu1 )
{
pY=new double*[yangbenzushu1];//yangbenzushu1数量个理想输出
pX=new double*[yangbenzushu1];//yangbenzushu1数量个样本
for(int yu=0;yuyangbenzushu1;yu++)
{
pX[yu]=new double[Inputnodenum+1];//每个样本的维数是输入点个数+1
pY[yu]=new double[outputnodenum+1];//输出的维数也是输出点个数+1
}
//每组样本的首值赋为1， 这样就可以使下标对应的比较好
for(int yu1=0;yu1yangbenzushu1;yu1++)
{
pX[yu1][0]=1;
pY[yu1][0]=1;
}
cout"请输入样本输入值"endl;
for(int yuy=0;yuyyangbenzushu1;yuy++)
for(int yy=1;yy=Inputnodenum;yy++)
{
if(yy==Inputnodenum) coutendl;
cout"X["yuy"]""["yy"]="' ';
cinpX[yuy][yy];
}
cout"请输入样本理想输出值"endl;
for(int yuy1=0;yuy1yangbenzushu1;yuy1++)
for(int yy1=1;yy1=outputnodenum;yy1++)
{ //if(yy==Inputnodenum) coutendl;
cout"Y["yuy1"]""["yy1"]="' ';
cinpY[yuy1][yy1];
}
}
/****************************************************************************/
//计算每个节点的输出值
double computeYl(int KK)//KK代表第几组组号
{
double sum1=0;
//把所有的层的每一个节点的输出值算出来并记录在pnodey里,不包含输入点值
for(int y=0;ySidenum;y++)//层数
{
for(int r=1;rpnode[y+1]+1;r++)//本节点数，加1是为了下标好看
{
double sum=0;
for(int z=0;zpnode[y]+1;z++)//前一层的节点数
{
if(y==0)sum+= pX[KK][z]*p[y][r-1][z];
else
sum+=pnodey[y-1][z]*p[y][r-1][z];
}
pnodey[y][r]=fas(sum);
}
}
for(int j=1;j=outputnodenum;j++)
sum1+=pow(pY[KK][j]-pnodey[Sidenum-1][j],2);
return sum1;
}
/**********************************************************/
//Compute Back-Propagation-Errors
void ComputeBackPropagationErrors(int gf)//gf代表组号
{//计算所有的ddlj[][]
//for(int gf=0;gfyangbenzushu;gf++)//组数
for(int q=Sidenum-1;q=0;q--)//从最后一层开始
{
if(q==Sidenum-1)//如果是最外一层的话
{
for(int rt=0;rtpnode[q+1];rt++)//每层的节点数
ddlj[q][rt]=pnodey[q][rt+1]*(1-pnodey[q][rt+1])*(pY[gf][rt+1]-pnodey[q][rt+1]) ;
}
else
{
for(int ry=0;rypnode[q+1];ry++)
{
double sumtemp=0;
for(int fg=0;fgpnode[q+2];fg++)
sumtemp+=ddlj[q+1][fg]*p[q+1][fg][ry+1];
ddlj[q][ry] = pnodey[q][ry+1]*(1-pnodey[q][ry+1])* sumtemp;
}
}
}
//计算所有的ddp[][]
//for(int gf1=0;gf1yangbenzushu;gf1++)//组数
for(int l=0;lSidenum;l++)//层数
for(int JJ=0;JJpnode[l+1];JJ++)//每一层的节点数
for(int i=0;ipnode[l]+1;i++)//前一层的节点数
{
if(l==0)//如果是第一层的话，y值为输入的X值
ddp[l][JJ][i]=ddlj[l][JJ]*pX[gf][i];
else
ddp[l][JJ][i]=ddlj[l][JJ]*pnodey[l-1][i];
}
}
/*************************************************************************/
void UpdatetheWeightsusingBPAlgorithm()
{
for(int cent=0;centSidenum;cent++)//层数
for(int J=0;Jpnode[cent+1];J++)//每一层的节点数
for(int i=0;ipnode[cent]+1;i++)//前一层的节点数
p[cent][J][i]+=0.2*ddp[cent][J][i];
}
/***************************************************************************/
double xunlianErrors()//定义训练误差函数
{
double error=0;
double sum=0;
double temp=0;
double temp1=0;
for(int gf1=0;gf1yangbenzushu;gf1++)//组数
{
temp= computeYl(gf1);
//temp1=zhengquelv(gf1);
//sum+=temp1;
for(int jj=1;jj=outputnodenum;jj++)
coutpnodey[Sidenum-1][jj];
error+=temp;
}
// sum=sum/yangbenzushu;
cout"用训练集所得到的正确率："sumendl;
return error/yangbenzushu;
}
/****************************************************************************/
double jiaoyanErrors(int yangbenzushu1 )//定义校验误差函数
{
double error=0;
double sum=0;
double temp=0;
double temp1=0;
for(int gf1=0;gf1yangbenzushu1;gf1++)//组数
{
temp= computeYl(gf1);
for(int jj=1;jj=outputnodenum;jj++)
coutpnodey[Sidenum-1][jj];
//temp1=zhengquelv(gf1);
//sum+=temp1;
error+=temp;
}
//sum=sum/yangbenzushu1;
//cout"用校验集所得到的正确率："sumendl;
return error/yangbenzushu1;
}
/********************************************************************/
double zhengquelv(int KK)
{
int count=0;
double av=0;
//for(int gf1=0;gf1yangbenzushu;gf1++)//组数
for(int jj=1;jj=outputnodenum;jj++)
{
if (pnodey[Sidenum-1][jj]0) pnodey[Sidenum-1][jj]=1;
else pnodey[Sidenum-1][jj]=0;
if(pY[KK][jj]==pnodey[Sidenum-1][jj])count++;
}
av=(double)count/outputnodenum;
return av;
}
/***********************************************************************/
void freeINput()
{
if(pX!=NULL)
{
for(int u=0;uyangbenzushu;u++)
delete []pX[u];
delete []pX;
pX=NULL;
}
if(pY!=NULL)
{
for(int u1=0;u1yangbenzushu;u1++)
delete []pY[u1];
delete []pY;
pY=NULL;
}
}
/***************************************************************/
//输出所有的权值
void wputout()
{
for (int j=0;jSidenum;j++)
{
cout"第["j+1"]层权值为："endl;
for (int k=0;kpnode[j+1];k++)
{
//if(k==pnode[j+1]-1) coutendl;
for (int t=0;tpnode[j]+1;t++)
{
coutp[j][k][t]' ';
if(t==pnode[j]) coutendl;
}
}
}
}
/**********************************************************/
};
void main()
{
BP bp;
int count=0;//用来统计所用的迭代次数
//FILE *fp;
int inputnodenum,outnodenum,sidenum,yangbenzunum;
double error;
cout"请输入：输入点数，输出点数，隐层数"endl;
cininputnodenumoutnodenumsidenum;
cout"请输入样本组数"endl;
cinyangbenzunum;
//第一步初始化所有的权值
bp.getW(sidenum,inputnodenum,outnodenum,yangbenzunum);
//第二步输入样本组
bp.INPUT(yangbenzunum);
for(count++)
{
double sum=0;
double temp=0;
for(int fuzu=0;fuzuyangbenzunum;fuzu++)
{
//第三步计算所有y值
temp=bp点抗 puteYl(fuzu);
//第四步Compute Back-Propagation-Errors
bp.ComputeBackPropagationErrors(fuzu);
//第五步Update the Weights using BP Algorithm
bp.UpdatetheWeightsusingBPAlgorithm();
sum+=temp;
}
//第六步判断是否收敛
error=sum/2*yangbenzunum;
//freopen("debug\\out.txt","w",stdout);
//fp=freopen( "out.txt", "w", stdout) ;
// coutcount' 'errorendl;
// fclose(stdout);//关闭文件
/*if(count==1000)couterrorendl;
if(count==1500)couterrorendl;
if(count==1600)couterrorendl;*/
//if(count==10000)couterrorendl;
if(error1.02)
{
cout"循环收敛""迭代次数为："countendl;
//bp.freeINput();//释放X Y空间
break;
}
}
cout"权值为："endl;
bp.wputout();
double XUNLIANER=bp.xunlianErrors();
//cout"训练误差为："XUNLIANERendl;
bp.freeINput();//释放X Y空间
/*
cout"请输入校验样本: "endl;
int jiaoyannum=0;
cinjiaoyannum;
bp.INPUT(jiaoyannum);
double jiaoyanER=bp.jiaoyanErrors(jiaoyannum);
cout"校验误差为:"jiaoyanERendl;
//fclose( stdout ) ;*/
}
见附件，一个基本的用java编写的BP网络代码。
BP（Back Propagation）神经网络是86年由Rumelhart和McCelland为首的科学家小组提出，是一种按误差逆传播算法训练的多层前馈网络，是目前应用最广泛的神经网络模型之一。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。它的学习规则是使用最速下降法，通过反向传播来不断调整网络的权值和阈值，使网络的误差平方和最小。BP神经网络模型拓扑结构包括输入层（input）、隐层(hidden layer)和输出层(output layer)。
你“行”的概念是什么？ 用C++之后在matlab中编译成mex后，使用的时候一行代码就可以了。
同理，实现算法本身中基本的运算过程是不是展开，用什么、语言？
再者，什么类型的网络？ 普通的全连接？ 局部连接的卷积神经网络？ Deep Residual Network? 不同类型的网络结构上会不一样。