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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
! T5 H9 s6 R! U3 W
#include "iomanip.h"( @4 ` i4 s) @: N8 s) O
#define N 20 //学习样本个数+ B+ |* ?& ?+ w2 r4 R\" u# S% Z
#define IN 1 //输入层神经元数目& s1 C1 ]) E8 G' b/ a) ~( |( H
#define HN 8 //隐层神经元数目2 j2 r) y! E, X. |
#define ON 1 //输出层神经元数目4 a P2 k& e8 T, `
double P[IN]; //单个样本输入数据) e# f+ }$ ~2 v\" e: I% S. ^
double T[ON]; //单个样本教师数据
0 w6 ~8 o$ f/ b* U
double W[HN][IN]; //输入层至隐层权值9 K& @- N5 l9 k. r2 k- `9 U- @
double V[ON][HN]; //隐层至输出层权值
6 k& _6 K+ V3 D! a+ N
double X[HN]; //隐层的输入& q$ |+ Q* w: u6 L( y7 J( o
double Y[ON]; //输出层的输入$ K; }' o, Y; a1 L7 M
double H[HN]; //隐层的输出
1 r7 L- ~, \0 W1 W' K
double O[ON]; //输出层的输出. M5 F: Z9 t8 B$ |: d\" P+ D
double sita[HN]; //隐层的阈值* ^% K$ u1 U4 P5 ]7 T/ I, o+ F
double gama[ON]; //输出层的阈值
7 V `+ v3 E7 x! T; T
double err_m[N]; //第m个样本的总误差
6 B* y% } U7 ?5 p
double alpha; //输出层至隐层的学习效率
* s+ i X1 }) q
double beta; //隐层至输入层学习效率
# }& G& g$ P, j
//定义一个放学习样本的结构
5 q3 e# @- D- \
struct {1 v; R$ `) z. b. F
double input[IN];
: u0 H\" d4 E6 c, e2 H
double teach[ON];# Y5 r2 K' n; r Z; z: [' ~: ]8 |4 M
}Study_Data[N][IN];
5 @, M5 E# D& R/ E
' q% Y5 c( {1 F& Y6 X- ]1 f
///////////////////////////
. V; c1 |. s5 H2 W# u/ ~' W& u
//初始化权、阈值子程序/////
& k8 G6 k4 r5 d
///////////////////////////- t+ Y( m: g; F# R
initial()
% c. n5 h% e0 f4 S0 K
{
: c- F$ J! V5 C( h! N( P0 I
float sgn;9 f. @1 j- B& X# N. u3 [. k
float rnd;5 j8 E8 r! [. e3 K/ I, I) L
int i,j;9 Y, i' z5 z5 ] w
//隐层权、阈值初始化//
# g9 K; y- f& z* I$ A0 |& H2 D' R8 Z
{
) a( |% k# J0 W, I) f% H
//sgn=pow((-1),random(100));
7 o9 U2 E9 w7 u, d9 }$ x) u: C
sgn=rand();
% x/ C% I/ J! F5 t9 M9 P
rnd=sgn*(rand()%100);
* ^. U, e) Q, y, l
W[j][i]= rnd/100;//隐层权值初始化。- \8 O5 j; ~% Y- C; C3 J
}
+ { G$ ^/ ^5 G3 ?' \
//randomize();, `) I9 `* ^9 D! n- m$ n\" p$ }
{
, q4 s, e, s$ X
//sgn=pow((-1),random(1000));
7 Z8 P: p# X& s. M5 [3 p+ `) J
sgn=rand();
- |- v! P8 s# B5 s6 B, G0 s
rnd=sgn*(rand()%1000);$ i, v# `6 r5 h9 K9 z
sita[j]= rnd/1000;//中间层阈值初始化
: z ]\" _5 ^6 {# i; a
cout<<"sita"<<sita[j]<<endl;( K& K3 G8 a6 z3 @& i
}5 ]/ x. `+ [7 Z; G, Q
//输出层权、阈值初始化//
/ [4 h2 F& k1 [5 f5 f
//randomize();
6 {( a8 t! P# P+ t
for (int k=0;k<ON;k++) z! J( J0 i8 Y\" g# ~$ {
for (int j=0;j<HN;j++) ) L, Z( H( K4 q( h! z) w
{
: L/ s7 l6 M, P
//sgn=pow((-1),random(1000));
! A2 t: w, |\" l
sgn=rand();; p$ P1 L' F. M- q
rnd=sgn*(rand()%1000);8 ]* m, x! [9 K$ x/ c4 U
V[k][j]=rnd/1000;//第m个样本输出层权值初始化* B* C9 o6 I% P) f7 K$ u: n
}
- }' E: r5 R3 S9 e; Z( X
//randomize();+ n, K0 {, S) h( `3 W# ]! f. O7 F# m
{
: Z. }5 _( U- L( ?% H! E: c
//sgn=pow((-1),random(10));
. G, \+ E\" o6 {
sgn=rand();
p\" O4 v7 E, }! u8 d$ O
rnd=sgn*(rand()%10);
0 r) y, _+ H4 S6 E) [) o
gama[k]=rnd/10;//输出层阈值初始化6 v. M, R! }3 @
cout<<"gama[k]"<<endl;
7 ^3 g/ Z3 F* _* a
}
( R# L) p8 b9 g4 i& _- d
return 1;
. l! v9 F6 e5 Z6 h3 g1 y6 b+ P
* O, g, h# y\" i7 ^' K# g
}//子程序initial()结束8 a4 P, L3 i' b9 j% M' B7 M5 z
* S5 l; Z/ k' N1 c
////////////////////////////////$ U6 w8 ?- g4 D! A: c# \) @$ `; E
////第m个学习样本输入子程序///
\" h! e6 i; l! _3 K& Y
///////////////////////////////% k9 f4 n# D2 K. \6 X
input_P(int m)
- Q0 y5 [- n7 |- ~1 }
{3 a' ^+ x( M5 f; H; B, X8 m/ I
for (int i=0;i<IN;i++)' ?' K9 d; h; K7 X7 S2 r5 ~* `; b
P[i]=Study_Data[m]->input[i];
q: y; O3 E* z; h6 B
//获得第m个样本的数据
( \2 b' @1 r2 X& r1 i
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：3 N8 p& ? w\" C( Z' e# \% O
//P[%d]=%f\n",m,P[i]);( d' u) G) r* i2 p# J
return 1;
* K% L) i6 }4 e. U8 l
}//子程序input_P(m）结束
; r9 A2 x5 g, T7 T) d0 z
/////////////////////////////+ t5 ?% Q: T+ c! {2 P- L4 X. `
////第m个样本教师信号子程序//
2 a5 \6 J/ O+ R, f
/////////////////////////////
. |; b. A' o) W7 P) r( h
input_T(int m)
6 O3 w# l* y3 J% t5 h
{\" k5 w- X\" _9 t' L9 l3 E
for (int k=0;k<m;k++)+ V% e( N6 P0 r+ U4 S
T[k]=Study_Data[m]->teach[k];( |9 w1 N- N& g( g# N\" T
//cout<<"第"< //
$ ^5 [) a: N+ J$ u3 j z K$ @$ q
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
9 O- K. ~. T0 l* F* R+ P: x
return 1;/ Z% Z: W4 g; L& y
}//子程序input_T(m)结束4 u\" S, \1 U/ W. M4 c+ q, o
/////////////////////////////////3 }! a3 I\" `# x
//隐层各单元输入、输出值子程序///
7 k- P. ?. h. J: {3 m- O, z
/////////////////////////////////
& Y& b4 P6 F( W4 H l
H_I_O(){
8 p0 x; m1 E$ E% ~5 j
double sigma;
. @0 a; O' t\" V
int i,j;; y' O% u* k6 j. g
for (j=0;j<HN;j++)
8 }( S3 `7 x. h1 N
sigma=0.0;
: q! B* [3 O3 I5 w/ [
for (i=0;i<IN;i++)$ K9 z\" ?- E3 E9 d( d4 o
sigma+=W[j][i]*P[i];//求隐层内积
( a/ Z4 Q$ Q\" I/ |. v2 P# ]
}
+ U( h( ?' d6 g& f' l
X[j]=sigma - sita[i];//求隐层净输入 q' ?0 _8 C4 b+ z3 i& T3 m( d
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出7 u( ]& I- O' \& B( n
}
. s7 `7 x; Y4 A. k& ]0 K+ k# M/ d
return 1;( t1 T/ i3 o$ J6 i4 c* [/ y
}//子程序H_I_O()结束
+ e5 i: x5 i$ |7 \
///////////////////////////////////
{: |9 @! U0 T
//输出层各单元输入、输出值子程序///+ n( ~$ }6 X& V
///////////////////////////////////
! X& k! ^4 ~+ O; O6 z3 y! L9 ^
O_I_O(): h& K* D. B7 }' p
{% l) s, e4 E, X0 _
double sigma;0 M+ p, U% O; x
for (int k=0;k<ON;k++)
9 ?3 @/ B: S3 E# e
sigma=0.0;
% E\" C- C! ?4 w& \/ X/ [, v/ k: A
for (int j=0;j<HN;j++)4 b! N E) g9 q3 l
sigma+=V[k][j]*H[k];//求输出层内积
, ]3 \# }1 ]) T9 [
}
4 J2 b7 R1 p1 X: G7 f4 a
Y[k]=sigma-gama[k]; //求输出层净输入
- p- w6 n8 a, R) F
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出& O# X2 m- a, o4 [! y
}
\" E& ? C& a& E' k* ~: k
return 1;$ g- H7 x1 E- D' X. ], P, a
}//子程序O_I_O()结束
& [' \. m6 f. l( [, Z% j2 O
////////////////////////////////////
\" H: S) S9 X# C1 m' q0 H* F
//输出层至隐层的一般化误差子程序////
8 F/ @+ u; B7 W- X- C
////////////////////////////////////
1 e b: v5 T7 g% h% R
double d_err[ON];5 B$ J* P `5 S: J
Err_O_H(int m)
8 l1 x9 X$ U0 b5 p( R: m9 a
{
K3 ~- M\" d1 P
double abs_err[ON];//每个样本的绝对误差都是从0开始的: H' \' w; {\" e+ K9 u, D
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
1 e4 R M V\" c3 d
//for (int output=0;output<ON;output++) //output???
! j) n\" S- M' r$ `8 s
for (int k=0;k<ON;k++)
5 m, {\" {% y, [# q- h. ^: M, x
abs_err[k]=T[k]-O[k];4 T\" x& }* R, A
//求第m个样本下的第k个神经元的绝对误差4 e) _% x, E3 ?; R
sqr_err+=(abs_err[k])*(abs_err[k]);
# Y4 G9 I& q; p( v, u; q
//求第m个样本下输出层的平方误差4 e! a; B1 p2 ^8 ?1 Q; x
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
, w0 q3 ?6 M6 u% ~
//d_err[k]输出层各神经元的一般化误差
2 [; q3 ?: I! s5 v
}4 x% A3 `0 ~/ |\" F6 j; E( |
err_m[m]=sqr_err/2;2 `# X\" K P1 M4 @% `, L
//第m个样本下输出层的平方误差/2=第m个样本的均方误差1 `. h# O7 m- \ ]$ r
return 1;
$ }\" J* ?- O7 {+ l- V
}//子程序Err_O_H(m)结束
% _\" d% p) R1 `! Q9 Q
////////////////////////////////////. e; p4 e' j$ z3 b+ [
//隐层至输入层的一般化误差子程序//// p3 j* V+ F9 T7 v
////////////////////////////////////8 G: D1 f( {+ A) |8 L! R
double e_err[HN];5 M3 |0 f, K0 |3 W4 _
Err_H_I(){
) B/ Q: b. | ?* y% o, B
double sigma;; o* Y. n$ Q( U7 B( h4 J
//for (int hidden=0;hidden
9 U- s9 B/ F# Y' p) z
for (int j=0;j<HN;j++) & S8 o' e' I! O# ~3 h% g
sigma=0.0;2 V' \# S- G: `1 {: s$ H: I, a3 P
for (int k=0;k<ON;k++)
5 c\" }$ M) n& R z. t
sigma=d_err[k]*V[k][j];! Q/ ~% k( x2 d, C$ }4 x
}& E( F/ p4 V0 W: x
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
0 J: g! t U! S$ y
}
: l\" i# U0 y2 _3 z4 _, ]
return 1;+ A4 e+ T* H4 g3 A! j' x4 C
}//子程序Err_H_I()结束
* s' t: p5 [$ J% m$ O. J2 Y% o+ X$ Z
////////////////////////////////////////////////////////
; i$ z6 v2 ^) m; _\" W
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
* s% Q% Y& ^* m: }
////////////////////////////////////////////////////////, f: ~5 l! d( ^% R& w5 U$ Z
Delta_O_H(int m,FILE* fp)
. V. f0 u& Y* V4 F% u. |2 g
{) u. \5 T$ A\" c! M
for (int k=0;k<ON;k++)% B# E\" x) K R/ ?
for (int j=0;j<HN;j++): [8 I/ k$ V) n- {
//cout<<"第"<
9 ~+ o; ?6 i2 W& I0 m' [4 l
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
1 `9 Z% w: P, s+ Q\" V5 B
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
! a+ Y, } L2 ^8 E+ J# y
}
\ g1 z3 B' z
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整8 c% c4 J. n2 N, I
}
/ Q% h2 V. i; H1 ~2 R
return 1;
( S/ {2 ?+ ^, r) H
}//子程序Delta_O_H()结束+ ?$ v: C' ?3 J2 r7 W Q+ X
///////////////////////////////////////////////////// `. t$ s4 P8 q9 G8 I
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////2 H j0 \$ C8 V2 B
/////////////////////////////////////////////////////7 r0 m7 s\" b; e* U# z* x- @4 w
Delta_H_I(int m,FILE* fp)
& T- s e( ~9 `7 n; B
{
3 X4 Z( I$ P1 {- Q
for (int j=0;j<HN;j++)
) e' z: L6 K5 f2 V7 D3 ~3 ?+ d, u
for (int i=0;i<IN;i++)
0 m3 K, p/ g. C, w, L, \1 b
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);9 U\" i! j. i6 v( {6 h: j
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整4 S( {9 {8 K! h* A! ^( ^4 X$ x
}9 v) ^$ E' C: O5 Y; b
sita[j]+=beta*e_err[j];1 s5 E1 }( J, u0 W& f! c& ^, [\" i
}9 R& _; g# k8 E x( y9 \0 k9 b, I
return 1;6 L9 V% O) K0 S* c1 r( N. A; y8 J
}//子程序Delta_H_I()结束) A\" Z, H3 A9 d\" }6 b
/////////////////////////////////9 _% T$ q% ]' U* y0 P\" P1 j
//N个样本的全局误差计算子程序////
; [* t) Q/ g5 n3 A2 P' m0 n
/////////////////////////////////; y2 A; \2 K2 x0 \; I4 u% k
double Err_Sum(). j u* e+ j8 ~
{/ v% B. e2 N+ K+ ~8 b
double total_err=0;4 d& p8 f- ? o2 \* f$ Y' u
for (int m=0;m<N;m++)
6 |: B2 a2 K6 S4 q0 Z
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
# `+ V/ U3 w- C5 P\" N- y5 J
}+ D2 E- G7 [\" c9 P8 V8 Q
return 1;0 @& H$ [3 J1 f. N
}//子程序Err_sum()结束
5 |) i# E! z0 ~/ [, k( w0 f, H
/**********************/% ]* k- h3 v* q9 H& E
/**程序入口，即主程序**/
- | p' D5 I- L6 x; F
/**********************/
0 x: b! t2 }& y( A1 b1 Z7 R* l; X: R
main()
' {# g; v; Y% |) W' q
{
) Q+ n3 f& M0 N( n8 e) P/ ]. `7 i
FILE *fp;! }2 N; ]3 N5 J F* M7 j
double sum_err;# m; _/ h$ _7 {& j6 k
int study;//训练次数. w' |0 Q( T; T% W1 C
if ((fp=fopen("bp.txt","a+"))==NULL)9 [0 }. t1 a' ~
{
* f% L. k\" o+ c
printf("不能创建bp.txt文件!\n");0 f/ U$ W# s; U- r/ \
exit(1);
e$ O2 J6 b c) y6 G
}3 v8 I. Z\" t9 R* N
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
d$ O7 ~7 A. j9 w6 U
cin>>alpha;
* q% `) X% d: e* V+ u$ V' P5 v+ J
cout<<"请输入隐含层到输入层学习效率: beta=\n";
3 H. f6 t+ c# X% Z% q7 O \
cin>>beta;
! q5 N2 ]2 u; O, r' T- Y
int study=0; //学习次数\" ?5 @3 R G! i: B/ @
double Pre_error ; //预定误差
7 w# J% ^- y7 J4 Z& ^
cout<<"请输入预定误差: Pre_error= \n"; w8 q5 Y6 }8 O# T3 T
cin>>Pre_error;
* ^$ v2 X8 r# O/ `6 A$ U
int Pre_times;
5 Z( ], K7 |2 I. \
cout<<"请输入预定最大学习次数:Pre_times=\n";
+ M# P5 F. A\" ^. _
cin>>Pre_times;\" z; T6 j) S ?! l
cout<<"请输入学习样本数据\n";
3 h! Z9 ?$ x% }; p
{
) g2 L) [9 R- d- ~% d
for (int m=0;m<N;m++)4 w* |+ S( H+ r* u/ R6 J
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; & j2 B* S% H1 P+ I
for (int i=0;i<IN;i++)7 h+ M$ N0 V {
cin>>Study_Data[m]->input[i];0 p9 @9 U# G9 i\" R1 F9 R\" F
}
4 E, S$ ?) s5 M, ?3 A C
{ ( {9 c7 M% U1 D8 ~ n
for (int m=0;m<N;m++)* V6 T4 s1 }4 t }( c R
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
8 J! [- y+ V1 H+ _9 A
for (int k=0;k<ON;k++)/ M( B% @9 ~* T7 {! J\" S& w9 M& P
cin>>Study_Data[m]->teach[k];
7 d: J7 A/ g) V/ k+ r
}9 V/ Y; W\" D( F' y' \* O( f
initial(); //隐层、输出层权、阈值初始化 (1) / Q7 U1 P1 K# s. W% z
do
% y% w4 r5 v1 s+ e7 V% }
{$ E) o; g# `\" ]! S4 L, z$ W5 Y
++study; ///???8 X/ ?; z* I r0 P1 {6 Q# T
for (int m=0;m<N;m++)
! ?1 S0 u$ Y1 n, W- v' f+ f
{5 X6 Y( R6 B: L7 g3 v3 @
input_P(m); //输入第m个学习样本 (2) e9 D- k: a! S7 t
input_T(m);//输入第m个样本的教师信号 (3)3 ]. ]$ M8 ~3 J7 n4 F% [0 L& k C/ ]
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
( y8 {* e0 Y+ V) d$ c1 E
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
, w6 |; e\" X% v\" _+ _) E* S
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) # w1 t& i( F# h
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
}! e% }( z/ r! M. V
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)$ q! I. `% S& C5 B# \# Q9 \' i
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)' h; C% l9 w; j5 Y9 w8 }
} //全部样本训练完毕
8 e: w% D |* ^& ^: l4 O' b7 x
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
$ c\" B7 Z+ i, U; s( N
{
+ G+ h7 E1 e8 A* h/ L- e
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;3 e, j# s, ~' c) I\" v; h: ]) Z/ r
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
, \) D5 f( ~7 Y* `
}4 A. d1 E. {6 O2 _; ^& m
while (sum_err > Pre_error) //or(study; T, a. O* D2 S
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
7 Y: l' m5 g# s
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;\" F, z X: D5 f E
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);: v% O& t\" D& \& K
fclose(fp);\" |6 p( O* J\" T' l! _1 G
}4 J Q% c* Y- ^& P
char s;& t* E# d; Y# Y, |- {
cout<<"请随便输入一个字符，按回车退出程序！\n";$ p2 q\" f/ K! P u; r0 @
cin>>s;
& t) e \; u# a! y/ Q; G( g
return 1;: r5 o# K* L+ q- o
}; [% j% Q$ k* y# P
( t& K& F\" S! F' ~\" z