【源代码】C++的BP算法源程序神经网络

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

发表于 2008-9-15 19:34 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

#include "iostream.h"
* u! L: Y5 @: T0 u; {3 M
#include "iomanip.h"
: {0 O, g3 A, i% e; e
#define N 20 //学习样本个数\" i9 w% y' X( j `5 [6 ~( S. k) w
#define IN 1 //输入层神经元数目+ t3 v2 L% O/ e& {$ D1 v
#define HN 8 //隐层神经元数目5 M' b* h) k0 K! s
#define ON 1 //输出层神经元数目
* g7 }( C* a\" [4 I
double P[IN]; //单个样本输入数据+ i8 Z5 c# L% f8 @: b
double T[ON]; //单个样本教师数据4 [. l: v. ^* O; y# b/ y
double W[HN][IN]; //输入层至隐层权值1 w. c* S5 X# Q
double V[ON][HN]; //隐层至输出层权值0 ^) \6 N( q# i9 y( W! d5 f
double X[HN]; //隐层的输入( Y7 f; B. j# j1 y. [
double Y[ON]; //输出层的输入
: S$ M# X* q\" ?0 t
double H[HN]; //隐层的输出
' V( R' v( c; K4 p- Z
double O[ON]; //输出层的输出
! }0 T# S/ F/ B\" |9 B: r1 k
double sita[HN]; //隐层的阈值; I' L' T9 [' a) t
double gama[ON]; //输出层的阈值
5 L( Y! J1 U\" `9 b, Y) j0 Z( |8 o
double err_m[N]; //第m个样本的总误差
: s1 w5 F5 ]. G
double alpha; //输出层至隐层的学习效率 S( J$ ?) z, M! @' m# q
double beta; //隐层至输入层学习效率
2 n4 J% |: @6 P- X* Q$ a
//定义一个放学习样本的结构4 z* G) M; u! @' N
struct {# l- S7 K+ P0 P\" y8 f6 \% h
double input[IN];
. N T |5 N6 E5 ?2 u
double teach[ON];
5 N0 w; i X! R- D$ c! n
}Study_Data[N][IN];$ G4 i, e2 g. U
( x+ ?* R9 M% a
///////////////////////////
- P- h( j* Y, H! S
//初始化权、阈值子程序/////$ g ]$ q+ {\" ]2 H. i0 W. G
///////////////////////////2 ?$ j' s Z) H( T+ D
initial()2 ~ f* m% O, T
{' m- G- a; s9 w o( l/ U5 Z
float sgn;
4 l6 H, V y0 f\" E- K
float rnd;' f) U6 ?: B' ^. H) X. U1 c
int i,j;
; \1 \9 P* J' P1 H! Z1 P/ a
//隐层权、阈值初始化//8 ~; s0 y: e8 \& e9 z9 N6 C
{
0 v: C1 t O f+ o
//sgn=pow((-1),random(100));# T. T; c, M/ d$ [1 E
sgn=rand();/ V/ i3 \5 b3 T, M, X, c7 k+ N
rnd=sgn*(rand()%100);4 m7 \ A\" ?* Y. [0 Q\" J# p
W[j][i]= rnd/100;//隐层权值初始化。
' L7 J [1 M) i
}
1 {& z* v2 `2 J. Y: i) E
//randomize();
; v9 e& I( u3 ?4 R
{
/ k0 Z5 W3 b6 G. w0 F/ q% r5 G1 O
//sgn=pow((-1),random(1000));* _( c# X+ p# \
sgn=rand();6 U' g; z% ]- z4 C4 Y2 T$ n1 }
rnd=sgn*(rand()%1000);
: M) @$ q7 U' v& s
sita[j]= rnd/1000;//中间层阈值初始化
- G. c. C. x/ i\" d: ^- [3 s\" b
cout<<"sita"<<sita[j]<<endl;
, X: c7 O: u. R R, u
}
\" H: {( p5 f2 w, `# ~0 u$ \$ T, t
//输出层权、阈值初始化//4 x! x- I. H$ l3 ~8 \2 `
//randomize();- i0 y, |0 ], e$ L% K
for (int k=0;k<ON;k++)+ S$ `. y/ O) g8 c, m
for (int j=0;j<HN;j++)
~+ K$ g$ [* q1 U
{0 Q1 @: M* Y. m& `8 X4 |
//sgn=pow((-1),random(1000));: ^ ~% B8 v/ q' K\" \) M6 n
sgn=rand();( g) f9 t- I4 L
rnd=sgn*(rand()%1000);% D. ], E4 p# s( a8 v4 m8 I
V[k][j]=rnd/1000;//第m个样本输出层权值初始化3 k+ [* M% j. n! v ?0 [( H
}
7 d- j7 h- S7 H; h! b\" n
//randomize();0 f, p1 [, j0 A, h: f$ b
{; X# q g3 q% s# t
//sgn=pow((-1),random(10));% [. I$ w. h/ ?\" t\" K! `
sgn=rand();
9 j- o6 \+ c6 h& |$ [9 }
rnd=sgn*(rand()%10);' [6 c3 K) g; g1 d( o
gama[k]=rnd/10;//输出层阈值初始化8 s- [\" I. [' H/ o5 n
cout<<"gama[k]"<<endl;
, f' V: v/ k) ^6 \
}
) U6 ]5 ^* C% x6 |& z7 m
return 1;
& \! E; N+ k: A& X0 N2 Z# [% c
# k7 [* d% F$ u/ P
}//子程序initial()结束 z9 ~# Z/ B2 A
$ a, M2 G) C$ \* B' ?! p4 I
////////////////////////////////4 a/ T0 |$ F/ D: N/ M. P& G: m
////第m个学习样本输入子程序///5 |4 n5 b v- Q5 j' @
///////////////////////////////5 }* j; A% ]: l N$ \* F6 k$ ]3 N; A
input_P(int m)
; d! t: D: z4 o$ U\" ^
{
& K$ P, G' l0 G6 O& a6 I% S
for (int i=0;i<IN;i++)1 W( _; f4 ]7 e6 z\" R9 p W
P[i]=Study_Data[m]->input[i];
' E5 K& m- l& A# t: ~
//获得第m个样本的数据
8 _: n: Q3 ^8 B! T9 E
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
9 |# `' k% u7 G9 O, H
//P[%d]=%f\n",m,P[i]);
) e+ J( A0 n% f, s
return 1;! ~4 O/ W$ m6 H0 U' x+ J
}//子程序input_P(m）结束
$ z5 O$ L: b( {$ R3 }9 D
/////////////////////////////
. }/ ?3 a/ ?: {2 c
////第m个样本教师信号子程序//
8 t9 r6 Q9 }) Q. R8 O! \2 ^1 U
/////////////////////////////2 j7 x$ Z: D8 o7 }& r/ L2 t
input_T(int m)( D% {/ ^( L& H) l
{
. t ? W+ N3 o9 D5 q# D5 j) G
for (int k=0;k<m;k++)
8 D: v$ D6 Z0 {
T[k]=Study_Data[m]->teach[k];
% t. `9 F7 C+ `4 x+ {. n5 H
//cout<<"第"< //
% e4 y% q2 q* ?. I7 x2 t
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
: i- S( n# Y$ x\" g/ N2 m6 d* O+ e
return 1;3 X C% v( J: z& ]4 o$ m
}//子程序input_T(m)结束
6 e) `6 ?* c) i4 p
/////////////////////////////////0 Z$ ~8 l2 w9 Q6 b$ ] @+ D. I$ v
//隐层各单元输入、输出值子程序///
4 ~8 N- f6 |2 L6 p; V! t7 ]
/////////////////////////////////- Q4 K; O, u0 x9 d9 Q: v
H_I_O(){3 L! @' \$ q( P! W
double sigma;. h* O j1 U6 s4 m4 u- A: ?
int i,j;
for (j=0;j<HN;j++)
+ k5 G) E* |+ g. Z0 g8 m$ U
sigma=0.0;# f; U6 u ^& c/ `2 Q; J( m9 x4 J
for (i=0;i<IN;i++)- E3 i; H4 {! k I
sigma+=W[j][i]*P[i];//求隐层内积
* l/ \! H\" [5 [4 q$ l* R
}
& R/ N$ ]' D5 b& W# ~% v8 K
X[j]=sigma - sita[i];//求隐层净输入
4 e: A/ ]0 o8 \/ f6 J
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出$ c) z0 V' h\" A( o! Y( Z1 a9 }6 k
}
4 h+ H/ Q7 N- `) m
return 1;. D! F7 k) t9 g0 g
}//子程序H_I_O()结束
R8 `1 U% F3 S9 D! S
///////////////////////////////////
2 i' g3 W$ ~* k) @; s
//输出层各单元输入、输出值子程序///4 i' K- n6 k5 R2 v+ [
///////////////////////////////////
- T$ F3 O: V* N( E6 {1 _ a) b0 i; p
O_I_O()+ `, A- y' y6 D0 z
{
2 P- e\" [6 J. J1 W! f! L, ^+ Q
double sigma;( y$ I. Q\" g; b6 B0 w7 ^, }
for (int k=0;k<ON;k++)
) @0 N8 ^0 t2 Q. \
sigma=0.0;
5 v) J7 r ^7 m# U# N
for (int j=0;j<HN;j++)
: n' W9 r* p- r; C% F5 T! K( H
sigma+=V[k][j]*H[k];//求输出层内积8 u\" x, d3 ~3 I\" i5 h, d6 y) ^
}
[- w( M3 V: @8 @& a0 @
Y[k]=sigma-gama[k]; //求输出层净输入
4 S2 U; p- w. J( V\" k3 m
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
, v0 w$ w7 `& H: D. Y
}) e3 W8 d- E7 ?
return 1;2 F- g. [$ y: J! a5 k. l5 i# w+ M
}//子程序O_I_O()结束2 _1 j8 W( J+ i
////////////////////////////////////
3 m b6 z( \% x! k* _
//输出层至隐层的一般化误差子程序////
7 ~8 F/ g3 V% T
////////////////////////////////////8 u. r) r6 {( J' O7 }
double d_err[ON];
\" r1 _8 ~# h# c4 o( U% p3 d
Err_O_H(int m)
% M8 q! z1 v# @
{/ ]1 {5 a, i6 Y7 I7 t
double abs_err[ON];//每个样本的绝对误差都是从0开始的' P5 X' j( I6 o
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
, Q0 G\" a' M/ J$ W8 K
//for (int output=0;output<ON;output++) //output???3 U4 A\" K+ p) P& W* Z& {6 Z F\" x
for (int k=0;k<ON;k++)3 K3 M; j4 B! B* l\" C% }) T6 l
abs_err[k]=T[k]-O[k];' Z5 ?\" Z3 V& A% T
//求第m个样本下的第k个神经元的绝对误差
/ Q3 n6 {) I* a* e
sqr_err+=(abs_err[k])*(abs_err[k]);
/ ~0 o: w\" ?\" P6 g) b( ?
//求第m个样本下输出层的平方误差
, c; r2 Q; c3 D$ u9 ^. h8 O* ^
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);5 [& a& g* R1 [& T
//d_err[k]输出层各神经元的一般化误差) x& \' g# v3 e5 m
}: \2 \* U# a. N& O% w9 q; N1 D9 V. h
err_m[m]=sqr_err/2;
' _0 s+ S( o) z8 O
//第m个样本下输出层的平方误差/2=第m个样本的均方误差( f; b& t3 l8 u: \, g( y
return 1;
( J. j4 Q+ c5 m
}//子程序Err_O_H(m)结束
/ r6 M- U* a9 \& }
////////////////////////////////////! ?' u7 P$ L7 Y* V
//隐层至输入层的一般化误差子程序////
! }& y/ m3 i\" T, _6 Z
////////////////////////////////////# e4 j1 R% a, r3 H- n4 X& g O3 p
double e_err[HN];
0 T4 }8 I1 _4 B' O r
Err_H_I(){% @4 C. H\" U2 b6 {6 i8 w
double sigma;' ]! t* a. H2 E8 l
//for (int hidden=0;hidden2 I, j5 t\" A/ X/ I\" Y. E9 p\" R( n5 U
for (int j=0;j<HN;j++) 4 }3 |& E( h. J, d4 ^
sigma=0.0; d8 X\" h3 e+ I
for (int k=0;k<ON;k++)
1 o# |- P, B% _$ E5 y, z9 g
sigma=d_err[k]*V[k][j];' j: }\" L! C; N) n, t; n6 F2 a) o
}
& l- d8 e& t$ O- X
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
# ?& ?7 {2 h+ g2 L
}6 a8 k( }; _+ D
return 1;( v5 y. U- N) X
}//子程序Err_H_I()结束* y2 o ?\" s\" J
////////////////////////////////////////////////////////+ N! \) D# H. h( C0 Z0 y
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
! s0 E5 h& N2 [7 n) S. T
////////////////////////////////////////////////////////( {+ V( {, I' L j
Delta_O_H(int m,FILE* fp): z* v' ]( v7 j9 H' P: }# q
{) i1 V* ?9 z/ s2 Q
for (int k=0;k<ON;k++)8 `$ V! |% b( E2 {; O- {# I' M
for (int j=0;j<HN;j++)9 E6 W, b7 a8 p) v
//cout<<"第"< : P Q p: ?: C' Y
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
; F+ s; I7 Q6 J, p2 `% T; G
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整* T B9 Z' q) x0 i3 V* {
}
9 d1 E* P0 o7 h) c' q
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整; r6 z8 N) o0 B3 U* {
}
% O% y V7 p4 t3 o* B/ q9 K1 C7 `
return 1;9 H2 e8 h1 {, w, R3 f! [9 P) _
}//子程序Delta_O_H()结束8 b1 F! ^. h+ p& i w2 w
////////////////////////////////////////////////////// `$ q: @% c0 ]! B/ S& e
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
' P+ g) K* ~7 g9 _2 `
/////////////////////////////////////////////////////* u3 Z$ ^' {3 u z# M) i/ A
Delta_H_I(int m,FILE* fp)
1 N9 ~4 ?, C9 z0 O8 P/ ]! k
{: [: |2 Z: T: L) z\" e\" b, ?
for (int j=0;j<HN;j++)+ O- E$ r& g\" `# l' y0 d4 Q
for (int i=0;i<IN;i++)
2 ^6 w* m+ Z& Y2 c. U
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
, v2 l9 e6 L. i, w
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
. R8 u* A% N, k! F
}5 C& \. B# |/ B* B# c, d. c
sita[j]+=beta*e_err[j];\" n6 R+ m4 X$ \) o2 H
}3 o\" [5 {4 P* ~5 j& |; z
return 1;
\" r\" R J9 K: i$ {
}//子程序Delta_H_I()结束
( J& J- Y2 v; Q7 J
/////////////////////////////////2 v' J* O: d, n: P# O2 O1 t3 G& {
//N个样本的全局误差计算子程序////: D' e7 O! c* s+ w
/////////////////////////////////: C. A6 ^' J) t
double Err_Sum()3 p% a8 k7 n2 W/ a' Q4 _2 a0 q ?
{. P5 U3 I, `) `- h7 ?
double total_err=0;
$ @% ]2 o# ~/ B8 r
for (int m=0;m<N;m++) ; {& d* D! e# ~ a9 }9 u3 t
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差$ G' d$ K3 Y/ d) r6 e
}/ B B6 b+ ]+ _- B; _/ f: X
return 1;5 [\" p. ]2 P3 W; k1 g% X
}//子程序Err_sum()结束; b4 z2 w) {: x* r& l8 l) x) b
/**********************/- k$ |0 s\" M\" j) W
/**程序入口，即主程序**/4 {1 }' t P( k/ _# y' l5 V
/**********************/
. ~) ]. w% ~: g# n' E* `% d u
main()
: g+ B* B\" T6 H. [. O0 ~
{
$ \/ C. V* R) h2 X
FILE *fp;, g# x6 U* L\" `+ k& v\" x
double sum_err;
1 ]0 H% d6 t2 ?' ?
int study;//训练次数
\" Q/ L+ ?$ w: I6 Z7 @2 b4 {
if ((fp=fopen("bp.txt","a+"))==NULL)
$ v- i, p* n7 f- ], R! e0 F
{
& @ ^7 q% [* @: _. R h
printf("不能创建bp.txt文件!\n");
exit(1);
+ f( e\" L; n' m2 w% w
}: `8 e v8 @1 r
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
# }& k o9 m! j: j
cin>>alpha;* n# v5 X+ ^. t
cout<<"请输入隐含层到输入层学习效率: beta=\n";; n5 B8 H! V# `+ G
cin>>beta;
5 E* a) [9 @+ {+ ?! f. N2 n3 F5 \
int study=0; //学习次数8 T2 r$ Y, g. p1 T5 y' a
double Pre_error ; //预定误差
: N$ `- l6 o ?- O1 u
cout<<"请输入预定误差: Pre_error= \n";
* m, j1 e: F+ W; X
cin>>Pre_error;
' q( E* M5 E0 M% l
int Pre_times;
& b6 w8 |# K- h( R7 W- b4 D
cout<<"请输入预定最大学习次数:Pre_times=\n";+ q0 M3 D3 x$ \' h& T
cin>>Pre_times;5 Z! i$ l' V- H+ K/ }
cout<<"请输入学习样本数据\n";( E2 P. A0 c G2 Q* ?9 X( e
{
- a- W8 a$ \: R, d8 J, x5 q
for (int m=0;m<N;m++); y& v\" H# Z0 w3 p
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; + K2 n4 M\" n\" |, t8 |
for (int i=0;i<IN;i++)
4 k* z0 G. l) z G# j
cin>>Study_Data[m]->input[i];: e$ A& O- |( b! O1 l/ }
}4 G7 z* w N7 G1 ?. o
{
; Z9 @; Q+ e8 T\" z
for (int m=0;m<N;m++)7 ~ W6 v( I2 _1 A+ K* A- o# ~3 Q1 V
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; ( W$ i2 q- I0 f! L
for (int k=0;k<ON;k++)
% ]( C5 Y: e8 K0 X' v
cin>>Study_Data[m]->teach[k];
. C( S. [8 H# w% ]5 f* e3 I9 R
}
7 L- b/ M! x# P. q; O
initial(); //隐层、输出层权、阈值初始化 (1)
7 b6 D( Z0 m9 }
do\" _! \1 R* z; b3 \
{
8 B- R i% g\" k* T! ^
++study; ///???
M- q% k0 S$ x5 P3 Y. @) T
for (int m=0;m<N;m++)
5 @5 B- o' J: n ?! G
{0 x: l\" f4 R1 p9 N
input_P(m); //输入第m个学习样本 (2)
8 ]3 y' v [* _! k
input_T(m);//输入第m个样本的教师信号 (3)
; M\" F& t% a2 n1 H) V4 S/ i8 Z- n
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)6 d% ?* u\" W& P- j\" ^. U2 A
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)& y7 u# J& J\" w# @( \- y& H
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
$ c. t7 ^. d7 y! q( a, ?
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7); V# U6 u* |! ?; ] Q% [7 e1 X
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
7 z2 S5 z& h( X6 Q/ C1 r/ J
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
/ M% T ]; a3 ^\" f3 O; o2 a$ }
} //全部样本训练完毕+ O6 s/ q0 g2 U5 B0 h
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
1 p/ Z$ |* c& d0 M( B; Y
{2 B7 L, w# V& u. h% M) l
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;! N( ~. p+ X\" ]$ ^: T
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);: k+ o/ \- u# ~\" A! j) g- B$ ]
}6 ^6 Z! i% S! c. j3 b2 s
while (sum_err > Pre_error) //or(study
2 O$ V% _8 O3 m' R5 o\" w
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
# h! V' i) O, `1 W\" \2 q
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
3 @\" e\" G0 U; q
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
9 g; v: k1 F& T$ s
fclose(fp);7 l- q( }\" [\" m9 ~9 I7 _
}
/ j5 w7 s4 ^5 w) u
char s;# ^, h& d7 k0 a
cout<<"请随便输入一个字符，按回车退出程序！\n";3 A\" ?* ^; C% }, u9 h8 K
cin>>s;
# @) n1 M4 U2 S) _4 R
return 1;2 J1 E# D9 b+ D( ^( n& `( }
}- i; E$ O4 s, T
3 }* z+ q\" {3 l2 [! W( _