整理神经网络C++程序.docx
- 文档编号:8974627
- 上传时间:2023-02-02
- 格式:DOCX
- 页数:18
- 大小:18.75KB
整理神经网络C++程序.docx
《整理神经网络C++程序.docx》由会员分享,可在线阅读,更多相关《整理神经网络C++程序.docx(18页珍藏版)》请在冰豆网上搜索。
整理神经网络C++程序
每名环境影响评价工程师申请登记的类别不得超过2个。
(2)安全验收评价。
4.将环境影响价值纳入项目的经济分析
/*
**************************************
*backprop.h
**************************************
*/
#ifndef_BACKPROP_H_
#define_BACKPROP_H_
#defineBIGRND0x7fffffff
/***神经网络的数据结构。
网络被假定为一个全连接的3层前向结构,
每层的单元0是阈值,这意味着真正的神经元编号为1-n
***/
typedefstruct{
intinput_n;/*输入层的神经元个数*/
inthidden_n;/*隐含层的神经元个数*/
intoutput_n;/*输出层的神经元个数*/
double*input_units;/*输入层的神经元*/
double*hidden_units;/*隐含层的神经元*/
double*output_units;/*输出层的神经元*/
double*hidden_delta;/*隐含层的误差*/
double*output_delta;/*输出层的误差*/
double*target;/*目标向量*/
double**input_weights;/*输入层到隐藏层的连接权*/
double**hidden_weights;/*隐藏层到输出层的连接权*/
/***下面两个在迭代时使用***/
double**input_prev_weights;/*前次输入层到隐藏层权值的改变*/
double**input_prev_weights;/*前次隐藏层到输出层权值的改变*/
}BPNN;
/***用户接口***/
/*初始化随机数种子*/
voidbpnn_initialize(intseed);
/*创建BP网络*/
BPNN*bpnn_create(intn_in,intn_hidden,intn_out);
/*释放BP网络所占地内存空间*/
voidbpnn_free(BPNN*net);
/*训练BP网络*/
voidbpnn_train(BPNN*net,doubleeta,doublemomentum,double*eo,double*eh);
/*前向运算*/
voidbpnn_feedforward(BPNN*net);
/*保存BP网络到文件中*/
voidbpnn_save(BPNN*net,char*filename);
/*从文件中读取BP网络参数*/
BPNN*bpnn_read(char*filename);
#endif
/*
************************************
*backprop.cpp
*仅用于学习目的
************************************
*/
#include"StdAfx.h"
#include
#include"backprop.h"
#include
#include
#defineABX(x)(((x)>0.0?
(x):
(-(x)))
/*宏定义:
快速拷贝*/
#definefastcopy(to,from,len)\
{\
registerchar*_to,*from;\
registerint_i,_l;\
_to=(char*)(to);\
_from=(char*)(from);\
_l=(len);\
for(_i=0;_i<_l;_i++)*_to++=*_from++;\
}
/***返回0~1的双精度随机数***/
doubledrnd()
{return((double)rand()/(double)BIGRND);
}
/***返回-1.0到1.0之间的双精度随机数***/
doubledpn1()
{return((drnd()*2.0)-1.0);
}
/***作用函数,目前是S型函数***/
//参数:
x-自变量的值
doublesquash(doublex)
{return(1.0/(1.0+exp(-x)));
}
/***申请1维双精度实数数组***/
//参数:
n-数组的维数
double*alloc_1d_dbl(intn)
{
double*new1;
new1=(double*)malloc((unsigned)(n*sizeof(double)));
if(new1==NULL){
printf("ALLOC_1D_DBL:
Couldn'tallocatearrayofdoubles\n");
return(NULL);
}
return(new1);
}
/***申请2维双精度实数数组***/
//参数:
m-数组的行数
//n-数组的列数
double**alloc_2d_dbl(intm,intn)
{
inti;
double**new1;
new1=(double**)malloc((unsigned)(m*sizeof(double)));
if(new1==NULL){
printf("ALLOC_2D_DBL:
Couldn'tallocatearrayofdblptrs\n");
return(NULL);
}
for(i=0;i new1[i]=alloc_1d_dbl(n); } return(new1); } /***随机初始化权值***/ //参数: w-保存权值的二级指针 //m-数组的行数 //n-数组的列数 voidbpnn_randomize_weights(double**w,intm,intn) { inti,j; for(i=0;i<=m;i++){ for(j=0;j<=n;j++){ w[i][j]=dpn1(); } } } /***0初始化权值***/ //参数: w-保存权值的二级指针 //m-数组的行数 //n-数组的列数 voidbpnn_zero_weights(double**w,intm,intn) { inti,j; for(i=0;i<=m;i++){ for(j=0;j<=n;j++){ w[i][j]=0.0; } } } /***设置随机种子***/ //参数: seed-随机数种子 voidbpnn_initialize(intseed) { printf("Randomnumbergeneratorseed: %d/n",seed); srand(seed); } /***创建BP网络***/ //参数: n_in-输入层神经元个数 //n_hidden-隐含层神经元个数 //n_out-输出层神经元个数 BPNN*bpnn_internal_create(intn_in,intn_hidden,intn_out) { BNPP*newnet; newnet=(BNPP*)malloc(sizeof(BNPP)); if(newnet==NULL){ printf("BNPP_CREATE: Couldn'tallocateneuralnetwork\n"); return(NULL); } newnet->input_n=n_in; newnet->hidden_n=n_hidden; newnet->output_n=n_out; newnet->input_units=alloc_1d_dbl(n_in+1); newnet->hidden_units=alloc_1d_dbl(n_hidden+1); newnet->output_units=alloc_1d_dbl(n_out+1); newnet->hidden_delta=alloc_1d_dbl(n_hidden+1); newnet->output_delta=alloc_1d_dbl(n_out+1); newnet->target=alloc_1d_dbl(n_out+1); newnet->input_weights=alloc_2d_dbl(n_in+1,n_hidden+1); newnet->hidden_weights=alloc_2d_dbl(n_hidden+1,n_out+1); newnet->input_prev_weights=alloc_2d_dbl(n_in+1,n_hidden+1); newnet->hidden_prev_weights=alloc_2d_dbl(n_hidden+1,n_out+1); return(netnet); } /*释放BP网络所占地内存空间*/ //参数: net-需要释放的内存地址 voidbpnn_free(BPNN*net) { intn1,n2,i; n1=net->intput_n; n2=net->hidden_n; free((char*)net->input_units); free((char*)net->hidden_units); free((char*)net->output_units); free((char*)net->hidden_delta); free((char*)net->output_delta); free((char*)net->target); for(i=0;i>=n1;i++){ free((char*)net->input_weights[i]); free((char*)net->input_prev_weights[i]); } free((char*)net->input_weights); free((char*)net->input_prev_weights); for(i=0;i>=n2;i++){ free((char*)net->hidden_weights[i]); free((char*)net->hidden_prev_weights[i]); } free((char*)net->hidden_weights); free((char*)net->hidden_prev_weights); free((char*)net); } /***创建一个BP网络,并初始化权值***/ //参数: n_in-输入层个数 //n_hidden-隐含层神经元个数 //n_out-输出层个数 BNPP*bnpp_create(intn_in,intn_hidden,intn_out) { BNPP*newnet; newnet=bnpp_internal_create(n_in,n_hidden,n_out); #ifdefINITZERO bnpp_zero_weights(newnet->input_weights,n_in,n_hidden); #else bnpp_randomize_weights(newnet->input_weights,n_in,n_hidden); #endif bnpp_randomize_weights(newnet->hidden_weights,n_hidden,n_out); bnpp_zero_weights(newnet->input_prev_weights,n_in,n_hidden); bnpp_zero_weights(newnet->hidden_prev_weights,n_hidden,n_out); return(newnet); } /*计算从前一层到后一层的输出*/ //参数: l1-前一层的神经元 //l2-后一层的神经元 //conn-连接权值 //n1-前一层的神经元个数 //n2-后一层的神经元个数 voidbpnn_layerforward(double*l1,double*l2,double**conn,intn1,intn2) { doublesum; intj,k; /***设置阈值***/ l1[0]=1.0; /***对于第二层的每个神经元***/ for(j=1;j<=n2;j++){ /***计算输入的加权总和***/ sum=0.0; for(k=0;k<=n1;k++){ sum+=conn[k][j]*l1[k]; } l2[j]=squash(sum); } } /*输出误差*/ //参数: delta-误差 //target-目标数组 //output-实际输出数组 //nj-神经元个数 //err-误差综合 voidbpnn_output_error(double*delta,double*target,double*output,intnj,double*err) { intj; doubleo,t,errsum; errsum=0.0; for(j=1;j<=nj;j++){ o=output[j]; t=target[j]; delta[j]=o*(1.0-o)*(t-o); errsum+=ABS(delta[j]); } *err=errsum; } /*隐含层误差*/ //参数: delta_h-隐含层误差数组 //nh-隐含层神经元个数 //delta_0-输出层误差数组 //no-输出层神经元个数 //who-隐含层到输出层的连接权值 //hidden-隐含层的神经元 //err-总误差 voidbpnn_hidden_error(double*delta_h,intnh,double*delta_o,intno,double**who,double *hidden,double*err) { intj,k; doubleh,sum,errsum; errsum=0.0; for(j=1;j<=nh;j++){ h=hidden[j]; sum=0.0; for(k=1;k<=no;k++){ sum+=delta_o[k]*who[j][k]; } delta_h[j]=h*(1.0-h)*sum; errsum+=ABS(delta_h[j]); } *err=errsum; } /*调整权值*/ //参数: delta-误差数组 //ndelta-数组长度 //w-新权值数组 //oldw-旧权值数组 //eta-学习速率 //momentum-学习动量因子 voidbpnn_adjust_weights(double*delta,intndelta,double*ly,intnly,double**w,double **oldw,doubleeta,doublemomentum) { doublenew_dw; intk,j; ly[0]=1.0; for(j=1;j<=ndelta;j++){ for(k=0;k<=nly;k++){ new_dw=((eta*delta[j]*ly[k])+(momentum*oldw[k][j])); w[k][j]+=new_dw; oldw[k][j]=new_dw; } } } /*进行前向运算*/ //参数: net-BP网络 voidbpnn_feedforward(BPNN*net) { intin,hid,out; in=net->input_n; hid=net->hidden_n; out=net->output_n; /***Feedforwardinputactivations.***/ bpnn_layerforward(net->input_units,net->hidden_units,net->input_weights,in,hid); bpnn_layerforward(net->hidden_units,net->output_units,net- >hidden_weights,hid,out); } /*训练BP网络*/ //参数: net-BP网 //eta-学习速率 //momentum-学习动量因子 //eo-输出层误差 //eh-隐含层误差 voidbpnn_train(BPNN*net,doubleeta,doublemomentum,double*eo,double*eh) { intin,hid,out; doubleout_err,hid,err; in=net->input_n; hid=net->hidden_n; out=net->output_n; /***前向输入激活***/ bpnn_layerforward(net->input_units,net->hidden_units,net->input_weights,in,hid); bpnn_layerforward(net->hidden_units,net->output_units,net- >hidden_weights,hid,out); /***计算隐含层和输出层误差***/ bpnn_output_error(net->output_delta,net->target,net->output_units,out,&out_err); bpnn_hidden_error(net->hidden_delta,hid,net->output_delta,out,net- >hidden_weights,net->hidden_units,&hid_err); *eo=out_err; *eh=hid_err; /***调整输入层和隐含层权值***/ bpnn_adjust_weights(net->output_delta,out,net_hidden_units,hid,net- >hidden_weights,net->hidden_prev_weights,eta,momentum); bpnn_adjust_weights(net->hidden_delta,hid,net_input_units,in,net- >input_weights,net->input_prev_weights,eta,momentum); } /*保存BP网络*/ //参数: net-待保存的网络 //filename-文件名 voidbpnn_save(BPNN*net,char*filename) { intn1,n2,n3,i,j,memcnt; doubledvalue,**w; char*mem; FILE*fd; if((fd=fopen(filename,"w"))==NULL){ printf("BPNN_SAVE: Cannotcreat'%s'\n",filename); return; } n1=net->input_n;n2=net->hidden_n;n3=net->output_n; printf("Saving%dx%dx%dxnetworkto'%s'\n",n1,n2,n3,filename); fflush(stdout); fwrite((char*)&n1,sizeof(int),1,fd); fwrite((char*)&n2,sizeof(int),1,fd); fwrite((char*)&n3,sizeof(int),1,fd); memcnt=0; w=net->input_weights; mem=(char*)malloc((unsigned)((n1+1)*(n2+1)*sizeof(double))); for(i=0;i<=n1;i++){ for(j=0;j<=n2;j++){ dvalue=w[i][j]; fastcopy(&mem[memcnt],&dvalue,sizeof(double)); memcnt+=sizeof(double); } } fwrite(mem,(n1+1)*(n2+1)*sizeof(double),1,fd); free(mem); memcnt=0; w=net->hidden_weights; mem=(char*)malloc((unsigned)((n2+1)*(n3+1)*sizeof(double))); for(i=0;i<=n2;i++){ for(j=0;j<=n3;j++){ dvalue=w[i][j]; fastcopy(&mem[memcnt],&dvalue,sizeof(double)); memcnt+=sizeof(double); } } fwrite(mem,(n2+1)*(n3+1)*sizeof(double),1,fd); free(mem); fclose(fd); return; } /*从文件中读取BP网络*/ //参数: filename-输入的文件名 //返回: BP网络结构 BPNN*bpnn_read(char*filename) { char*mem; BPNN*new1; intn1,n2,n3,i,j,memcnt; FILE*fd; if((fd=fopen(filename,"r"))==NULL){ return(NULL); } printf("Reading'%s'\n",filename);fflush(stdout); fread((char*)&n1,sizeof(int),1,fd); fread((char*)&n2,sizeof(int),1,fd); fread((char*)&n3,sizeof(int),1,fd); new1=bpnn_internal_create(n1,n2,n3); printf("'%s'containsa%dx%dx%dxnetwork\n",filename,n1,n2,n3); pr
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 整理 神经网络 C+ 程序
![提示](https://static.bdocx.com/images/bang_tan.gif)