神经网络BP算法

ken1983414

神经网络BP算法(vC++程序)
                                       

文件输入输出目录为：F:\BP\

训练样本文件名：训练样本.txt

值为：

1
1
-1
1
-1
1
0
1
0
1

输出文件名为：阈值.txt    权值.txt

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

1. #include "stdlib.h"
   
2. #include "math.h"
   
3. #include "conio.h"
   
4. #include "stdio.h"
   
5. #define N 2 /*/学习样本个数*/
   
6. #define IN 3 /*/输入层神经元数目*/
   
7. #define HN 3 /*/隐层神经元数目*/
   
8. #define ON 2 /*/输出层神经元数目*/
   
9. #define Z 20 /*/旧权值保存-》每次study的权值都保存下来*/
   
10. double P[IN]; /*/单个样本输入数据*/
    
11. double T[ON]; /*/单个样本教师数据*/
    
12. double W[HN][IN]; /*/输入层至隐层权值*/
    
13. double V[ON][HN]; /*/隐层至输出层权值*/
    
14. double X[HN]; /*/隐层的输入*/
    
15. double Y[ON]; /*/输出层的输入*/
    
16. double H[HN]; /*/隐层的输出*/
    
17. double O[ON]; /*/输出层的输出*/
    
18. double YU_HN[HN]; /*/隐层的阈值*/
    
19. double YU_ON[ON]; /*/输出层的阈值*/
    
20. double err_m[N]; /*/第m个样本的总误差*/
    
21. double a; /*/输出层至隐层的学习效率*/
    
22. double b; /*/隐层至输入层学习效率*/
    
23. double alpha;  /*/动量因子，改进型bp算法使用*/
    
24. double d_err[ON];
    
25. 
    
26. FILE *fp;
    
27. /*定义一个放学习样本的结构*/
    
28. struct {
    
29. double input[IN];
    
30. double teach[ON];
    
31. }Study_Data[N];
    
32. 
    
33. /*改进型bp算法用来保存每次计算的权值*/
    
34. struct {
    
35. double old_W[HN][IN];
    
36. double old_V[ON][HN];
    
37. }Old_WV[Z];
    
38. 
    
39. 
    
40. int Start_Show()
    
41. {
    
42. clrscr();
    
43. printf("\n                       ***********************\n");
    
44. printf("                       *    Welcome to use   *\n");
    
45. printf("                       *  this program of    *\n");
    
46. printf("                       *  calculating the BP *\n");
    
47. printf("                       *      model!         *\n");
    
48. printf("                       *   Happy every day!  *\n");
    
49. printf("                       ***********************\n");
    
50. printf("\n\nBefore starting,please read the follows carefully:\n\n");
    
51. printf("    1.Please ensure the Path of the '训练样本.txt'(xunlianyangben.txt) is \ncorrect,like 'F:\BP\训练样本.txt'!\n");
    
52. printf("    2.The calculating results will be saved in the Path of 'F:\\BP\\'!\n");
    
53. printf("    3.The program will load 10 datas when running from 'F:\\BP\\训练样本.txt'!\n");
    
54. printf("    4.The program of BP can study itself for no more than 30000 times.\nAnd surpassing the number,the program will be ended by itself in\npreventing running infinitely because of error!\n");
    
55. printf("\n\n\n");
    
56. printf("Now press any key to start...\n");
    
57. getch();
    
58. getch();
    
59. clrscr();
    
60. }
    
61. 
    
62. int End_Show()
    
63. {
    
64. printf("\n\n---------------------------------------------------\n");
    
65. printf("The program has reached the end successfully!\n\nPress any key to exit!\n\n");
    
66. printf("\n                       ***********************\n");
    
67. printf("                       *    This is the end  *\n");
    
68. printf("                       * of the program which*\n");
    
69. printf("                       * can calculate the BP*\n");
    
70. printf("                       *      model!         *\n");
    
71. printf("                       ***********************\n");
    
72. printf("                       *  Thanks for using!  *\n");
    
73. printf("                       *   Happy every day!  *\n");
    
74. printf("                       ***********************\n");
    
75. getch();
    
76. exit(0);
    
77. }
    
78. 
    
79. GetTrainingData()      /*OK*/
    
80. { int m,i,j;
    
81.   int datr;
    
82. 
    
83. if((fp=fopen("f:\\bp\\训练样本.txt","r"))==NULL)         /*读取训练样本*/
    
84. {
    
85.   printf("Cannot open file strike any key exit!");
    
86.   getch();
    
87.   exit(1);
    
88. }
    
89. 
    
90. m=0;
    
91. i=0;
    
92. j=0;
    
93. while(fscanf(fp,"%d",&datr)!=EOF)
    
94. {j++;
    
95.   if(j<=(N*IN))
    
96.    {if(i     {
    
97.       Study_Data[m].input[i]=datr;
    
98.       /*printf("\nthe Study_Datat[%d].input[%d]=%f\n",m,i,Study_Data[m].input[i]);getch();*/  /*use to check the loaded training datas*/
    
99.       }
    
100.     if(m==(N-1)&&i==(IN-1))
     
101.       {
     
102.        m=0;
     
103.        i=-1;
     
104.       }
     
105.     if(i==(IN-1))
     
106.       {
     
107.        m++;
     
108.        i=-1;
     
109.       }
     
110.    }
     
111.    else if((N*IN)    {if(i      {Study_Data[m].teach[i]=datr;
     
112.        /*printf("\nThe Study_Data[%d].teach[%d]=%f",m,i,Study_Data[m].teach[i]);getch();*/  /*use to check the loaded training datas*/
     
113.        }
     
114.      if(m==(N-1)&&i==(ON-1))
     
115.       printf("\n");
     
116. 
     
117.      if(i==(ON-1))
     
118.       {m++;
     
119.        i=-1;
     
120.       }
     
121.     }
     
122.   i++;
     
123. }
     
124. fclose(fp);
     
125. printf("\nThere are [%d] datats that have been loaded successfully!\n",j);
     
126. 
     
127. 
     
128. /*show the data which has been loaded!*/
     
129. printf("\nShow the data which has been loaded as follows:\n");
     
130. for(m=0;m {for(i=0;i   {printf("\nStudy_Data[%d].input[%d]=%f",m,i,Study_Data[m].input[i]);
     
131.    }
     
132.   for(j=0;j   {printf("\nStudy_Data[%d].teach[%d]=%f",m,j,Study_Data[m].teach[j]);
     
133.    }
     
134. }
     
135. printf("\n\nPress any key to start calculating...");
     
136. getch();
     
137. return 1;
     
138. }
     
139. 
     
140. 
     
141. /*///////////////////////////////////*/
     
142. /*初始化权、阈值子程序*/
     
143. /*///////////////////////////////////*/
     
144. initial()
     
145. {int i;
     
146. int ii;
     
147. int j;
     
148. int jj;
     
149. int k;
     
150. int kk;
     
151. /*隐层权、阈值初始化*/
     
152. 
     
153. for(i=0;i {
     
154.   for(j=1;j   {W[i][j]=(double)((rand()/32767.0)*2-1); /*初始化输入层到隐层的权值，随机模拟0 和 1 -1 */
     
155.     printf("w[%d][%d]=%f\n",i,j,W[i][j]);
     
156.    }
     
157.   }
     
158. for(ii=0;ii {
     
159.   for(jj=0;jj   {V[ii][jj]= (double)((rand()/32767.0)*2-1); /*初始化隐层到输出层的权值，随机模拟0 和 1 -1*/
     
160.     printf("V[%d][%d]=%f\n",ii,jj,V[ii][jj]);
     
161.    }
     
162.   }
     
163. for(k=0;k {
     
164.   YU_HN[k] = (double)((rand()/32767.0)*2-1);  /*隐层阈值初始化 ,-0.01 ~ 0.01 之间*/
     
165.   printf("YU_HN[%d]=%f\n",k,YU_HN[k]);
     
166.   }
     
167. for(kk=0;kk {
     
168.   YU_ON[kk] = (double)((rand()/32767.0)*2-1); /*输出层阈值初始化 ,-0.01 ~ 0.01 之间*/
     
169.   }
     
170.   return 1;
     
171. }/*子程序initial()结束*/
     
172. 
     
173. 
     
174. /*//////////////////////////////////////////*/
     
175. /*第m个学习样本输入子程序*/
     
176. /*/////////////////////////////////////////*/
     
177. input_P(int m)
     
178. { int i,j;
     
179. 
     
180.   for(i=0;i  {P[i]=Study_Data[m].input[i];
     
181.    printf("P[%d]=%f\n",i,P[i]);
     
182.   }
     
183. /*获得第m个样本的数据*/
     
184. return 1;
     
185. }/*子程序input_P(m）结束*/
     
186. 
     
187. /*/////////////////////////////////////////*/
     
188. /*第m个样本教师信号子程序*/
     
189. /*/////////////////////////////////////////*/
     
190. input_T(int m)
     
191. {int k;
     
192. 
     
193. for(k=0;k  T[k]=Study_Data[m].teach[k];
     
194. return 1;
     
195. }/*子程序input_T(m)结束*/
     
196. 
     
197. 
     
198. H_I_O()
     
199. {
     
200. double sigma;
     
201. int i,j;
     
202. for(j=0;j  {
     
203.    sigma=0;
     
204.    for(i=0;i    {sigma+=W[j][i]*P[i];/*求隐层内积*/
     
205.     }
     
206. 
     
207.    X[j]=sigma-YU_HN[i];/*求隐层净输入，为什么减隐层的阀值*/
     
208.    H[j]=1.0/(1.0+exp(-X[j]));/*求隐层输出 siglon算法*/
     
209.    }
     
210. return 1;
     
211. }/*子程序H_I_O()结束*/
     
212. 
     
213. 
     
214. O_I_O()
     
215. {int k;
     
216. int j;
     
217. double sigma;
     
218. for(k=0;k {
     
219.   sigma=0.0;
     
220.   for(j=0;j  {
     
221.    sigma+=V[k][j]*H[k];
     
222.   }
     
223. Y[k]=sigma-YU_ON[k];
     
224. O[k]=1.0/(1.0+exp(-Y[k]));
     
225. }
     
226. return 1;
     
227. }
     
228. 
     
229. 
     
230. int Err_O_H(int m)
     
231. {int k;
     
232. double abs_err[ON];
     
233. double sqr_err=0;
     
234. for (k=0;k  {
     
235.   abs_err[k]=T[k]-O[k];
     
236.   sqr_err+=(abs_err[k])*(abs_err[k]);
     
237.   d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
     
238.   err_m[m]=sqr_err/2;
     
239.   }
     
240. return 1;
     
241. }
     
242. 
     
243. 
     
244. double e_err[HN];
     
245. int Err_H_I()
     
246. {
     
247. int j,k;
     
248. double sigma;
     
249. for(j=0;j {
     
250.   sigma=0.0;
     
251.   for(k=0;k  {
     
252.    sigma=d_err[k]*V[k][j];
     
253.    }
     
254. e_err[j]=sigma*H[j]*(1-H[j]);
     
255. }
     
256. return 1;
     
257. }
     
258. 
     
259. 
     
260. saveWV(int m)
     
261. {int i;
     
262. int ii;
     
263. int j;
     
264. int jj;
     
265. for(i=0;i  {
     
266.    for(j=0;j    {
     
267.      Old_WV[m].old_W[i][j] = W[i][j];
     
268.     }
     
269.   }
     
270. for(ii=0;ii  {
     
271.    for(jj=0;jj    {
     
272.      Old_WV[m].old_V[ii][jj] = V[ii][jj];
     
273.     }
     
274.   }
     
275. return 1;
     
276. }
     
277. 
     
278. 
     
279. int Delta_O_H(int n)                 /*(int m,int n)*/
     
280. {int k,j;
     
281. if(n<1)  /*n<=1*/
     
282.   {
     
283.    for (k=0;k    {
     
284.      for (j=0;j      {
     
285.        V[k][j]=V[k][j]+a*d_err[k]*H[j];
     
286.       }
     
287.      YU_ON[k]+=a*d_err[k];
     
288.     }
     
289.   }
     
290. else if(n>1)
     
291.   {
     
292.    for (k=0;k    {
     
293.      for (j=0;j      {
     
294.        V[k][j]=V[k][j]+a*d_err[k]*H[j]+alpha*(V[k][j]-Old_WV[(n-1)].old_V[k][j]);
     
295.       }
     
296.      YU_ON[k]+=a*d_err[k];
     
297.     }
     
298.   }
     
299. return 1;
     
300. }
     
301. 
     
302. Delta_H_I(int n)               /*(int m,int n)*/
     
303. { int i,j;
     
304. 
     
305. if(n<=1)   /*n<=1*/
     
306. {
     
307.   for (j=0;j   {
     
308.     for (i=0;i     {
     
309.       W[j][i]=W[j][i]+b*e_err[j]*P[i];
     
310.      }
     
311.     YU_HN[j]+=b*e_err[j];
     
312.    }
     
313. }
     
314. else if(n>1)
     
315. {
     
316.   for(j=0;j   {
     
317.     for(i=0;i     {
     
318.       W[j][i]=W[j][i]+b*e_err[j]*P[i]+alpha*(W[j][i]-Old_WV[(n-1)].old_W[j][i]);
     
319.      }
     
320.     YU_HN[j]+=b*e_err[j];
     
321.    }
     
322. }
     
323. return 1;
     
324. }
     
325. 
     
326. 
     
327. double Err_Sum()
     
328. {int m;
     
329. double total_err=0;
     
330. for(m=0;m {
     
331.   total_err+=err_m[m];
     
332. }
     
333. return total_err;
     
334. }
     
335. 
     
336. 
     
337. void savequan()
     
338. { int i,j,k;
     
339.   int ii,jj,kk;
     
340. 
     
341. if((fp=fopen("f:\\bp\\权值.txt","a"))==NULL)         /*save the result at f:\hsz\bpc\*.txt*/
     
342. {
     
343.   printf("Cannot open file strike any key exit!");
     
344.   getch();
     
345.   exit(1);
     
346. }
     
347. 
     
348. fprintf(fp,"Save the result of “权值”(quanzhi) as follows:\n");
     
349. for(i=0;i {
     
350.   for(j=0;j  fprintf(fp,"W[%d][%d]=%f\n",i,j,W[i][j]);
     
351. }
     
352. fprintf(fp,"\n");
     
353. for(ii=0;ii {
     
354.   for(jj=0;jj  fprintf(fp,"V[%d][%d]=%f\n",ii,jj,V[ii][jj]);
     
355.   }
     
356. fclose(fp);
     
357. printf("\nThe result of “权值.txt”(quanzhi) has been saved successfully!\nPress any key to continue...");
     
358. getch();
     
359. 
     
360. 
     
361. if((fp=fopen("f:\\bp\\阈值.txt","a"))==NULL)         /*save the result at f:\hsz\bpc\*/
     
362. {
     
363.   printf("Cannot open file strike any key exit!");
     
364.   getch();
     
365.   exit(1);
     
366. }
     
367. fprintf(fp,"Save the result of “输出层的阈值”(huozhi) as follows:\n");
     
368. for(k=0;k   fprintf(fp,"YU_ON[%d]=%f\n",k,YU_ON[k]);
     
369. 
     
370. fprintf(fp,"\nSave the result of “隐层的阈值为”(huozhi) as follows:\n");
     
371. for(kk=0;kk  fprintf(fp,"YU_HN[%d]=%f\n",kk,YU_HN[kk]);
     
372. 
     
373. fclose(fp);
     
374. printf("\nThe result of “阈值.txt”(huozhi) has been saved successfully!\nPress any key to continue...");
     
375. getch();
     
376. }
     
377. 
     
378. /**********************/
     
379. /**程序入口，即主程序**/
     
380. /**********************/
     
381. 
     
382. void main()
     
383. {double Pre_error;
     
384. double sum_err;
     
385. int study;
     
386. int flag;
     
387. flag=30000;
     
388. a=0.7;
     
389. b=0.7;
     
390. alpha=0.9;
     
391. study=0;
     
392. Pre_error=0.0001;/*实际值为Pre_error=0.0001;*/
     
393. 
     
394. Start_Show();
     
395. GetTrainingData();
     
396. initial();
     
397. 
     
398. do
     
399. {int m;
     
400.   ++study;
     
401.   for(m=0;m   {
     
402.     input_P(m);
     
403.     input_T(m);
     
404.     H_I_O();
     
405.     O_I_O();
     
406.     Err_O_H(m);
     
407.     Err_H_I();
     
408.     saveWV(m);           /****************/
     
409.     Delta_O_H(m);                             /*(m,study)*/
     
410.     Delta_H_I(m);                              /*(m,study)*/
     
411.    }
     
412.   sum_err=Err_Sum();
     
413.   printf("sum_err=%f\n",sum_err);
     
414.   printf("Pre_error=%f\n\n",Pre_error);
     
415. 
     
416.   if(study>flag)
     
417.    {
     
418.     printf("\n*******************************\n");
     
419.     printf("The program is ended by itself because of error!\nThe learning times is surpassed!\n");
     
420.     printf("*****************************\n");
     
421.     getch();
     
422.     break;
     
423.    }
     
424. 
     
425. }while (sum_err>Pre_error);
     
426. 
     
427. printf("\n****************\n");
     
428. printf("\nThe program have studyed for [%d] times!\n",study);
     
429. printf("\n****************\n");
     
430. savequan();        /*save the results*/
     
431. End_Show();
     
432. }

复制代码

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

权值.txt

1. {Save the result of “权值”(quanzhi) as follows:
   
2. W[0][0]=0.350578
   
3. W[0][1]=-1.008697
   
4. W[0][2]=-0.962250
   
5. W[1][0]=0.055661
   
6. W[1][1]=-0.372367
   
7. W[1][2]=-0.890795
   
8. W[2][0]=0.129752
   
9. W[2][1]=-0.332591
   
10. W[2][2]=-0.521561
    
11. 
    
12. V[0][0]=-2.932654
    
13. V[0][1]=-3.720583
    
14. V[0][2]=-2.648183
    
15. V[1][0]=2.938970
    
16. V[1][1]=1.633281
    
17. V[1][2]=1.944077
    
18. 
    
19. }

复制代码

阈值.txt

1. {Save the result of “输出层的阈值”(huozhi) as follows:
   
2. YU_ON[0]=-4.226843
   
3. YU_ON[1]=1.501791
   
4. 
   
5. Save the result of “隐层的阈值为”(huozhi) as follows:
   
6. YU_HN[0]=-0.431459
   
7. YU_HN[1]=0.452127
   
8. YU_HN[2]=0.258449
   
9. 
   
10. }

复制代码

==================================

以上程序为VC++的程序改制而成！

[ 本帖最后由 风花雪月 于 2006-11-29 07:53 编辑 ]

xmwhit

算法很简单，编写和调试程序却不太容易，楼主辛苦了。

ascendman

向你学习