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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
3 V; q2 Q3 k2 |6 O% x( O
#include "iomanip.h"$ ]3 A: `\" \3 J7 \5 l7 J
#define N 20 //学习样本个数
; ]/ N' g1 `$ e- \) \
#define IN 1 //输入层神经元数目: U. g) m0 F: [) m
#define HN 8 //隐层神经元数目/ w. U5 d- V9 x2 b4 R' W e
#define ON 1 //输出层神经元数目% P/ D5 n. D8 r
double P[IN]; //单个样本输入数据/ X8 } K w7 P2 B! f\" r) a- ~+ O
double T[ON]; //单个样本教师数据
7 x( j+ p7 z( x- ~, d
double W[HN][IN]; //输入层至隐层权值0 y( k, n- z' q( @3 H' O& K7 z\" u
double V[ON][HN]; //隐层至输出层权值
: a& s, i8 u A! T/ E
double X[HN]; //隐层的输入( K1 F. w( K! O
double Y[ON]; //输出层的输入' a$ T2 p( j; k- s
double H[HN]; //隐层的输出
3 D4 L4 U+ ?( R* l' ~
double O[ON]; //输出层的输出
% F' N. g: F! E( I2 X9 z
double sita[HN]; //隐层的阈值0 ?& [4 d0 I- [5 I# j g6 l
double gama[ON]; //输出层的阈值
! S/ k1 F8 P; F/ E; |
double err_m[N]; //第m个样本的总误差- \/ @. x; M4 l. |8 H
double alpha; //输出层至隐层的学习效率
! _' d' c! Y\" `) H
double beta; //隐层至输入层学习效率
\" o9 m c$ H+ t1 l
//定义一个放学习样本的结构
% r$ ?. G, C% J) S: N, e. c) E
struct {2 H7 ?5 ~- E* E\" o\" m& [
double input[IN];$ z, G& {( d/ s, z3 T
double teach[ON];
+ j7 W/ u, A9 @
}Study_Data[N][IN];% p# c7 b' p. A4 b C. D( p- \) y
; Y+ q7 v* s. J- [\" m
///////////////////////////
( O% O Q2 D7 l' E
//初始化权、阈值子程序/////
9 y+ I/ Z) R/ T% p7 | F8 b2 D1 H
///////////////////////////
+ K R\" X( H* u
initial()
c4 K\" A& k+ U# M\" {
{: J8 P/ s, O9 L0 c; W' `: s
float sgn;
0 l, j9 h\" A$ _+ [ U& A) [; M
float rnd;: n% ?8 P6 l( M9 X4 F\" i3 z\" a+ ~
int i,j;
I0 E0 ^' y+ \& d+ P. t
//隐层权、阈值初始化//- q. y- V& g% w7 c7 I
{7 m, X) Q( f$ p! i8 g4 c8 m- U5 u
//sgn=pow((-1),random(100));
. {8 m3 x; ^1 I* o4 F( U
sgn=rand(); A# l$ f* }5 L' K6 J
rnd=sgn*(rand()%100);& C2 q\" Q\" `: q, p5 P
W[j][i]= rnd/100;//隐层权值初始化。) m6 \9 K! {: r5 {4 _/ O2 d
}
( Z+ R+ ?6 E( V8 w+ {
//randomize();3 ^$ v: o7 S+ \
{( Z0 e4 M' v+ N/ h5 O( r* v7 D- ?
//sgn=pow((-1),random(1000));
2 f& C' H/ `! \\" @
sgn=rand();
& ?+ K8 g& i2 U+ c7 x; }9 P/ q; V/ G4 |
rnd=sgn*(rand()%1000);* H2 `' `3 u7 d7 l8 r/ b# N
sita[j]= rnd/1000;//中间层阈值初始化- X% f1 y: Z; v\" l& R
cout<<"sita"<<sita[j]<<endl;
5 v: a, T4 j8 ^* y/ k' W! \
}7 @5 x+ C) k2 \* _\" q\" s
//输出层权、阈值初始化//2 c# k& B J+ ]! }7 a
//randomize();1 f% a4 W% w+ _5 _
for (int k=0;k<ON;k++): x/ w' q m* ?. z: L; |
for (int j=0;j<HN;j++) % h. ]$ e& v\" @- q4 \. ?# k
{/ u+ p6 C4 y& _2 k e
//sgn=pow((-1),random(1000));* e' w8 s1 }0 y8 b$ n
sgn=rand();
1 m; I, L8 s! J) f0 T+ G1 [
rnd=sgn*(rand()%1000);
- K+ N! Y8 [+ m1 G/ y+ [. ^
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
9 }/ u0 o5 ~* h! e
}. a' T7 p# Q/ m8 d( [! j
//randomize();$ c. R+ b( V( M; k+ V1 z
{( ` C2 B/ N. o- M; K
//sgn=pow((-1),random(10));
, T* _3 u) q% b
sgn=rand();
/ R. o- O7 Y/ ?& M\" `2 h
rnd=sgn*(rand()%10);! @3 n5 T4 `5 `; w
gama[k]=rnd/10;//输出层阈值初始化& H0 G: [ C+ ]( d7 F6 X) W
cout<<"gama[k]"<<endl;( K c9 p. ?0 ^. u0 V1 G4 u
}
\" T1 F- F2 x% b
return 1;
5 I- }, Y; H- p4 N+ V
; j! J; I, S6 C2 a& h& z) U
}//子程序initial()结束# O* A8 i0 p2 B% n+ x
2 [- H5 C\" M3 L9 h! k* @- a
////////////////////////////////2 N/ P9 q6 [' F\" t* Z, j
////第m个学习样本输入子程序///4 f5 e6 S7 b3 _! M% ^- _6 q
/////////////////////////////// h8 ]% E: D! _% d
input_P(int m)
1 s\" y- I; T3 Y& S+ k
{1 F& z6 ^4 w1 r5 j; x
for (int i=0;i<IN;i++)
\" V9 F\" r7 M\" l. f3 a7 r
P[i]=Study_Data[m]->input[i];' [! _2 U; Q E- c* K6 L6 H
//获得第m个样本的数据
8 X& P) A$ S3 N
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
) _9 |; N6 ^% T# F* e\" g
//P[%d]=%f\n",m,P[i]);
, L) W\" h+ E& d1 x, d\" E
return 1;
\" `# w% \# C4 p$ |2 d: J
}//子程序input_P(m）结束$ T6 E/ h9 ?3 v' u) D$ L: B3 g( {
/////////////////////////////
+ e% X- S- P9 O5 U; i9 V
////第m个样本教师信号子程序//4 z6 i! l! L7 e) m. R% b
/////////////////////////////
* M; D3 u\" U' c. X
input_T(int m), ]5 U* _5 {' C+ I6 E# ?5 c
{
8 a$ N$ o1 n. D9 y& E* [2 p) V
for (int k=0;k<m;k++)
: b; E( h% K5 M3 }, |
T[k]=Study_Data[m]->teach[k];
/ `# p+ P- o1 l; u5 A1 u
//cout<<"第"< //
8 R6 S# ` q9 z6 {! g% I2 L
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);- K, _; C+ K |1 h+ @' o2 G
return 1;% F1 Y/ f& o2 B8 t# X/ @$ g
}//子程序input_T(m)结束
9 V7 b0 \9 f! G1 f# @' D( N
/////////////////////////////////. Y& E, V# U7 s8 Y( r& O
//隐层各单元输入、输出值子程序///
5 {( _9 ]: d& W3 @2 b( y/ f! X$ ~5 |+ g
/////////////////////////////////( Z! o/ `$ _( g0 o* |3 t
H_I_O(){
% |) p; U' a\" h
double sigma;) j' Y; R\" L# p* [, v
int i,j;
2 Q* Q! [- P5 R) h( s! w w% Y
for (j=0;j<HN;j++)
6 [) h7 ?9 y( F, }; \
sigma=0.0;+ O1 y2 N+ A0 E. y% m& I S
for (i=0;i<IN;i++)
0 ^+ V- W9 z, s9 K, F# |0 Y
sigma+=W[j][i]*P[i];//求隐层内积
1 n) B% }$ h% f a
}, q! Q* T) p9 S\" L2 W
X[j]=sigma - sita[i];//求隐层净输入: {( J# H; ~% @. d: l+ J' t; k
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出5 I+ N; }. c' M5 R9 V( W; f
}- ]8 \1 i0 Y+ f# c/ s4 m
return 1;0 y\" ^* i! x0 C\" g1 u# D0 u5 d% ~
}//子程序H_I_O()结束
7 i7 Z( A( Q6 j- K5 U) l
///////////////////////////////////6 p# m/ m7 b9 w/ R. [
//输出层各单元输入、输出值子程序///
$ G\" [( j1 \8 |
/////////////////////////////////// ]% Y6 D( S, |5 u9 a
O_I_O(), |9 V- g9 d3 _9 x
{
! t1 F8 }, q6 F S9 w
double sigma;8 u+ i' H$ ^3 m
for (int k=0;k<ON;k++)
4 `! b0 A' D. s: p. A. D+ B. F
sigma=0.0;2 P1 p\" O* C% K. x/ S; d\" y% r# z
for (int j=0;j<HN;j++)% B# V+ x7 ?) w+ c+ w
sigma+=V[k][j]*H[k];//求输出层内积0 p# V, x/ `3 z5 ]
}8 h, U' K) W2 `$ }# V$ T
Y[k]=sigma-gama[k]; //求输出层净输入) e- A& S y' {9 y
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
& N0 Y6 K! Q' T, W4 p3 ?3 ], V9 W
}; M& U8 Q* g, ^! P$ n4 j# }' i
return 1;
& `8 U$ }( s\" k3 @4 H' k# X
}//子程序O_I_O()结束, T, b, `. P! m( S4 n) d
////////////////////////////////////
! e0 Q7 a9 [% N2 r e1 Z- R- a3 ^
//输出层至隐层的一般化误差子程序////
, w6 F* G7 v! E' B% G3 d\" G+ n
////////////////////////////////////
1 F4 I5 h3 x6 [5 s2 W' N2 @
double d_err[ON];2 v: ]. L- m7 M* {
Err_O_H(int m)4 I8 U, C5 `3 e; d; c
{! ^- n* A+ C% I; s! N0 P# j
double abs_err[ON];//每个样本的绝对误差都是从0开始的
; t. B/ ^5 ^7 ^2 d% e0 p7 q0 z
double sqr_err=0;//每个样本的平方误差计算都是从0开始的1 i ^- T! T' n5 s X3 }
//for (int output=0;output<ON;output++) //output???
\" F2 e9 o5 [: [+ R
for (int k=0;k<ON;k++)
n( Z% K( y- ?! F5 I* h4 O
abs_err[k]=T[k]-O[k];
$ o( N Z+ t( q\" T2 H
//求第m个样本下的第k个神经元的绝对误差
' J$ J8 v+ |% Q6 Z
sqr_err+=(abs_err[k])*(abs_err[k]);9 I7 J! ^. b g! r
//求第m个样本下输出层的平方误差% d7 p7 S\" _7 p
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
' \& X/ C9 r1 n3 b0 L* |6 K
//d_err[k]输出层各神经元的一般化误差% W& }$ @1 T& t+ n5 k _4 v5 i
}0 M8 H: |& ?' B3 }+ F
err_m[m]=sqr_err/2;+ V) B: d( z# q: \8 P, }- ]
//第m个样本下输出层的平方误差/2=第m个样本的均方误差) S; |8 ?* C' e, H- l _4 W
return 1;
$ C) @! j Z7 H9 ~# ]8 s% t6 @\" F
}//子程序Err_O_H(m)结束! P, `& r\" y* T
////////////////////////////////////
$ i W* z3 r, k) ]
//隐层至输入层的一般化误差子程序////
r' _5 x, l$ ]
////////////////////////////////////
# j+ S% {5 P+ q! _; ~
double e_err[HN];5 R2 z) ?: R\" b' `) i5 Z1 ~# @
Err_H_I(){- Q. r( J% {3 H
double sigma;. w0 N- G) [% H3 l1 W- z& U
//for (int hidden=0;hidden- @) Z) C, o6 @0 m# s J* i5 T8 |% x8 [
for (int j=0;j<HN;j++) ! d3 ]( g2 d1 A h& V
sigma=0.0;
8 I( m8 G* P) g* `
for (int k=0;k<ON;k++) 6 ~$ n\" D1 t\" K5 V6 t
sigma=d_err[k]*V[k][j];3 E\" ?! h& Z7 O+ |5 D
}' U9 P! H. ]% H2 n$ T1 {4 Q z
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
! N$ l: u6 t( J& i6 V% P: @
}$ {7 c9 H- l, t9 K4 ]+ j6 P J# u
return 1;
. I% m7 c8 Y3 F$ C, E
}//子程序Err_H_I()结束\" B4 E8 t! E( L
////////////////////////////////////////////////////////! R4 a* u/ u2 O\" K
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
# D* X9 k: ~+ T- V
////////////////////////////////////////////////////////- t3 r2 Z1 _/ i- L0 S' A
Delta_O_H(int m,FILE* fp)
7 Y& i) C7 M0 G' W% R, c
{
8 ]1 W! D% g/ [! d- C9 U1 v
for (int k=0;k<ON;k++)
( d; X) Q+ V- y5 k$ e! i# Z
for (int j=0;j<HN;j++)
, N, |! F' r( o. v. X\" F
//cout<<"第"<
0 X9 ]* z/ [9 o+ F
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);6 l. W6 L/ \9 d9 ~1 @0 ~
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整7 z' y2 c7 W6 ]' z$ [- ~6 P% {
}4 P0 u. \% l; J, W6 ]: W+ z
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
# r! X- x+ e M) J! g
}
5 H9 R. `. |6 a
return 1;/ {: a G# R. J: T
}//子程序Delta_O_H()结束
2 s4 e( [8 P+ i! ]\" u: r+ v
/////////////////////////////////////////////////////+ @# q' U* u0 c( [+ G. O
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////# v* L+ A/ @6 J- [' [
/////////////////////////////////////////////////////4 J: s H5 A: ` S+ _! W& v& e& A- p
Delta_H_I(int m,FILE* fp)
\" r/ l' ^6 }5 J
{) {% @! `7 j; w
for (int j=0;j<HN;j++)
% K( B/ E& k8 ~
for (int i=0;i<IN;i++) & C9 t9 q; e& d1 ^0 k
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]); U! |% {; ^3 `4 x\" K
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
5 S4 y; c# Y2 m! ]* ^. ]- Z
}/ ]% B$ U, q! Y6 H% n8 ?2 a- Q
sita[j]+=beta*e_err[j];
9 O N0 z& L2 L9 Y; ]
}
8 s) K. ]- |- T2 b* s' i% Q! u
return 1;
1 l) k& ^/ u\" a4 t4 m6 B
}//子程序Delta_H_I()结束
\" O1 X: q. @! _1 m9 ]. A8 M/ O
/////////////////////////////////- a% ]' M# j$ u! k0 `: Q- G, ]; P
//N个样本的全局误差计算子程序////( ] w, B3 P7 g0 T4 n
////////////////////////////////// F9 U! Y+ G# A8 W, x3 w
double Err_Sum()
* w( ^' N5 c. H% _. O/ U; O8 U& r
{, x/ |- v4 A3 ?7 i& J$ D! o8 _
double total_err=0;
+ e9 O, ^6 b8 `5 q) r) }
for (int m=0;m<N;m++) ! y7 S3 o4 Q( t2 C' ]4 [
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差% v* M% @/ j. b# z# h
}
, G\" P& u {2 N( Y( W
return 1;5 `, s2 W9 i+ X. @
}//子程序Err_sum()结束
4 D' u( L8 J3 H, [, b: |: R5 ~
/**********************/* c! Q' `- A' V3 f\" q' T\" }
/**程序入口，即主程序**/
# t8 E/ R3 X; t3 Z
/**********************/1 H5 L/ N& _% p# q$ l
main()
4 v/ z! c# F% u% u. _3 K
{
4 e2 J/ {5 z+ J# Q9 a
FILE *fp;9 n+ C) x* c3 U; J2 D* o* k* O
double sum_err;$ i# r+ q* V; f' @0 K
int study;//训练次数
+ U! v) U0 ~6 L- C
if ((fp=fopen("bp.txt","a+"))==NULL), H/ p5 r$ `% G; B5 R8 y0 Q
{7 m: [# i& H+ I( w+ s3 O
printf("不能创建bp.txt文件!\n");
M9 m, o\" B L9 d( j% P
exit(1);5 w% ~- g5 e' ^. W. X
}1 j7 O4 f% g/ i5 F
cout<<"请输入输出层到隐含层学习效率: alpha=\n";7 \\" y8 k, H& Z2 @
cin>>alpha;
/ X a7 B/ n7 N2 Q& r
cout<<"请输入隐含层到输入层学习效率: beta=\n";
7 h. z+ B+ Z5 B6 Z
cin>>beta;
2 l. t! g7 ^7 Z\" i
int study=0; //学习次数
\" S& y4 J. | Y
double Pre_error ; //预定误差6 P% x- V& A. I/ p! g2 v3 |. `
cout<<"请输入预定误差: Pre_error= \n";/ `4 i; U1 h9 `/ C# v( s1 V: u
cin>>Pre_error;
; o% A6 H4 S$ k5 d7 X
int Pre_times;, n\" i8 Q! {% a
cout<<"请输入预定最大学习次数:Pre_times=\n";; q, m& l P7 T6 V
cin>>Pre_times;
, N: [ a6 H' Z; e x
cout<<"请输入学习样本数据\n";
P6 h9 R\" |+ Y9 K+ g5 g
{
& F: u* R$ X- P) l* s S/ {' X/ Q
for (int m=0;m<N;m++)
* Z; C0 |) E8 t. t0 D
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
% X. m5 A$ }- C9 [\" U% z: [
for (int i=0;i<IN;i++)
\" r\" u' \\" a1 r2 m
cin>>Study_Data[m]->input[i];
( o4 N% k- o, t8 U/ o9 T1 U
}
$ ^$ \& q& H& F9 \$ G0 \
{ 8 x R7 [ E; Z, F. f
for (int m=0;m<N;m++)& w2 ?& r; C8 a
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
6 x; a+ F8 U/ L+ C& s: }
for (int k=0;k<ON;k++)
/ L: Q# s; x, Z( l; J4 b
cin>>Study_Data[m]->teach[k];
9 ?8 r, z' a3 Q1 _8 Y
}
: ~ W* M1 o$ m) J4 B% {4 V9 _! O( O
initial(); //隐层、输出层权、阈值初始化 (1) + y4 e- a* `- o9 C7 k W' Q
do' c: o* ]' u: q
{
. q( S0 f8 x; |7 u4 F2 f
++study; ///???
* c! H* D) m( Q\" Y. U9 V0 ` g
for (int m=0;m<N;m++)
9 X6 k! b7 N t/ U+ a
{& W. i2 Y9 b3 c8 N: g
input_P(m); //输入第m个学习样本 (2)2 e% j% E) q4 M+ z
input_T(m);//输入第m个样本的教师信号 (3)
6 l3 W, y+ o, s1 g* E. L: \5 o
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
\" M$ y' I5 u. @. U6 X: t
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) ) v) j3 @' W( a' ] `3 I
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
+ H\" p2 g/ H6 n8 ^% g
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
: R2 y w! S1 I\" ^9 j
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9), O& _. x. K* B8 H! g' f$ V
} //全部样本训练完毕
' X: ]8 o( p/ K+ z8 J( I
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
# f5 b, [1 p$ ?: `/ C* F& y
{
, _, k: ?' W T* u1 Z6 Y& U
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;% E' i' f6 U1 e# K+ Z; ]
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);/ c) l, }0 m4 d
}
( t! Q* I1 T\" D1 H2 T
while (sum_err > Pre_error) //or(study
/ E3 ? {. R, D) ?1 O( N
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
\" `$ U, ^' O. w4 Z8 `
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
$ I+ }: W+ k8 [4 q, o& q) g! X5 {
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
\" [8 D3 J% C+ H* l* u* T
fclose(fp);$ O2 c! u6 {* x: B. C5 {+ H
}
/ @' h S A. T/ @: _5 v/ p) M1 G
char s;
' T3 a, ~% h# @
cout<<"请随便输入一个字符，按回车退出程序！\n";
& m) q# I' @0 Z+ H7 H k
cin>>s;7 u% L- }* i Q4 N, U- h
return 1; G$ c4 e; E! K4 F; _8 d3 |& s
}
/ P& x% d6 V6 M9 ]
q( p\" s) F) m* ?