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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"4 H# s! X. O) l N% U: f
#include "iomanip.h"7 N, b9 _2 w: ]
#define N 20 //学习样本个数
/ J9 u+ |' e( Y
#define IN 1 //输入层神经元数目\" `: j. \; _, m4 I3 q
#define HN 8 //隐层神经元数目
! ^7 c+ u2 p5 n
#define ON 1 //输出层神经元数目' Q5 \0 R; h$ V! o! J) i0 k% \
double P[IN]; //单个样本输入数据
' y$ o\" S/ s. i
double T[ON]; //单个样本教师数据
, o1 E\" m% c4 w\" r/ O
double W[HN][IN]; //输入层至隐层权值
0 w7 o* m1 p2 A( Z) X5 k' w3 {
double V[ON][HN]; //隐层至输出层权值
+ |( J1 I1 S0 w2 O, p: Y. o: C# i
double X[HN]; //隐层的输入
; [* ]. y: B8 A7 O' u8 W8 A# V4 m
double Y[ON]; //输出层的输入3 k6 z+ w( w* o K& M* c
double H[HN]; //隐层的输出; A j H) v7 I1 Q) j
double O[ON]; //输出层的输出7 S1 L\" M& x0 E6 w6 |) T
double sita[HN]; //隐层的阈值 @\" W. b) y, ?6 w( G
double gama[ON]; //输出层的阈值 f\" m4 e, t) K% c: a, i( L$ z
double err_m[N]; //第m个样本的总误差
\" [- K8 g: S9 L C6 I
double alpha; //输出层至隐层的学习效率$ r$ W$ ^ {- D6 {' }% F( Q$ x
double beta; //隐层至输入层学习效率
# a3 ]3 C0 f\" O% {# u; I0 |: P P
//定义一个放学习样本的结构
; F\" r7 L) b8 t0 ^
struct {6 w( P0 s+ [9 r. S1 a9 [: S7 ~4 U
double input[IN];$ r2 _, D# @6 x( E2 ?' F; S1 m6 ^7 X7 Q
double teach[ON];- C7 a2 f* ]# S1 `, c3 ^; X& [
}Study_Data[N][IN];, {0 j& z+ C: b- ~- F+ a6 _
/ F2 P O- g; p( Z$ J9 v0 m/ J
///////////////////////////
& G% A\" Y# O; T9 p4 e u0 N1 t
//初始化权、阈值子程序/////
7 T' K! C! L7 a3 C
///////////////////////////
& Q3 w6 d- Z/ l2 M! D, W1 A- U3 ^
initial()
8 e! p6 L* z7 Y! S) k0 Q {/ X$ {
{9 T% S& U5 Q0 f\" Y$ V9 f* N
float sgn;% _' f% m7 i! w
float rnd;; d8 o7 K6 d) G( M. E: R3 z
int i,j;7 o) ?: g0 ~7 F5 Z+ K\" h: _
//隐层权、阈值初始化//
D, z- `/ B1 E1 Z* N- `
{5 A\" _9 h$ O) e- L$ w
//sgn=pow((-1),random(100));
. I2 @; {! P' }9 o% i c( O1 K9 q
sgn=rand();- y8 D7 v; _ a* v( _- l
rnd=sgn*(rand()%100);+ p# t3 ^8 r/ Y r8 y; T- Q7 D
W[j][i]= rnd/100;//隐层权值初始化。. V4 f* W\" o: ~
}: r' D* R( {: r3 A& J
//randomize();
1 h3 s+ b, U) w* e0 M
{
, F: T% A; I! m/ P# J* h+ c$ S. l3 n/ n
//sgn=pow((-1),random(1000)); K+ R6 d3 a% f\" C2 `9 Y% ]8 H\" m) O
sgn=rand();
4 T) K7 b N% l/ i/ C$ ~
rnd=sgn*(rand()%1000);
3 G6 R# X# s4 t8 Q8 Z
sita[j]= rnd/1000;//中间层阈值初始化
9 G\" n, y) _0 i6 Q$ t
cout<<"sita"<<sita[j]<<endl;4 t* m2 r& g4 T. a$ c
}9 Q7 ^* N+ i* ~5 S
//输出层权、阈值初始化//& l$ {7 ~9 k( R7 ^/ _& ^
//randomize();
: q. T, v2 {! Y! u. G
for (int k=0;k<ON;k++)
8 w+ s; q. v, N+ v' t$ }
for (int j=0;j<HN;j++) 3 Z, i8 y6 M8 I
{\" o. g8 I! x: w$ i* K, o0 K% k$ g0 O$ F
//sgn=pow((-1),random(1000));
7 x; a1 t\" J0 c2 P3 f' J
sgn=rand();
) q/ E\" ^0 @% P; ~9 R8 c
rnd=sgn*(rand()%1000);
7 `$ y- k' d; Y; x\" s; j
V[k][j]=rnd/1000;//第m个样本输出层权值初始化2 K; Z) t, d9 c9 h! F( r/ F# K' b* E
}. g; R1 \/ F0 z _& q, X
//randomize();8 m& p( s: e5 ?8 d% A4 A- v
{8 \1 l4 D# e- N' b. k. |! O
//sgn=pow((-1),random(10));( n1 k0 \6 x! z- j\" j( M4 s
sgn=rand();
. c% E) K y\" m; O6 s: E
rnd=sgn*(rand()%10);, D& G ]' p. R8 H9 u- T( e+ N) r# I! @
gama[k]=rnd/10;//输出层阈值初始化
+ V. s e8 x% y# H* f+ W
cout<<"gama[k]"<<endl;
7 N R1 p! ?7 _+ n6 x3 G
}( Y/ _- m4 O\" ^0 K- a. J
return 1;% A% R+ W8 @5 D; E3 O% [+ C
' h5 U, |; Z8 t, F
}//子程序initial()结束
& ], P: ^8 X' [0 k7 D' p& |
( S2 h4 Q6 `- }. \% B& S
////////////////////////////////# e! \$ d, _1 N' U( q
////第m个学习样本输入子程序///7 o6 |# }2 A' O9 @! t
///////////////////////////////# T1 A% X; K# I2 v- ~2 x- w
input_P(int m)
8 _& P; n; V# z* B
{
( ^ M6 K# I# T! | ? _\" B
for (int i=0;i<IN;i++)
! ~' s2 O- C8 u: K
P[i]=Study_Data[m]->input[i];. }: C1 C/ I# Y# J# f7 L2 D+ `0 `
//获得第m个样本的数据9 {+ u2 n( `\" Y' `- r
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：. o- a% x T$ |
//P[%d]=%f\n",m,P[i]);6 |1 O( r6 `! S7 ^
return 1;
$ M6 H\" E. m' k% M
}//子程序input_P(m）结束+ P, }* i; ]4 Y( N! _4 i8 w
/////////////////////////////' P+ b: ^4 N6 M' h: D- Y$ ~ S
////第m个样本教师信号子程序//. c1 S2 W0 I6 c6 m' r- ]: E$ S
/////////////////////////////
T, C: d1 ^0 |2 [, Z6 ^
input_T(int m)
\" Y# g5 Q\" F) T+ p5 c- m' |1 [ F
{
. j! I5 j% C\" |9 e
for (int k=0;k<m;k++)
! B+ E& v% [& f
T[k]=Study_Data[m]->teach[k];
) {7 ^! ^) S0 n) T
//cout<<"第"< //
' @8 W: t% }; {( o7 i
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
- F% o( T\" D& L# j1 d
return 1;
/ q/ O* X! U/ ?4 R: K
}//子程序input_T(m)结束2 L2 Z& b E* J5 H
/////////////////////////////////1 Z, U; g$ L1 `4 L- L L- `. K
//隐层各单元输入、输出值子程序///
6 H8 k# c+ I6 }7 ?
/////////////////////////////////4 ^& m0 D\" Q3 y- @
H_I_O(){3 V0 m' U2 \\" _\" K s
double sigma;
! I( [* Z2 @9 u+ H/ `0 |7 W1 ^
int i,j;2 m0 e( W8 i6 g4 ]/ C
for (j=0;j<HN;j++)$ _% E2 r( k5 \\" Q
sigma=0.0;
1 U( i/ F. a) [9 m
for (i=0;i<IN;i++)
/ G4 _' |& p$ P/ M2 j- g
sigma+=W[j][i]*P[i];//求隐层内积
; W* j9 N\" S+ w0 l0 q
}! i9 B/ _; ` P5 ^4 b
X[j]=sigma - sita[i];//求隐层净输入
* ` {) p7 N, v
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
; P# |) M! F\" H, e& {% L p' L
}
& x$ C0 Q2 F! U* |
return 1;
& W. z S# W1 S8 ?' Y
}//子程序H_I_O()结束\" c# m7 E# J+ u
///////////////////////////////////
2 J# y% Y+ K& ^+ f2 K7 d! X% q+ j
//输出层各单元输入、输出值子程序///) R0 t) B c9 U7 j: ~: k6 f0 A ^
///////////////////////////////////
3 F* G u# ]$ r5 E1 v6 z& x& C$ n
O_I_O()7 ^* K4 c3 ? b2 n9 M
{ g$ O5 u5 `( r
double sigma;
/ g\" N: ~0 O3 |# o
for (int k=0;k<ON;k++)* [8 l6 U. R$ x1 O; I4 {# z1 f( D
sigma=0.0;
1 J$ O2 w: U, c: J# E
for (int j=0;j<HN;j++)6 H6 x9 M6 c0 v3 C) q
sigma+=V[k][j]*H[k];//求输出层内积
7 \\" `4 m3 M: M& ^! H\" g
}
4 b! _4 ^2 x5 v+ {; g
Y[k]=sigma-gama[k]; //求输出层净输入
; W\" u0 c! n- `2 a- p0 t5 g
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
5 Q7 o+ [8 n7 R2 n/ y& o- a& J
}
8 U9 E6 `5 z# c- u3 R8 K; A7 E2 U8 F
return 1;6 a* f' s* B1 F# ^! l
}//子程序O_I_O()结束
4 r* `* o! T: |, t) r5 s7 b
////////////////////////////////////\" r\" d3 u+ B: W4 S& |: U
//输出层至隐层的一般化误差子程序////
) d- n, U& @+ Y$ h' t\" T ?, S
////////////////////////////////////! z4 Z2 I) y; N2 K$ f# h) T
double d_err[ON];& \) ~0 t+ v7 Y# D- Y3 ~
Err_O_H(int m)1 w& I# w8 n/ Y$ m$ g
{0 J& A6 N7 `& I8 e( U8 \) h
double abs_err[ON];//每个样本的绝对误差都是从0开始的- y b& R. c9 G7 Y2 E
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
* [8 Q' M+ @$ {1 L
//for (int output=0;output<ON;output++) //output???$ f- J( \9 d/ M: R+ ?
for (int k=0;k<ON;k++)) J1 e) I! J) j3 C9 p9 b3 m0 C9 p1 j
abs_err[k]=T[k]-O[k];. n/ I; [3 R) `- [
//求第m个样本下的第k个神经元的绝对误差
, Z( U8 A: f5 Z$ z\" v
sqr_err+=(abs_err[k])*(abs_err[k]);
\" b7 L H8 V. V0 t
//求第m个样本下输出层的平方误差; J! e\" z5 W0 D- i$ A. O, v# R; {0 m
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);0 v$ C$ J( H* z2 U2 b0 }9 M
//d_err[k]输出层各神经元的一般化误差
1 B: G8 \7 [# U
}
3 b) `/ u$ ]! Z- r
err_m[m]=sqr_err/2;; F% `. l' }6 T5 L+ a4 j
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
+ z$ v! l6 n- }# z$ U
return 1;
: ~4 J# n% b9 ^/ [
}//子程序Err_O_H(m)结束
# x; c% b# \1 D3 y6 j# c! | B
////////////////////////////////////( Z/ q9 t5 ~' }1 U x
//隐层至输入层的一般化误差子程序////
2 _- X6 p6 }/ B/ x- R
////////////////////////////////////; O: ~\" k4 @8 ?. {
double e_err[HN];
! V. |) S# F$ W9 @
Err_H_I(){7 n+ S9 |# ]/ H7 D6 ?
double sigma;* {9 l+ l' b6 m) w$ a8 u
//for (int hidden=0;hidden9 A- \7 b% K7 u- Q1 F3 D1 Z
for (int j=0;j<HN;j++)
& T\" e4 ?, P* S- p& O) \' ?9 ~( e
sigma=0.0;0 x) U2 P! t; {# _. b! u% Q1 T, d
for (int k=0;k<ON;k++)
# K9 j( s; n) H& C1 l, J* h
sigma=d_err[k]*V[k][j];
* o0 I! O0 A0 M2 B2 X, B
}
4 d9 Q, c, O# U5 ^9 N
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差' u4 a6 {7 v ^# n0 [# s\" W
}
7 T% C6 N! K6 v8 G \( E
return 1;
/ A, n7 J4 [. |# r$ D
}//子程序Err_H_I()结束
: @ B% Z# T$ O# q8 W. I
////////////////////////////////////////////////////////1 s/ `& y, A# f\" [- a _
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////) J& a2 `2 b o& G) q: e8 b
////////////////////////////////////////////////////////
) a8 Q! h+ y2 t9 v+ x
Delta_O_H(int m,FILE* fp)& Q1 u2 ?6 K9 s; S; q: l
{
1 K J\" Z2 H- {
for (int k=0;k<ON;k++)
0 V( r8 }$ g v! L+ Z6 r
for (int j=0;j<HN;j++)# M% p% \: P/ t( O+ ?
//cout<<"第"< % G _$ \- L\" l* _. k8 L8 \\" |
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);; t4 X, y8 L4 z( z
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
( b. C& A& @/ W- W$ d& ~
}
( {- u. s\" W3 ?\" }% w' s+ E, [
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整8 _$ b' G7 ~% B, b
}& l\" ?- y, e) M3 v V9 R
return 1;
1 ~0 w0 z8 ]! m- v& v
}//子程序Delta_O_H()结束9 B2 v6 E) w4 P/ E8 [
/////////////////////////////////////////////////////7 F+ v r; X: |+ }; X
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////; l8 i5 k6 B0 m: ^0 O8 `8 J: c
///////////////////////////////////////////////////// [. ], J+ m/ X' ~
Delta_H_I(int m,FILE* fp)
& y9 `6 ?+ X- l$ u
{
. t5 l9 |* p; l1 |' F) C
for (int j=0;j<HN;j++)
, F- [. C( T0 U L( m3 e
for (int i=0;i<IN;i++) 8 R. L\" \\" y, Q. U
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
: O/ Y* ^$ b8 R9 [4 ]
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
# o4 n4 e& G5 d/ y& A$ j! ]
}
/ o$ A& L! v) m3 q
sita[j]+=beta*e_err[j];
- O4 G+ z8 S2 X+ Y
}/ X7 g; b' @# H! b% n2 |/ V2 Z
return 1;# L1 V- k+ ]7 i- ]6 A9 A
}//子程序Delta_H_I()结束
/////////////////////////////////
! u$ y! M& e8 q
//N个样本的全局误差计算子程序////\" j- _/ D9 K: S7 W\" n Z) I
/////////////////////////////////
) C; P) a+ ~2 M) F: k' ^
double Err_Sum()+ b* V+ w2 H4 o$ K0 l+ \) R- f% w
{4 Q- c s! @2 a& J9 K
double total_err=0;
0 z) x( L9 ]1 N2 F8 x
for (int m=0;m<N;m++) ; l) ^) \9 `4 M
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
) A) n8 w8 o\" f$ j+ R/ e/ H
}0 t0 F\" S. T3 y* o6 B2 N
return 1;
& z4 G8 R f2 K8 J\" b% p& L0 h$ K
}//子程序Err_sum()结束
& V5 d2 @2 m1 @4 I9 e8 G\" C
/**********************/ T; K% x8 x: ^5 Q
/**程序入口，即主程序**/
7 E& |, B' ]' J% y* b
/**********************/, e/ G\" z$ F3 Y+ y: {1 D
main()
; r0 T- e( [0 t: N
{3 ?0 a( F' B' i+ u# v& D! d7 A
FILE *fp;
_- e7 j! D$ `' _. z\" x1 E
double sum_err;
0 f0 }( |* N0 o P5 G7 b5 e; [
int study;//训练次数& @* R; [5 L, M, b8 z9 G
if ((fp=fopen("bp.txt","a+"))==NULL)
$ T: Z6 l7 T# J6 _) b
{
/ W X1 v: |: S
printf("不能创建bp.txt文件!\n");* y: ]2 P; E/ u# d
exit(1);
) h3 J) h% M$ n: M/ p4 N
}1 H' W7 u$ k: [ t1 ?5 {5 o
cout<<"请输入输出层到隐含层学习效率: alpha=\n";3 z! i6 s' G$ C+ u* w- e
cin>>alpha;2 t5 ?' Z% j8 m% O. F% l
cout<<"请输入隐含层到输入层学习效率: beta=\n";\" B* u# p\" v7 {& D4 H; c5 o\" \
cin>>beta;6 L6 O1 h1 a& o! o
int study=0; //学习次数% E0 p\" `$ T' u7 q F
double Pre_error ; //预定误差
* V* A) a2 z6 v, Q. ?' k
cout<<"请输入预定误差: Pre_error= \n";6 a% p: r: f5 k4 c
cin>>Pre_error;
# a\" g5 u+ Z: R
int Pre_times;
+ z7 V7 l8 |+ L6 e& ?# W5 ]\" G
cout<<"请输入预定最大学习次数:Pre_times=\n";2 k+ H7 ^4 |( H4 a7 ^4 ~7 b
cin>>Pre_times;
% X, u; ~1 L+ c. d4 s( [
cout<<"请输入学习样本数据\n";' _\" ^# P1 ]. b- G1 V$ k\" V8 M2 X* {
{: s8 g& G; W! b* ^+ }. P- k% `
for (int m=0;m<N;m++)# H# B* M: p. t# P+ A7 M
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
7 K* O+ ]. U- ]6 M/ q! D; W
for (int i=0;i<IN;i++)0 T' v/ r6 M0 B1 j7 u7 ?
cin>>Study_Data[m]->input[i];\" z1 z8 Q2 X3 F2 W8 C% \
}
\" n6 u$ K, z. r `. g3 U. P
{
8 }3 x9 q# r3 }; h$ G
for (int m=0;m<N;m++)5 P7 a3 g2 v. n. y# D4 w# k9 s
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; , i; Q, B; I$ {! o; ?) M
for (int k=0;k<ON;k++)' `, H\" N8 k# r, m2 @
cin>>Study_Data[m]->teach[k];
0 v9 E' s: S$ E8 H9 M7 j2 S6 A1 a
}# `% G4 b1 m1 m: S, R3 z\" @9 v
initial(); //隐层、输出层权、阈值初始化 (1)
1 C\" U1 R; C! k# Q) a4 j
do
2 o, }% Y2 l7 F
{
' @. w- |: x$ J$ T# s4 v
++study; ///???
& w' [( Y1 b2 ~: w. {
for (int m=0;m<N;m++)
- y; G# q7 k3 X. @. o; W: y5 D
{
! q( @8 z2 n5 m3 H
input_P(m); //输入第m个学习样本 (2)) I' r3 } O% ~2 ]
input_T(m);//输入第m个样本的教师信号 (3); V- \5 C. _, v2 `3 B. `) @
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)7 f( X# a- U6 i- W\" W
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5), H# ?+ e- L+ T& m
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
& M0 p6 U5 ?/ Z, H2 a9 D
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)* E\" T e+ B. K; l0 X( F
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
6 _: Q4 v {, B# v& T# W1 i
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)3 [! T; S; z i* D
} //全部样本训练完毕( N! k( ]& | C% Y9 b t$ Q
sum_err=Err_Sum(); //全部样本全局误差计算 (10)# K, N) W3 @ R P# _
{4 ?5 T# j9 z+ v+ R5 ~2 @
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;) M3 s! J6 W- y# B1 Z/ `' }8 Y
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);$ h2 v9 l6 V' _
}: y1 X# \6 y& s7 x
while (sum_err > Pre_error) //or(study
/ p% y, h8 Y9 K\" u
{ //N个样本全局误差小于预定误差否？小于则退出 (11)$ O2 R5 ?5 \2 y- ~9 y2 |
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;) `$ @: M% K; [* A6 k8 H& r
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
. g& S4 D% p. ^
fclose(fp);\" ~: d- y; z5 q0 w
}( J\" }8 L3 ]/ \ M; E
char s;
5 W1 M( D+ n G% A# A' I
cout<<"请随便输入一个字符，按回车退出程序！\n";- G t7 O+ Y, G6 O: H
cin>>s;
* P( r3 i. l u) o E$ f3 d
return 1;\" b I* x2 G1 Y2 k3 p4 W
}( [' A8 P6 q2 K( E6 z5 s) w
9 T( Q' B1 [- l/ k, G