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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
) ?. M1 \9 t( U# ?- J
#include "iomanip.h"& x& |( K0 b+ V
#define N 20 //学习样本个数& s2 {4 h' [. J! }
#define IN 1 //输入层神经元数目
. O& g2 S# Z, F. G3 M2 A\" p5 L/ I
#define HN 8 //隐层神经元数目, Y3 Q; W# k+ d: \1 h
#define ON 1 //输出层神经元数目
8 p, L* ]# }\" D7 Y& p
double P[IN]; //单个样本输入数据; w; S; {0 F! g
double T[ON]; //单个样本教师数据
2 @& C: |; d' E4 O
double W[HN][IN]; //输入层至隐层权值
) l9 @+ l1 k& ^9 T: A8 B5 k6 A
double V[ON][HN]; //隐层至输出层权值2 d( u7 Q5 n) x2 ~
double X[HN]; //隐层的输入
: J0 ~9 Z. b6 B- M# L
double Y[ON]; //输出层的输入
1 [2 d! \2 r3 V0 `. k6 ?- X
double H[HN]; //隐层的输出
3 t9 \' D: ?9 M% K: w& j! O3 ~# p
double O[ON]; //输出层的输出2 U4 `) B6 Y- z; W/ D
double sita[HN]; //隐层的阈值
. [5 N8 U$ o# j
double gama[ON]; //输出层的阈值( W4 x\" l& u5 V+ ]7 V# ^
double err_m[N]; //第m个样本的总误差
) ^9 j0 G9 V+ K* t% b\" _& Z
double alpha; //输出层至隐层的学习效率# ]. p1 D\" k\" B! G( Y
double beta; //隐层至输入层学习效率
- t; g3 X# J/ E1 c+ Q
//定义一个放学习样本的结构
0 M( o: L/ u- n3 A& _6 y
struct {3 G% x! m' v0 T% Y; [' N
double input[IN];: H! G' `. @% f2 v6 i6 H
double teach[ON];
2 Y\" ~# g# y: ~9 g: W5 T
}Study_Data[N][IN];0 z/ }# n2 {; f5 i5 {* B' w* A6 ~
% M% @/ b/ [' p. H
///////////////////////////
0 w4 @! i- [$ ?& a3 w
//初始化权、阈值子程序/////
6 A; C1 y: R% g3 s/ a- g
///////////////////////////# x9 Z/ O6 v8 N q0 }* S$ [
initial()% ~; n\" b\" T# ~
{
( T+ \6 s$ }, [# C
float sgn;
9 @ S. x! G' }9 ~+ _1 v2 G
float rnd;6 ^8 M1 H8 G' ?5 f8 F. P' C
int i,j;: Y9 p- B. j( ~: I& \; Y* ` X: {
//隐层权、阈值初始化/// ^1 O2 k0 [/ l
{
) o; U0 }: Z( a
//sgn=pow((-1),random(100));) w, w1 z2 Y7 W; E
sgn=rand();
3 @* B\" q& x) E' c/ w
rnd=sgn*(rand()%100);
5 p: A( _/ y% _9 U
W[j][i]= rnd/100;//隐层权值初始化。: _# n* b/ C9 e) m8 \7 j4 r; m2 L
}
: P& ^, H J6 b/ H) t! W/ @
//randomize();+ N$ Z& W; |4 {8 ^
{) j8 P! z0 X6 z% s! D
//sgn=pow((-1),random(1000));
; P( x* g' N0 P\" J\" F0 P
sgn=rand();. J* ^3 K% A6 j. _
rnd=sgn*(rand()%1000);& [( S& k( C( M* m
sita[j]= rnd/1000;//中间层阈值初始化
6 C% @7 u4 S$ @, Z9 b- @3 @+ {
cout<<"sita"<<sita[j]<<endl;
' [' Y- T9 U, L# j. V
}
+ E- p\" H4 _8 z3 x7 `, e& }1 I
//输出层权、阈值初始化//
) ?- L' T; E+ _' X2 Y: y- K
//randomize(); Z* r\" Q6 Q7 P- I2 |
for (int k=0;k<ON;k++)' Q& |0 n. w+ D' N
for (int j=0;j<HN;j++) - I$ X) n! \) V7 B
{
1 i. c( R: H# q2 K\" v
//sgn=pow((-1),random(1000));' p0 L6 A( j, g7 J2 Q, ]
sgn=rand();0 M$ I1 `8 G2 Y2 ^& g
rnd=sgn*(rand()%1000);6 e- S/ N$ {' P; | U
V[k][j]=rnd/1000;//第m个样本输出层权值初始化9 [8 e2 E$ M* E) O/ `+ ~5 V/ I% r
}
. \% `+ r I$ g% h+ j
//randomize();
0 [# ^5 Z3 V/ Y& L! r
{- d/ b' M2 X( I% \% L' { \
//sgn=pow((-1),random(10));
\" a# Z% v0 c& R
sgn=rand();% k# {\" ]% `9 Y) t
rnd=sgn*(rand()%10);
( z5 J8 F! \0 O; V1 t* f
gama[k]=rnd/10;//输出层阈值初始化\" A\" H8 D# o9 y' C+ W) T
cout<<"gama[k]"<<endl;
6 t0 U6 d# Z& ~3 c3 R\" Y2 @
}
6 @& |5 p- ~4 N1 ~\" O
return 1;/ }# x0 v! C6 }0 c\" y: d3 }
: y( s' V2 U. s5 Q. C, f
}//子程序initial()结束/ t; W$ W) Z. C. H$ u! F- r. m& ^
; g, ?' a' P' |; H( h
////////////////////////////////
! ?) Y. s# E0 {9 O! F
////第m个学习样本输入子程序///
# F8 q\" ?$ z( A. M9 R
///////////////////////////////
/ x3 h! U. b5 b, H+ y9 Z5 _# Q
input_P(int m)& T- B% L) x% ^6 {/ f' G0 K\" o
{* l- i2 I6 E8 J/ i, J4 f
for (int i=0;i<IN;i++)6 U ~# f/ M+ b. A+ {\" u0 D! |
P[i]=Study_Data[m]->input[i];/ B2 C$ c! K% R+ a
//获得第m个样本的数据
# N0 O& N% ~3 W- s j
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：- p\" t$ }* ~8 @
//P[%d]=%f\n",m,P[i]);
* K. b2 k0 t4 Q$ [. D
return 1;
& H0 s8 j6 a9 O5 h& `
}//子程序input_P(m）结束) k r9 C, s) a; V
/////////////////////////////
5 S K6 s: e, b5 s1 p% ]9 G
////第m个样本教师信号子程序//$ B2 `, K8 ]- s9 S. ~
/////////////////////////////
[# A2 X( q8 D$ c* @\" F- z+ v
input_T(int m)
8 ?! f B. D% ^\" v# P4 K- S! c
{
n. v$ _ }- F
for (int k=0;k<m;k++)$ f: Y5 ?- o: y) N! B
T[k]=Study_Data[m]->teach[k];' n' X2 G, G. K& `; v
//cout<<"第"< //
6 q, g' H. U& f. |: V
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
, v% b/ B9 c6 ?0 [- g* R! \
return 1;
+ E* T! V# J: q1 R0 Y
}//子程序input_T(m)结束
) H\" N* g. v4 F- X- ?4 o* ?
/////////////////////////////////
/ j, n! @3 Z5 C) m# H( ?: l
//隐层各单元输入、输出值子程序///
& T\" P7 g2 ~: N: E6 M* A! `0 C
/////////////////////////////////0 |5 {8 ^* l P$ Q
H_I_O(){
( M- ^, \% P, _- {8 ~\" Z- Z
double sigma;
1 o+ C6 Q1 ?! P- W
int i,j;
/ W1 M* N/ f* h4 R+ W: ?
for (j=0;j<HN;j++)
. n4 K/ T- e5 z/ G4 R- Q
sigma=0.0;1 u C) t5 _, U; R! ]
for (i=0;i<IN;i++)
\" p. C1 r5 S) A: s' q
sigma+=W[j][i]*P[i];//求隐层内积( b& t' f9 j# i. t/ ]
}
\" M6 k6 j% x' ]7 h- D
X[j]=sigma - sita[i];//求隐层净输入, o0 l0 h0 w$ m( m4 N9 N0 v& I, w
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出0 I* n; \, {/ Z2 J# a
}2 O! M! j- @$ P0 S
return 1;
! g; s. V& H9 Q B( b
}//子程序H_I_O()结束
\" M: Z- [9 E, M- X1 @
///////////////////////////////////% s3 a( @9 I2 J4 O
//输出层各单元输入、输出值子程序///& x9 |) @: }# O! O& K
///////////////////////////////////
( F$ |% z8 B7 C
O_I_O()) u' |) n* m0 s5 d
{: N3 n+ N! y8 f1 n\" D# w* |
double sigma;
) v7 Q/ n7 u$ P) D9 b, Q
for (int k=0;k<ON;k++)
* f' d* F. o$ R e. L: i
sigma=0.0;- h, U' `: ~# e6 K1 I. k p% G' [1 F: |
for (int j=0;j<HN;j++)( A1 w8 e* K5 }6 }' t7 O$ t
sigma+=V[k][j]*H[k];//求输出层内积' F; ^7 j$ X P5 }; l7 {) W
}
' [) Z4 O3 ]- P/ z8 t) m, B
Y[k]=sigma-gama[k]; //求输出层净输入
! ^; T4 I/ g0 p1 L7 x, t& P& K+ e
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
! k. c9 g8 o1 ?: G
}1 V6 a1 a\" U; B8 c& ~( Z2 |$ B
return 1;6 i: K. o* n\" V
}//子程序O_I_O()结束
; B5 T) t4 v1 u5 U1 ?
////////////////////////////////////
( Y' x\" r# l; c5 \& a
//输出层至隐层的一般化误差子程序////4 A* m. w: g' O$ G8 Z+ e
////////////////////////////////////
5 d- ]1 B+ v) E& ^' E! C- x\" b$ I1 K
double d_err[ON];7 k8 c. T0 P- B6 M( ]' @
Err_O_H(int m)
Q( S; Q) ` g8 `* n; n a' `
{
' b! K! P# R5 A! a& C1 X
double abs_err[ON];//每个样本的绝对误差都是从0开始的! P- Z. s\" a; `9 K% |( s1 ^
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
//for (int output=0;output<ON;output++) //output???5 A/ d9 ?8 {4 ~6 B
for (int k=0;k<ON;k++)/ y% e( M4 Q6 O/ ]! N
abs_err[k]=T[k]-O[k];
3 b8 R y$ U6 \\" O: |
//求第m个样本下的第k个神经元的绝对误差\" }# `\" s! K/ E$ G# I5 R; V
sqr_err+=(abs_err[k])*(abs_err[k]);
3 U0 W! D/ U8 U
//求第m个样本下输出层的平方误差
: R: m1 E7 {5 g4 h\" l* H+ F% \1 `0 W
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
. h) M. [. j0 r8 r% Q
//d_err[k]输出层各神经元的一般化误差
$ [5 G# f' W3 {
}+ I6 k* e& o+ p5 U& I y
err_m[m]=sqr_err/2;
3 g) O# x# W, U1 l5 ]4 o
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
6 n+ y4 |# t# [7 @% f
return 1;
\" J7 Q- t( t g: m2 o7 R9 g; L
}//子程序Err_O_H(m)结束# _/ C# [) R1 Y& E
////////////////////////////////////
7 h1 R/ A+ h8 E5 v3 n% m
//隐层至输入层的一般化误差子程序////
: G' n) |' P( N' {, J& }
////////////////////////////////////5 s+ X# @$ Q X' n3 {& m
double e_err[HN];% N0 b; S; R, o# ?2 h0 z; k
Err_H_I(){
* w6 `0 r ~4 ^
double sigma;
$ V9 A% X: e7 |# j1 X
//for (int hidden=0;hidden( x- `# N( J0 L4 ^$ d4 I7 v
for (int j=0;j<HN;j++)
# Z, V\" \& o, E. z8 j0 v
sigma=0.0;: s3 t8 y# q' o* p; L
for (int k=0;k<ON;k++) - M1 z- R; ?* s ?\" f9 i' k
sigma=d_err[k]*V[k][j];& D2 E- g: a. t5 B
}
( P2 J% h5 Q- k) _
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差5 p! j0 h& }\" k% U; X7 g
}& ^9 e+ v\" g' j3 e3 K' i
return 1;* E\" C0 A* B. W
}//子程序Err_H_I()结束
1 e) Q j( h6 Y2 i5 V& f, o1 Y
////////////////////////////////////////////////////////
+ i, N. E0 ~& b
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
$ W/ X$ u* i3 w) A. w
////////////////////////////////////////////////////////
* B6 U; ]; k7 z: r, d
Delta_O_H(int m,FILE* fp)( j# e, R8 A9 T) o' P2 `
{
# `$ s, l% s& \# S5 E; d9 h5 u
for (int k=0;k<ON;k++)5 W; O$ Y0 |, c9 A4 V
for (int j=0;j<HN;j++)
! s. H$ P$ p6 j c. ~ B4 s: Q
//cout<<"第"< 0 Y7 ?- X\" s( a' J
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);9 h$ i2 P5 l$ `) R* z
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
/ n- f3 a! g- b, R2 l' a
}2 a- d0 ]: t3 Y6 v
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
Y7 v0 u: |2 K( B4 u
}
+ }2 R$ P3 K! ]; ]( I9 `
return 1;9 z+ x/ J& n N. y J
}//子程序Delta_O_H()结束# z% k4 t, _5 ]6 s( n$ @
/////////////////////////////////////////////////////
+ |6 |, _% P/ I$ `6 v- E
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
: v* V6 t0 U9 L0 R' H7 B# O
/////////////////////////////////////////////////////
5 w. X0 q$ G\" Y\" X# {
Delta_H_I(int m,FILE* fp)
1 c4 L% n4 n3 a/ G
{) G- i3 u; W( S7 L
for (int j=0;j<HN;j++)
2 K i3 g& I2 i0 l, T# `' S) h5 R\" b
for (int i=0;i<IN;i++) + Z* [5 F1 H$ P0 x
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
$ v0 I( V2 t( H7 Y0 I
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
; ~. g' @8 E5 V, I( [( c
}\" R9 v: t, q- R0 ~7 v( T R
sita[j]+=beta*e_err[j];! E( E1 D% e8 O4 L2 m( Y% ~
}
! K' _& u2 F, w: N/ h
return 1;. u, J8 K: o, n
}//子程序Delta_H_I()结束# T0 s! L# a1 h- d
/////////////////////////////////0 _# f% c( b! b& D6 D8 V; ?3 k- v* v
//N个样本的全局误差计算子程序////
9 W; m- G3 n6 c; D: ?
/////////////////////////////////+ b$ {! X5 B$ Z, }' ~
double Err_Sum()
, _ h( u0 J9 f6 S: K
{
: N2 q( _9 z5 z' S
double total_err=0;7 ?. w2 L$ z5 u) u1 B
for (int m=0;m<N;m++)
; p' X$ H2 W+ u1 i1 I
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差6 A& G. f* {1 o% r9 @5 k5 I
}6 [& n$ Q d/ T$ w% h8 a
return 1;$ v- W8 i; K! Q% F: ?: s
}//子程序Err_sum()结束
, u. C\" P4 H. i# k\" Z, U4 t
/**********************/% c# T) u2 m( s+ g4 _$ T
/**程序入口，即主程序**/5 y4 U- t( A# s
/**********************/
: Z4 F( y/ l' w1 M
main(); l+ n1 t& G, v% q2 Z$ n\" `, S5 d
{: V& I$ c/ a6 M\" J4 O
FILE *fp;! ^1 \$ P% D- {6 U s6 M1 c
double sum_err;# _7 r7 ^' ~6 _) z, P4 T
int study;//训练次数
( }4 t2 e3 g; m2 a/ z; m+ E& W
if ((fp=fopen("bp.txt","a+"))==NULL)
* L\" d. l4 H7 Y
{
5 B4 G1 @3 H% W& p+ b- T
printf("不能创建bp.txt文件!\n");. |1 ~6 T7 o. `, l7 R1 D' ^
exit(1);
/ k& g: }4 N9 x$ p: t
}
2 X+ g. c+ }! I) A' P# h8 i
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
- Y) n1 q( ]2 v5 i' Q- p
cin>>alpha;' C# E% M6 w2 a* Z! _/ D
cout<<"请输入隐含层到输入层学习效率: beta=\n";4 R {\" \5 y( {9 \\" J9 z
cin>>beta;& v& ?1 q4 J) L0 V7 U
int study=0; //学习次数+ h* J7 I6 ]9 m2 x l1 k5 R
double Pre_error ; //预定误差
' T# L) l8 x/ u6 `
cout<<"请输入预定误差: Pre_error= \n";) \9 g8 ?* `+ U, i; E1 {8 w) H
cin>>Pre_error;. u7 g& ]1 E( i. u# Y- n5 Y# j' \
int Pre_times;
0 y$ ]! _' D& `( N
cout<<"请输入预定最大学习次数:Pre_times=\n";9 U( k* h: u! U6 Z
cin>>Pre_times;/ S( O& e5 o7 B4 y
cout<<"请输入学习样本数据\n";
3 ]\" T @1 U$ r/ o+ T
{
0 m+ X; r: U! K% e/ Y5 O4 h
for (int m=0;m<N;m++)8 n6 h9 I6 n& H7 w2 n
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
\" [, [0 B1 q5 n7 L
for (int i=0;i<IN;i++)
\" {. j0 w1 @( D/ T# @7 ~
cin>>Study_Data[m]->input[i];
* ^ Y- |4 H# v F4 F m
}
3 u- @ F O7 ~
{
( ?! E6 N2 S1 Q2 }
for (int m=0;m<N;m++); d' n( N% |/ Q\" x8 l$ v
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
% d) {; w4 h# v A/ P. U! c
for (int k=0;k<ON;k++)
, ]* w7 \, H' Q
cin>>Study_Data[m]->teach[k];
0 s. h) F3 P# X, q/ @3 \; C
}
4 Q$ S; f- c' x
initial(); //隐层、输出层权、阈值初始化 (1) ( ~, J: r* r& k8 a. _
do* ?; [& O4 N4 l
{
# z; m0 A' _' ^$ S3 G7 ]
++study; ///???
4 ?# [1 r, v: K
for (int m=0;m<N;m++)
- {7 F' Q; p) U0 L- { K9 ]( c3 U1 \
{
2 Z5 T: I& g8 W
input_P(m); //输入第m个学习样本 (2)
\" ^9 p% G% y1 s; C- |: y
input_T(m);//输入第m个样本的教师信号 (3)
1 o- Z& `' F4 F R J1 r
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)& M. f: n6 |4 d, {/ u
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
7 ~/ J* Y/ J6 a% D* `
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
$ ~& s& r6 v5 k0 N
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)+ l4 D/ k2 i4 ]; E( _* {, j8 T
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
* U, ?% v; w+ W( S) o( h. j\" s4 c' z
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
# N4 a% I; v; g
} //全部样本训练完毕
% x\" x3 E, U* Z# \
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
b/ V) s7 C) Z3 j: ?
{
% s, F# l3 q- g9 f8 U* f6 Y9 |
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
\" X; K4 n8 i% l
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);% t8 x F) Y& u& n
}
! [% Q% O a5 x: T
while (sum_err > Pre_error) //or(study
4 Q. [9 f7 z: Z+ I& g* \$ y! [. W6 G
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
5 |5 f$ y7 M0 E) b, S
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
7 F* T8 e# a0 r4 E( U$ o. U
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err); H8 [, b) E9 k9 s D- h
fclose(fp);1 q; [/ A0 _1 K, s. `
}
9 ]\" o* [/ n) P/ h8 s
char s;: L$ a' G6 @* D
cout<<"请随便输入一个字符，按回车退出程序！\n";0 g, {$ v( h4 ]! {1 |# K/ |3 m
cin>>s;% _$ K% Y& n1 g! k
return 1;
9 r5 T! V+ b% _1 T; K. T
}
. w, T, {1 U4 t- k$ D
# z4 Q- i) |6 I2 m