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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
+ x1 C; y+ l& O/ P% |5 X% r0 ?
#include "iomanip.h". T7 f k% S3 g\" p% q* k
#define N 20 //学习样本个数
6 t8 [- t* z4 d; C. W0 ^0 \- w
#define IN 1 //输入层神经元数目
4 X, q$ s3 g6 @! a/ ~$ O
#define HN 8 //隐层神经元数目: X9 @/ e. A4 c0 x; A0 F
#define ON 1 //输出层神经元数目9 D! `+ S! T1 r; a9 ?\" x2 y- X
double P[IN]; //单个样本输入数据
( G7 W( `( G) q2 ~
double T[ON]; //单个样本教师数据2 a/ _, W$ X, u
double W[HN][IN]; //输入层至隐层权值* O( q7 O$ c4 X+ f5 x9 \
double V[ON][HN]; //隐层至输出层权值
- O4 i f9 R- t\" I
double X[HN]; //隐层的输入* \1 }: T+ w, i, c8 G5 n, {& d( W
double Y[ON]; //输出层的输入
9 J% X* a' M; ~# }2 g1 B
double H[HN]; //隐层的输出. K/ ]9 x- x! ~% _) m' m/ `' @
double O[ON]; //输出层的输出4 p: V3 d% x& h( e
double sita[HN]; //隐层的阈值
double gama[ON]; //输出层的阈值
4 P' A9 u9 i2 W( U1 j
double err_m[N]; //第m个样本的总误差4 V5 N5 |& J- d# ~* T1 \; d
double alpha; //输出层至隐层的学习效率8 O. d6 { Q' c( Y4 ]
double beta; //隐层至输入层学习效率9 {+ v7 E* S2 f( U\" W. {: Z. ]
//定义一个放学习样本的结构 P+ d7 U! F* i1 j5 ~8 n/ d1 N6 p
struct {8 j) y W6 v$ m/ e, j' o
double input[IN];( R# b1 v1 {0 o; z) n' ] q
double teach[ON];
5 r# E- E$ T8 F) l0 j\" d/ k. S7 y
}Study_Data[N][IN];! [8 ~1 k; H& Y3 B9 `# o
: m( d& s) k6 V
///////////////////////////
8 ?0 k# r) `9 {) Z
//初始化权、阈值子程序/////4 ?8 z5 i( [4 O& _$ }
///////////////////////////9 l& D! P7 M: Z J/ }; j; a9 G' x
initial()8 }\" r& s) Y ?/ c( J+ T' t
{
\" ]8 h& e# J* H2 N3 a4 k, j
float sgn;
, z' c0 t* M0 T* _
float rnd;. x9 ^& x8 k: {5 z$ j9 j! U5 @
int i,j;\" ~0 _7 g- Y7 Y7 k) @
//隐层权、阈值初始化//. u\" L3 y$ F- [' \ a
{
+ O8 S% [9 |' e: q: V) n
//sgn=pow((-1),random(100));2 X* q: \5 n( @& w- P+ y! C
sgn=rand();' T8 D. @7 C. W. U7 U& e5 L
rnd=sgn*(rand()%100);
( z3 E+ W! K& X: @
W[j][i]= rnd/100;//隐层权值初始化。- ~, t\" @/ } J
}) v* A3 k B1 e& F0 f k8 A1 s0 ?
//randomize();
) A m7 H' d( T) X3 o& ~
{
6 w2 n( F, L\" W% ^2 u# z# c
//sgn=pow((-1),random(1000));! g\" M6 F' Z/ S7 u5 h5 j
sgn=rand();
/ A- _/ {$ J\" | o7 Q$ z2 k
rnd=sgn*(rand()%1000);
6 |: H: ]\" n( n+ `0 m0 S6 d* S# m
sita[j]= rnd/1000;//中间层阈值初始化
5 w3 k* V, p+ A$ w
cout<<"sita"<<sita[j]<<endl; g0 w7 f T' C% t( w
}
9 j8 }4 w, P9 h; ~' P- h
//输出层权、阈值初始化//
# O$ N f1 F1 z, F
//randomize();
) O7 e c9 t5 o( I V6 r
for (int k=0;k<ON;k++)3 U4 `4 m3 y) m: A) I6 h! B
for (int j=0;j<HN;j++) & N0 S4 q/ [' S$ R, I
{
2 B- \4 I+ j/ v* K6 r
//sgn=pow((-1),random(1000));) B1 e; P6 c- S% K4 v
sgn=rand();3 n\" r( H9 j$ G2 |! n2 U& n! k$ q
rnd=sgn*(rand()%1000);
5 l: A, Q7 Y3 ?( l8 |) e/ \
V[k][j]=rnd/1000;//第m个样本输出层权值初始化8 G L ]& Q: @& `
}
3 L3 d' B/ ~% f. X2 `
//randomize();/ V4 n2 ~6 L, V0 h0 V2 O5 O' H
{% Q9 k, }) Y; H% j
//sgn=pow((-1),random(10));) Q0 w, I& n+ w( n
sgn=rand();
( N# f3 n; n( d
rnd=sgn*(rand()%10);
; A1 e- P0 y/ M. a: m/ p- G% j
gama[k]=rnd/10;//输出层阈值初始化
4 x) y7 W: [5 {\" Y' E6 U
cout<<"gama[k]"<<endl;
: B+ t\" b. a, K5 i
}
0 n8 k) `: ?- E E3 M
return 1;4 t3 r+ c& ~6 J* n* \
% F! F. Y! U# o% l\" b
}//子程序initial()结束8 h. v# O3 u- s7 j
1 l5 d5 X/ c( ]0 F; p$ g6 s; N2 u
////////////////////////////////
: ~1 L) L2 f @\" w) M8 w9 x
////第m个学习样本输入子程序///
, j3 D5 A0 A+ A( X5 a
///////////////////////////////2 }1 t( }$ T) S& h/ ?8 b
input_P(int m)0 _8 Z5 Y: W, v5 S% P. b
{4 K6 ?# x& s8 r7 U
for (int i=0;i<IN;i++)
0 A5 r) p8 D* A$ n8 u
P[i]=Study_Data[m]->input[i];3 Z% C% Z& e4 q' @7 ~
//获得第m个样本的数据
; a) ?\" u2 t, \9 \
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：% t4 K6 v1 J& u- r {6 j; d2 w; P) l
//P[%d]=%f\n",m,P[i]);' m2 |9 l% C2 G9 N9 g7 H: J4 L! S8 A! c; ?
return 1;
9 e$ N N/ I7 U5 Y\" L p; R
}//子程序input_P(m）结束
8 E1 W\" O5 r. e; p; o
/////////////////////////////$ P: ?( }# r$ {) b0 k: `
////第m个样本教师信号子程序//
* D\" ]' B. E) v# T/ a \
/////////////////////////////
9 R+ w4 C\" S. D* F7 s1 a
input_T(int m)
0 ?+ p) I% c- J! K9 u% {( n
{' T( B% T% t; i$ C @7 n
for (int k=0;k<m;k++)
+ c5 k4 ?, O) m. Z7 \) y: ]\" G
T[k]=Study_Data[m]->teach[k];
- P W/ R `, x9 n8 v
//cout<<"第"< //
4 G6 t. y$ c6 \\" U! Y
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
! L, Q1 _' O+ z$ Z
return 1;
6 w# h\" x+ N) T0 }, e\" {
}//子程序input_T(m)结束' f) Z. P# A( G# v* v! x) v* S: X' j
/////////////////////////////////
3 w\" x0 P$ c$ P; x% w
//隐层各单元输入、输出值子程序///
; [\" C' b% l) C* ~, a3 i' ~
/////////////////////////////////\" e' C7 l T. c1 d ]$ c
H_I_O(){& C4 p1 c! k8 z9 G7 M6 [) H' R
double sigma;+ H3 y Y3 w& Y9 b8 v! ~
int i,j;
& |4 K! ^/ P0 A& [0 |
for (j=0;j<HN;j++)
* G\" B6 O5 d& o1 Q. e
sigma=0.0;2 R, X# O/ E; ?# j& d
for (i=0;i<IN;i++)6 I' w: Q' Q* d* m' A
sigma+=W[j][i]*P[i];//求隐层内积
& X. r& V# x. }% y9 a
}\" Q' Z3 p\" d8 i9 O. S
X[j]=sigma - sita[i];//求隐层净输入% ?) P9 t1 E0 C- C6 I7 q
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
8 o6 t: P1 m& Q* e
}6 F0 W% H: K9 D$ g! z0 G l
return 1;2 \- D# p/ `! N7 u% j' }
}//子程序H_I_O()结束
) L) P- ^\" F2 H( k
///////////////////////////////////$ S% e8 @' w N7 g0 q. G1 i
//输出层各单元输入、输出值子程序///# m0 Y\" @( N9 W2 w
//////////////////////////////////// B5 O0 O* G5 Q9 o. f
O_I_O()
+ |$ Z+ F& w; N* k
{4 g L9 P* X! G1 p/ @ i8 p; q
double sigma;
. u& t) r/ z$ C% p) e2 a
for (int k=0;k<ON;k++)' w4 X2 A* } M9 [! w, G, b
sigma=0.0;
m; h: ~1 v\" K d+ I- h
for (int j=0;j<HN;j++)
`) I3 b- _9 K! z: B7 c: q
sigma+=V[k][j]*H[k];//求输出层内积. L* C& @' k$ l2 q
}; h& U! U. a9 Z; v
Y[k]=sigma-gama[k]; //求输出层净输入- V& s3 N3 q$ Q+ k$ r# g
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
4 l5 c; R; `9 R
}
% B# j! K7 m' v
return 1;
- r/ M0 a2 X6 Z& ~4 _ J) c
}//子程序O_I_O()结束
# {7 C: P* A\" O, O7 F p1 K* \. E
////////////////////////////////////7 {+ D, ^. ?9 J# y' h* k
//输出层至隐层的一般化误差子程序////7 `% Y- m2 M: H- @4 n
////////////////////////////////////2 f! r% q1 w0 [+ i3 J, j1 e
double d_err[ON];
3 Z3 t) i3 F; T% {8 K
Err_O_H(int m)6 Z0 ]% r+ D9 Z
{* ?9 V9 s1 G* ~. C( u' j- v
double abs_err[ON];//每个样本的绝对误差都是从0开始的' t7 o$ u8 ~; S: u; B L/ t3 h
double sqr_err=0;//每个样本的平方误差计算都是从0开始的4 P: P f* k% V# Z% ~6 x. ^+ |
//for (int output=0;output<ON;output++) //output???
( h7 P6 l5 ?$ n4 w4 l. i3 A
for (int k=0;k<ON;k++)
3 ]6 Z. B) s [! g0 n
abs_err[k]=T[k]-O[k];
; ]1 n* H5 v/ I# b A
//求第m个样本下的第k个神经元的绝对误差
# l# S; a8 ]! B- `! O
sqr_err+=(abs_err[k])*(abs_err[k]);
1 P- G/ t. Q+ W& \6 S
//求第m个样本下输出层的平方误差$ y+ q\" r2 R; w# e; w
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);7 \8 P! Z; i+ |6 z+ \% V' `0 G! @
//d_err[k]输出层各神经元的一般化误差( _# i% I [, W
}
- i5 q5 m8 C3 V8 C% i( S: ]
err_m[m]=sqr_err/2;
* Z6 ?2 K) z* _' u* y* w1 q
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
\" ]0 s9 T ^+ M5 ?* n7 l: l9 r, U
return 1;+ s8 C. T- [& t% a
}//子程序Err_O_H(m)结束
* p7 l8 R1 k9 K- W1 Y2 ^
////////////////////////////////////
+ O, Q& S9 H5 J3 Y8 T( s
//隐层至输入层的一般化误差子程序////
& [# ?2 O+ Y! P, y! r
////////////////////////////////////
) L1 z* ^6 D, V6 [8 x' u
double e_err[HN];* Q) ^: Z3 c6 P; S4 ^5 H; X8 t
Err_H_I(){' n9 i- M: \( A! V- J
double sigma;# s! h% k3 N6 F- I4 @! B
//for (int hidden=0;hidden3 i! v\" `* y# N/ g# O
for (int j=0;j<HN;j++)
- k+ n9 x; q( C. F# [ g2 s
sigma=0.0;
2 G1 K% ~+ f1 S% x! K6 o5 H
for (int k=0;k<ON;k++)
: P. {) g( Q/ c+ t( c' m
sigma=d_err[k]*V[k][j];
3 w( f; y6 Q6 K
}
+ I' }3 X# x* W# P$ h8 _
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差7 ] c9 U& s2 _7 ~7 x; U) `4 U0 w3 i* O
}
& W/ f5 p7 X( x; _* U( d' h
return 1;
9 Q\" Y. }- u0 C& u
}//子程序Err_H_I()结束
% R, E& j( N8 a6 }
////////////////////////////////////////////////////////
; n8 d- I# B% U
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////- @: L% j/ K6 ]8 |6 P6 Z$ |( a: U
////////////////////////////////////////////////////////
+ K& H; Y+ q0 L; c
Delta_O_H(int m,FILE* fp)\" R& d7 b' {3 J\" X9 w# I
{+ o. B8 S+ P2 z, ~4 D! @$ \
for (int k=0;k<ON;k++)
G& i* E0 P9 U/ P3 I% h
for (int j=0;j<HN;j++)
6 s, e8 l/ l Q8 a
//cout<<"第"<
1 S/ ]: R) c4 z5 e$ c( G
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
' U! _! O7 f\" t3 H/ b1 ~\" m
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整+ \& N8 S\" {6 \0 w: P0 }
}
& D, n9 `/ @4 t$ ?; t7 j! U4 L
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
- l4 o, W6 {) a( R' Z* |7 S
}0 v; [9 e; \( u
return 1;
7 X: \% N( f. T) M- {
}//子程序Delta_O_H()结束
- Y! s8 k' k2 X% e4 U\" j
/////////////////////////////////////////////////////
) u* |* ?! v( Q: R
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
# A5 Y4 \4 c+ w/ p7 C
/////////////////////////////////////////////////////6 b- y. {7 z# |7 j# {
Delta_H_I(int m,FILE* fp)
9 ]. l1 ]7 u6 c. s; B\" [5 `1 Z
{/ R' L9 ] ^\" t3 ?
for (int j=0;j<HN;j++)$ O- \7 ^/ E\" n/ G+ Z3 y: y
for (int i=0;i<IN;i++)
5 k3 b* b* b+ ^ j- s% x4 U
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
6 N: X1 F) O( {3 C( c% o
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
. O0 q- P8 r: D- L% B; J) g: I' z
}2 S8 ]# D5 v0 L* L. k; n5 r4 E
sita[j]+=beta*e_err[j];
8 O9 }! t( @; p' g0 o% p3 I, l7 F# e
}
! i/ X\" M/ \\" _1 F' Y2 H7 w3 Y
return 1;
I. ~' D% V6 [5 L0 r+ G* I. m7 e! m
}//子程序Delta_H_I()结束6 b/ F* ?/ H+ k
/////////////////////////////////
4 U; i( t1 T1 D# K4 k
//N个样本的全局误差计算子程序////
+ _) G5 F% h2 t9 o K1 k
/////////////////////////////////
2 v! Q( C- H9 k6 p4 P
double Err_Sum(). i/ m7 V+ @* ~3 B% X
{7 r4 j- L0 ]' J7 Q6 e
double total_err=0;
) J: e$ ?6 n\" g* Q. s* N
for (int m=0;m<N;m++)
\" b1 x! ]3 T3 [$ @1 T
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差. G/ B% d% i/ d7 M$ v4 D. C% Y
}
\" X: Y `/ s- B\" f, S4 N1 P# \
return 1;. A\" }0 {* K& e0 m& }
}//子程序Err_sum()结束4 Z5 k* X& X\" [# [
/**********************/
% k; _, M1 h, y) B
/**程序入口，即主程序**/
\" r m# {' ?4 n- ~$ U* L7 r- K) y
/**********************/
\" Y- Q, o% g1 w
main(). Y, ]- V; i5 I) s: ~$ d8 u
{
0 I5 ~& c: Q4 @( t
FILE *fp;& p\" ]+ P1 T# y4 y9 E4 U& n# R5 Y
double sum_err;
$ |' O+ r9 U. V- V, b
int study;//训练次数
) F& H# f$ S( F8 C) ~; r+ N
if ((fp=fopen("bp.txt","a+"))==NULL)6 k; D0 S# t4 b9 P, d% l\" z6 Q
{
$ h2 b7 h0 ^/ V5 ^7 n
printf("不能创建bp.txt文件!\n");' G5 E9 I; i7 I' m; ~; h) [! b
exit(1);6 l0 }9 j/ `1 j# T; g
}1 m9 Y0 I3 r4 y. E. @
cout<<"请输入输出层到隐含层学习效率: alpha=\n";8 z! k) c0 M, r: h X
cin>>alpha;
/ o/ U7 n9 q\" w/ N. b3 @$ O
cout<<"请输入隐含层到输入层学习效率: beta=\n";
0 ~) ~* ?* H' E/ [6 o
cin>>beta;$ P; q8 d/ ^ Q, O
int study=0; //学习次数
( v$ m% p! y5 Q, j+ }% R, e M9 O
double Pre_error ; //预定误差% I; {5 n2 B0 a. [- P# W; @
cout<<"请输入预定误差: Pre_error= \n";, U3 R' T, m K6 j4 t4 j+ {
cin>>Pre_error;
) ~* ?3 S w* G* g\" J
int Pre_times;
0 W; @, O\" _\" ]5 ^- }
cout<<"请输入预定最大学习次数:Pre_times=\n";
! ]& q3 i+ ?' K/ |
cin>>Pre_times;6 \3 U8 k! m6 L! ?, Z
cout<<"请输入学习样本数据\n";
L3 B* t/ R. t2 Q. U
{
% X6 C; n0 P+ s. s- F
for (int m=0;m<N;m++)0 Z; b* N. @9 y% G\" r/ Q, a! w- c
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
8 u$ M2 \: E1 \: {# ~
for (int i=0;i<IN;i++)4 w9 }2 v& ~; T) Q\" ?* n& j' t
cin>>Study_Data[m]->input[i];
4 I* c4 w, K3 D5 R& k% P
}9 M7 R8 N, q) P* Q3 H9 u
{ 5 s! k5 N i/ }9 s, r
for (int m=0;m<N;m++)
1 ^. S; Q\" N& t1 l0 A, _\" `
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
: w5 `: L0 ~8 x9 s4 X
for (int k=0;k<ON;k++)4 y* `, m9 T3 P4 r. W; M8 Y
cin>>Study_Data[m]->teach[k];
. x7 W\" e0 p; M `6 Z' u0 ^
}/ j; i2 \/ e8 s7 P
initial(); //隐层、输出层权、阈值初始化 (1)
$ }3 t5 [' }\" V6 K# G- U4 O: q, [
do
4 M2 s8 t( e\" i/ y5 Q2 |
{
4 l: p1 ?0 Z( Z3 D6 o3 Z+ E7 W
++study; ///???9 l5 ^0 ?# l; X2 M) N9 ~2 V6 W
for (int m=0;m<N;m++)
1 L+ f5 W8 N5 J
{
8 k8 x$ m- p; T; W% F) r
input_P(m); //输入第m个学习样本 (2)
- i! [9 J$ h/ D/ d\" h$ I) w
input_T(m);//输入第m个样本的教师信号 (3)
+ j+ Q' S\" X! ?: Z/ \\" f
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
9 |0 Y' Z( U: D& c$ i/ a& g& B/ C* i
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)' S* g\" s; U0 F) r8 d5 [
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) & j9 z n% m! A3 Y0 ?1 r
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
7 q9 u, {2 U) O- r
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
' O' w; j0 [% S& f( d: p
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
& R2 e$ s* L5 H% P& s
} //全部样本训练完毕# b: \1 _: d( D+ J( C
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
- R7 f3 m9 ?9 z2 j* l
{
% v! {8 R/ w4 T4 D+ @' u) b
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;& k' d2 u' _2 e! G: A( U: V: B
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
: u1 u: q& j0 F( ], x
}
& i! H\" Y6 L N$ @$ S\" e( n+ J: K
while (sum_err > Pre_error) //or(study0 T1 R$ g5 f9 h+ a\" q9 L( U/ J
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
\" z: l; j& G2 p' \7 m+ c/ C7 W
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;3 i+ h+ J/ `. \) n
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);# r: c1 w' o+ f4 s1 [
fclose(fp);
: |) j8 Y, \; h) }5 {
}2 @& S. C6 x\" V( V( Y- e( E m
char s;$ t; j% M A* O. u: r! ]5 c
cout<<"请随便输入一个字符，按回车退出程序！\n";: C9 A3 M$ ], [6 V. q T# X1 S
cin>>s;
$ L, z0 [2 I) L5 d
return 1;
: c% ^9 s8 y' X+ n: @
}
- e6 E `& O0 }
. W2 m% J) _) Y