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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"/ I9 f' i! f. @4 ?6 K
#include "iomanip.h"
4 C& H! S \0 | w\" f) k
#define N 20 //学习样本个数9 c) \* S1 Y, a6 N6 _
#define IN 1 //输入层神经元数目2 q/ b5 ]- E7 m) j8 L7 b) e; @. z
#define HN 8 //隐层神经元数目
. S6 l: n5 x9 K0 S: u$ j+ U' i6 r
#define ON 1 //输出层神经元数目% O& w. b0 c' l& ?\" u2 T
double P[IN]; //单个样本输入数据& K( Z2 F, V9 l: p! V& T
double T[ON]; //单个样本教师数据8 A4 Y5 S* I+ O6 F
double W[HN][IN]; //输入层至隐层权值
& j\" w- x0 a3 l9 G: b
double V[ON][HN]; //隐层至输出层权值) O& V6 ^: g0 A/ u3 m5 K\" u
double X[HN]; //隐层的输入; R; C, {' p5 k$ @7 v/ c, t: e0 f+ ^
double Y[ON]; //输出层的输入2 C% e7 L5 }1 o* G: v
double H[HN]; //隐层的输出% q$ k: h# e* z' W* g4 \' Y9 H% O
double O[ON]; //输出层的输出
+ t+ m1 V( p# e; F9 r5 x* B( c; h
double sita[HN]; //隐层的阈值% I9 h# t b4 s, |
double gama[ON]; //输出层的阈值% J- O2 U! X& J) o5 h
double err_m[N]; //第m个样本的总误差
% O8 i\" o% R: [# `. m5 t8 }* {\" h
double alpha; //输出层至隐层的学习效率
1 ?2 h; V. K$ b3 D7 Z
double beta; //隐层至输入层学习效率# s/ h3 J+ X) [! h2 G0 @! a- S
//定义一个放学习样本的结构7 M6 t% ]. ]- x\" X\" F5 m
struct {+ I) b5 R: } `\" {1 q
double input[IN];
, F6 q$ X$ @: ]\" n& K7 @9 Z
double teach[ON];9 o( {: s7 F' d( g
}Study_Data[N][IN];
1 T6 Z$ {2 B8 x\" {+ H n\" O8 W
7 p; k% [1 r7 P) K- Y
///////////////////////////, ^3 ]; Q5 c+ z, A' n1 a1 {. N
//初始化权、阈值子程序/////
, Y* M8 E: r9 ^
///////////////////////////
% ^4 a; _/ l: j+ M$ }
initial()3 Q3 G0 k! ]+ I8 o+ N: |; B. d\" C
{* P: h$ N I5 ]1 I+ N) N
float sgn;
+ v2 A# G8 r5 N
float rnd;+ H) h* o+ D\" r7 L M0 e
int i,j;! x2 j% y9 V, K) m
//隐层权、阈值初始化//
8 p: S3 l/ B# x' _
{, a' L& ?1 w% M' v) }
//sgn=pow((-1),random(100));
C, U8 x* B$ _! E2 l: v
sgn=rand();8 k. m% }1 E8 @
rnd=sgn*(rand()%100);\" B- O' \3 q& X6 S. Y
W[j][i]= rnd/100;//隐层权值初始化。
! E. M o2 A$ b( K) B$ Z
}! X. j7 S# H# f0 ?; v
//randomize(); o( G, o. k1 t( N( T
{& p$ b) \. }6 ?\" k A1 ^
//sgn=pow((-1),random(1000));1 w: f3 Q* y, c. H\" ]( w\" v! Q' h
sgn=rand();4 O$ n) D& o, d' G\" R) W' N8 H, z
rnd=sgn*(rand()%1000);8 G1 g# C+ y( U4 |
sita[j]= rnd/1000;//中间层阈值初始化
* H; o# |, R1 ` I0 C, r
cout<<"sita"<<sita[j]<<endl;
' {( W% L$ h: ~7 S% T, W! k
}, f3 [: d7 A! W6 \+ Q7 _
//输出层权、阈值初始化//7 n# }/ |/ x) c% u- A% r2 G6 }3 I! K
//randomize();
& @) T& l% V: R# X, j2 J
for (int k=0;k<ON;k++)4 @0 X: d7 x- ^4 z# ^8 y
for (int j=0;j<HN;j++)
3 o: i4 J: K( O. ]$ b8 M8 S; {
{
( _$ h* W6 Y. D! C4 s% D
//sgn=pow((-1),random(1000));5 C; z1 Q. C H2 O/ C
sgn=rand();
. f! ^+ \% x( q; p6 a8 y+ v
rnd=sgn*(rand()%1000);. [+ A4 A4 ?4 }
V[k][j]=rnd/1000;//第m个样本输出层权值初始化7 c% L\" U' ~6 I: ?
}
6 m6 h8 V& Z7 M% _1 B9 `0 P8 b
//randomize();
) P( s# x3 m; L! x% }) G. ~. W3 a
{, P) A( ^7 A! o# r, B2 E
//sgn=pow((-1),random(10));
( }' e2 |. |, U) O% n# D
sgn=rand();; Y2 ]7 r; q9 y* b
rnd=sgn*(rand()%10);# h+ M$ U( _* e, q
gama[k]=rnd/10;//输出层阈值初始化
\" D2 y$ @ y7 Y\" ?1 P' x# P
cout<<"gama[k]"<<endl;
* F( a8 Z, X\" I2 y0 ?' j! d) B
}9 z+ v' j! Y( U/ i8 v5 E# e- C
return 1;
) K8 D, I- A6 H3 ?8 x! T. y
' t& ?* s9 O\" ]+ f3 z7 u3 N
}//子程序initial()结束. ]; c7 V' L( O2 [' q
% }; U4 @. z* M\" r# j5 R6 Z
////////////////////////////////2 Z3 @* ]& G: a, B$ X
////第m个学习样本输入子程序///$ h/ N/ x' s q
///////////////////////////////\" a# r$ R& \/ h; n# o Q2 g/ H2 S1 x
input_P(int m)' C O V5 N. A+ H
{
) j% a- C- O; {6 D, Q& X+ o
for (int i=0;i<IN;i++)2 @+ H( r* s8 @& F
P[i]=Study_Data[m]->input[i];# B- n8 X/ l& [! G
//获得第m个样本的数据
# T- {& o3 }: a1 e7 z4 V
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：! R F3 P/ A1 u0 a- t
//P[%d]=%f\n",m,P[i]);( h) b% J2 i& d* u- ^+ o$ A
return 1;4 J: N9 r- I5 c! O
}//子程序input_P(m）结束8 p1 o$ B/ d0 |. s) ^
/////////////////////////////
! A% t6 H7 ^; C* H$ ]& F, {
////第m个样本教师信号子程序//- J P; I. V& P9 i7 G
/////////////////////////////
7 h; K# \+ s' B& ]% U
input_T(int m)
0 ~' [7 J; a\" P, Z! c
{
4 o8 J( |4 z8 N
for (int k=0;k<m;k++)
6 B! t$ g' d- u. G7 N: T6 e' P( H$ D
T[k]=Study_Data[m]->teach[k];
! A4 C* [3 L; G, H% J
//cout<<"第"< //3 ?) I+ R$ E I. g\" G9 X; r5 e
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
; N# F; [6 `0 u5 t$ r% m; ?% D
return 1;
8 T\" A4 g% h$ Q
}//子程序input_T(m)结束- V1 P) x; {4 W* C& _& f\" L
/////////////////////////////////
+ F: s! ~ ^* T9 e\" m+ Z! H
//隐层各单元输入、输出值子程序///
( W0 C$ ~+ b/ K\" F
/////////////////////////////////& ~) n: j$ }; q* D4 a
H_I_O(){
- F4 d1 |* A/ U\" I5 p! Z
double sigma;+ n6 V0 b0 P: a\" \6 p
int i,j;$ q1 U8 }- n1 v. d
for (j=0;j<HN;j++)' _3 a8 V# W' f1 k1 y4 \5 ]2 X+ y/ }
sigma=0.0;
$ O5 A1 V3 b/ E* O) K% C$ G; ?* s' |5 p
for (i=0;i<IN;i++)1 G& l: W D, G I2 ]5 F5 j0 L
sigma+=W[j][i]*P[i];//求隐层内积
1 @( r$ J& s p7 W8 U
}
0 s/ t: ?: a, F! |8 t- [; R3 W- g
X[j]=sigma - sita[i];//求隐层净输入+ D9 M5 O2 U6 D\" T
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
' n0 \8 d! R$ {8 N# A* J
}. M' ]5 a8 K4 }8 M- j. z! }
return 1;
2 `6 l$ d6 j& q; r( Z, a& B) }) w
}//子程序H_I_O()结束
' }) r8 t( _/ E; s
///////////////////////////////////
6 [$ |( d3 N. ]& J! I3 t
//输出层各单元输入、输出值子程序///# d T, f; l1 I# A\" M6 Y; d
///////////////////////////////////
8 ], E U. ]$ }- j\" g
O_I_O()' g! T7 c/ Q: a0 f2 \
{2 }: r6 L; {; N
double sigma;
& \; |1 B7 e+ B) J
for (int k=0;k<ON;k++)5 g2 t* S1 Q/ U. [; ]
sigma=0.0;
$ }. C4 R1 R6 w0 ~( A# {/ N
for (int j=0;j<HN;j++)
% B( L\" s6 U( Q0 K+ { h2 e: ]4 K
sigma+=V[k][j]*H[k];//求输出层内积
4 S- o2 z* t4 y! _\" C' Y2 \
}9 K B* O2 _6 Y2 r4 \; J4 ]4 L
Y[k]=sigma-gama[k]; //求输出层净输入\" I\" v\" }) O\" c. L& [
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
. Y% `2 ^3 v$ Q3 @8 c S1 w' E\" L
}, `( S2 h$ c) y% p |
return 1;# h, A: Z# j& y4 Z4 x. f: q
}//子程序O_I_O()结束
* o\" _' r7 J/ h! U# J3 Y% ^
////////////////////////////////////
& E8 j* Y( y- a
//输出层至隐层的一般化误差子程序////3 E% Z z. e6 S- v* c7 ^
////////////////////////////////////
* z$ u$ U/ L3 f) x6 _
double d_err[ON];6 ?; S, L8 E2 f3 `4 B1 g
Err_O_H(int m)' O& H' ?4 q/ O2 Q ?
{! T; a+ f# \0 L }
double abs_err[ON];//每个样本的绝对误差都是从0开始的0 T# c, [/ p' I( @2 y! W# c. m
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
7 V# q% K' }, g7 W. r/ x, O
//for (int output=0;output<ON;output++) //output???5 H. B. D c- D7 ~( S z5 t% `9 ~
for (int k=0;k<ON;k++)
2 G1 J' ?& t/ R% d: [4 D1 V/ O; B
abs_err[k]=T[k]-O[k];
8 L, a9 V) ]1 |3 W4 I k, d4 z
//求第m个样本下的第k个神经元的绝对误差# E- M; B- P7 O\" w- q5 L$ |- D
sqr_err+=(abs_err[k])*(abs_err[k]);
1 G+ O+ `. D4 Y' @( Z! y! n$ p! J
//求第m个样本下输出层的平方误差! s# s; K( `. S7 f3 U8 j g( _
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
\" T L\" U4 e; {
//d_err[k]输出层各神经元的一般化误差! |8 O# f: G& z; w$ U. k( O2 O; G7 v
}
+ j2 w- t I0 F# ]
err_m[m]=sqr_err/2;# ?1 `) V( \) J- r a5 k
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
' @9 A& G- K9 c6 B$ I\" c0 ]
return 1;; C3 }0 z4 v# P: U\" i3 W\" w
}//子程序Err_O_H(m)结束% i0 X( e8 U, W# I3 c* a
////////////////////////////////////8 C; D$ g( d$ B! T1 g
//隐层至输入层的一般化误差子程序////3 |\" e1 `, o* M$ I; ~
////////////////////////////////////
6 l/ |) n1 T- g
double e_err[HN];2 Z W! p/ ^, L
Err_H_I(){* W2 W0 R; E5 g* D- Y, W
double sigma;- e. Q* Z0 t Y' W* Y+ Z1 w7 d0 k
//for (int hidden=0;hidden4 Y. Y) {. t% m) C$ s# P5 d1 ^) c\" Q
for (int j=0;j<HN;j++) \" s2 W( J9 w3 W0 P, |' q5 Z% r/ L
sigma=0.0;
$ H% w6 V, c7 V0 ]- c8 h
for (int k=0;k<ON;k++) ( ~7 q6 j5 a0 o2 \/ C$ c
sigma=d_err[k]*V[k][j];
\" J1 b, j! Y* a, }; y: h
}
8 f* G3 X* Q7 d5 U% K) Y
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
) T/ e; I& t n4 O
}. ]1 X8 v( X2 v8 m, L; Q
return 1;
\" Z- Z# v3 T3 X
}//子程序Err_H_I()结束
8 U6 B; Q& _# t5 B( b
////////////////////////////////////////////////////////* Q/ Q& R! g4 c/ [5 h
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
5 j( M+ B9 Q' ]9 X) Z# |! \+ y q8 m
////////////////////////////////////////////////////////% b5 T5 Q8 r3 \: o6 v2 b9 y
Delta_O_H(int m,FILE* fp)% P6 x# Q1 e) g* [: `$ Z
{\" T! M( c4 P; }9 ~+ ]
for (int k=0;k<ON;k++)3 c3 n5 Q. [4 F/ T/ ^
for (int j=0;j<HN;j++)4 N3 B) C1 t1 F% v: ^' ^
//cout<<"第"< 8 Z% g9 j$ r- Q8 O5 h: o
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
9 {3 U. [. ]' y& {# r! ?6 O
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整, G- z% \1 z. W% o$ P
}
1 z/ w4 D7 S3 G$ A `) g* k; D
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整' Q2 R1 m+ ^8 I2 y' W1 m: D
}7 h% l* ?0 c\" B2 {1 R* A' D
return 1;
$ [/ O i. P: U! A\" {! b r
}//子程序Delta_O_H()结束
$ G; I- ^3 k% f6 n. x( v8 x' y) b! ^
////////////////////////////////////////////////////// u( h9 |1 d# q! ?* y
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////6 {: m' i7 {\" e& g4 E
/////////////////////////////////////////////////////$ [* a6 x- v4 R
Delta_H_I(int m,FILE* fp)7 o) ?$ @2 t* O Y
{! [/ T/ j) A# W
for (int j=0;j<HN;j++)
8 U J- M' h/ K h& V5 D
for (int i=0;i<IN;i++) . \) g3 `8 d( h0 j( ?7 O! G8 z/ G: Z
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);1 ?( x7 m3 s8 _9 N n6 l- o. K
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
! O. C' Y! D( W6 r4 f
}- B2 d, W* o2 d+ a& p
sita[j]+=beta*e_err[j]; P1 T- W2 ^* n1 W* m
}
3 v( G& w( p: x# a9 S' _# _
return 1;
7 }4 u( w' ~% e* I2 G
}//子程序Delta_H_I()结束
# y- ]9 g0 P: C9 e/ Q7 Q- `! G6 B
/////////////////////////////////( v9 ?2 o; {# x9 K G; a, o
//N个样本的全局误差计算子程序////
9 I a! ?4 s7 k2 @& [% {
/////////////////////////////////\" x2 x0 w+ h0 p& G& `/ h7 d
double Err_Sum()
4 r8 X5 m& A( X
{9 {0 i0 S* p) e2 S6 {! l! h
double total_err=0;
7 s0 U4 p! p. P7 Y
for (int m=0;m<N;m++) 8 }+ I9 |7 h\" T2 m+ z
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
; S( r l/ f& X% ?, P
}
2 n' G! D# \* C
return 1;\" x7 Q3 k2 }1 I L& i4 _! m# O
}//子程序Err_sum()结束7 b' F0 Z8 T' z\" y6 y
/**********************/
& s3 f# G+ O2 s7 K- \/ ^2 S# R8 c
/**程序入口，即主程序**/9 W2 M5 j\" l\" t2 I, v2 _0 P
/**********************/ g1 t- I6 `7 n, ? x
main()
\" V4 r' f9 i) }* m; Y5 b
{
0 Y5 J\" M9 Q/ N3 J* x
FILE *fp;
3 X; ]) r6 M& s ?+ B; Y
double sum_err;$ {* W; V8 w5 _\" H
int study;//训练次数
. ^, J+ V% H0 t! i! I% v- `1 j
if ((fp=fopen("bp.txt","a+"))==NULL)
; V% e) J% k1 I2 y! |/ J
{0 T# q# h1 R8 S; z8 Y
printf("不能创建bp.txt文件!\n");* |( Y5 |& ]# R9 A: H
exit(1);6 s5 C4 Q0 E) b
}
- `/ s6 O3 ~& D% r/ V
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
! L' g1 ` w _9 B m3 z
cin>>alpha;
6 r! M4 t7 }: |& L4 B& P
cout<<"请输入隐含层到输入层学习效率: beta=\n";
- g; N. p3 Q. f( ~. k, t6 `5 e! p
cin>>beta;, X {\" C& v# J! ?2 C5 l& W6 O
int study=0; //学习次数: S. @% x3 P* v1 a) g) ^. D8 H
double Pre_error ; //预定误差
+ y1 q' R9 X: z6 L
cout<<"请输入预定误差: Pre_error= \n";3 E: R; h4 M. q% _2 w3 x. x
cin>>Pre_error;9 e4 Y Q+ M$ x; J7 c9 `' J8 @
int Pre_times;
9 E9 {9 |) N; o, I0 C9 ]$ ]
cout<<"请输入预定最大学习次数:Pre_times=\n";: e+ i% G. H) ?) Q8 I( b$ T$ e2 s
cin>>Pre_times;+ W5 J\" T7 Z1 ?& R$ l3 Z8 j
cout<<"请输入学习样本数据\n";+ H& K) N! L\" N) ^
{
' K1 U% |# O- ~3 I' @9 R
for (int m=0;m<N;m++)
! O( N2 H5 u% a# B- J
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; * t- m\" h' m$ X! p% @
for (int i=0;i<IN;i++)
, {' e* M3 h. f8 M( _$ W* {
cin>>Study_Data[m]->input[i];
\" b! M9 M4 i. n0 [6 t
}
2 o' e. E# l, Z6 ^- Q& q: ^
{ 1 L: z( T/ H& g\" m
for (int m=0;m<N;m++)
3 o9 ?5 U) K' ?
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; * v, d V/ _9 a* I2 Q
for (int k=0;k<ON;k++)
, A. h4 ^5 u$ I/ x- f\" \
cin>>Study_Data[m]->teach[k];
\" [5 @5 s8 ]0 V3 u. M6 I
}
8 L9 O g* D, `7 S+ C) |- k. w
initial(); //隐层、输出层权、阈值初始化 (1) 3 g$ _9 s+ z) R: W% T W
do7 n5 n2 O% m) [; l
{: D\" A9 C3 n. D1 F5 l9 z* A
++study; ///???4 B3 {/ ]# Q+ H
for (int m=0;m<N;m++)
2 W& k3 M4 F A- q9 S4 B+ n
{\" T/ _! b% H$ o% Y
input_P(m); //输入第m个学习样本 (2)
9 k( J3 F# k, O7 f, D+ A
input_T(m);//输入第m个样本的教师信号 (3)0 {* r; }* n' O8 }' m\" ^% {# O
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)) ?6 ]- i) M+ T Q- w7 [
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
$ T5 J. r4 l5 p2 _! [+ u
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) 9 i. E% P/ Z) @% T
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7) X; J1 ~% E+ L$ {. x8 O' H
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
/ p' ~# i9 n/ c. S6 K0 o7 q9 \
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
# ?' \- b, g' g/ \( a# G. f
} //全部样本训练完毕
3 W9 I5 r$ K0 Q) i
sum_err=Err_Sum(); //全部样本全局误差计算 (10)/ X- C3 J& b8 O, I5 @
{) J. O) C- c6 J+ ?' |1 Z
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;/ s2 [8 n/ r- O& G5 G- D) S
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);& @1 N5 {8 ~4 Q' ]
}
\" D8 F9 b0 s$ C- i/ O8 W$ U
while (sum_err > Pre_error) //or(study, b: r# G! j9 X! }& @
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
! w% @5 j& \0 q/ M8 V+ A
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
+ L) s: L$ x |3 f3 [
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);5 n3 V2 @0 p; x8 b0 G0 N9 ^
fclose(fp);
) d( `# w* _6 k& E4 D7 r' I0 }) \8 U
}& n- z. A/ f\" j; [
char s;
# g; a8 H% [8 j: q
cout<<"请随便输入一个字符，按回车退出程序！\n";
; Z# @* e% s B6 R- L
cin>>s;, X; k) p) {, a3 Z3 A8 Z; }3 M% E
return 1;4 a\" e, q4 ~/ [1 r5 z7 U; p: m$ v, _) j
}$ C/ Q% p7 x4 x8 ?- D4 X
$ |- C* [4 y5 ^( k# N$ ?- g