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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h" m7 E5 }( q! Q, h
#include "iomanip.h"+ V\" ]# n; y4 Z/ d
#define N 20 //学习样本个数! _/ z8 k9 A5 Z, Q0 P1 d9 I
#define IN 1 //输入层神经元数目6 G- K! z0 g# y& f1 [
#define HN 8 //隐层神经元数目
, v: c4 i5 D; W& p# p0 O\" ]- B
#define ON 1 //输出层神经元数目
& P# R. M2 e& z; ]7 h6 G\" z2 `
double P[IN]; //单个样本输入数据3 ?' {9 v\" w# Q q0 g& ^
double T[ON]; //单个样本教师数据! R3 D6 P; ~9 k8 O# V2 q0 n3 _
double W[HN][IN]; //输入层至隐层权值
: z8 _0 T: N# ~3 m& S. h' v
double V[ON][HN]; //隐层至输出层权值
+ W6 f% ?# }7 y
double X[HN]; //隐层的输入
' v4 S9 k1 Y' o' U _8 X- ^* J& }
double Y[ON]; //输出层的输入3 U8 D3 K0 _, j9 V1 I
double H[HN]; //隐层的输出# F% b: n0 r4 j\" \& R! F
double O[ON]; //输出层的输出
n$ h: L2 j6 M5 m! {$ ?\" o( R5 G
double sita[HN]; //隐层的阈值
1 M; d3 D6 c1 \: \
double gama[ON]; //输出层的阈值3 ]; p; I3 A/ i( g, |
double err_m[N]; //第m个样本的总误差4 B/ i3 m% J e8 @! T- c: I# ]- M
double alpha; //输出层至隐层的学习效率
5 y7 F8 U- C4 |+ j
double beta; //隐层至输入层学习效率' q& i& X3 j: V+ Z7 H
//定义一个放学习样本的结构5 S/ Z: V2 b, `* m) S
struct {
1 A, I/ i4 f2 [
double input[IN];
8 k1 Z9 ?- R& i+ ?
double teach[ON];; m$ C+ k; y% H) w& u0 U
}Study_Data[N][IN];
/ O5 q, b8 s7 M
\" s. S; G\" G3 `4 x4 k1 a
///////////////////////////
! X( f- Q\" `8 N$ d( @\" M: P; I, ?
//初始化权、阈值子程序/////
G& N& ]# L; F1 t% R( F, g
///////////////////////////. W+ z0 q/ q- W, M\" F+ z
initial()
: `; @2 f( I$ z' m: o4 ]8 ? t
{) y. n2 ~\" d7 o1 ]' s
float sgn;
9 i s% j+ s' I8 v
float rnd;5 j7 {+ a. ~; b\" Z
int i,j;5 Y$ K0 z. d1 F5 Y. _
//隐层权、阈值初始化//$ | Y8 ^6 K! L5 @
{# I! d* U1 Q2 T8 H& w\" O
//sgn=pow((-1),random(100));
9 o' }# t7 H6 T3 f# y# y
sgn=rand();1 h- v/ {3 \# x
rnd=sgn*(rand()%100);
; [' Z) Q# } [$ Y$ P/ P. q
W[j][i]= rnd/100;//隐层权值初始化。
; K# p B, s* C( @
}
# j, N7 Y0 Y+ _' N' @0 _
//randomize();
+ G8 B' e8 g* ^0 W: ?7 q' r9 r x
{$ Q4 Z9 j* N: d
//sgn=pow((-1),random(1000));
3 U1 H2 n; ~/ K+ z6 @) j
sgn=rand();* \\" h: M4 R2 o( ]+ s9 K4 R
rnd=sgn*(rand()%1000);
2 Z! x7 h6 q, l
sita[j]= rnd/1000;//中间层阈值初始化/ b& F. P, N8 M8 Z
cout<<"sita"<<sita[j]<<endl;$ |9 x) n8 Q0 m% w l
}+ A% {* E& u5 l# z
//输出层权、阈值初始化//. q3 R0 e1 h! c
//randomize();
# T, L, q1 T) L9 {* P\" m Y
for (int k=0;k<ON;k++)+ J1 f( }' {+ W; z& Z+ @
for (int j=0;j<HN;j++) $ s+ M; V* v5 y+ q3 J% j
{& L( n- t! @$ `# \$ ]' N
//sgn=pow((-1),random(1000));
0 a6 D4 _4 u/ U+ q, S
sgn=rand();
1 T$ `9 e& v5 k. l
rnd=sgn*(rand()%1000);
8 H( I2 a4 ^8 r4 {; z\" L
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
& Z9 @& U( a: Z\" c' q/ v\" W
}
0 }# s$ {) M1 t7 l
//randomize();2 e! l7 B. {) P2 K7 E+ y; }
{
: P1 h! @; y8 G\" x6 p
//sgn=pow((-1),random(10)); m- m' X- u$ a& O4 R% o$ j
sgn=rand();
$ W7 X @ J$ j) I# w4 o
rnd=sgn*(rand()%10);\" m% n) F0 D' b. R. e! M6 s' A6 {$ d
gama[k]=rnd/10;//输出层阈值初始化
3 B& z3 [( ]. b
cout<<"gama[k]"<<endl;
% s5 U+ R+ G* X3 [. L* f, d
}
' V) z\" R4 i( n+ i: ^\" C
return 1;
; y3 j+ `4 \6 P/ n4 w% [* g
- ?$ F5 k- v- A% p* t) {: D
}//子程序initial()结束) ~0 n; w\" }, Q# \' a7 r: K
, j# N+ ^; Y% F\" c; j% x
////////////////////////////////\" C9 W\" c$ V. Z1 O2 {8 a/ r
////第m个学习样本输入子程序///
\" G& X* ]5 J# x+ b3 U. ^. D: \
///////////////////////////////
( {- p7 \9 c( C# k
input_P(int m)
$ G4 g. V7 _! B
{. G; V4 O& j$ x7 y
for (int i=0;i<IN;i++)9 B$ K5 |9 {5 \. O9 k! j0 [
P[i]=Study_Data[m]->input[i];
: w/ y2 E+ r0 w2 ^4 N. T; [
//获得第m个样本的数据$ F# L0 ]% l. e. x! |6 K
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
9 U) P. O+ n\" y8 P2 a% Z
//P[%d]=%f\n",m,P[i]);
+ D5 M* g1 O0 k+ }2 ?; H
return 1;
2 w5 A) q) N0 x) [0 B; [
}//子程序input_P(m）结束1 m2 L& H; e8 Z\" `
/////////////////////////////
& ~( @1 l1 W. R( ^: y# D) F
////第m个样本教师信号子程序//- _! r1 E/ S8 E. |% Y7 e
/////////////////////////////\" z4 _& T( v R: A6 z: _$ b, v, D
input_T(int m)/ W( c T O: v
{
4 { ?& X& V) w* l. X; d8 y+ Y
for (int k=0;k<m;k++)
+ N2 N( c6 y$ P% V v g
T[k]=Study_Data[m]->teach[k];6 f% R% q1 a2 z$ S
//cout<<"第"< //
; Z2 O6 [, t& M8 W! f\" c
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]); Q4 _6 K5 M4 K( G% |1 I
return 1;3 K# W. N, L8 l
}//子程序input_T(m)结束7 I6 F3 b\" o& }\" K0 D
/////////////////////////////////
5 z' G5 y* y7 b% d
//隐层各单元输入、输出值子程序///
: [& ?6 } J; V( q% ]! `2 R3 Z
/////////////////////////////////1 } O! ?7 _+ z' u$ w$ h0 i
H_I_O(){
% Q7 x2 K% r, L& w: y
double sigma;
4 \* q6 C\" V) H
int i,j;
$ @+ Q, Z9 {2 @5 h% y/ @) H
for (j=0;j<HN;j++)\" x, }+ ?; N m. K8 n! c+ @
sigma=0.0;
) K; ^# {0 ^2 r% F
for (i=0;i<IN;i++): {4 G* D1 e! S, G\" k7 A q: n, F
sigma+=W[j][i]*P[i];//求隐层内积
8 P. A4 w\" ]3 h0 Z
}+ R9 Y2 n L\" |; V
X[j]=sigma - sita[i];//求隐层净输入, X( p p- j3 p% G9 P0 b
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出8 T4 E# [5 T' @/ g p
}
0 q7 F3 T3 U1 j9 W! f1 y& t
return 1;- g: l% \( y; f9 v, X
}//子程序H_I_O()结束# D& H4 d1 S+ @- W- X2 H$ A( |
///////////////////////////////////- J' T% c4 ?+ \. O
//输出层各单元输入、输出值子程序///
9 B, n1 e% \+ F% n1 C2 }
///////////////////////////////////0 i3 Z2 P6 m6 j6 Z, B3 \% J7 v
O_I_O()
7 W* \' n4 i* X6 U' X6 T9 C
{; r+ g+ v9 E5 V) b! j\" S
double sigma;
# ^- A& y/ R\" D
for (int k=0;k<ON;k++)+ _4 b8 |8 b5 Q
sigma=0.0;
1 k1 `6 l5 }$ n3 V% L4 ]# P/ Q# u
for (int j=0;j<HN;j++)9 I6 n! b% X& t9 i
sigma+=V[k][j]*H[k];//求输出层内积
2 ?: C, M% ^; R7 J
}( |3 v% N( b7 f7 E; t7 e
Y[k]=sigma-gama[k]; //求输出层净输入
, [! R; e$ t5 T
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出. @ X2 [( i [8 L9 u+ @2 Q
}
6 e5 |+ C' Z6 M7 N/ d* ~- @/ B\" b
return 1;5 c% N/ J; t, @) }
}//子程序O_I_O()结束; h% R\" X H# i7 T, e7 e* u# J8 l& y
////////////////////////////////////\" t* a, `: E9 ]* t& ^( f
//输出层至隐层的一般化误差子程序////
: U2 N9 ]$ Y! ?# z G4 T# m
////////////////////////////////////2 r! W8 c/ t+ N7 c1 z; A
double d_err[ON];' |- T# \( d! Q; r3 S6 w4 q. X
Err_O_H(int m)
. V( ?2 @' Z3 G* _
{% b+ M) z# r+ Q8 m. X\" m8 }8 _1 j7 O+ S
double abs_err[ON];//每个样本的绝对误差都是从0开始的9 [& d( s! g6 f
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
9 Y' P1 e9 `3 ^& i$ g
//for (int output=0;output<ON;output++) //output???
$ H! i f5 F! f\" Y
for (int k=0;k<ON;k++)2 R8 V; Q$ [$ D
abs_err[k]=T[k]-O[k];: u; w. t5 h4 Q+ ^
//求第m个样本下的第k个神经元的绝对误差9 f; Z. Y, r: S
sqr_err+=(abs_err[k])*(abs_err[k]);9 R8 ^) L5 ^: Y0 C4 J0 L* m# r/ c
//求第m个样本下输出层的平方误差
: ?: [# J2 w2 A3 g) u0 a5 n1 p2 F
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
* J- \+ X4 H/ B; p7 b) V
//d_err[k]输出层各神经元的一般化误差
5 B0 y, i\" ]4 P4 n$ G& W, G
}( k\" n/ @: t7 ~% P\" O j( g2 g\" c
err_m[m]=sqr_err/2;/ G( H/ i5 {7 U5 i+ w6 ?( ^% I% ~
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
) ^$ p9 A+ Y3 j1 f4 w/ h8 t
return 1;
/ h3 L6 R, E) W' c- N
}//子程序Err_O_H(m)结束
2 j, k% }+ j, _* x2 q) }0 ~
////////////////////////////////////
5 b8 M- b( Z6 j6 @: B
//隐层至输入层的一般化误差子程序////
1 R; T, h! T. q/ }$ v( G) B+ h
////////////////////////////////////9 N7 t2 `' }% M; O; j/ R
double e_err[HN];7 X3 ?2 A. M4 q$ n! X9 \
Err_H_I(){
N7 d8 G, P% i. U
double sigma;2 M8 @. ~1 W7 w8 u! S2 e
//for (int hidden=0;hidden
\" ~* K) f5 m* w& g
for (int j=0;j<HN;j++) - _1 g7 j( h3 R: k* \) ]+ n
sigma=0.0;
+ O3 e3 u) D/ A
for (int k=0;k<ON;k++)
) f% ` X$ r# h, }6 C6 J
sigma=d_err[k]*V[k][j];
# y& Q, Q$ F2 V
}
$ O+ [- R; z9 m\" I( J; U2 e
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差: J: T( s3 B; K( u B* M; g
}7 J\" o7 E; {/ s/ T. e
return 1;
6 P4 ]) \; }7 d# [
}//子程序Err_H_I()结束
' e, ^. [; X2 I% J/ S
////////////////////////////////////////////////////////
' y# P+ c- G8 g2 B& V9 @
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////6 t. ~3 v+ B5 X' W+ q& B: D( R
////////////////////////////////////////////////////////. m0 S3 B1 B% P( t2 ?2 m- n
Delta_O_H(int m,FILE* fp)
7 u: f* [( F) c: u6 v! i
{! J& V+ v1 {\" r+ m/ I/ M
for (int k=0;k<ON;k++)
\" u, B$ b' t) y- T
for (int j=0;j<HN;j++)8 d% [; A. p( F% U# }6 n: @- H
//cout<<"第"<
. h: {1 N7 h* D4 j2 S
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);' V8 I' D$ R5 f9 c
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
) [3 |' r) m: F8 m/ t
}
8 [+ V; C! V* L5 U& {4 m4 _3 v7 j
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整\" w* `8 K2 Q4 j) D\" J, X( P9 k2 N
}3 d* R1 j l; L5 U% B% |) |\" @, p& C
return 1;/ l9 m9 n2 I0 }/ B2 p# }
}//子程序Delta_O_H()结束( B6 ^; y1 K\" Z+ l$ i1 d
/////////////////////////////////////////////////////: c& ?* ]- E& H- _7 `; \
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////9 J1 c, R# _0 s, {8 @6 J
/////////////////////////////////////////////////////
# x. x9 q1 C, L5 j
Delta_H_I(int m,FILE* fp)
. B4 B$ G \# i
{
, @6 S- @ l+ I& ~
for (int j=0;j<HN;j++)1 o0 A+ z6 S0 c- y6 ?0 D
for (int i=0;i<IN;i++)
. S: x4 k/ J/ M0 O, X9 \- _% I
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);1 o1 e2 k2 h( D: D
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整# q4 e/ N. ^) l4 s- e5 x3 i0 z
}
/ T& p8 S4 H6 v* i7 O
sita[j]+=beta*e_err[j];5 o! o$ y' D# d0 q, z; M
}
' W& p4 I0 i, v2 t: |. Y
return 1;
1 h4 C W) [, e! o& c+ J. F5 k5 a
}//子程序Delta_H_I()结束) J! E2 |9 p) `% K6 m' r; G8 Z& b
/////////////////////////////////
8 T h. n+ Y\" z\" X
//N个样本的全局误差计算子程序////
; L% c9 c/ |' ]6 `/ H
/////////////////////////////////
! O! }0 x& f. Q6 x8 w1 w! }: e
double Err_Sum()
0 E; U0 \5 ^1 J- }
{
: x6 E- ^3 r2 O7 H% e& i/ t
double total_err=0;
6 I! B' D) u# n: T
for (int m=0;m<N;m++) , O8 U7 a+ x$ a* R. d. _) i4 T$ ^9 p( g
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差$ Z8 }* Y/ X/ c) m; D1 h
}
! q4 h i) E! g2 n$ @; A8 i
return 1;
5 a3 }& c% N D# X; U1 W
}//子程序Err_sum()结束 z y& c+ }2 m% R' |1 z7 c
/**********************/5 [& T! n! E5 l. t
/**程序入口，即主程序**/' y- J7 ?9 A; a# L. P- f D$ r# c
/**********************/
: [# x. f\" n3 c
main()# {( n2 ^& |' l3 K3 L
{
% ]$ a) N3 u6 n M) |# Y! N7 y
FILE *fp;5 S m- f. a6 F
double sum_err;
int study;//训练次数
! ]% g$ u E* h( @
if ((fp=fopen("bp.txt","a+"))==NULL)
7 l, g( u$ J\" ~/ |\" }/ N\" U
{
7 p% h! b4 Q, P# K/ Z
printf("不能创建bp.txt文件!\n");! K4 v+ G' @+ t
exit(1);1 }* ~7 K9 s1 q8 f3 K
}% [! g5 y$ S# x+ N) L
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
4 r& A' T- k- B1 T0 j* K
cin>>alpha;1 j! _: a1 w! d
cout<<"请输入隐含层到输入层学习效率: beta=\n";
- G8 G* D$ |6 e; D
cin>>beta;& H' [& p7 |% ]' [ ?$ X
int study=0; //学习次数
' Q( G4 }8 G# |/ `% x. c4 N& M
double Pre_error ; //预定误差
& g6 a; L5 n7 v# L: S7 T- [
cout<<"请输入预定误差: Pre_error= \n";
/ z\" l, W2 y! p0 y
cin>>Pre_error;
/ @+ b0 F/ t( \1 V, l
int Pre_times;+ S5 K: U _ j2 z; s
cout<<"请输入预定最大学习次数:Pre_times=\n";. u+ M0 l* G* J# N
cin>>Pre_times;
, O% B4 s3 |) y$ i: ^( K7 W
cout<<"请输入学习样本数据\n";
- L' w% k6 J4 P: k8 y* z
{
( T) I, Z, F% T/ V/ V d2 N
for (int m=0;m<N;m++)
% p S* C7 y- U2 g\" t! ]
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; : Y* U F3 |& K1 g' o\" N
for (int i=0;i<IN;i++)$ \5 [( W$ f# U& g\" D3 g( I7 Q+ S3 E
cin>>Study_Data[m]->input[i];
7 Q4 G- D\" G% I\" ]
}
! p( \% R* i2 P2 r
{
3 F1 o/ ~4 F\" A2 F8 x9 m. c& f
for (int m=0;m<N;m++)
. e& ], I( l: j4 M
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; + q: q. r/ c r) z# s
for (int k=0;k<ON;k++)4 v; \; z- W. n$ C
cin>>Study_Data[m]->teach[k];3 A$ m2 O\" @/ b/ H6 r
}
8 G8 _7 X5 |) d8 e+ c0 ^- x/ W
initial(); //隐层、输出层权、阈值初始化 (1)
! o! K- |\" W9 D& c\" `
do
\" ]3 |- ~, ]9 `3 m, \! V
{' n3 f\" A \. z
++study; ///???: ? q% X1 o3 w# Y6 `
for (int m=0;m<N;m++)
2 N: Z, A) u! X2 H& ]: _
{
% o5 u6 ]9 i! C
input_P(m); //输入第m个学习样本 (2)$ F% } ~\" @3 L- ^3 F( v
input_T(m);//输入第m个样本的教师信号 (3)+ d/ H8 Q5 { Z; z4 r
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
% S) d: ?- Z: w' f\" q4 h
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5), G4 i# y9 R G) h* M
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) ; D: P' Y, b; X$ ^3 `
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7), z, R5 h; T h7 S T4 \
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8): v4 j8 b# m# [$ a' t
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)8 I% u2 v8 Q\" F( v6 l, a# `
} //全部样本训练完毕
0 x\" ~' U8 z: q3 f* _
sum_err=Err_Sum(); //全部样本全局误差计算 (10)8 `5 f0 v' y, Y. Z0 I9 s
{' c# A4 V/ z8 v! z
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
6 T$ d- F0 ^' z\" p T- Y
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
6 b0 L, }. i# R2 O( ]( U
}
0 O0 G* J$ M( L4 A) M
while (sum_err > Pre_error) //or(study8 O4 t7 s1 k( f4 t$ f x }
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
) |. ^* H\" F& L. C- v. V
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;( n2 u4 M. E* j' ^: }2 G
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);% Z9 a3 V0 h; i
fclose(fp);
# {9 e4 v\" J! h( m( y( s6 G
}- d( i# b0 R# ]. L! {
char s;
; O( p+ ~6 U+ y& r
cout<<"请随便输入一个字符，按回车退出程序！\n";
: a- r; G4 k% V0 A+ p
cin>>s;
% A+ P1 ~9 [4 U4 K
return 1;
' X, I) T0 j6 m6 y; P5 H
}
. l$ ]' f/ n$ ~9 E4 C
Q: ?- D9 c' J) h+ {