返回首页
当前位置: 主页 > 网络编程 > 其他实例教程 >

C++的BP算法源程序详解

时间:2011-05-20 21:30来源:知行网www.zhixing123.cn 编辑:麦田守望者

BP神经网络算法C++源程序:

  1. #include "iostream.h"
  2. #include "iomanip.h"
  3. #define N 20 //学习样本个数
  4. #define IN 1 //输入层神经元数目
  5. #define HN 8 //隐层神经元数目
  6. #define ON 1 //输出层神经元数目
  7. double P[IN]; //单个样本输入数据
  8. double T[ON]; //单个样本教师数据
  9. double W[HN][IN]; //输入层至隐层权值
  10. double V[ON][HN]; //隐层至输出层权值
  11. double X[HN]; //隐层的输入
  12. double Y[ON]; //输出层的输入
  13. double H[HN]; //隐层的输出
  14. double O[ON]; //输出层的输出
  15. double sita[HN]; //隐层的阈值
  16. double gama[ON]; //输出层的阈值
  17. double err_m[N]; //第m个样本的总误差
  18. double alpha; //输出层至隐层的学习效率
  19. double beta; //隐层至输入层学习效率
  20. //定义一个放学习样本的结构
  21. struct {
  22. double input[IN];
  23. double teach[ON];
  24. }Study_Data[N][IN];
  25. ///////////////////////////
  26. //初始化权、阈值子程序/////
  27. ///////////////////////////
  28. initial()
  29. {
  30. float sgn;
  31. float rnd;
  32. int i,j;
  33. //隐层权、阈值初始化//
  34. {
  35. //sgn=pow((-1),random(100));
  36. sgn=rand();
  37. rnd=sgn*(rand()%100);
  38. W[j][i]= rnd/100;//隐层权值初始化。
  39. }
  40. //randomize();
  41. {
  42. //sgn=pow((-1),random(1000));
  43. sgn=rand();
  44. rnd=sgn*(rand()%1000);
  45. sita[j]= rnd/1000;//中间层阈值初始化
  46. cout<<"sita"<<sita[j]<<endl;
  47. }
  48. //输出层权、阈值初始化//
  49. //randomize();
  50. for (int k=0;k<ON;k++)
  51. for (int j=0;j<HN;j++)
  52. {
  53. //sgn=pow((-1),random(1000));
  54. sgn=rand();
  55. rnd=sgn*(rand()%1000);
  56. V[k][j]=rnd/1000;//第m个样本输出层权值初始化
  57. }
  58. //randomize();
  59. {
  60. //sgn=pow((-1),random(10));
  61. sgn=rand();
  62. rnd=sgn*(rand()%10);
  63. gama[k]=rnd/10;//输出层阈值初始化
  64. cout<<"gama[k]"<<endl;
  65. }
  66. return 1;
  67. }//子程序initial()结束
  68. ////////////////////////////////
  69. ////第m个学习样本输入子程序///
  70. ///////////////////////////////
  71. input_P(int m)
  72. {
  73. for (int i=0;i<IN;i++)
  74. P[i]=Study_Data[m]->input[i];
  75. //获得第m个样本的数据
  76. //cout<<"第"< //fprintf(fp,"第%d个样本的学习输入:
  77. //P[%d]=%f\n",m,P[i]);
  78. return 1;
  79. }//子程序input_P(m)结束
  80. /////////////////////////////
  81. ////第m个样本教师信号子程序//
  82. /////////////////////////////
  83. input_T(int m)
  84. {
  85. for (int k=0;k<m;k++)
  86. T[k]=Study_Data[m]->teach[k];
  87. //cout<<"第"< //fprintf(fp,"第%d个样本的教师信号:T[%d]=%f\n",m,T[k]);
  88. return 1;
  89. }//子程序input_T(m)结束
  90. /////////////////////////////////
  91. //隐层各单元输入、输出值子程序///
  92. /////////////////////////////////
  93. H_I_O(){
  94. double sigma;
  95. int i,j;
  96. for (j=0;j<HN;j++)
  97. sigma=0.0;
  98. for (i=0;i<IN;i++)
  99. sigma+=W[j][i]*P[i];//求隐层内积
  100. }
  101. X[j]=sigma - sita[i];//求隐层净输入
  102. H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
  103. }
  104. return 1;
  105. }//子程序H_I_O()结束
  106. ///////////////////////////////////
  107. //输出层各单元输入、输出值子程序///
  108. ///////////////////////////////////
  109. O_I_O()
  110. {
  111. double sigma;
  112. for (int k=0;k<ON;k++)
  113. sigma=0.0;
  114. for (int j=0;j<HN;j++)
  115. sigma+=V[k][j]*H[k];//求输出层内积
  116. }
  117. Y[k]=sigma-gama[k]; //求输出层净输入
  118. O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
  119. }
  120. return 1;
  121. }//子程序O_I_O()结束
  122. ////////////////////////////////////
  123. //输出层至隐层的一般化误差子程序////
  124. ////////////////////////////////////
  125. double d_err[ON];
  126. Err_O_H(int m)
  127. {
  128. double abs_err[ON];//每个样本的绝对误差都是从0开始的
  129. double sqr_err=0;//每个样本的平方误差计算都是从0开始的
  130. //for (int output=0;output<ON;output++) //output???
  131. for (int k=0;k<ON;k++)
  132. abs_err[k]=T[k]-O[k];
  133. //求第m个样本下的第k个神经元的绝对误差
  134. sqr_err+=(abs_err[k])*(abs_err[k]);//求第m个样本下输出层的平方误差
  135. d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);//d_err[k]输出层各神经元的一般化误差
  136. }
  137. err_m[m]=sqr_err/2;//第m个样本下输出层的平方误差/2=第m个样本的均方误差
  138. return 1;
  139. }//子程序Err_O_H(m)结束
  140. ////////////////////////////////////
  141. //隐层至输入层的一般化误差子程序////
  142. ////////////////////////////////////
  143. double e_err[HN];
  144. Err_H_I(){
  145. double sigma;
  146. //for (int hidden=0;hidden
  147. for (int j=0;j<HN;j++)
  148. sigma=0.0;
  149. for (int k=0;k<ON;k++)
  150. sigma=d_err[k]*V[k][j];
  151. }
  152. e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
  153. }
  154. return 1;
  155. }//子程序Err_H_I()结束
  156. ////////////////////////////////////////////////////////
  157. //输出层至隐层的权值调整、输出层阈值调整计算子程序//////
  158. ////////////////////////////////////////////////////////
  159. Delta_O_H(int m,FILE* fp)
  160. {
  161. for (int k=0;k<ON;k++)
  162. for (int j=0;j<HN;j++)
  163. //cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为:%f\n",m,W[k][j]);
  164. V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
  165. }
  166. gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
  167. }
  168. return 1;
  169. }//子程序Delta_O_H()结束
  170. /////////////////////////////////////////////////////
  171. //隐层至输入层的权值调整、隐层阈值调整计算子程序/////
  172. /////////////////////////////////////////////////////
  173. Delta_H_I(int m,FILE* fp)
  174. {
  175. for (int j=0;j<HN;j++)
  176. for (int i=0;i<IN;i++)
  177. //cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为:%f\n",m,V[j][i]);
  178. W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
  179. }
  180. sita[j]+=beta*e_err[j];
  181. }
  182. return 1;
  183. }//子程序Delta_H_I()结束
  184. /////////////////////////////////
  185. //N个样本的全局误差计算子程序////
  186. /////////////////////////////////
  187. double Err_Sum()
  188. {
  189. double total_err=0;
  190. for (int m=0;m<N;m++)
  191. total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
  192. }
  193. return 1;
  194. }//子程序Err_sum()结束
  195. /**********************/
  196. /**程序入口,即主程序**/
  197. /**********************/
  198. main()
  199. {
  200. FILE *fp;
  201. double sum_err;
  202. int study;//训练次数
  203. if ((fp=fopen("bp.txt","a+"))==NULL)
  204. {
  205. printf("不能创建bp.txt文件!\n");
  206. exit(1);
  207. }
  208. cout<<"请输入输出层到隐含层学习效率: alpha=\n";
  209. cin>>alpha;
  210. cout<<"请输入隐含层到输入层学习效率: beta=\n";
  211. cin>>beta;
  212. int study=0; //学习次数
  213. double Pre_error ; //预定误差
  214. cout<<"请输入预定误差: Pre_error= \n";
  215. cin>>Pre_error;
  216. int Pre_times;
  217. cout<<"请输入预定最大学习次数:Pre_times=\n";
  218. cin>>Pre_times;
  219. cout<<"请输入学习样本数据\n";
  220. {
  221. for (int m=0;m<N;m++)
  222. cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
  223. for (int i=0;i<IN;i++)
  224. cin>>Study_Data[m]->input[i];
  225. }
  226. {
  227. for (int m=0;m<N;m++)
  228. cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
  229. for (int k=0;k<ON;k++)
  230. cin>>Study_Data[m]->teach[k];
  231. }
  232. initial(); //隐层、输出层权、阈值初始化 (1)
  233. do
  234. {
  235. ++study; ///???
  236. for (int m=0;m<N;m++)
  237. {
  238. input_P(m); //输入第m个学习样本 (2)
  239. input_T(m);//输入第m个样本的教师信号 (3)
  240. H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
  241. O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
  242. Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
  243. Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
  244. Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
  245. Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
  246. } //全部样本训练完毕
  247. sum_err=Err_Sum(); //全部样本全局误差计算 (10)
  248. {
  249. cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
  250. fprintf(fp,"第%d次学习的均方误差为:%f\n",study,sum_err);
  251. }
  252. while (sum_err > Pre_error) //or(study
  253. { //N个样本全局误差小于预定误差否? 小于则退出 (11)
  254. cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
  255. fprintf(fp,"网络已经学习了%d次,现在的全局误差为:%f\n",study,total_err);
  256. fclose(fp);
  257. }
  258. char s;
  259. cout<<"请随便输入一个字符,按回车退出程序!\n";
  260. cin>>s;
  261. return 1;
  262. }
  263. }

------分隔线----------------------------
标签(Tag):人工智能 人机交互技术
------分隔线----------------------------
推荐内容
猜你感兴趣