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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
8 l! N' c7 t, c( F$ G2 I4 L2 |* g' ~2 ]
#include "iomanip.h"
; F. U3 w8 W1 S0 C( a8 E; P2 a
#define N 20 //学习样本个数; G; E# M/ {6 [' C' D# Q
#define IN 1 //输入层神经元数目( J) O\" q3 {+ U
#define HN 8 //隐层神经元数目9 e: f2 K0 ?6 K% ^( R; {
#define ON 1 //输出层神经元数目
& m2 n @( n E: }/ n
double P[IN]; //单个样本输入数据2 T( t\" ^( a) T1 m, ~3 Q2 f\" ?# R# A
double T[ON]; //单个样本教师数据
* ]2 V) W) t4 ~, E. B$ @- i
double W[HN][IN]; //输入层至隐层权值
. b; l3 _5 s; m, y
double V[ON][HN]; //隐层至输出层权值' p( y; R, }& e H
double X[HN]; //隐层的输入; m# ?# H4 G2 `6 s B& e2 a
double Y[ON]; //输出层的输入
5 f, v/ t+ T8 w' P& G/ G* d
double H[HN]; //隐层的输出
9 ]) S9 H# M! W. J! O3 @9 J
double O[ON]; //输出层的输出
5 A% q& t5 u ^4 ~3 Z* Z
double sita[HN]; //隐层的阈值
5 D4 B# z5 I8 f$ d
double gama[ON]; //输出层的阈值$ g3 E1 b4 H( l6 ^4 u
double err_m[N]; //第m个样本的总误差
* w0 y4 t( ~( A/ N( l7 P
double alpha; //输出层至隐层的学习效率
1 \5 G+ L' i% I2 w1 X: k
double beta; //隐层至输入层学习效率2 k\" o4 E- O$ E9 e2 e* A
//定义一个放学习样本的结构
2 v1 U0 d8 \/ A% y, q6 w) Z
struct {
- Y+ s5 z' m) x1 }
double input[IN];% X9 Y: z2 z5 {5 ^: O
double teach[ON];
3 F4 }9 `; V+ A5 I
}Study_Data[N][IN];
- R8 G3 x4 _$ J/ U7 X! F1 a V
3 L+ c {% J8 R* D
///////////////////////////( q# y/ Q' b4 p! u7 a0 `' M: T
//初始化权、阈值子程序/////
1 Q6 _! ?. k5 [/ y' K0 L% x
///////////////////////////: D2 _0 c2 }* Y3 X# b
initial()6 [6 F5 b. o& P- t\" d
{
! T# z, w: d0 L- l: U. ]! V; }
float sgn;, D9 ^2 e: P\" ? z
float rnd;. V1 h4 N+ c1 t
int i,j;
* o/ |( @\" e. f: c- O( W* b
//隐层权、阈值初始化//
4 u. C2 R2 E b0 k
{- h% X2 X+ C8 W0 H' H
//sgn=pow((-1),random(100));
- z% }2 B$ o3 V2 Z' Q; S! l
sgn=rand();
$ W: i9 I# e. ^9 i9 ~6 @
rnd=sgn*(rand()%100);0 _; E7 l9 q. u5 H
W[j][i]= rnd/100;//隐层权值初始化。9 l2 m3 C/ p, I
}
9 U8 x6 f) [( U7 I8 n( N8 K
//randomize();
: K1 B( E* O w2 B q/ [
{
5 z! P9 y8 i! b' E8 a
//sgn=pow((-1),random(1000));
! ^6 b6 [8 K9 k5 T. P
sgn=rand();* Y. B3 J7 a+ d. L\" c p+ V5 p: e
rnd=sgn*(rand()%1000);
* m, P C8 [, G
sita[j]= rnd/1000;//中间层阈值初始化% a8 F, u# R1 w+ K4 ]! b
cout<<"sita"<<sita[j]<<endl;
! E1 f1 x# j, h2 e
}
, ]# t7 d& S& i; I
//输出层权、阈值初始化//
- E' T n' D! _1 z
//randomize();
( m X s: y& l2 V1 C
for (int k=0;k<ON;k++)
8 H1 V% b' x1 ]2 i3 x& A
for (int j=0;j<HN;j++)
% d8 F n9 M+ x
{. j- j0 a2 d* i3 P2 e' M l
//sgn=pow((-1),random(1000));1 F+ H. f: C. y+ p6 E# t5 i; N9 p0 H
sgn=rand();( j\" \( |+ w% \3 w S, R
rnd=sgn*(rand()%1000);+ `' g1 R- w* D\" D1 o4 b0 l/ J9 t: M
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
; k\" p4 B) [5 `- }, E- W, Q
}
% Z; R: n6 |# c\" E% Q; {& Z* a& M
//randomize();
0 ?8 f' S8 V' L1 D& X
{5 a1 [0 Q) \9 }
//sgn=pow((-1),random(10));# u D* e\" a' V/ Q+ {9 S& `4 K; ]& Q. k
sgn=rand();: [% ^& B+ }7 l/ w3 z k
rnd=sgn*(rand()%10);; ~/ A/ f: O\" W
gama[k]=rnd/10;//输出层阈值初始化
. A5 D G' g( }4 m
cout<<"gama[k]"<<endl;
c0 n/ q% K4 {8 h5 t2 Q2 }8 t& `
}$ I1 K0 M6 b1 Y. P1 o* g- A+ l
return 1;
; B0 [, `* C' k0 } s
' {: U3 B0 V) L1 S' J
}//子程序initial()结束& y; t. d: Y/ ~' f; |\" P
7 T& [# H8 y3 W2 d7 O) Y
////////////////////////////////
8 V4 |; E; S& ^# J. O6 P$ l
////第m个学习样本输入子程序///& h& T# |5 R/ N; ^ V: H% e4 G; g2 t
///////////////////////////////+ n2 v, n8 [\" ^- g( @: Z' _
input_P(int m)
* ]7 O9 i* D! s( ]3 I\" t+ T) u5 {% q
{8 C/ @' G/ x( q! E% _) s9 F
for (int i=0;i<IN;i++)3 W `+ [6 z5 l& y4 S# I- o
P[i]=Study_Data[m]->input[i];
$ N1 M1 o0 w- M7 ?2 g1 X6 D
//获得第m个样本的数据
% E, ~6 o/ J' O0 l
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：6 k\" Y) K V' r) L
//P[%d]=%f\n",m,P[i]);6 Z9 S* N( |/ |8 U' ?; L$ y
return 1;7 D4 o8 ^- \/ c4 Q5 V5 V
}//子程序input_P(m）结束
6 ~0 R$ j( V# ~\" y2 K
/////////////////////////////
^8 a3 |9 g) w. [# F5 _\" v
////第m个样本教师信号子程序//. k6 J7 Y- r9 B\" v C
/////////////////////////////
\" M3 o$ e$ D: `
input_T(int m)
2 T. J# O/ P& c% E, ?9 k
{# R' u5 t2 K% C+ y1 v Y+ x
for (int k=0;k<m;k++)
0 s# b5 G' O9 J# T, ^
T[k]=Study_Data[m]->teach[k];% K% M; I4 u+ `
//cout<<"第"< //
% P0 g! T) ]$ G- v7 R* ~4 w8 ]
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);. V3 {/ o0 F9 y\" X% n
return 1;8 x, w$ g H' O: }5 G* i0 Y' x
}//子程序input_T(m)结束
5 d! R1 I; U+ J5 m& ^
/////////////////////////////////
$ M) Y; n' k4 M) Z
//隐层各单元输入、输出值子程序///
\" L( n3 Y# q/ N8 |\" W5 n
/////////////////////////////////: f1 N c\" a7 Z2 Z\" v1 n
H_I_O(){4 T0 v7 a O/ C7 `' _; u( c
double sigma;) V; ~/ V- v/ \0 x
int i,j;
: P2 x& Z6 X/ P
for (j=0;j<HN;j++)2 z' i4 p+ M& P9 s
sigma=0.0;( W1 F# a! U0 k
for (i=0;i<IN;i++)
: Z( b$ v% w9 O
sigma+=W[j][i]*P[i];//求隐层内积
7 K' b6 ^3 U& E6 f
}\" |0 J: x' x\" W+ B
X[j]=sigma - sita[i];//求隐层净输入, e# K5 k1 S% c2 O& F' j8 K
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
, L\" _6 X9 N4 j$ R# \: C* w
}% |8 S* a7 j; W! d
return 1;; z3 b1 U8 x: [ _! E\" G
}//子程序H_I_O()结束
9 T1 w! b3 s. l/ w0 f5 Q
///////////////////////////////////
2 L* a) {- R& J$ M2 W
//输出层各单元输入、输出值子程序///
+ }1 j\" [$ V4 _1 D\" V5 o
///////////////////////////////////2 L0 N% x$ o' M3 Q
O_I_O()+ A( `- o! s2 p/ z2 f# p7 J
{: r/ O0 E) a' w2 \) `, A }2 z# J7 Z
double sigma;
# t+ S7 `1 ^! I9 E
for (int k=0;k<ON;k++)
6 U8 B$ P8 P' A0 x# B x5 Z. E0 O
sigma=0.0;
3 p9 s# |% W! e4 M8 B$ X1 G! j
for (int j=0;j<HN;j++)
6 H# y- b: S; N. i
sigma+=V[k][j]*H[k];//求输出层内积
* T* x x1 P* v$ u
}: D& e8 @\" ]9 z
Y[k]=sigma-gama[k]; //求输出层净输入, y; W2 ~, _' K9 s; t X' l% u
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
2 f1 @1 t0 L2 K# e: t
}
2 T: W/ i$ f$ H, `( ~( u
return 1;9 A- K1 a+ H- v
}//子程序O_I_O()结束
* ?4 N; ~& g( p% ^* _
////////////////////////////////////8 y' H' T% A0 M# H O4 {6 p- L0 G* z8 q
//输出层至隐层的一般化误差子程序////
$ X/ l; U# D+ d5 H i( W% Z
////////////////////////////////////! S5 ~\" G8 V/ `5 j' f
double d_err[ON];% o8 m5 p/ H4 w7 i2 M6 }$ w! c\" J
Err_O_H(int m)
% z; M6 z, r9 g; F0 I2 t
{& o* m/ K5 l N V
double abs_err[ON];//每个样本的绝对误差都是从0开始的: E$ i2 o1 B2 [7 D
double sqr_err=0;//每个样本的平方误差计算都是从0开始的4 e8 d: p# u ]4 W, G\" v
//for (int output=0;output<ON;output++) //output???! J% V) v: Q# ~\" t
for (int k=0;k<ON;k++)
) ~\" Y6 N# V# }2 h$ Q( K5 r3 T+ O' G
abs_err[k]=T[k]-O[k];
( m Y% p1 Y. p1 z
//求第m个样本下的第k个神经元的绝对误差
4 L# m( O9 E! i) `/ R1 @9 [
sqr_err+=(abs_err[k])*(abs_err[k]);8 n) `& ?: g) J- T* c
//求第m个样本下输出层的平方误差) ?, x4 H! T+ g# A/ Y
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
. D) @1 ?! H0 {! f2 N
//d_err[k]输出层各神经元的一般化误差
3 C5 [+ g- M; x5 R- ^2 |' Q D
}
1 [, l; m\" C, O) n6 { }0 N
err_m[m]=sqr_err/2;
, Y a\" s$ L# H5 a% z3 A6 _
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
- G/ i2 B6 H+ L- ^
return 1;
- k p\" D0 j( p. O) ~
}//子程序Err_O_H(m)结束
( Y& I4 A: @# m, e2 F\" w m
////////////////////////////////////
3 n- ]- b5 o/ f* X
//隐层至输入层的一般化误差子程序////4 }. Q# l9 i$ J( K\" W4 n
////////////////////////////////////3 w' ?8 H1 M$ c' ]9 {6 V
double e_err[HN];( E3 u\" ]3 i7 D5 T' B
Err_H_I(){/ Q9 Q9 s7 b8 ~7 N
double sigma;- j\" i ?4 _# Q |2 I; v3 B
//for (int hidden=0;hidden
9 t1 R2 o\" @% g: W
for (int j=0;j<HN;j++) }8 k6 A9 t9 @1 W8 E0 D
sigma=0.0;8 @0 u' D) [ k& y\" O
for (int k=0;k<ON;k++)
# s' n, K5 w) X# w0 N. p
sigma=d_err[k]*V[k][j];, y; m: Q% }5 G. N\" ]( I! R
}
' D2 e( R\" f- T
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
. j% v. x, F8 [9 e0 g
}2 \/ M# Y7 A3 Z
return 1;* d4 G& N1 Y\" g( q& F& g9 h
}//子程序Err_H_I()结束3 }) ^; N3 b. ^) C3 j# F( W* x
////////////////////////////////////////////////////////) B9 b/ B( V6 o+ T/ L/ \
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
x8 C2 A\" P8 c6 w
////////////////////////////////////////////////////////0 }7 C7 C8 J\" }. D
Delta_O_H(int m,FILE* fp)1 G2 a3 w' y9 ~- P' k( l- {
{5 W% H( @, D! u
for (int k=0;k<ON;k++); ]; L; d. e3 m\" h8 ]
for (int j=0;j<HN;j++)
% Y% u$ P9 P0 X$ n |
//cout<<"第"< 4 P2 m {/ a2 P4 N$ J3 K% p
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);$ k+ A! K4 @% ?% J% N
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
6 M& W. [4 z/ K- C+ H4 m
}3 d7 @# f7 H# G/ |/ C
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
- b# m: C. f: L& I\" `. |) K* w' F
}
& b! U/ V7 ]5 x( Z, w
return 1;
+ }! \3 B/ ~! D# d& `& }. V
}//子程序Delta_O_H()结束( h1 e5 }- H% s* q% }/ H) _
/////////////////////////////////////////////////////
& @: y& Y3 z% R4 r) E
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////9 Q2 u) X( A\" t0 N\" i! V3 e0 ~
/////////////////////////////////////////////////////2 C. B+ A0 v! o+ l+ a7 K9 o' k, A
Delta_H_I(int m,FILE* fp)
6 A# q4 s2 Q E2 g4 \; q! m1 v: ^
{6 T/ K' a1 [\" H1 g$ y2 M
for (int j=0;j<HN;j++)8 G: n3 T8 @ ~1 y
for (int i=0;i<IN;i++)
$ ]# r5 Y' c [* I' ?
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
0 t9 }7 `& m% m# ]# a/ E
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整5 i y' o T\" {: L6 E! v; r
}% B B2 z/ W1 K$ J
sita[j]+=beta*e_err[j];8 D: \/ C+ f! y# |6 U* k, {2 q
}; K/ o\" u8 g( s\" n
return 1;1 X1 r; I3 F% Y+ |9 `7 {; k6 m8 C
}//子程序Delta_H_I()结束
6 O' ?\" n\" e0 u! Z- B
/////////////////////////////////
, P( C9 G\" u5 b4 Y# S# j j$ X3 H
//N个样本的全局误差计算子程序////2 P' c5 }6 x# n! T! S
/////////////////////////////////
5 r, J* F/ P( k9 e3 m. F, `. r
double Err_Sum()- ^) B2 t5 Q2 g: N) s\" L
{
/ J0 g! f+ u1 _) Q, i
double total_err=0;9 P5 ^# X2 a$ O! \0 J\" n, g2 k
for (int m=0;m<N;m++) 2 t8 y6 @ `% A7 y/ q$ K
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
1 f\" t- ~0 J2 f7 G( J- `
}1 w5 i; m& q5 X8 ^8 b3 b4 l3 L
return 1;$ }$ a# ?+ \) v& r' B( M; \
}//子程序Err_sum()结束
3 ]: _, b/ d* b
/**********************/
; m/ s6 L% M: V! a5 R9 I0 B
/**程序入口，即主程序**/\" M6 `& \: P8 r. G! Q
/**********************/
main()! l* w7 ?5 D- h2 m# I
{, P; d C/ ?1 z7 Q
FILE *fp;
I- I1 |$ h W4 P
double sum_err;
8 y) v: A1 c; w- ~5 u\" U9 g
int study;//训练次数
* }8 f. l. N3 f
if ((fp=fopen("bp.txt","a+"))==NULL)
/ x: b( m' g4 R+ _! X4 k
{; C4 m4 J' [3 b$ d' L+ e
printf("不能创建bp.txt文件!\n");/ z: F7 z' ]2 J+ o. S
exit(1);# s N* u6 P w; T- M
}1 C9 X8 a6 K0 P- _: d. R
cout<<"请输入输出层到隐含层学习效率: alpha=\n";' i0 f9 x; p+ P
cin>>alpha;
* M; O' y' e- p' D
cout<<"请输入隐含层到输入层学习效率: beta=\n";
. e$ e, @. E8 r\" l/ Z0 s2 D
cin>>beta;
( p3 f8 N# s3 G% |$ R
int study=0; //学习次数
: f/ P8 L* h0 ^ V- }
double Pre_error ; //预定误差$ y# b% l% E% H, k
cout<<"请输入预定误差: Pre_error= \n";
( }, _1 V; L1 Z
cin>>Pre_error;
+ y& J: ?& h0 G5 q6 T3 g: `* P; i* ?
int Pre_times;+ ]- E; J6 Z( B* p' ~% ^& @
cout<<"请输入预定最大学习次数:Pre_times=\n";' {7 }9 j! g- t9 `
cin>>Pre_times;
* r& B: d; h9 K ~2 J( p( V
cout<<"请输入学习样本数据\n";6 n: d9 V% \# D n W
{% H4 ^5 H- i/ A2 u' b1 y9 M: e
for (int m=0;m<N;m++)) Y) l+ g; L/ i* |9 n( l& w
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
5 W' ?+ U, g\" W
for (int i=0;i<IN;i++)9 j( R: X% G7 d. i4 l6 }. {
cin>>Study_Data[m]->input[i];* e7 j% Z- z& n
}+ W+ z/ H3 Q2 v# M) t4 M o
{ + B$ E; b6 V/ X3 ?2 c
for (int m=0;m<N;m++); r- x2 D3 X, e$ j
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
' ?% w w8 G& ~7 H4 ^* g8 h
for (int k=0;k<ON;k++)& z) R G+ Q- v\" l7 A! T
cin>>Study_Data[m]->teach[k];
' z7 {$ a g* ^1 ^8 x# x
}
. U- I& @; X4 ]3 e% Q, T* J\" i
initial(); //隐层、输出层权、阈值初始化 (1) 6 ?0 u8 f O# ?: b3 r8 n5 r2 N
do
( J/ T: c. G2 `4 p
{/ \/ N2 r# R4 B' E\" s% |6 t
++study; ///???, _. N8 a1 c3 Z7 o7 I
for (int m=0;m<N;m++)
( b' h* ^7 Y: P; j$ N8 j6 j, Y
{
) y( |* T1 [# U: z2 T$ u4 E
input_P(m); //输入第m个学习样本 (2)2 n, @- h/ w3 s5 r b6 I
input_T(m);//输入第m个样本的教师信号 (3)
' {* O! O f! P7 A
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
/ o) A8 f# J) B( A% {
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
+ @, l& G0 x# w& m8 U3 Q
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
# M: Y& |$ I q! F
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
! h1 ?/ S1 B7 O/ Z\" v
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8): V/ p\" o/ f\" v% o- p! A3 ]! {
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)$ g) O+ I0 I' ]0 N( z
} //全部样本训练完毕2 e0 g6 Y+ J$ n o' B! \: x2 F
sum_err=Err_Sum(); //全部样本全局误差计算 (10) r7 F% N/ A) H& h, v2 ^
{& w/ _) g' }; N4 b* G
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;$ x* M+ K4 l- [+ M- a
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
( r3 e1 X: V A, K( h% o/ j& }
}& ^4 a6 Z: d. ]! ~! J( I
while (sum_err > Pre_error) //or(study
2 C- }& W+ T6 R8 E$ M
{ //N个样本全局误差小于预定误差否？小于则退出 (11)1 }9 ^4 M* t+ M4 v( G
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;2 l) a) x' b. u+ X. X% A
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);& q5 x v2 d5 ]% k+ p. j v
fclose(fp);
: _: \9 r8 S# d# s4 t+ B9 d+ N
}
: h. {3 W6 X% E
char s;
! R$ i9 R9 ^: T' h4 J% r% F; k
cout<<"请随便输入一个字符，按回车退出程序！\n";9 {' r! `7 G+ Q# {) d* I( `0 S
cin>>s;: O- N3 v) h: c# \! H6 m: R7 U
return 1;
$ u4 t9 e- s$ o
}
5 j5 n% d8 X1 g, e
d( q8 `5 \& u/ v: Z5 R