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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"9 z# c3 {/ ]1 p3 N5 ^# [) a
#include "iomanip.h"- p8 r* d' ~& D. o8 {
#define N 20 //学习样本个数
- R) ?& w# h! e8 `% `5 n( n\" @! n; j
#define IN 1 //输入层神经元数目\" y3 Y! ]5 a# B( M\" B- b
#define HN 8 //隐层神经元数目
Y+ k# b- {; n0 ?* S. ]
#define ON 1 //输出层神经元数目8 s) q4 ?\" a8 S2 i
double P[IN]; //单个样本输入数据; V1 M0 l. V) ^8 `# h1 i! C X\" S2 C! d
double T[ON]; //单个样本教师数据
0 R* g5 o7 j- w- B\" e9 q! ~5 T
double W[HN][IN]; //输入层至隐层权值
/ A\" e4 E* |( B9 x5 X2 l
double V[ON][HN]; //隐层至输出层权值
$ y Z4 h6 d) u
double X[HN]; //隐层的输入\" d5 H: d8 M: u$ Y; |4 l- w
double Y[ON]; //输出层的输入
7 X! V S1 M: _+ T. [
double H[HN]; //隐层的输出
* \& Q5 q* f+ e( H3 s$ @3 m
double O[ON]; //输出层的输出
% y* W8 q4 j\" r: [( l* `
double sita[HN]; //隐层的阈值
$ L! J5 u v; Z! a
double gama[ON]; //输出层的阈值
\" w, B4 }6 L# G9 F* Y' x
double err_m[N]; //第m个样本的总误差
/ E' ]' I* h6 [\" o' O
double alpha; //输出层至隐层的学习效率\" b4 Q' _$ n\" k1 J7 Q, a$ B. T
double beta; //隐层至输入层学习效率- f4 f6 w7 q. ]8 |
//定义一个放学习样本的结构
* p6 U( M+ U\" B; g- a- x1 _5 b
struct {; |( a! w* x2 t, J% a; s( x' f. B
double input[IN];
3 C; d6 k- {* ?: E U1 e, t7 d+ C- ?
double teach[ON];4 g6 A* o E5 n
}Study_Data[N][IN];; e5 d% S. n, ?- j* x; a
) P0 I( S( }7 V! W! J
///////////////////////////
/ q0 [7 e [1 l% ?) p
//初始化权、阈值子程序/////# D3 v4 ?7 ~' o: G2 a( ?/ Z
///////////////////////////$ i, v9 z' A2 d7 n9 f9 E/ ?/ i
initial()
{
; i' E1 f# G5 N0 O5 b
float sgn;; z# T# z/ U) b s) S' Q7 Z( E! R
float rnd;
$ }/ v# ~\" b' z$ q, u
int i,j;; J+ F9 o$ A! e
//隐层权、阈值初始化//
* y3 Z) q+ N: k ? G
{: v, F5 `# J1 S3 c\" m7 R
//sgn=pow((-1),random(100));1 |* x) Z9 _. @5 Q
sgn=rand();
/ C' O# h3 _3 X5 c1 d5 n
rnd=sgn*(rand()%100);
\" F6 ?: P& S: d
W[j][i]= rnd/100;//隐层权值初始化。
/ ?- f D8 }! g1 u' i- P) ?
}
# m1 t9 e# j% M9 _
//randomize();4 h8 v' t' i, l6 p* Y! s5 K
{
' E1 Z4 \4 _. ]* \' _; L& F0 c
//sgn=pow((-1),random(1000));4 C0 S$ Y1 s; d3 `
sgn=rand();
5 {# X& t* Y$ @+ k: C8 E8 f* f
rnd=sgn*(rand()%1000);
% f `: b! i, _
sita[j]= rnd/1000;//中间层阈值初始化
1 ~7 U\" p) `% e
cout<<"sita"<<sita[j]<<endl;7 _5 a: f6 T: k0 I5 V
}9 w' U9 ]! N4 O% |) Z! {2 r: k7 \
//输出层权、阈值初始化//# w$ t5 L1 D9 ~: q' z. I
//randomize();5 j: R$ v: p3 T: N5 O8 U D* T5 F
for (int k=0;k<ON;k++)
, [) @3 r7 F8 Z2 f/ |
for (int j=0;j<HN;j++) . i* j* D+ e2 I5 [! a1 p
{
: y/ v; {: E# c; k) w* e
//sgn=pow((-1),random(1000));
$ ?. J9 _/ [/ e! h8 J- `$ c* b% Q
sgn=rand();
) x/ o' `$ d) c' l) M4 ^5 k4 W
rnd=sgn*(rand()%1000);1 T, L) M0 ^: w; d8 I! E
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
. v3 }# i# W% Q- k
}' F( ~/ @* p\" ]& `
//randomize();
9 H! k1 R, \* H
{5 E7 y! V; J' L, v
//sgn=pow((-1),random(10));/ v# A8 e- q. X) M+ Z
sgn=rand();! S; b. E4 k* {1 w9 l) `- i
rnd=sgn*(rand()%10);# `1 U\" _6 |7 P4 |9 U: }5 D( n& E, {
gama[k]=rnd/10;//输出层阈值初始化. A+ ?/ w) g( U) {3 N3 J
cout<<"gama[k]"<<endl;* s# x4 u+ U$ G: R t+ n
}
- M) u1 ~/ q ^& E, T
return 1;3 H; c- b6 Z* w
# T2 T. q# m! x% i7 V
}//子程序initial()结束$ {7 J# I0 r0 M! I* |1 E0 K
6 ] X. I7 j5 [8 {\" u5 I. N\" |
////////////////////////////////4 c7 c6 f0 ?. e K7 H
////第m个学习样本输入子程序///
% S) v+ h0 E, x
///////////////////////////////1 y8 s\" L. A% q9 U/ J
input_P(int m): C1 K1 f' a9 O% Z) ]6 G! w+ D
{
9 l$ j+ w. ?0 E& q. J1 r
for (int i=0;i<IN;i++)
1 w+ {* u, v' ~8 V7 R2 O
P[i]=Study_Data[m]->input[i];
' M- u7 |# }. Y2 q) F' b$ n
//获得第m个样本的数据
* q0 F. U9 R' ~
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：# _- W: w2 x' L
//P[%d]=%f\n",m,P[i]);
\" B0 y\" ^3 E1 Y D
return 1;
1 r: `5 `4 p8 J; h( D$ M* v
}//子程序input_P(m）结束
4 l' T1 L' p/ L; Q
/////////////////////////////
6 U% e4 o6 {\" _\" ?
////第m个样本教师信号子程序//4 t\" w. H4 Y) l
/////////////////////////////3 a0 z& f$ o+ c1 U# P; y
input_T(int m)
$ a6 I) \0 l s- t2 X: J4 p9 [\" s
{, o& E4 r, H) _3 t' a, f0 b
for (int k=0;k<m;k++)
4 U) \. ^' [( l/ _9 |+ p: S. a
T[k]=Study_Data[m]->teach[k];
& `7 K* ~. @\" p! A$ W$ W+ k
//cout<<"第"< /// Y7 M8 n; C' v
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
0 S3 b3 u2 C9 Y5 |. b\" R
return 1;
; }3 m6 D2 q$ V8 I J/ E, j
}//子程序input_T(m)结束$ n& _! _( N+ K
/////////////////////////////////5 U* v. x$ n, i& r( w! P
//隐层各单元输入、输出值子程序///. l3 {$ O. e% `( c1 Q- N# K# e
/////////////////////////////////
, ?0 @* f, m' _% X7 j5 J3 L
H_I_O(){/ P' z5 l9 O, ^8 p8 Z. R
double sigma;
2 T: y3 ]. n3 s
int i,j;
/ T: R! b# E% Y4 s+ i/ k7 N! T
for (j=0;j<HN;j++)
# d% H* }, D/ y3 U' j& j
sigma=0.0;
1 H- g$ L% p3 S$ ?& p
for (i=0;i<IN;i++)0 E- t$ r/ j1 g0 e- v
sigma+=W[j][i]*P[i];//求隐层内积
3 V' s; l3 B3 m+ O2 S$ W) m3 N
}7 c0 g3 r3 {$ n2 p4 W
X[j]=sigma - sita[i];//求隐层净输入
) ?) ]9 z5 }$ F- _
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出0 ]0 R+ J; ]( x
}
\" l* V! P7 v$ f- t& q
return 1;
; q2 Z3 R3 P+ H, S. n: c) B1 k3 n4 L
}//子程序H_I_O()结束
, }8 M1 v# _6 z* G\" F
///////////////////////////////////
4 j& A( y# @$ Q2 b& _4 W7 J( L- {
//输出层各单元输入、输出值子程序///
8 `7 W1 h1 h: w$ }; N( a
///////////////////////////////////
. X5 H$ R$ L8 i' a1 W
O_I_O()
- k2 W9 j) v! v- i# T* r
{
3 L& R- j# y: D9 p O3 D! [1 Q' ^
double sigma;
6 c1 U9 c! F& d
for (int k=0;k<ON;k++)9 Z2 D5 d% Y7 l\" ]8 C
sigma=0.0;% I$ E7 d# d% V
for (int j=0;j<HN;j++)& ^. g; \, ^\" s2 ?
sigma+=V[k][j]*H[k];//求输出层内积; i, B9 V9 s6 t& O
}
4 M: Z0 X0 y# J$ A, d
Y[k]=sigma-gama[k]; //求输出层净输入
8 O4 R9 P; G# y) N# ?$ Q
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
. j/ T7 m& G& d! \5 I. j, N
}8 k0 H% q: q( S6 K3 H5 N4 {5 J
return 1;% F1 K3 j# \2 y$ o+ P+ \4 D
}//子程序O_I_O()结束
5 J, x& _: A$ q. H B* t1 j: O6 }
////////////////////////////////////
$ D8 ]0 Y1 ]6 s& \) F/ n3 v, H
//输出层至隐层的一般化误差子程序////3 w% ]/ v- ?/ \
////////////////////////////////////
' D9 z# M& ]9 X& D3 g\" S: u
double d_err[ON];
, |5 V0 s P& Y; ^' `! {3 s
Err_O_H(int m)) S' O' G: U+ I3 N' g% Q; L+ l
{\" `' U- e; r* {$ n0 J5 `6 j$ [
double abs_err[ON];//每个样本的绝对误差都是从0开始的# e5 v1 f) [. C; g( W) Y
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
* q2 r/ D$ l# C# B# @* r+ A
//for (int output=0;output<ON;output++) //output???
9 f+ O\" l2 V' t4 O+ d
for (int k=0;k<ON;k++)) f: f' o& r N. [! _& M
abs_err[k]=T[k]-O[k];. m) d* U! j2 @5 N9 A- C/ D
//求第m个样本下的第k个神经元的绝对误差
6 K* V+ p5 I7 E) d
sqr_err+=(abs_err[k])*(abs_err[k]);\" K7 q. v/ D# b. |9 W7 S
//求第m个样本下输出层的平方误差
6 E: ~0 J* ~/ Y3 |; ?
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]); \. k9 N a* A p) x
//d_err[k]输出层各神经元的一般化误差3 q% V! x. k0 Y# \ U0 E* a* s' J
}
: q2 q* ?$ w; d, ^
err_m[m]=sqr_err/2;
2 L9 U( Q1 P) l; e) O8 \! E
//第m个样本下输出层的平方误差/2=第m个样本的均方误差# j) i, ]. v0 \2 [0 \3 }/ |8 G
return 1;
1 t! B$ k* ?, n! e
}//子程序Err_O_H(m)结束( {' `. f& U. }/ r
////////////////////////////////////
1 A1 _' H7 f' K R
//隐层至输入层的一般化误差子程序////4 Y+ }( q6 l1 D5 V
////////////////////////////////////
1 U* m# {+ B8 |
double e_err[HN];
: d: e# e& B$ b+ w2 p! p
Err_H_I(){9 o: j0 i: d, w3 R6 w6 ]
double sigma;
+ }& J* ]1 F) t
//for (int hidden=0;hidden( O( ?' z/ c0 J
for (int j=0;j<HN;j++) # p& w7 j1 ?7 I5 \7 k. u
sigma=0.0;: b) g% S% b% t4 K/ w4 D3 S
for (int k=0;k<ON;k++) & G9 O0 G% C6 a+ M4 a% M% a+ ~
sigma=d_err[k]*V[k][j];
) |$ I\" K# @ m\" U* C) b3 X
}0 r7 F5 o& J& k& I9 c6 m: q8 A
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
- x+ x' c S$ O. y) O! S2 J
}( Q0 P$ T9 z5 B* N- U& P: ^- {
return 1;
\" l: a1 `0 K, J. ]% L
}//子程序Err_H_I()结束
1 f7 l+ r# n: Y! x0 i5 B5 _, H
////////////////////////////////////////////////////////1 B$ U% W A& P& n( v1 Z
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////2 |* ?& n4 b$ U3 ? Q9 ~\" y$ i
////////////////////////////////////////////////////////* U) Y8 [& c' N! Y
Delta_O_H(int m,FILE* fp): _* T V: }& J. d c; b; }
{
1 S& i+ y- J\" i8 g\" G\" T
for (int k=0;k<ON;k++)
( s( k& U, n9 c7 o$ v2 z1 I
for (int j=0;j<HN;j++)
% P2 U t, L. T1 b5 V\" O
//cout<<"第"<
7 o! \; \) o# e+ B8 a
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
9 R# S, H7 p4 a: g: l, @5 d6 `7 p; _
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
( I( t4 ^% g- H# K% |) A
}
& E0 v3 z: `. }$ H/ ?3 M
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整9 U7 } u' A7 W
}
Q7 q. q- K! _' Z4 f
return 1;
% @: z# ?, S/ d: V1 j: b7 b
}//子程序Delta_O_H()结束' X2 u\" I; @4 _5 q q
/////////////////////////////////////////////////////
# e- m* b! R' s9 z+ X0 t6 m
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
, D/ {6 z8 `+ V
/////////////////////////////////////////////////////
& O% T+ j, ^5 U: V A
Delta_H_I(int m,FILE* fp)6 V+ U& o) ?& [- z
{
6 H' ], ]5 z6 l! U
for (int j=0;j<HN;j++)\" D$ y! s( g' N% v; `- {9 {
for (int i=0;i<IN;i++)
4 g' X, w9 U) z% P* I8 c) B
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);9 U% `& Q# `8 {2 P5 F+ P
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整2 L/ k+ P5 E0 Q8 p* u; b
}
+ c( _' J( c0 X* b. F
sita[j]+=beta*e_err[j];
& V$ e0 N: r1 L' T8 S3 p4 x# v$ Y
}
; j! | ?\" U; [. H0 W- G
return 1;; K$ I) k\" y; W
}//子程序Delta_H_I()结束
4 |: z& v, P6 B9 S& M
////////////////////////////////// p3 N& o) _# A* f
//N个样本的全局误差计算子程序////
6 T- |% u8 e3 g2 S5 \7 E6 ^
/////////////////////////////////. R5 U4 l3 h, I. l8 R
double Err_Sum()
* [3 f7 p- n4 E% K
{; ~! w5 C\" U: [+ ~6 [' H
double total_err=0;' d0 m' S9 Y% e
for (int m=0;m<N;m++)
, P4 i7 z- a4 ?* v% g- L' R' J4 y3 T
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差0 P6 Q0 N7 Y: S' N
}0 H) _& o4 J4 l* f
return 1;
\" s' C/ @$ J# O( R/ j3 d) e
}//子程序Err_sum()结束+ ~3 }$ q& I# l/ \: u' m\" v+ x
/**********************/! t1 p/ K4 \9 S$ k3 x
/**程序入口，即主程序**/# ?6 W& ?' U- c) w: r' ~) y: o! L\" C3 W
/**********************/8 I a\" l8 ?/ o0 E
main()3 S! K\" A+ Y+ G/ Q$ Y
{2 N: d, N4 t _: P0 U7 H9 _
FILE *fp;* ?* b/ v\" z' W& O1 Y
double sum_err;8 w3 n* g- f1 d1 s+ U
int study;//训练次数( S* N$ N/ Y1 _2 x
if ((fp=fopen("bp.txt","a+"))==NULL)
# U6 g4 `3 j5 `$ q; I& g: q% k1 t
{
5 A, b% U9 l# a6 f1 ~% i
printf("不能创建bp.txt文件!\n");. g9 y7 I3 @5 Q( o4 o- |
exit(1);
! x# ^3 a' Z! X ~1 j
}# F; U6 l5 i. C9 y# Z
cout<<"请输入输出层到隐含层学习效率: alpha=\n";8 {. _ U U s
cin>>alpha;: j+ r2 j8 g! i# g+ I
cout<<"请输入隐含层到输入层学习效率: beta=\n";
6 j) ?, l\" v2 u2 q
cin>>beta;
) E. m4 b0 N* M: C4 J4 A3 o) p' n
int study=0; //学习次数5 {5 y% \, a. m4 ]
double Pre_error ; //预定误差) I- }6 t; A' ]) D2 ?! c% J
cout<<"请输入预定误差: Pre_error= \n";7 F. Q5 G! E1 Q
cin>>Pre_error;
, @4 Q$ C% D6 Q# S: Q
int Pre_times;
& A\" k2 E, p8 g
cout<<"请输入预定最大学习次数:Pre_times=\n";
; Z4 L5 J) ?; Q5 s
cin>>Pre_times;1 I\" P9 \4 \0 E e5 X
cout<<"请输入学习样本数据\n";% e# O1 A. s2 ?% D& N0 O: {
{, s4 G0 X: K& x4 |7 ?
for (int m=0;m<N;m++)
! V$ S, {9 K6 ?! u9 Y
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
3 C- _; i( r `. C4 N1 k
for (int i=0;i<IN;i++)\" Z4 E u- k$ [1 o! [' p
cin>>Study_Data[m]->input[i];
4 f2 q/ A8 R& t. x* F: `# V9 s
}; |, P8 f6 ^0 V) ]; p6 w% {
{ - z; U# _2 K, P* Z
for (int m=0;m<N;m++)! ]6 ]2 T\" s8 X3 U# `% X
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
, B' O4 ]3 H6 R4 ` S4 ]( [
for (int k=0;k<ON;k++)/ \$ Y7 Z W. m
cin>>Study_Data[m]->teach[k];/ N6 h, d$ X/ y1 A5 W
}2 h( U- R2 C L) I
initial(); //隐层、输出层权、阈值初始化 (1)
# Q5 p: ?* H- C$ v
do0 f9 \6 a9 f2 `: I/ Q
{# c, P4 j: G1 z\" R/ A3 Z
++study; ///???' G1 U. S i8 A8 I/ ^
for (int m=0;m<N;m++) % \' U9 I. q# G* p5 e! }\" `
{: A9 Z\" L7 g+ @
input_P(m); //输入第m个学习样本 (2)
% U3 N* I( {8 t: n2 p, o# ]
input_T(m);//输入第m个样本的教师信号 (3)7 S0 G0 G/ J% V$ D4 O0 H, N; Z
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
9 m$ v F( w# b( N0 E9 w9 e1 `
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)3 c, T% k' [+ r( o% }
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) & Y' r/ W8 ` V2 p/ q
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7), y* P' M6 C8 A# _( y
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
( U9 ]0 b2 |( w: l
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
' B4 ?- B7 c4 \# A& P4 u; m! N
} //全部样本训练完毕: |& ~* F8 G+ [/ G
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
# l1 x3 g' n0 o1 ]6 X
{
6 i' {5 m% d0 s# I C0 l
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
( I6 W; @. m5 Y7 {$ S! ^
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);; W' s! N& ^. t8 r, r$ Q7 q
}
% T8 D5 G3 F z( o* X4 z
while (sum_err > Pre_error) //or(study1 A7 O' d\" P) |, e* ~
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
6 ?* h$ c4 \- u
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
& [8 `! M& u: |& d! E( G
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
( E1 ^9 A; M7 |/ N2 x6 A
fclose(fp);+ X: L# O# ~) r
}- I* r) r- n; M' b# _& N3 I
char s;& M% M) I. ?+ U( I! q
cout<<"请随便输入一个字符，按回车退出程序！\n";+ X& D5 X+ U2 S+ T: ?
cin>>s;
^- H X* x' a. z
return 1;. H\" Z5 T8 l* T0 `2 i; h3 G
}
0 x$ U9 s' I/ {9 o6 L* l1 \3 j
, s$ i/ l0 _9 G; h* E