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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"$ [5 j4 H; v\" L6 O\" _2 i. n
#include "iomanip.h"
7 P- W; n( U, z g6 A2 h0 I
#define N 20 //学习样本个数
' w\" p. J% ~7 ^
#define IN 1 //输入层神经元数目
5 e1 r0 {& M5 \/ Y2 @1 m
#define HN 8 //隐层神经元数目
9 ~: i8 g9 z3 C- g
#define ON 1 //输出层神经元数目
}* V9 Q3 G) a1 V$ I, l* J
double P[IN]; //单个样本输入数据
( q' }5 ]' d' }: I
double T[ON]; //单个样本教师数据1 V( a0 O; z! U5 y7 y0 E
double W[HN][IN]; //输入层至隐层权值/ o' ~0 C( D; C3 p5 l
double V[ON][HN]; //隐层至输出层权值8 Q1 }# o- ?! g5 f, ?( z, F
double X[HN]; //隐层的输入! J1 G8 E! t8 z P/ I
double Y[ON]; //输出层的输入. M8 C2 P0 R3 @- P) p/ Y
double H[HN]; //隐层的输出\" @6 H% o0 k$ Z/ t7 ]
double O[ON]; //输出层的输出3 k0 d/ T( |. l9 s
double sita[HN]; //隐层的阈值
# c! d8 b7 R- X\" M/ X& x* N
double gama[ON]; //输出层的阈值0 ?\" ~, y* |. Z
double err_m[N]; //第m个样本的总误差
* L* ~! g/ a2 K, ?: S3 y
double alpha; //输出层至隐层的学习效率8 L7 P e0 i' o! ]
double beta; //隐层至输入层学习效率( _; m# ?# K! ?3 R3 H) p& D
//定义一个放学习样本的结构
/ s3 \ X2 ]: w: L, Q
struct {
f( n2 U! n( x0 l% ~
double input[IN];
& f0 T T5 e! l) D& X( I
double teach[ON];- T) q }/ t+ u j
}Study_Data[N][IN];
s- s0 N& H' s2 i' {' p
; K) g) _( b7 \# u
///////////////////////////+ t0 u y6 p! Y/ D- B
//初始化权、阈值子程序/////; r2 p% v- I2 X$ }\" W\" R9 ]
///////////////////////////
, N1 r0 Q9 v Z, C z
initial()5 \* T/ m; Y- p/ O
{0 @0 Y5 P* T% N9 L: G; t& N
float sgn;- W1 k4 ^7 o; z! A- ?9 u
float rnd;6 Q8 F4 e g: z# S
int i,j;: V4 H. ?9 y* ^7 r$ X$ Y
//隐层权、阈值初始化// F9 P% F! p5 ?0 B
{
0 a0 E; @# K; q
//sgn=pow((-1),random(100));7 j, H# [% A* n- M- {, F% V( q( j
sgn=rand();
& q. [0 ^' e* Q1 k; E
rnd=sgn*(rand()%100);4 H+ ?) s1 v2 l6 I5 ]+ l
W[j][i]= rnd/100;//隐层权值初始化。% ^# I x8 n( o
}
) u# R5 v- k( B7 ?- i) N) \
//randomize();
: a0 T# A* _/ o; T) P+ _4 A
{
( G& S6 d2 Y( X
//sgn=pow((-1),random(1000));1 f! f4 s: t n' [$ ^0 g2 ^1 T
sgn=rand();
: _: P2 |+ d% o) e6 J
rnd=sgn*(rand()%1000);$ Q7 o+ r6 q& O1 |+ ~& [3 o& E
sita[j]= rnd/1000;//中间层阈值初始化
0 |: U& _! R* Z
cout<<"sita"<<sita[j]<<endl;
$ H' H4 k\" I4 t/ e, g; f' b
}, H# u* }$ B( X# w7 P4 n* B. ^
//输出层权、阈值初始化//
6 u- F\" C8 I% I8 Y5 B
//randomize();
. K, I/ I6 O) z& k% K7 [
for (int k=0;k<ON;k++)( x$ N0 M% {, O5 N) F
for (int j=0;j<HN;j++) ; W- @* K* ]: C& p' `; U3 O/ n* ]
{
4 o, d+ K\" U6 \, u# U5 f
//sgn=pow((-1),random(1000));
& ?+ C' z4 w1 J. L
sgn=rand();
' v9 n4 R9 w) |* O6 \
rnd=sgn*(rand()%1000);/ w# p. G; n' ~
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
$ `# w* Y' |3 y# ~
}
, n4 \! ]* v& g: r
//randomize();
& N4 c# Z& {\" j/ S c
{ G% Q- ?* u0 _\" Y& O2 ~
//sgn=pow((-1),random(10));
5 I# O2 y! b. \- e' _4 i: ~3 E
sgn=rand();
. {4 y0 s& K6 V! B
rnd=sgn*(rand()%10);
1 t* e! ^; D; j+ }7 Q
gama[k]=rnd/10;//输出层阈值初始化
2 m+ c7 i7 Z; q! S
cout<<"gama[k]"<<endl;) K# o3 m: E, X' q. S% z$ S/ v
}
: g\" G7 l+ K6 d; t; {. y
return 1;
4 |$ N/ S! o8 C y' H: f. B* a. w8 l
6 j% S8 \, H \5 w5 {# B
}//子程序initial()结束
( N/ ~8 x: z0 K- Z2 E2 i
* ]. `5 G& N) [- @4 {
////////////////////////////////! S( e3 i. J4 g4 J
////第m个学习样本输入子程序///8 V$ p9 l2 w) M
///////////////////////////////9 h9 p3 `' @6 C+ m$ a
input_P(int m)) d5 N/ P4 ]4 V& @' W* \) Z
{$ P. J- m1 o# h/ f0 _8 `$ x! I2 p9 {
for (int i=0;i<IN;i++)( [. P# E/ u0 J1 N4 ?) n\" y
P[i]=Study_Data[m]->input[i];
2 W) r( K0 A\" {8 Z \4 s\" L
//获得第m个样本的数据. p! x, L7 y1 I8 O$ K
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
& d# ~1 z! e8 i# j7 @$ z& L3 k/ }
//P[%d]=%f\n",m,P[i]);
7 `, D\" S: I7 z. X; @
return 1;
3 t& ], U. r$ U* m
}//子程序input_P(m）结束7 C% F) ^' t' _& L% u7 [6 H
/////////////////////////////, m0 p) Z# v\" K S1 r6 G
////第m个样本教师信号子程序//
- j# n2 n1 `. G+ X- ]& l& Y) ^
/////////////////////////////0 e\" ]7 a1 G/ p8 [: B' x
input_T(int m)) l& o9 }( ?. `, \. w+ s7 Y
{\" t5 O( w6 ?\" V
for (int k=0;k<m;k++)8 z& q# p& ] T8 c
T[k]=Study_Data[m]->teach[k];
/ E* h0 h$ U; d; i
//cout<<"第"< //
\" i* i/ x4 g5 ^
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
& q# n$ G' b( D9 E
return 1;
. J3 L( }\" B: ?
}//子程序input_T(m)结束
; B( C S) b# @
/////////////////////////////////' Z) Y: c6 \/ \/ w+ c
//隐层各单元输入、输出值子程序///
$ T8 e1 B/ q# ?; V. Q% l. x
/////////////////////////////////4 m/ Q8 @1 o0 x: |2 {
H_I_O(){0 c9 I# M3 {. J' ~$ |: ~
double sigma;
& ~9 v7 ]# K; _1 U\" A* @3 U
int i,j;
7 U n) v* l! D: ^( o% D' `) u
for (j=0;j<HN;j++)1 x9 M. K4 K/ d9 B7 V, ~$ m+ F
sigma=0.0;
* E0 k& m' t! R% ]+ z) D
for (i=0;i<IN;i++)
! c0 M1 F; ]3 d O, [
sigma+=W[j][i]*P[i];//求隐层内积
, \ {( `9 U! f3 i3 \; p U
}
5 D4 u S8 U! O! N, C
X[j]=sigma - sita[i];//求隐层净输入4 ~\" f2 I\" M7 @+ k2 a
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
\" Z& S( K$ a4 l. I+ B
}
) U i% U E1 n& b6 ?* { J
return 1;
3 Z) k$ A' g: O9 x
}//子程序H_I_O()结束
0 B2 }1 M1 u( f- [3 x- H, j1 W' w
///////////////////////////////////
% U; D; J+ Z& x# g
//输出层各单元输入、输出值子程序///
p6 l, j; C3 n
///////////////////////////////////
5 l6 l0 o! m0 D/ s% L4 }! Y
O_I_O()) l\" ^+ E% f- z
{3 q/ S e6 V# k: `/ f& p- Z: @
double sigma;
( N0 v% Q& H# q2 p6 Y* e
for (int k=0;k<ON;k++)
$ R- _+ \& Z7 h$ ?& Q
sigma=0.0;. M: |4 a& D- i- G
for (int j=0;j<HN;j++)
) J7 ]- a, F+ G. M
sigma+=V[k][j]*H[k];//求输出层内积
2 X9 ], |/ F\" C. Z. {
}$ m3 r\" t7 w) c1 s; A( ~* y0 O4 l
Y[k]=sigma-gama[k]; //求输出层净输入6 T6 [; O% _9 o1 M
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
2 Q( L9 J* r* p3 f; j, g; ?- G
}
8 }# k% O! Z4 O5 X
return 1;/ \8 p: a; H. Q7 R' ^1 I
}//子程序O_I_O()结束
\" s, i# j, J7 l# N' Y
////////////////////////////////////1 m6 q6 p6 P+ p# k9 q
//输出层至隐层的一般化误差子程序////5 b0 ?) P1 x( q
////////////////////////////////////
: L3 J\" p4 d5 V5 o; } G
double d_err[ON];1 b3 p) J! |' g$ s( w
Err_O_H(int m): C! }+ Y% o9 V* M: D- I- O4 A
{8 x% B\" X' |% ^* @
double abs_err[ON];//每个样本的绝对误差都是从0开始的
' N) I1 L' i. _9 ~2 I4 k
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
; }. b) l& H, K
//for (int output=0;output<ON;output++) //output???# a6 S1 z. {6 }
for (int k=0;k<ON;k++)8 Y; q% [9 K, B# o2 F& j
abs_err[k]=T[k]-O[k];% p+ S) p) t0 ^% |
//求第m个样本下的第k个神经元的绝对误差
; l+ I- q3 W% m- K5 ^5 d
sqr_err+=(abs_err[k])*(abs_err[k]);
. O( s p' d2 Z v) ]+ \
//求第m个样本下输出层的平方误差4 g; t, j8 d! Y6 Q0 q. o$ U8 D
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
2 n; ?; l3 v- x
//d_err[k]输出层各神经元的一般化误差 B: l1 i7 \$ H- R
}
# M( _! O/ @& \
err_m[m]=sqr_err/2;1 K+ x4 m0 v& v2 p' f
//第m个样本下输出层的平方误差/2=第m个样本的均方误差: l2 S, X- K* f# h; D. K3 j2 l
return 1;. \2 Y8 s1 V+ A# _( E! `
}//子程序Err_O_H(m)结束
2 A4 Y) v& e, I\" i5 A7 ?3 k1 L
////////////////////////////////////
$ c\" k& `( R- C2 _8 |; S
//隐层至输入层的一般化误差子程序////
* q! Q, V @\" a! z% U, y
////////////////////////////////////
6 ` g% N/ F M7 [( [/ e& s, y- h
double e_err[HN];
- N: Q$ |\" k- k' s' k d$ B. ^
Err_H_I(){
8 }; Y }. ^3 ]: L\" O3 R& Y( T) T
double sigma;( L: @$ A3 G4 B4 h
//for (int hidden=0;hidden5 ^7 _ B! A0 B
for (int j=0;j<HN;j++) ) ]: Y0 ^4 c+ E) P+ S% t
sigma=0.0;
, R5 \( ]! Q9 c( e
for (int k=0;k<ON;k++) 6 G5 s1 M9 o( i& e1 z% n( D
sigma=d_err[k]*V[k][j];
# M; q) T: p4 T) z) N
}
: _, n! Y _% K! ^. s0 \
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差0 e7 k, @4 l4 C
}$ Q+ a; P$ \5 T m/ }
return 1;9 j( I) N* C. q1 j3 ^1 r) R2 T
}//子程序Err_H_I()结束
. K9 l/ U( O0 L/ @
///////////////////////////////////////////////////////// n\" \7 Y* u3 Q: G: X p
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
! y0 ^4 Z0 f/ p( X0 x
////////////////////////////////////////////////////////
) [% ~# u& ~6 p
Delta_O_H(int m,FILE* fp)
8 v0 L! J; ~7 Q s/ k5 N
{
5 R0 O% |$ M: z
for (int k=0;k<ON;k++)0 w8 T1 K# x: u: A7 R* w. Z6 O- x
for (int j=0;j<HN;j++) e# R$ i! Q9 ^& \% O
//cout<<"第"<
6 Q2 R/ L( o) ~1 G O- @
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);: D2 r+ R W( L, i, c& n& V\" i
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
3 g4 t: D; I. [! u
}
4 o( [8 P1 g% S( q. I2 y: E1 |2 s
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整\" u- E- f/ T& q+ N$ b$ `+ Z* H\" m
}. L- p3 `6 |' L. c
return 1;
# h1 A% q3 R& t- o
}//子程序Delta_O_H()结束
' y\" z2 n\" X\" @, a) h7 g; l
/////////////////////////////////////////////////////) G4 A+ p/ I `' K2 l
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
5 @3 L8 g% Q! o% b/ c\" P; f2 q4 t8 X
/////////////////////////////////////////////////////
. O' b\" p) f8 w% \1 O+ o6 b9 y
Delta_H_I(int m,FILE* fp) e) O$ R\" l! q4 S! s
{0 E/ |2 O' a7 N
for (int j=0;j<HN;j++)
- h: W$ n# E$ g2 t, V
for (int i=0;i<IN;i++)
! S) I# u$ P) q7 t% a
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]); N4 T* v7 [9 `8 d* ~; K8 R
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
$ C( z8 i& Q9 j9 A& ~
}
$ `3 F/ G/ w: T\" O' h; W
sita[j]+=beta*e_err[j];
7 H4 _6 e* c\" {6 O @\" Z
}
8 K. m, R; M7 m u G( X& i
return 1;
* V- _\" g& ?/ w# Q( o$ n% x
}//子程序Delta_H_I()结束3 _\" _\" x3 i: T4 Y
/////////////////////////////////
+ ^2 s7 F, O5 S; v# Q
//N个样本的全局误差计算子程序////
, U5 P9 ]6 ~/ @\" X
/////////////////////////////////\" q# F/ b. x$ |6 M/ ~& }8 r
double Err_Sum()( {$ ]% \9 C7 [6 m\" }4 g3 c
{! j7 O( q3 }0 e7 l3 X5 |3 Q
double total_err=0;
# [ s& h+ w! w7 K
for (int m=0;m<N;m++)
A3 ^/ O% I# K8 S
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
2 g( R7 Y3 w# ?% O+ H# u# ^4 r y
}5 E. b. j4 Z. A0 |1 K/ f+ A' G
return 1;* _/ d4 ]6 N% E# V
}//子程序Err_sum()结束
) k; \- W) c* c
/**********************/
5 S/ f2 |1 g8 u\" M! \: o# K' I( A\" e
/**程序入口，即主程序**/
7 L2 D' g3 T1 `: m2 U( u3 b\" V
/**********************/
5 u _5 D+ d% e
main()
0 y! o( V* }6 S7 ?( `$ u7 e2 F
{
( K& `4 ~1 `5 d1 d0 h# p( m l/ m. M
FILE *fp;! ?; m8 |- G+ M7 G+ o
double sum_err;
7 v* M* `' G' S% z
int study;//训练次数
1 }% z) p6 Q# l! w* ], K& I0 n( I* X
if ((fp=fopen("bp.txt","a+"))==NULL)
% M3 {( D4 n$ i/ I; L
{
8 a2 k: C8 ]6 `
printf("不能创建bp.txt文件!\n");5 ?8 ~9 M' o O1 K7 h6 L
exit(1);\" ?( V& o7 g) _0 F3 n6 K8 S$ z! ~- v
}
% z- S\" I& q& X; G: T
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
5 z- R6 Q# h; ^( T5 b
cin>>alpha;
! n- L; z) Z3 T- e. j) Q8 [( H
cout<<"请输入隐含层到输入层学习效率: beta=\n";
% r% w$ s1 q2 }, _. G7 ]* L3 L4 h
cin>>beta;
7 G- X* ]. h4 O m, c' M t
int study=0; //学习次数
3 s) ?. K# d( }6 }+ p( r$ T
double Pre_error ; //预定误差
6 ?; e$ m/ R/ _! D
cout<<"请输入预定误差: Pre_error= \n";2 I/ q2 }3 \% d3 B% w+ q9 J. |' k
cin>>Pre_error;
0 \% ~/ \/ ?6 l4 K
int Pre_times;
\" G4 C$ j$ c- p! B8 X4 }5 S3 W! d) G
cout<<"请输入预定最大学习次数:Pre_times=\n";8 u. B7 X3 ]! x
cin>>Pre_times;2 L8 G% C% W( [, l# ^* M8 }- [
cout<<"请输入学习样本数据\n";
4 g& s' i) c O V9 `( B l
{6 Z5 f# t' @+ G8 x- m
for (int m=0;m<N;m++)3 n3 n- m1 F1 H9 t* J0 ~& K5 E ^
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
; d9 Q6 g2 w; x* p
for (int i=0;i<IN;i++). S\" S* t m% F6 q
cin>>Study_Data[m]->input[i];/ L' s/ e1 Y9 M) b
}\" R w. I+ F- W0 K7 N
{ 0 v; s# C- w/ w) l
for (int m=0;m<N;m++); v+ y2 l' \4 q6 M3 L6 g( d
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
: p8 |- V$ l8 i2 }+ x; n
for (int k=0;k<ON;k++)
t1 X& {/ a6 |\" q
cin>>Study_Data[m]->teach[k];, x9 Y, s4 n5 v2 X5 i( K
}7 M' z! s3 I\" O
initial(); //隐层、输出层权、阈值初始化 (1)
0 T+ d# h5 _, R, C: m7 ^6 j: B6 P
do
* B: |( [8 a$ s/ T) }
{- h3 k$ B/ e1 f# r o% O
++study; ///???+ T& N* |. @; o% R) Y H4 T
for (int m=0;m<N;m++)
4 ^+ [3 k! w l: a& z! K+ q0 p
{$ M- Q Z: c7 d) |+ F. h0 ]) [
input_P(m); //输入第m个学习样本 (2)9 Y* C/ ]# V8 j2 ?) W& a
input_T(m);//输入第m个样本的教师信号 (3)\" W/ Y# ]6 Q; x% O
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4), }0 I( O( |) M2 ~; v7 Y
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)- b' q# f9 ^7 [
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
$ W$ e4 d* C& u
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
$ ^; z6 l* e1 y
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)9 J; y5 ?( z1 C) M
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
( u/ m% k7 ^0 i, n. I9 [
} //全部样本训练完毕
* w0 F* e2 v/ v7 y
sum_err=Err_Sum(); //全部样本全局误差计算 (10)- M4 `: c& y0 m
{
7 N: C) s6 x\" a1 W; v$ h4 w4 ^
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;! K( X* }. I- z3 x3 ]
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
) t6 p3 Z! L\" E$ k
}5 L$ x/ ~- z1 Y- z1 n5 N/ Z5 @
while (sum_err > Pre_error) //or(study/ Z& v- t( h% E/ W( D5 \5 Y. U
{ //N个样本全局误差小于预定误差否？小于则退出 (11)! R' Z8 J5 `: E5 O
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;: a; \# a) z: F/ _
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);. y+ w0 ?# s V
fclose(fp);5 _' Q% i+ e7 J! f! C7 @; J# \- h
}0 i( B6 D9 G' @% i
char s;
8 Y& ]% B2 ~5 U x. r
cout<<"请随便输入一个字符，按回车退出程序！\n";) c0 d: l) o) o
cin>>s;8 I! F; u( Y6 k' a0 i) }5 q
return 1;
; u# f: o3 T* W, I ]4 s% P
}
5 d( v( i' k1 R/ d4 S/ o
: R; S) d3 s( }! z