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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
6 v+ W\" p( Y7 r
#include "iomanip.h"2 l! w7 p: w+ ~; m- P6 b& [2 ?
#define N 20 //学习样本个数
% z' m1 F5 H, I8 N& Y, s
#define IN 1 //输入层神经元数目
9 _ m& {4 {8 S( v
#define HN 8 //隐层神经元数目7 Q: M/ W\" i$ D% h, c* |8 y9 d
#define ON 1 //输出层神经元数目
2 `\" ?9 `\" }- `( p
double P[IN]; //单个样本输入数据: K\" B2 N/ R9 |
double T[ON]; //单个样本教师数据3 f& Q% P# [: a0 {1 \& [% f
double W[HN][IN]; //输入层至隐层权值
. O0 z; q& o T# J( \; k
double V[ON][HN]; //隐层至输出层权值( `, u; ?! z( O4 H9 |2 y
double X[HN]; //隐层的输入
4 g0 e' {+ m f8 z3 j
double Y[ON]; //输出层的输入' w% V$ _8 b0 Z
double H[HN]; //隐层的输出
6 F1 d2 V. p7 j9 B
double O[ON]; //输出层的输出
5 P, s4 n* y6 f1 @
double sita[HN]; //隐层的阈值# |$ Q, n! p; p3 y# v# t
double gama[ON]; //输出层的阈值
4 `% u0 t6 \ P* I) w$ z
double err_m[N]; //第m个样本的总误差
9 l! h4 F9 e! B- w% M
double alpha; //输出层至隐层的学习效率
* {4 _* l7 A d) T: t6 d
double beta; //隐层至输入层学习效率9 Z9 w% `. X! K3 u2 d9 _
//定义一个放学习样本的结构
( v% v7 h1 `7 U
struct {- T+ |$ C$ @, N9 A8 ]
double input[IN];
\" ]0 |4 `& e$ W, O$ ]
double teach[ON];
! g3 s8 a& q& l' B+ R! h& C
}Study_Data[N][IN];
5 H ?4 {( Y2 e- }4 i7 B8 ~- l
; O. P$ n5 T6 N
///////////////////////////! e1 k: R\" B: d% J% s2 x
//初始化权、阈值子程序/////
. }2 U& c5 _' G4 o! }
///////////////////////////
/ i; T\" g0 g6 O) o, Y) _
initial()
- I$ ^) t |+ S+ g% H
{
$ Z3 ?9 d% g, U2 T& }
float sgn;
2 N9 B$ ?# \0 g1 w( B
float rnd;* q/ P: @0 _8 P2 K! d4 N
int i,j;
9 w2 L% [/ s) e* B8 v$ i( O
//隐层权、阈值初始化//, u& Y9 T! _- L' N' _: z
{
% \0 K) K8 [( `0 w& e
//sgn=pow((-1),random(100));
% t, h0 J9 Z& f7 g/ _: x8 [
sgn=rand();2 \1 B6 W0 N# F* s
rnd=sgn*(rand()%100);
2 h% R7 D% `\" w3 ?$ w/ Q
W[j][i]= rnd/100;//隐层权值初始化。\" y9 j& N, @3 f
}7 L1 Y6 y+ w+ u7 a
//randomize();
+ s1 Y5 b2 w! u- h( m% W8 [2 k- W/ E
{
0 z& Q0 [& j% [
//sgn=pow((-1),random(1000));
& h) z, g* _# \* M1 T4 k
sgn=rand();
1 [7 R4 _6 _/ f6 Z$ n( ^. `
rnd=sgn*(rand()%1000);+ @8 R& a4 D6 O3 O4 `
sita[j]= rnd/1000;//中间层阈值初始化
cout<<"sita"<<sita[j]<<endl;\" ?\" B& z9 ` w6 V
}
: m: ]! H, b! N9 W5 n( ]
//输出层权、阈值初始化//8 W: K9 R, v* ^
//randomize();9 |\" U) w# L: V M0 j; h. L8 f
for (int k=0;k<ON;k++)
/ p& Y2 ^+ B' e/ ^3 I! [
for (int j=0;j<HN;j++) # p1 L0 [ R1 s+ i* Q# {
{- H X: `+ Z5 |( U8 h$ a\" w
//sgn=pow((-1),random(1000));/ k\" t6 g( u/ ^) Z& \# B
sgn=rand();5 {2 C% b\" V& U2 _
rnd=sgn*(rand()%1000);( ^- z\" f8 B1 R& M! H
V[k][j]=rnd/1000;//第m个样本输出层权值初始化* P k8 q4 f3 v4 k& q8 y( u
}
/ R6 O4 `\" h, `! i
//randomize();, D* G# F6 m ?
{- \/ _% @7 S8 p- S9 \+ z: H6 e, C9 H
//sgn=pow((-1),random(10));
, q L l% s# Y1 z) r
sgn=rand();
$ e. L: `+ a& p/ D( V5 D/ ?& e, T
rnd=sgn*(rand()%10);! f) y3 e+ @6 i3 x
gama[k]=rnd/10;//输出层阈值初始化\" S0 n) F) [) |- l
cout<<"gama[k]"<<endl;0 e+ E: {; X* e- a# @& Y
}
; y% j6 X' b1 e+ G1 s
return 1;
6 b4 N5 R, S9 R. o0 |\" \
9 o% {. J/ n: E9 D. q# |* c4 X
}//子程序initial()结束
2 C5 D6 Z Z( z. J8 S# _# D
& p. R/ d4 s! X; q# _4 v
////////////////////////////////, f8 S/ i3 H2 U3 {. w$ G
////第m个学习样本输入子程序///
\" p5 R+ R( @, d& F. {$ V) x1 e
///////////////////////////////
* p* X/ e; [8 |& i\" W, {6 X& {) c
input_P(int m)6 H+ c* G) }$ N6 N
{
) J8 r- |! f i' Q& b
for (int i=0;i<IN;i++)
C7 f1 o2 r5 Z! i: N
P[i]=Study_Data[m]->input[i];
' K4 u; Z% w* Z0 t% ]1 e8 a7 [
//获得第m个样本的数据+ Y2 u3 j# I3 c! V; J( @ k& Z* F
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：/ W a8 w |, l\" Z, r' U\" J& o4 B. t
//P[%d]=%f\n",m,P[i]);5 n, ^/ Y6 o9 Z
return 1;8 f6 F8 @1 z' k( y8 T* u, J) z) e
}//子程序input_P(m）结束
7 S- l3 A+ [$ P3 W$ _2 L' e
/////////////////////////////; D/ y7 e( o4 Q
////第m个样本教师信号子程序//
_7 J% d9 c$ J- {
/////////////////////////////
3 i, Z$ ^+ w1 [
input_T(int m)) l! M. U% q) A\" b m) [
{
- H! P7 Q\" d) ^9 A+ j; c, H
for (int k=0;k<m;k++)
x. @# V$ e' J$ k- L
T[k]=Study_Data[m]->teach[k];4 J/ u* Z$ p) E+ P
//cout<<"第"< //9 W3 Y) t6 C* q. ~8 \2 M
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
1 x6 X, R: u$ ?- I9 H- p0 }
return 1;\" @3 |) @& [. {8 \5 n. P
}//子程序input_T(m)结束7 }6 I' K$ N% d4 @
///////////////////////////////// k$ L% t$ m\" N
//隐层各单元输入、输出值子程序///
+ p! r2 V- ]8 M% A
/////////////////////////////////7 A: _# z, `\" D$ d5 R
H_I_O(){
. C$ z) ]* P' _0 u. \
double sigma;% u: Z6 P) C K i: q
int i,j;/ U% F) L# M- Q% U
for (j=0;j<HN;j++)& m0 X+ t: q$ F; Y- T! b
sigma=0.0;
* L& T4 `4 i. E' ? u
for (i=0;i<IN;i++)
! A9 ^+ B3 i; {9 H3 k, Z* V8 `
sigma+=W[j][i]*P[i];//求隐层内积7 M& o- M* H x3 R+ X$ [1 U5 Q
}
, n( ?# [& {4 |' m$ `0 {4 Z
X[j]=sigma - sita[i];//求隐层净输入' H7 u6 W: n9 {8 ]
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出$ J4 |' q9 h* H8 b8 ~$ n' U
}) r; A6 Y# d& A6 p, Z# S8 X
return 1;1 c' _& r) q- s( [9 J& o' _$ j* A
}//子程序H_I_O()结束
; F- A6 Q& N\" f8 u
///////////////////////////////////
: C% V2 A% q: h\" S+ P
//输出层各单元输入、输出值子程序///& P' \% ^5 z+ ?8 i I) @5 H\" ]
///////////////////////////////////
& X2 B2 J. f7 J7 f3 W$ o/ d; k
O_I_O()- j9 h7 J1 {\" ?) w
{1 _# j$ l l9 K, v5 ^1 M: i
double sigma;
8 A5 A4 e2 p, _& I# e
for (int k=0;k<ON;k++)
O5 C% v/ F+ ^2 S- _
sigma=0.0;
) y8 Y8 q9 |- `\" q8 {1 ?: Q
for (int j=0;j<HN;j++)8 u* R* o+ q) o2 Y+ ?% W
sigma+=V[k][j]*H[k];//求输出层内积
8 T% V/ b1 J$ k8 n
}
4 p2 f3 a' R; v( m\" z
Y[k]=sigma-gama[k]; //求输出层净输入
* ]% A; O8 p) Y; ]9 Q\" p( s7 J
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出* ?; d0 K5 u q# Y- ]/ B
}6 M* Y9 O# _' }% J0 @, ?5 m! ]5 W$ ~
return 1;
/ A, X' |( ]+ ^8 m3 J i
}//子程序O_I_O()结束, B8 F) V2 G! f& e3 t3 H4 ]
////////////////////////////////////
( b% f2 S% r- \3 ]: T! {7 `
//输出层至隐层的一般化误差子程序////! W- l0 T9 v5 b! W
////////////////////////////////////
( P R- H7 u% U. ]
double d_err[ON];, W! C* H3 ~) e9 N6 D
Err_O_H(int m)
8 e* K; v& w+ ~( V W; J( J5 N
{, w\" R0 S& ?' _: A8 P2 _
double abs_err[ON];//每个样本的绝对误差都是从0开始的
9 m) o; P% e' h9 C: I2 Z
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
& D# D% c! x }! @
//for (int output=0;output<ON;output++) //output???
& ~5 y1 s9 g& T* C9 F
for (int k=0;k<ON;k++)
$ J6 |0 p! e- ~4 y
abs_err[k]=T[k]-O[k];
; u. i. P% E6 b/ X- o6 s
//求第m个样本下的第k个神经元的绝对误差: s4 P; ]1 g1 [# ?; D. S/ j8 K, B
sqr_err+=(abs_err[k])*(abs_err[k]);
+ j( e\" V% r9 i& S/ q
//求第m个样本下输出层的平方误差+ M% U. `- Z5 X' n d: T
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
# g$ ~; ^+ r+ L
//d_err[k]输出层各神经元的一般化误差
) M8 B( r4 N6 p7 R8 G
}7 [, O$ b) S4 |9 i/ z
err_m[m]=sqr_err/2;0 h, q& R2 O\" h9 m0 P s2 v
//第m个样本下输出层的平方误差/2=第m个样本的均方误差. ?9 ~% p) b2 o
return 1;
* N1 k) j) ?# ~\" V' H4 {% Q
}//子程序Err_O_H(m)结束/ X1 T: M; S- y( m
////////////////////////////////////8 T4 k |; y/ L; [$ e; `
//隐层至输入层的一般化误差子程序////
3 F8 x; k% P- Z& ~! d
////////////////////////////////////
* y1 ?0 n) O2 q: l5 T
double e_err[HN];
) X/ B- x7 E$ ^4 x
Err_H_I(){+ Y1 G9 O2 ^4 Q. @( b
double sigma;! i\" x2 k, a2 }: t$ i+ S
//for (int hidden=0;hidden
for (int j=0;j<HN;j++) ( A q+ _: X0 w$ F! `5 q4 g8 o
sigma=0.0;
x, r6 K% z1 @
for (int k=0;k<ON;k++)
9 s L: \, T$ N5 E* u
sigma=d_err[k]*V[k][j];7 i8 ~9 ~# Z' e. H2 I8 t
}0 ]& {, ]4 W+ U. m% }
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差! t' d- B6 N5 S' [0 U2 Y) b
}
8 }8 M I9 y* i% T. u& W8 o
return 1;
1 q2 S/ O- k s2 P- n
}//子程序Err_H_I()结束
# \$ r+ y7 i3 z3 X2 [; P! {
////////////////////////////////////////////////////////4 ]9 U3 T1 `1 r3 |0 G5 g- ]
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
, t: }, v ?3 W4 y6 d2 ~
////////////////////////////////////////////////////////
) |2 n+ C; Y6 [
Delta_O_H(int m,FILE* fp)2 Z' |7 z. d5 d
{+ u& e) Y3 ]4 z' i
for (int k=0;k<ON;k++)
8 q\" f7 H6 y( h\" Z! \
for (int j=0;j<HN;j++)6 g' s3 ]* S\" @3 B2 i9 J
//cout<<"第"< . L4 G* p `) _4 F! f5 i8 }
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
& u3 A1 y6 O+ L F+ C2 F
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整% e3 [, U1 q) V\" o
}. F1 p% Q+ l' S( @; f3 j
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
6 A7 T& G* ^ e\" ]% N
}
* P% \, G\" E0 `8 S+ {/ h
return 1;3 w# T! P- [\" b# a4 q3 R
}//子程序Delta_O_H()结束\" j# H' E: T. I0 N' c `9 W
/////////////////////////////////////////////////////, G$ k8 t; A/ T8 E! Y& w+ A$ ?
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////7 C: n9 @. l# N- e; x6 a& ~ T2 V
/////////////////////////////////////////////////////
+ T4 ~/ Y9 p- o# ?8 b* Y* T+ e8 \
Delta_H_I(int m,FILE* fp)
. R3 w\" C+ f+ N0 M) s- x
{
for (int j=0;j<HN;j++). |$ ?% p u2 v6 M C/ D c; H/ C
for (int i=0;i<IN;i++) / P1 r1 `; n+ z N# b) }
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
( p& z5 R' o! G+ `4 D' z: F
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
3 X7 z. m- `: x$ }0 r% k9 O( ?
}0 F* P7 b( f% d& U
sita[j]+=beta*e_err[j];8 D- h3 h6 o7 V% J; c, l
}$ [* f- ]5 B6 D4 Q* l- ~9 N; M- v
return 1;6 g/ L/ o/ g5 k/ p/ d. T4 F0 X
}//子程序Delta_H_I()结束+ g2 L4 ~+ m& M\" W: b9 G% c
/////////////////////////////////
$ @) @% f# F' k4 B& m7 G, }0 i
//N个样本的全局误差计算子程序////
- |, q\" f( ]1 l- f. e: x
/////////////////////////////////& n' ]7 {0 n0 f8 g9 M: |
double Err_Sum()8 L, L1 ^9 z8 i( @
{
& ?9 V1 z0 T4 J/ V
double total_err=0;/ a* A7 f4 L3 H E\" p
for (int m=0;m<N;m++) - K\" j* r9 M, Q& ]5 q/ s
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
* @- a\" P# i& ~- n
}
\" P6 o\" p3 u: E I- @( e- S
return 1;
0 O- D4 A9 @, C7 `1 s+ S3 ^
}//子程序Err_sum()结束
9 J) d\" |7 b( c3 B) y0 J
/**********************/
; X% I& S: [: v# l+ v9 X
/**程序入口，即主程序**/
5 Y- ? B: g* L
/**********************/5 v: v0 ?! k! a8 h. W
main()
' ^+ n- F- z0 E1 }* Q
{\" A/ v\" E# k9 U% B
FILE *fp;
$ W# ?3 ^( `$ {% |; c4 ?9 m' H/ ~3 M
double sum_err;
/ I3 a7 d! W1 C$ ^& H& p
int study;//训练次数
' K; \4 ]: L9 x- ^3 I/ l$ |
if ((fp=fopen("bp.txt","a+"))==NULL)
\" H: p7 E* h. l, i5 `! y2 o. {% }& r
{9 u6 ]8 C9 ~) W* P# m! Z
printf("不能创建bp.txt文件!\n");) X. M, u3 E' q9 F; [5 a
exit(1);
m( s& x6 r# c2 l( s% O7 T/ c
}8 l, _) G9 V: I k9 ?# ~\" e% S
cout<<"请输入输出层到隐含层学习效率: alpha=\n";# |- Q0 t- S3 w
cin>>alpha;
( K2 w$ x\" Z( H. E A7 q
cout<<"请输入隐含层到输入层学习效率: beta=\n";
6 I6 {% C3 E& A; R
cin>>beta;
; Y+ w9 ~* F/ d+ V\" F9 d
int study=0; //学习次数
4 P\" ~2 ? j\" m; W
double Pre_error ; //预定误差
* a7 t) w% ]% d5 C0 j
cout<<"请输入预定误差: Pre_error= \n";
% t: }4 N; v* O- o/ a5 S
cin>>Pre_error;
0 d4 c0 X! Q1 t: h( o2 w7 S
int Pre_times;
8 v4 T/ B; h* u7 H: m( z
cout<<"请输入预定最大学习次数:Pre_times=\n";
$ B% g; |8 Q' S& w\" s- ^; t
cin>>Pre_times;
5 g\" q8 ]4 _( u, G4 Z
cout<<"请输入学习样本数据\n";
$ ~; L4 j5 c* r5 S
{\" V# }0 S5 w5 @, H4 G3 }) W
for (int m=0;m<N;m++)\" H( D0 G, L3 F3 C* B. n3 l
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; 8 q3 W! [3 l9 f# {
for (int i=0;i<IN;i++)
+ L\" G) y* ^& x\" K
cin>>Study_Data[m]->input[i];
% I' T* \1 ]3 e: ?3 {- D. U1 x+ B
}* \0 l/ z( _5 S4 Q\" M* B
{ ! ]* l6 O1 }# @
for (int m=0;m<N;m++) b' `) |$ M1 r
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; & P$ l( B8 }7 W% O
for (int k=0;k<ON;k++)
! y+ G\" m) D' S5 h k! v: D
cin>>Study_Data[m]->teach[k];
0 a% L* C3 f3 A' T. M1 _8 [0 r! x
}
- g, J7 s& [' d* s5 F' S( S, `
initial(); //隐层、输出层权、阈值初始化 (1)
! |7 M. w- ? Z' u
do
% d# ^: F) C* j' ^: P; g9 E( ?/ n& Q
{
) ^2 Q+ f c8 ?% Z8 b
++study; ///???2 N4 N4 n! A( b, w7 r
for (int m=0;m<N;m++) 2 }$ u, i: L' `
{8 H3 c& ^5 C# l) K
input_P(m); //输入第m个学习样本 (2)
l) ^6 y' ?1 A
input_T(m);//输入第m个样本的教师信号 (3), i+ O1 s5 z7 t6 l# I4 r* V8 b
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
1 U$ N' X8 w4 q: G. A2 B$ k
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
1 m6 i0 j9 K/ G: ~
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) * L7 j& s3 }, C( r3 y* A3 ]
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)9 }8 o) l9 h5 ^) E* d+ ~
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)& v ?: \& m% |+ u. x
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)6 x8 c/ \, ^\" u& n\" X8 d
} //全部样本训练完毕
9 r$ x1 }# z: F
sum_err=Err_Sum(); //全部样本全局误差计算 (10); y) T5 b& }1 t, d, O3 G- S
{2 y: j( t$ r; i
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;8 e8 b: h& T' X8 J- K4 B
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);& H3 r. d; Q; E/ f+ A
}
2 \/ E/ _* q) f% y- s
while (sum_err > Pre_error) //or(study
) T2 F5 m% K* w$ W* O6 r p
{ //N个样本全局误差小于预定误差否？小于则退出 (11). e\" m* X* [- L) W
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;4 ~9 q0 Z, [; o& F, x F
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
+ g8 ?; r1 i4 }. ^0 _8 S. }) @
fclose(fp);0 _% w2 J) J2 \\" V\" ^
}
+ j7 J0 O. V$ z8 Y+ t
char s;3 G+ F( }2 m; c- }3 N. }
cout<<"请随便输入一个字符，按回车退出程序！\n";* a\" D; h) k2 V* c
cin>>s;
6 G' } j( e; C) a% G. v4 H$ A
return 1;
5 L+ E2 _6 n' u' d3 u6 F
}! X% g; K2 X* C9 E# i; F* K% d
5 ? o* v9 K, }; B