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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
2 G/ y1 `6 o _# U
#include "iomanip.h"
# k\" ~+ e' u' Z
#define N 20 //学习样本个数
$ o1 L! p0 s1 w0 l5 {
#define IN 1 //输入层神经元数目
/ M& @0 T5 N. b1 m( @
#define HN 8 //隐层神经元数目
; A: ?# h; D9 z; w4 @
#define ON 1 //输出层神经元数目
0 | W: R+ C! A3 X! d0 ?\" Z
double P[IN]; //单个样本输入数据\" c0 ^( A! C* S- b, X
double T[ON]; //单个样本教师数据
3 a, r0 a( Z) S6 M; T! w
double W[HN][IN]; //输入层至隐层权值
+ @( H4 ~* |( F) X5 }2 D* e! w \
double V[ON][HN]; //隐层至输出层权值
5 z2 o3 [$ r; m' h! L8 n1 C F& `6 W
double X[HN]; //隐层的输入
! l! k. V' K+ t% X
double Y[ON]; //输出层的输入; m8 q* X5 H9 k
double H[HN]; //隐层的输出\" r\" E& k, s4 v5 C* g9 m9 {
double O[ON]; //输出层的输出
6 j: y% j: V: [6 a; j2 W4 p2 o- q
double sita[HN]; //隐层的阈值
3 ]4 D& U' X, c
double gama[ON]; //输出层的阈值
0 V9 M* m7 z# N8 L& W( E
double err_m[N]; //第m个样本的总误差
) u; S* R6 ?7 H1 ^! ^/ S1 a1 ~$ C2 ]
double alpha; //输出层至隐层的学习效率
! ~\" l\" _$ n4 l4 R
double beta; //隐层至输入层学习效率
* e6 S+ t! E6 q$ }1 q+ ]6 r
//定义一个放学习样本的结构) ]\" Z/ d: ]/ ?) i p
struct {7 L) i# Q+ S* b; R8 Z3 c' D
double input[IN];, d8 A2 x5 O\" O4 c7 a/ A
double teach[ON];- Q: v5 ~ d3 y0 Z\" t c6 {$ g
}Study_Data[N][IN];' O- u3 M/ W. ]0 j! ^
( b# ?- ]9 ^7 k
///////////////////////////
, V! h$ e* K; R3 d; `* R
//初始化权、阈值子程序/////
6 F0 F5 z9 Q\" [! B% Q
///////////////////////////
' a1 i' u% \; K' s& F7 ?
initial()
* ~+ r# I; i E9 M+ `: n, L
{
3 M# S8 J- k% `5 i( ?% ]- k: w
float sgn;+ M\" [. i/ L5 i/ G
float rnd;
0 t3 ?, U1 M! U6 ]
int i,j;: o* s' {# z/ j8 H. }( C( O0 }
//隐层权、阈值初始化//
$ r( N\" ]: b6 M\" i' e* X
{
9 l) v% {! d. b9 x( ~) D1 _
//sgn=pow((-1),random(100));
5 o# L& p& J7 s0 L$ I9 `3 ]\" t- D
sgn=rand();
+ L4 x! @5 u# B\" r5 O+ u3 ~
rnd=sgn*(rand()%100);
* }! w, i) A7 u0 v$ ~2 w
W[j][i]= rnd/100;//隐层权值初始化。
( A; H\" _+ | t: C: g; l
}% P$ L% i7 U% @
//randomize();
( J# u! m6 j8 b# S
{( p& q2 `0 q7 T* o4 Y
//sgn=pow((-1),random(1000));0 X2 A2 I/ Z7 A! u9 n
sgn=rand();
8 b+ ]. v( A% w
rnd=sgn*(rand()%1000);
5 U# z\" i, B1 T5 N0 e4 e6 v
sita[j]= rnd/1000;//中间层阈值初始化
0 Q\" @5 F' W4 D8 a
cout<<"sita"<<sita[j]<<endl;
' U# j& n, |. `7 G( c5 x0 f
}
& V0 v4 d\" u# F* ~. }
//输出层权、阈值初始化//% |6 `# A9 \6 M$ @
//randomize();
% N$ w; D0 M& S7 f1 a* h7 @3 m6 |. {( h
for (int k=0;k<ON;k++)
8 U H% Y& L! Q+ R
for (int j=0;j<HN;j++)
2 N6 Z& K' h# _3 {0 m
{
# U. s& u C& O+ B$ Y) m
//sgn=pow((-1),random(1000));# v% f% E! u$ U5 h7 E5 j: t4 E
sgn=rand();
8 `. j. q5 z+ ]) \0 Q2 j3 }; ^
rnd=sgn*(rand()%1000);
( j8 U; |: w# t
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
6 Y0 D ^+ l8 n
}
. A\" y( \3 E( d( `\" d\" {- T0 j* I
//randomize();
! P! Y$ ^, h2 ?1 Y r
{0 p, p) J- y+ H: U
//sgn=pow((-1),random(10));2 N\" N+ k6 w$ Y8 o- G\" O
sgn=rand();
1 _- Z' K2 r+ L; M
rnd=sgn*(rand()%10);( v% Y/ A T- Z2 G9 S
gama[k]=rnd/10;//输出层阈值初始化# U+ O. ^' r) p& D9 S
cout<<"gama[k]"<<endl;
9 ]; V3 `& ?6 b
}+ m! u' k) ~# N/ G0 ]$ U
return 1;5 c6 `) ~' \# p2 O\" t' u
, O# _' H& o; ~! B8 O8 I% J
}//子程序initial()结束1 D- J: N. |$ X* L! b- Z) H* T
4 m* d. J0 k6 T0 r& w6 @
////////////////////////////////0 S) J! `, O: |; F. Z5 ^\" s3 m
////第m个学习样本输入子程序///, S3 l5 C* ]6 ]
///////////////////////////////+ x/ Z! z7 n$ P\" S- w6 d
input_P(int m). S: Y2 G. H4 z- p6 |( O
{/ K+ y0 P7 ?& X- e7 Z k. I* O9 R
for (int i=0;i<IN;i++)* r1 ?/ ^; o# `
P[i]=Study_Data[m]->input[i];
6 C }0 G. O' r6 i
//获得第m个样本的数据
* {/ D0 X& o* h) M. G
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：0 _4 k\" S: E+ Z: | a/ D) h
//P[%d]=%f\n",m,P[i]);7 N6 t; `( O8 a' a/ G
return 1;# T1 m1 G8 Y3 J1 O0 c9 T! }
}//子程序input_P(m）结束
[5 o2 w. A, f2 \. ?. u- J0 B$ ?! B
/////////////////////////////& H4 w0 d5 u\" {4 A$ g( ?
////第m个样本教师信号子程序//
5 ]: `' z. a4 y$ Q, p
/////////////////////////////
' z8 @, n: Q/ v7 ^
input_T(int m)9 ?* i( |- R/ ^( X# D9 o2 D
{/ h# x7 I) `- t: H2 t/ _
for (int k=0;k<m;k++)
H: b2 Z. l9 E8 o& n0 m
T[k]=Study_Data[m]->teach[k];7 \2 d f* X, k9 N$ I
//cout<<"第"< //! r- i) M6 O0 W1 h) z2 E3 b
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);6 F& O9 Q( M# A3 C. f
return 1;) d\" p4 K\" Q9 a8 O
}//子程序input_T(m)结束
' @6 v, ]1 f! S3 X3 A$ z! b
/////////////////////////////////* Y& }, y7 m# m
//隐层各单元输入、输出值子程序/// r: }: M- L+ r4 R
/////////////////////////////////
5 e8 u+ R% R\" O# i
H_I_O(){
# Q$ ]! M' `' e: s
double sigma;
8 g1 j& u) W6 F$ K5 n( e9 T
int i,j;
0 R7 g# Z; p- T; ~8 c' l
for (j=0;j<HN;j++)\" Y# X6 h& V6 T
sigma=0.0;
\" I8 @2 u5 [0 R% R) Q6 V' y
for (i=0;i<IN;i++)6 m# U, ? A g+ n# @; j
sigma+=W[j][i]*P[i];//求隐层内积' |$ }* Y& j% Y+ |+ E8 R: L+ ]
}' l3 w3 y2 z# J5 m
X[j]=sigma - sita[i];//求隐层净输入
6 ~- X, L7 W5 e7 I8 S( Y* J
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出7 i: P- u6 s7 B q* z
}
0 N\" ^& w. x2 N% l
return 1;
) {* M. ]( R) F4 h# s; g
}//子程序H_I_O()结束# Q3 J# ~$ w6 r2 E& x: d( L
///////////////////////////////////
8 t) L& X7 a6 [7 d
//输出层各单元输入、输出值子程序///* a5 ^5 [6 n& e6 m: o$ M
///////////////////////////////////
9 _5 e+ U; i2 }4 M8 V% ^\" j
O_I_O()2 z\" C+ H: z$ b$ a7 J( ]
{* a/ i6 r i2 r# n2 t6 o
double sigma;
: R0 c9 b6 H6 V/ y/ \; Z
for (int k=0;k<ON;k++)
* j0 \+ B- F7 D3 S7 ^' E( S
sigma=0.0;& t# w I$ z( c- z+ v/ ?
for (int j=0;j<HN;j++)0 \\" k1 b4 H+ s( g. s! @
sigma+=V[k][j]*H[k];//求输出层内积
, g8 J5 ?7 u\" x
}. a1 A. i) K\" ~# G
Y[k]=sigma-gama[k]; //求输出层净输入
0 x8 q8 W1 ^0 ?8 E8 L; s8 m* S0 _/ h
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出7 o2 G0 A+ h7 z+ ^. J+ T- f% z
}8 k+ v5 I1 K) B1 g: [
return 1;( x7 R7 s, w\" _. |\" J a
}//子程序O_I_O()结束' j; n/ {# d6 ^
////////////////////////////////////
$ v% n) y+ q( N3 |, h
//输出层至隐层的一般化误差子程序////6 O- A1 ]3 i6 z; C5 a8 P3 r
////////////////////////////////////0 \- W- J$ w6 g# F+ R n* w& I: T
double d_err[ON];
3 L* T6 j/ x2 m0 ]9 {5 b* a
Err_O_H(int m)1 i- R7 q\" ?. ~3 W* D
{+ ^/ k) C, ?0 W
double abs_err[ON];//每个样本的绝对误差都是从0开始的
* p& _) R' P6 x9 Z
double sqr_err=0;//每个样本的平方误差计算都是从0开始的\" j f) Z3 t$ w0 N\" B\" O
//for (int output=0;output<ON;output++) //output???: T8 N$ T2 t/ E# j X; U/ s
for (int k=0;k<ON;k++)
' O) ^# F- U* u* _, Y* N& T
abs_err[k]=T[k]-O[k];0 P- d- L' c4 _4 |/ O- h3 h0 U$ F
//求第m个样本下的第k个神经元的绝对误差
3 c7 y0 q, {( M4 {9 O8 d
sqr_err+=(abs_err[k])*(abs_err[k]);9 X; n& I9 M' j0 z
//求第m个样本下输出层的平方误差, e, @, R' M: J. I; E# x
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
# e2 h* b) k( E6 d- [
//d_err[k]输出层各神经元的一般化误差
5 y% K+ ] Q+ M+ V5 L
}) x: H/ h) O4 o- Z, j- F& K
err_m[m]=sqr_err/2;7 R: m: B% h% s\" L
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
+ y' z\" w' w- V2 d5 L) K0 P
return 1;) D1 H. E6 J5 o- p. T# V3 ]2 N
}//子程序Err_O_H(m)结束
\" `\" e6 m$ p. ]8 P2 Y0 S
////////////////////////////////////
1 N1 ?4 x& G\" W% D$ E
//隐层至输入层的一般化误差子程序////
; W4 r) j( n! }9 t+ b\" G
////////////////////////////////////
1 _4 f1 F$ k) M2 _
double e_err[HN];
+ m8 G6 {. L* F& d, c5 ~5 n+ W
Err_H_I(){
) k/ [0 Q c( ~% Y6 _2 I
double sigma;
* Q+ m2 n1 q) O6 L
//for (int hidden=0;hidden( V6 a$ S' ?% r2 e2 f
for (int j=0;j<HN;j++) ( L, R. j6 u) d, `$ \
sigma=0.0;* \4 {: @5 M; z- W# t
for (int k=0;k<ON;k++) ; ?3 _8 F% \: z\" F5 G# Z8 P* O2 M7 P
sigma=d_err[k]*V[k][j];. g\" o2 r3 Q/ S1 Y' C6 T: T+ D8 |
}( L* `: p& z+ Y% ?+ ~9 [' ]9 m
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差3 m6 G2 j\" x( ^* |) C
}% T3 d! j& F7 G
return 1;5 z' S- ]7 K# ~7 U/ o% m3 G0 c( R
}//子程序Err_H_I()结束
\" w, F$ t2 r2 \5 B. O1 V: G
////////////////////////////////////////////////////////. d' y' d$ @1 @
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
3 l; k5 Y# }) ?& K4 D( b
////////////////////////////////////////////////////////\" V4 `1 p. g# {, [* |; B. x\" T
Delta_O_H(int m,FILE* fp): D# j. n1 ?6 j. l k' g7 U
{
1 }- z. d) e4 c* k
for (int k=0;k<ON;k++). C x) A2 m s( p4 m; [
for (int j=0;j<HN;j++)& `6 a9 D1 U. o. _\" F6 F\" I* n# K5 i. W
//cout<<"第"< * g m/ c\" ^5 D- ]. D
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
. L1 @$ A. v. w9 T
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整% S\" x4 e; x% D, h; X
}
! o3 R# l. M5 h4 f8 Z( d. v\" P( k
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整$ O/ {. A1 R% F, U4 i
}
! B5 l2 S2 N8 Z4 k
return 1;: x7 y6 \2 Z! D- H& A3 y3 @
}//子程序Delta_O_H()结束
$ g- \1 j\" L+ T
/////////////////////////////////////////////////////
* u* z/ W* y2 ]* w7 e) q
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
! ]\" Y4 x8 i$ k
/////////////////////////////////////////////////////
- P, L l\" w* X7 _: W8 u$ ^6 I
Delta_H_I(int m,FILE* fp)- v, e\" y9 ]. P' T3 I; P
{! T; E* s3 l5 v: B! w
for (int j=0;j<HN;j++)
3 G& X( i0 S1 g/ s
for (int i=0;i<IN;i++)
7 i7 R+ ^* T- _
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
9 z$ w+ G+ ]$ Z- ~, h5 V0 p
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
, [4 x0 {1 _) q0 h0 j
}4 S: O( c6 m, j* V1 n. g, [
sita[j]+=beta*e_err[j];
2 X7 K1 |, u+ }9 `& }; n
}
5 o4 |, o4 i3 a
return 1;
( e3 }( Z! I, T3 P- a- l
}//子程序Delta_H_I()结束' N e; J- `3 C
/////////////////////////////////
, g3 D# [6 X1 r
//N个样本的全局误差计算子程序////
# a# U! H: y. f& A
/////////////////////////////////5 S\" T8 H4 B! d& I# }
double Err_Sum()8 g7 Q8 j) e4 ]4 i
{1 H* c\" W0 M% m, q
double total_err=0;
- m. z! Q% e3 X' l; k( [, w+ }; F ~
for (int m=0;m<N;m++) 4 ^& e3 k6 z2 T) R7 [( @3 i
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差3 T9 U* @7 d; |* U+ L! G1 K1 o8 L3 r
}( J+ m6 x: _\" w4 Z( M4 a3 g
return 1;
7 c& G9 w\" E4 z5 ^; y* D
}//子程序Err_sum()结束
' ]2 ^3 V+ m/ c; O8 }6 G6 o5 D
/**********************/
! e1 E' U: ~3 j3 e! `
/**程序入口，即主程序**/
6 G\" ^( x, W1 t% g$ `
/**********************/
6 c/ u( z\" }\" b1 ~5 y) ]2 b# U
main()
9 w* u- T: M4 U# l6 _
{
v0 ^% L( ?5 G% v' G
FILE *fp;
$ ?. @+ n2 ?/ N5 W: `
double sum_err;) L\" I; d- _& u
int study;//训练次数
% [2 f& Q$ N' ^! n3 f& a& h
if ((fp=fopen("bp.txt","a+"))==NULL)
{, w. K( q/ ^/ r; c, l+ |
printf("不能创建bp.txt文件!\n");
+ n: o0 Y, ?5 H/ j3 {\" w! W8 M
exit(1); O- W& X. y/ h4 k; z$ m8 B
}) m# Y! ~/ Y8 ?. L
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
$ C1 i& r# A6 Q* W% y/ |5 P. x/ t
cin>>alpha;
/ A9 F, k& u1 S+ w. g5 }! B1 N1 M3 I
cout<<"请输入隐含层到输入层学习效率: beta=\n";- E7 D U$ I2 ?/ q
cin>>beta;, f f3 a* A; V7 k! @* R
int study=0; //学习次数
/ K4 N; j$ p) @
double Pre_error ; //预定误差
- X: {: ~! V/ _# w
cout<<"请输入预定误差: Pre_error= \n";, y) O( @- `3 Q7 w+ u& v* P
cin>>Pre_error;
# T1 p0 r8 u\" w: l1 Q
int Pre_times;
h6 X7 Z( Q4 |5 q1 w( W, A
cout<<"请输入预定最大学习次数:Pre_times=\n";
q\" n0 s: ]; C, B
cin>>Pre_times;4 W3 l. P0 N* ?# x
cout<<"请输入学习样本数据\n"; U1 w: ]) E$ L* u6 l
{- a! B\" B& L( Y8 d4 A/ W0 ~
for (int m=0;m<N;m++)
3 ]; P. |+ V% \6 P9 m; C) C
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; 4 A% f5 H* m5 e. h: m6 g
for (int i=0;i<IN;i++)
/ t$ N& }1 E' f) ?
cin>>Study_Data[m]->input[i];
0 g. U3 x9 I5 r
}
+ t0 S; T8 B\" l5 K E\" B' j6 Y1 y
{
4 z# i e, Z4 r\" @% V c5 X2 V9 g
for (int m=0;m<N;m++)
1 E* T0 Z7 y/ i0 x0 j$ N |
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
2 p; c: k1 Q, E
for (int k=0;k<ON;k++)
2 G/ j: P; _7 t7 _
cin>>Study_Data[m]->teach[k];
1 ~9 g, Y9 b2 P
}! |: Z& Q# T2 l$ A, C; P r
initial(); //隐层、输出层权、阈值初始化 (1)
6 o7 t# n3 P\" h; R* J5 @* _
do
/ \( V! W$ E( w6 o
{
1 j* m5 _! N5 X% }4 O
++study; ///???$ S5 L, G' J2 S. {- P9 `- {
for (int m=0;m<N;m++)
\" O, x# ^% z0 z) G0 ^
{
% R9 t8 Y4 C; D y) x* \ r
input_P(m); //输入第m个学习样本 (2)
( P% ?# d& S* v6 p
input_T(m);//输入第m个样本的教师信号 (3)
# z: A9 ~! P& `! n9 u$ R/ b0 h
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)) }8 F; ]\" x# J) y( D: a- u
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
; G- @5 {( Z# ~% n! a) H
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
% ^5 U5 Z$ s8 k4 i$ q
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)6 z9 W2 i |; F7 X0 x7 T
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
7 G, E4 |6 S$ g' `\" r
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)4 G1 X- y$ Q8 q. v3 }3 m$ H! V
} //全部样本训练完毕' S7 d9 g# R1 m, V7 A
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
- N. Z5 s; T% K: ~8 U1 Y
{
5 h _% M; o% q' y6 a
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;9 @& Z* ?7 V$ J: \5 @0 ]& e
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
4 t; g3 B/ Q! v/ X$ T
}
1 l0 j7 l _& @' y6 M
while (sum_err > Pre_error) //or(study4 b |2 X% o* T) o n( v
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
! |& p0 Y* b7 G6 ~ N& A
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
) u8 m3 J5 g4 ~+ c/ M\" f+ T
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
) {3 g& ^( P) m6 \9 B! T9 c# |
fclose(fp);- f4 }+ r; m: z1 j\" u0 U
}
5 l- a9 u' y K# S
char s;+ u$ H9 d! w\" q9 ?: ?# f# S6 x
cout<<"请随便输入一个字符，按回车退出程序！\n"; s9 q3 S9 k1 \) p
cin>>s;3 c& ^8 k& a# }6 r& s
return 1;6 H. h6 w: O1 |\" {3 y3 s' ]# k
}7 e! ~2 U\" S8 M; y* }7 p, m* A
7 ` @) e8 |* o