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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"/ F' J- K# o/ P6 @5 ~: X
#include "iomanip.h"
* I, d$ M4 B/ h) G
#define N 20 //学习样本个数
! D% G7 s7 J( j# W
#define IN 1 //输入层神经元数目$ ]\" l: D% @) s3 l2 r; U/ }% l. r- D
#define HN 8 //隐层神经元数目
7 l& k3 `& d8 P( ]
#define ON 1 //输出层神经元数目
3 l0 G: j! B' T% `. t2 w9 i
double P[IN]; //单个样本输入数据! d; t\" [\" }# S# }
double T[ON]; //单个样本教师数据
0 t5 h# N' }1 g& g/ u9 F
double W[HN][IN]; //输入层至隐层权值
0 ^3 n( j @. N. h
double V[ON][HN]; //隐层至输出层权值6 m) Q% W+ R. \7 _3 k6 I
double X[HN]; //隐层的输入* x: U- X( x9 [0 Q7 I N `
double Y[ON]; //输出层的输入
$ Y% w/ @0 c! a\" ~3 W0 |
double H[HN]; //隐层的输出
- F4 Y9 P) ^! o9 p0 O- a, m% Q& O
double O[ON]; //输出层的输出
% B2 h+ C8 a1 a6 v3 j. Y+ u0 B
double sita[HN]; //隐层的阈值& _3 c Q3 o. p/ Z7 G- K
double gama[ON]; //输出层的阈值
9 e2 }: n, [1 P' j; _
double err_m[N]; //第m个样本的总误差; p m p% C$ r1 @
double alpha; //输出层至隐层的学习效率
- V) \+ n+ m1 I% H) c
double beta; //隐层至输入层学习效率
$ o4 N) e3 w. u; c
//定义一个放学习样本的结构 Z, C J! {6 [6 f2 m% \$ k/ k4 p
struct {- @: U2 S\" `. t/ w
double input[IN];: q\" i2 ^7 v7 b5 ^3 R0 \
double teach[ON];
2 L7 B0 Y( ~0 F6 `
}Study_Data[N][IN];
f' { m2 I& R0 D7 J
6 [+ g# F/ x; W! `
///////////////////////////0 Y. M+ N/ f- C% r
//初始化权、阈值子程序/////
\" Z9 j2 ]5 [0 }0 F1 H' h$ b7 ~
///////////////////////////
5 U\" n( M5 B- @2 X
initial()5 R+ Z* }- A! a
{
5 z& h# r9 D3 @3 X
float sgn;
& p5 ~& ]9 n; z. y! Q M
float rnd;. P\" E4 n: i- T+ f$ u! e9 u( r, `8 J
int i,j;0 y5 Q) `8 J% v2 e8 _/ X
//隐层权、阈值初始化//
\" h6 H* h\" m. N$ d, l, |
{
( n: j8 j8 r* W* U* ]
//sgn=pow((-1),random(100));
B3 h\" q( }9 r' Z
sgn=rand();
: _, d* l; z' o% U( U$ a& ^
rnd=sgn*(rand()%100);4 ]0 @9 J S& z\" ]9 I0 u
W[j][i]= rnd/100;//隐层权值初始化。
& p' S8 S3 d8 h3 k+ O+ e
}- M4 Q0 s- B6 v# i
//randomize();
. P' W7 V- \- B/ i* ]. z0 a1 x. ]\" y
{
5 ~- W( V- R# l$ O9 P6 ]& T: E
//sgn=pow((-1),random(1000));$ C F! q: q0 d: ?
sgn=rand();
' s6 y4 C* Z4 j% J6 l
rnd=sgn*(rand()%1000);' ?) O; a' v r2 t6 {' z4 `# B% M
sita[j]= rnd/1000;//中间层阈值初始化* [9 P6 f# E5 _, J, J
cout<<"sita"<<sita[j]<<endl;\" ]# I b$ u6 a; d R4 Z; Q
}
4 ~1 p- j2 P' j; U# v. J3 M. |
//输出层权、阈值初始化//# ^\" m7 a- T7 @2 K
//randomize(); c+ e) `1 K# ^
for (int k=0;k<ON;k++)
/ w4 e0 s7 e5 z& I: I( B8 c
for (int j=0;j<HN;j++) ! B2 U- x% U2 w0 |& w
{3 P& p+ I: d% B0 P8 @. u
//sgn=pow((-1),random(1000));* f: C4 u- l2 @3 e\" G9 L
sgn=rand();
* H* q6 @; I$ y5 k4 ^# W$ `1 |
rnd=sgn*(rand()%1000);
- e3 q+ c! ^; \
V[k][j]=rnd/1000;//第m个样本输出层权值初始化( Y- s1 g/ q9 j; U% Z; h ^% M! t
}
) k N/ f. m' P
//randomize();
5 e i0 A# o: j\" u% u- e% C
{
( Y8 H! Y# L9 h
//sgn=pow((-1),random(10));8 \% ?1 A4 \/ _ q# N
sgn=rand();
3 [+ Z. {8 G. V\" H. y
rnd=sgn*(rand()%10);
% B\" b+ L3 ~7 N+ i7 V- x2 f
gama[k]=rnd/10;//输出层阈值初始化% C. x( C1 C' [
cout<<"gama[k]"<<endl;
& V- I! I4 z( \( F
}
5 z- f' U5 F\" _/ J% M7 F- r
return 1;) K\" R+ {' ~5 w4 x
( W9 @ Y) ~' X$ ~0 k2 K0 K
}//子程序initial()结束2 A0 _# R# T6 H\" [
P+ K4 i& D+ P
////////////////////////////////
' I6 L( v0 P- z( ?8 t0 }' M0 V
////第m个学习样本输入子程序///
9 ~6 ` u* B( h( r# O
///////////////////////////////, f3 W. C8 l\" y) U' {/ i- c
input_P(int m)
7 l: t) \, G0 c( T
{
: Z$ ?3 `0 Q G
for (int i=0;i<IN;i++)\" A8 P8 Q% b' n7 Q4 q
P[i]=Study_Data[m]->input[i];' x- N3 E5 X6 A9 l+ f
//获得第m个样本的数据
& x, ^, U9 F% x\" y! U) J# k6 Z
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
: @4 R1 M0 t1 {& j( D\" }
//P[%d]=%f\n",m,P[i]);2 R3 x& [1 z1 h! D\" E
return 1;
& \+ m J9 S) t! Z: F0 ?
}//子程序input_P(m）结束2 J6 w3 E& t/ Y* C- ^ K9 U
/////////////////////////////
& J* `* n% O4 `& E6 R* h) \8 H
////第m个样本教师信号子程序//
) W5 ?3 d4 ~. C! _0 g5 s
/////////////////////////////; H; i' C3 ] B% d6 |3 v
input_T(int m)
3 F2 P4 x6 Z( M) J4 Y: |- u
{\" F0 c7 f( [- t6 j
for (int k=0;k<m;k++)
5 O+ |( H! ~1 Q7 Z6 d2 m2 t
T[k]=Study_Data[m]->teach[k];- d+ O5 {: `6 {2 J
//cout<<"第"< //
; k! |! j8 H\" A4 r' J
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);! R% Z5 O( K, S4 n, Y1 d
return 1;
' [, [5 ?$ K4 ]8 {6 P0 D
}//子程序input_T(m)结束
- S$ N4 Z/ p* k- Q) e% C
/////////////////////////////////
( {) D8 _9 P9 `$ @0 @: Z, J
//隐层各单元输入、输出值子程序///
\" O. S; V9 V3 m
/////////////////////////////////5 H7 d5 t# S& g6 Q+ `/ d3 _
H_I_O(){$ W5 p' n4 d9 G W. ^ K
double sigma;! Z3 }# [- \\" `* ~
int i,j;( r& c5 s8 [& `! m, g
for (j=0;j<HN;j++), C8 C# N$ `3 k
sigma=0.0;) F; r; j& U, U8 U. p. r. H5 J
for (i=0;i<IN;i++)
8 r9 b5 A4 M' o
sigma+=W[j][i]*P[i];//求隐层内积
* M# b9 x! k' Q i/ V2 ]3 r
}\" t' C7 W( m9 g7 w
X[j]=sigma - sita[i];//求隐层净输入0 x, b6 Q7 s2 W) s# L( {
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出/ h J0 n6 H& h I- t1 L
}8 {\" w8 j# j, d$ _2 [- d
return 1;. ?1 I* ^; m' }% M6 o) |& D
}//子程序H_I_O()结束) E% ^- i, R, G
///////////////////////////////////2 G6 v8 }8 O3 O4 K
//输出层各单元输入、输出值子程序///* m/ [. M; i8 ?/ B2 l' V# V9 _
///////////////////////////////////
( n3 @( J: p9 w$ V4 V7 s\" S
O_I_O(). D) Y% o+ a- N8 G2 F. A7 n* M) |& j# m1 S3 y
{8 \ o' V2 K\" a/ e2 T\" L5 m/ H
double sigma;$ N' y0 _9 ]1 q2 x, y* n; v
for (int k=0;k<ON;k++), v5 W6 x3 M6 S
sigma=0.0;2 m& \1 q) D; p) K2 ^
for (int j=0;j<HN;j++)
6 w6 d\" _( T+ K; f# k
sigma+=V[k][j]*H[k];//求输出层内积
1 L9 d3 f- J$ H0 T* k
}* J h9 x1 q5 V( w, T3 y7 [
Y[k]=sigma-gama[k]; //求输出层净输入
* E& v! V) |$ C9 b
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
+ P2 b3 I0 Q Q8 q3 h
}
& O% `$ A% `. }5 n
return 1;
7 f6 G P2 P! n1 ^& Z
}//子程序O_I_O()结束\" f\" G6 I1 M! o% v) s3 ~$ I6 R! h: {7 U t
////////////////////////////////////
\" W$ K& h& T* a
//输出层至隐层的一般化误差子程序////
! f7 @6 z. |% k: ~! j$ H% D6 y$ T
////////////////////////////////////) [9 ~6 B1 u. e2 q8 t8 V% _) j$ r5 Z
double d_err[ON];6 q% Y Z: S. j9 u
Err_O_H(int m)+ j8 D( }8 b: z2 G\" p
{
; D6 c- k4 ~8 \3 D. G5 x
double abs_err[ON];//每个样本的绝对误差都是从0开始的, M! \9 l% ]% n, d! p& x
double sqr_err=0;//每个样本的平方误差计算都是从0开始的, }7 T# H6 p1 B+ \4 z
//for (int output=0;output<ON;output++) //output???
% ~* S+ Y; R) V\" C2 w7 t: b% m
for (int k=0;k<ON;k++)
! L5 M6 g+ g# D* d0 k9 z) g
abs_err[k]=T[k]-O[k];- L3 o\" C! m8 c6 Q
//求第m个样本下的第k个神经元的绝对误差- @3 T$ M3 T9 S2 r7 v
sqr_err+=(abs_err[k])*(abs_err[k]);
+ ]; a& L* X* ?$ `0 t5 L- p
//求第m个样本下输出层的平方误差
, w- d- ^; V% d$ k& q; b
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
$ d2 h0 S( }2 k3 I1 J; C
//d_err[k]输出层各神经元的一般化误差% k\" h2 [( `+ P4 O, k% e
}, W. j0 Q) j& u1 `6 @0 R
err_m[m]=sqr_err/2;
$ ?9 O* U; s8 i\" ^& m5 b
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
: J4 b& [5 s- }
return 1;) N* \ p2 ^3 ~7 ` G
}//子程序Err_O_H(m)结束
$ p5 w) V2 P: U X
////////////////////////////////////# Y1 Q q\" `# L\" w\" P! {0 n5 u
//隐层至输入层的一般化误差子程序////
- J6 R) c7 V8 B8 _3 x& y) t2 ], z
////////////////////////////////////% Q% w3 s- a, Q
double e_err[HN];
9 N8 C) d6 b5 L2 @( E2 \
Err_H_I(){
\" l3 D F8 ~! n
double sigma;. |2 ~8 D+ P5 X7 \
//for (int hidden=0;hidden' Y0 S! e- u/ Q- M! ]2 L
for (int j=0;j<HN;j++) , G2 U* N/ o) Y4 w5 f, I n9 i
sigma=0.0;
/ c% [ ~\" Z9 O& b
for (int k=0;k<ON;k++) \" X b+ y% W+ P3 V6 ]1 l
sigma=d_err[k]*V[k][j];7 w% h7 u8 A* L
}
2 W' j D- d0 `* @' }( U5 L+ {
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差+ d9 o$ B# A0 x
}% z+ a5 R. ]2 b; {1 `) n
return 1;
2 i5 q4 X) k2 T2 }2 a. q% m# `9 w
}//子程序Err_H_I()结束
1 p% s( E0 D4 {
////////////////////////////////////////////////////////8 A0 H+ l( C$ _1 D, {
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////. c b f2 \& f8 E4 z
////////////////////////////////////////////////////////6 I* }7 k1 T- ^3 A# ^
Delta_O_H(int m,FILE* fp)
& o1 G l\" r4 _$ M
{
6 \1 v) [8 G, O) L% v% f0 g7 f- ~
for (int k=0;k<ON;k++)
6 g$ e4 C$ c! [2 q' T) \: N
for (int j=0;j<HN;j++)
( @% `/ n- y/ G# r- P
//cout<<"第"< 0 T/ @: w; i* T
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);' ^% P: X8 _! }; e8 k
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整9 d$ n\" v. [/ N2 X
}- o* w7 ]/ t+ z+ }5 `
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整4 E) i6 K4 H& l/ w3 b; ]4 I
}8 t& x\" l9 m. X; l
return 1;3 C; p0 l/ d. b( k9 S
}//子程序Delta_O_H()结束: t8 {& T n/ G3 I
/////////////////////////////////////////////////////
7 I1 B& ~! ?& b4 e/ A
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
# y! S& @8 ~# r$ A. v# I
/////////////////////////////////////////////////////
4 g! t3 _, h: J+ L
Delta_H_I(int m,FILE* fp)
: X0 A% N, F% q
{
1 [+ l+ p) ?* V! G
for (int j=0;j<HN;j++); l2 x5 Z4 J\" X, C0 K: ?. r* h6 @
for (int i=0;i<IN;i++)
0 n5 `( L9 z$ G
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
$ Q) X+ S7 w% G! D( t. i1 E
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整4 k b Z- z. o6 s# h7 c
}8 v4 s; |$ ?# _7 ?
sita[j]+=beta*e_err[j];8 t$ X* f+ W: T' C
} J. O+ v* j7 w$ A2 `
return 1;
$ ?\" X/ q( m4 Z
}//子程序Delta_H_I()结束
( V/ q/ ~. y) E
/////////////////////////////////
- U8 y l/ [, p8 ^6 s- J4 Z
//N个样本的全局误差计算子程序////
7 ?7 O8 g0 h) b& U& W
/////////////////////////////////
# d9 C, Q2 j6 f l& c
double Err_Sum()
4 R2 N% ~1 g1 A8 P\" w0 O
{6 t- d6 H; u: q
double total_err=0;
7 f. S5 O5 ]0 ^0 K9 f* s7 z
for (int m=0;m<N;m++) : G# o4 {7 w7 C4 c, ]6 c Q8 L( E; J
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
. F$ |( y7 z z' }
}& |1 s. B6 T7 r: j4 t0 O# Y
return 1;
& `$ K) Q\" ?& z
}//子程序Err_sum()结束4 X) J5 j I3 x\" N* e
/**********************/
# F2 Z$ a2 V$ _7 o
/**程序入口，即主程序**/5 a) \: ]' {: k2 N9 a
/**********************/, \9 h* |7 l9 l6 I
main()
* E* V1 M; o, E$ s2 k. w* l
{5 }5 B! C9 Y1 e
FILE *fp;
; i$ v- f. r. x! S$ G$ C( C
double sum_err;
/ J, ]. ?) [$ b
int study;//训练次数, D+ ~. t% f$ U5 `* m1 m- Q/ c
if ((fp=fopen("bp.txt","a+"))==NULL)4 v& R8 E( s* t# r' [) p
{
2 W; n9 F8 Z$ G2 h! l3 [
printf("不能创建bp.txt文件!\n");
/ W4 J3 H9 g7 v3 J1 ?+ U
exit(1);% y7 Q; p% @8 O% E% g3 m
}
3 p% E! t7 P\" d# H
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
e4 o% Q5 R8 W( `1 G
cin>>alpha; h- [6 H5 q4 |. b' h
cout<<"请输入隐含层到输入层学习效率: beta=\n";
! o& O, _$ w# } i; ^7 D! b# t0 c
cin>>beta; g& A) I% l7 {( a
int study=0; //学习次数 H6 G. \% B* c' Q
double Pre_error ; //预定误差$ G% H; Y\" A2 v9 u% K! Y, G* ]! l
cout<<"请输入预定误差: Pre_error= \n";
7 J- ?0 S0 ^1 \# p$ P6 P! p
cin>>Pre_error;) P' N; C: i2 s\" w, _& o; }
int Pre_times;: \4 o% [) I) _\" t: ^
cout<<"请输入预定最大学习次数:Pre_times=\n";( d0 u, M% k+ |\" r! p. C
cin>>Pre_times;, A% B$ o$ Q' m1 j0 _8 V4 E
cout<<"请输入学习样本数据\n";
! z7 G. e5 E/ m% B( i s0 ^
{& E4 _6 W* t% h9 B0 y
for (int m=0;m<N;m++)
& o# }. C4 p$ ~3 i8 I
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; ! F* \; R& q$ U3 m7 B
for (int i=0;i<IN;i++)4 R2 N; h\" |% a5 i J
cin>>Study_Data[m]->input[i];
& q% Y9 v: [8 b1 u. W! P; \+ Z2 C
}
; a0 M3 q( F2 J+ _/ i O
{
$ M\" ^8 q; C! \/ c; X, e2 P S: p/ I
for (int m=0;m<N;m++)
: a6 D4 w8 _, Q, R
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
' Q4 z9 u* _9 [0 Y+ B2 i4 [
for (int k=0;k<ON;k++)
1 m+ }\" i: \5 y- _( x
cin>>Study_Data[m]->teach[k];/ o* N: z3 H- b- Q8 W8 `. E
}( {, @, s) ]! ` K
initial(); //隐层、输出层权、阈值初始化 (1) G) v$ c U4 h7 L# @
do+ o4 e, x+ \. i2 \ g
{
4 J) {% H, D6 @
++study; ///???( _* C$ H4 O c% H3 Y/ R! s
for (int m=0;m<N;m++) + S: s- D' m* Y2 V, o* l
{: M- a6 A; m) `
input_P(m); //输入第m个学习样本 (2)$ R4 N. B1 h4 g9 L
input_T(m);//输入第m个样本的教师信号 (3)
$ L\" U' F( z4 Q% ^: }0 L; a
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)' }! s3 k! B& W# Q! W\" r
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
3 R c- f0 b$ u\" J
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) - M; K# |* I\" @. G( ?+ ]
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
8 X6 H8 b' q+ k3 C6 E$ p
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)* ?3 ^8 X1 L+ Y6 ]
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)% K( q! e8 k# `. V( N/ ]
} //全部样本训练完毕/ v9 H2 V; H3 ~9 Z1 }; O- d1 y
sum_err=Err_Sum(); //全部样本全局误差计算 (10)4 Q' |. I; T! d' b' i# S- o
{/ w s, W2 k+ w9 H( l9 b- `
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
! Y7 u\" d; X% g% G
}* j: x9 B7 L# X. F\" x8 y7 B$ Q
while (sum_err > Pre_error) //or(study
. I6 h0 F: u' g/ |1 `0 H: K a
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
+ a9 ]$ w& m0 r7 R* e
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;' d# ~; i- R G, ~
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);, Y0 `0 p9 G1 x, l3 g
fclose(fp);
3 q {* T0 Z, S g+ F) k& E
}6 f/ g% N% ?/ O* i2 k6 ?
char s;
+ b/ x# H( p; P\" o4 c
cout<<"请随便输入一个字符，按回车退出程序！\n";
2 e E+ q( R: u) i5 H1 q
cin>>s;/ n+ @\" C4 d' W4 g
return 1;
! Z0 K4 o$ i I2 `
}; j! W0 V6 R1 W7 K, F- Z
/ B$ M4 N8 {6 y5 ~& X6 I/ ~