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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
: L5 O1 m0 g+ ~/ N' O9 T
#include "iomanip.h"
5 E8 @/ _\" @; s3 Q3 P9 e$ z
#define N 20 //学习样本个数
/ k* `+ [' L7 E% \5 l, E
#define IN 1 //输入层神经元数目
& {# T# Q0 K/ @! D8 P
#define HN 8 //隐层神经元数目
}# h2 @: x% p) Y! O7 o/ |
#define ON 1 //输出层神经元数目( Y; n% S, ?, b
double P[IN]; //单个样本输入数据
1 d1 K: m) f( ^$ n/ p z
double T[ON]; //单个样本教师数据
9 h$ h& ^8 m2 o. g
double W[HN][IN]; //输入层至隐层权值' z0 S2 G1 o& I K3 I
double V[ON][HN]; //隐层至输出层权值# X% D; W+ m3 {; Y, R* n8 D( \
double X[HN]; //隐层的输入, ]& V. o3 `; g\" S( B+ [ Q
double Y[ON]; //输出层的输入
9 @9 E6 t. |8 @& I
double H[HN]; //隐层的输出
# Z, Y# u$ J' j
double O[ON]; //输出层的输出
9 Z/ A$ A& _# F- _. T1 ^
double sita[HN]; //隐层的阈值3 E, ]3 o) l1 S$ d4 }& D
double gama[ON]; //输出层的阈值
+ q5 s- @ j4 u: Y
double err_m[N]; //第m个样本的总误差3 p1 z; q' a: {- ]
double alpha; //输出层至隐层的学习效率% }' R# [- D\" H; ]& A, ]% w: Z
double beta; //隐层至输入层学习效率
' }6 v/ ?# E$ a; T( a; a
//定义一个放学习样本的结构
7 ~6 r5 s6 b' f: a# f$ [& U+ i
struct {
: ~% h! F- b* E, X5 I! g- Y
double input[IN];! K F8 A\" q3 e
double teach[ON];6 x7 q9 G# }3 D/ x\" f
}Study_Data[N][IN];
# ?8 ?+ C\" R7 f3 U) q; _: \# @
& K/ d% k4 S) x6 `3 R
///////////////////////////: j \: g7 r: C0 O8 |
//初始化权、阈值子程序/////0 w; d\" p4 J! c G
///////////////////////////5 U& @1 E' N' q$ R( [ z
initial()) }9 v; ]0 `! S$ K' R, Y
{! T( ?+ f: F* R
float sgn;. }\" D# _! J6 \
float rnd;: ~3 r# X1 M7 r6 q1 r
int i,j;
, _ O' s( A2 _! w
//隐层权、阈值初始化//
# L( B/ z: h1 `8 _
{
4 s( U6 @% S; l3 w6 \
//sgn=pow((-1),random(100));
5 }% A/ ` t/ d0 ^\" j3 ?
sgn=rand();
rnd=sgn*(rand()%100);3 |: T9 P3 H+ H0 j* r* g; v- w
W[j][i]= rnd/100;//隐层权值初始化。
* u- \* c3 ~3 V, ~. `7 R! H- Q$ |
}) |: u9 f, g) E7 @/ X+ g
//randomize();
0 I7 v+ ? }$ e3 I& p: g8 F
{5 K, ?7 y& \8 B- _, e U4 @
//sgn=pow((-1),random(1000));
) y7 Z9 u1 ]) r& I1 B' i6 d0 m6 f
sgn=rand();
% x2 M1 |( [- ~2 D- Q) P
rnd=sgn*(rand()%1000);
4 W! p1 d8 w: J0 J; J
sita[j]= rnd/1000;//中间层阈值初始化
: n8 V1 L$ p# ?7 x- ?/ D
cout<<"sita"<<sita[j]<<endl;
4 r! U9 H8 \# \) i f) B
}
7 {* R$ |8 _3 E' A
//输出层权、阈值初始化//
$ v+ w5 @, c1 b6 e! J6 V% E
//randomize();
9 S; T$ [+ }' @/ ~# T
for (int k=0;k<ON;k++)
7 ~- w$ N) M7 Y5 p4 G
for (int j=0;j<HN;j++) ' [0 n1 u* A: ~# r! I1 g
{( O5 u9 s9 }4 r% Q) }7 D
//sgn=pow((-1),random(1000));6 z8 M+ G+ k' B/ c7 C
sgn=rand();
$ b) k- B, f- d\" G
rnd=sgn*(rand()%1000);
3 f1 x6 N3 c! z% I* ?
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
( i6 o7 P2 ?' G! S- `# }, E# E$ b
}( }( c0 @2 m4 C6 i- P' M/ b
//randomize();
, Z% I/ O) l% |1 b
{
* a7 N8 z8 E% d7 W
//sgn=pow((-1),random(10));
; @+ G; v- W8 `
sgn=rand();' D' J1 I, P7 p: t7 O, T! @; U
rnd=sgn*(rand()%10);
. g7 D. A& n6 _9 F
gama[k]=rnd/10;//输出层阈值初始化 O+ L7 d# q; e0 h8 d) C6 o! @
cout<<"gama[k]"<<endl;
4 U+ Y# r2 V* K% O* q& J
}# {+ ]1 G# n\" @ g, j; P9 l5 w6 {
return 1;9 c! ~/ t4 E$ m1 n! U1 R) b
3 B- k4 I F$ b9 h8 i8 Q9 d8 i
}//子程序initial()结束- L4 ~$ k1 i2 c3 @. N, u/ n3 m& b
( W( w p, e0 l* v4 W2 y
////////////////////////////////5 ]0 P- {9 X& r+ ?( U. y\" N( X8 Q ?
////第m个学习样本输入子程序///& s' P0 _2 `8 r# w# [7 E4 u. V2 u
///////////////////////////////, ?$ O m% Z$ @* v1 s1 i8 r' f/ P
input_P(int m)0 t2 ^8 m7 b: ^0 J! `& J. i4 F4 V) |
{# w4 n2 F% u; g* O
for (int i=0;i<IN;i++); X. O: k+ n5 p! c; t+ s
P[i]=Study_Data[m]->input[i];
6 y8 F- U\" M3 O! { r! C
//获得第m个样本的数据7 R; `- Y4 `: l. b0 {5 R8 s6 t) a0 k* p
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
9 W. k3 v, p0 a1 z: H& O
//P[%d]=%f\n",m,P[i]);
! u8 F4 J4 w# G\" ~
return 1;
. I0 X5 r! r4 i* X
}//子程序input_P(m）结束* f; @- F2 _ `$ @
/////////////////////////////
2 B2 k, z- S6 q7 {3 L
////第m个样本教师信号子程序//7 d% z8 _, Z% i
/////////////////////////////2 G$ G& J/ w/ ]& g2 D- A. H; s
input_T(int m)+ J, t% s1 i3 \$ C\" ?, `, g& {
{3 \% k# k4 }7 a8 h6 U
for (int k=0;k<m;k++)
( i- s, h- O! a& ?. i N7 k0 X
T[k]=Study_Data[m]->teach[k];. E7 M2 g: ]* o+ o$ {
//cout<<"第"< //
\" R( X; S M# n7 i J
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
1 W3 X: ^$ K4 |) a K
return 1;
) c1 W3 G& n. o/ ~+ l
}//子程序input_T(m)结束
\" u\" N4 X9 O# n% Z: K8 V$ y
/////////////////////////////////& C8 L9 i( W$ v6 @; S7 \ r
//隐层各单元输入、输出值子程序///
& q3 E' Q( h( t' d; Z# [0 d
////////////////////////////////// [7 z' l* X7 f\" l3 v\" P8 [, @
H_I_O(){
8 _+ q; m5 b2 v$ i% Q3 X2 w, r
double sigma;7 M1 n/ V7 G! O) [\" n: S
int i,j;- y1 W8 F+ g# S: L' k/ i, k. a
for (j=0;j<HN;j++)
9 x7 F8 D( @* u0 K
sigma=0.0;
+ A# G6 X# G D' k! u% z
for (i=0;i<IN;i++)2 @7 |% B% s( {' e# y3 G
sigma+=W[j][i]*P[i];//求隐层内积, E+ C2 C' }1 y# x8 _* L: H9 f3 D+ b
}
2 S5 W6 P- K! D8 s6 S5 i! g( x
X[j]=sigma - sita[i];//求隐层净输入
7 u) x8 p. d$ v3 f) Y* b
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
% j- R5 [4 _3 Z4 z
}* M& d0 Q: `3 W. ^, S\" W
return 1;
9 L5 h1 H* Y5 \
}//子程序H_I_O()结束
, | j% `: _) t- w8 `5 N! q% ^
///////////////////////////////////2 x( U5 t8 Q( X; E
//输出层各单元输入、输出值子程序///# N! x* G, o( w/ u
///////////////////////////////////1 i$ r% A% W. g
O_I_O()7 X0 H+ F/ D4 d, M1 G
{
. q8 G2 s6 R5 N* i
double sigma;' Q\" o' y. \& I1 H+ m
for (int k=0;k<ON;k++)! b* ^2 t6 y) `% W }/ _
sigma=0.0;
. f4 z' t/ V5 n# ? Q9 l* R
for (int j=0;j<HN;j++)
2 L* L6 Q- y# a
sigma+=V[k][j]*H[k];//求输出层内积/ S\" c: P# v L0 Y1 _$ `
}
0 x' F0 i: A% d
Y[k]=sigma-gama[k]; //求输出层净输入
) k% w. N: h( D( C; F\" L
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
( Y7 l3 D G) l; g8 c9 W
}
6 t& S6 u, `% g3 N( `4 m
return 1;* `6 }( u G. s% W( n: x
}//子程序O_I_O()结束 D/ q% ^\" l4 ]7 U5 X% S. M
////////////////////////////////////
5 q1 j. T0 |- M' p3 }- s% D+ S. b
//输出层至隐层的一般化误差子程序////
2 B1 `+ j* R% a3 t. ?
////////////////////////////////////( V' l1 v& p2 e\" D, L) P { W v
double d_err[ON];
! B4 s! A6 ~5 Q\" @/ H: B% Z
Err_O_H(int m)
# o0 S; z* k\" N4 w7 R. R x$ Y
{
$ K. L) u; B! A# c* L
double abs_err[ON];//每个样本的绝对误差都是从0开始的
, w1 B' `\" Q9 b$ e9 w% y# G7 o
double sqr_err=0;//每个样本的平方误差计算都是从0开始的 B1 E( Y6 Q& a: N
//for (int output=0;output<ON;output++) //output???& w S7 e( A. O, ?* w& T; g4 O\" g
for (int k=0;k<ON;k++)
; L A7 }4 ?5 h' ^' ^7 w! t) i
abs_err[k]=T[k]-O[k];8 S1 u- g6 D: M
//求第m个样本下的第k个神经元的绝对误差2 P6 c/ Y; `- o7 j! u
sqr_err+=(abs_err[k])*(abs_err[k]);
4 L2 e8 i% g5 g, s; w9 j2 m
//求第m个样本下输出层的平方误差
6 z/ e$ ~, T/ H5 Z\" {8 l# d
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
7 }' W8 S+ j/ i% C\" V! R
//d_err[k]输出层各神经元的一般化误差 ~* `) M) s5 W. h6 o
} J. X( i1 H) T0 x
err_m[m]=sqr_err/2;
+ d2 Q6 q! e. I6 v$ T
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
& `' a2 ^: ^! P; Y: N' z
return 1;
) y: u: C6 Y0 b* n7 c
}//子程序Err_O_H(m)结束
. ^- C, L- G6 F# [+ V/ g, L
////////////////////////////////////1 b1 g; G$ f& }. x9 h/ f
//隐层至输入层的一般化误差子程序////% g7 E. g\" m. b7 C) y
////////////////////////////////////
\" a$ ~/ u$ K0 x8 M
double e_err[HN];
$ ], n. g, t7 L A9 [
Err_H_I(){
7 j2 q0 q' l2 e1 ^+ @$ Y
double sigma;* Q8 d6 m9 e* d+ q
//for (int hidden=0;hidden
1 y' p( L p+ \# w
for (int j=0;j<HN;j++)
\" U$ v7 N8 i9 _% ~, _! p# n% T# h. G
sigma=0.0;$ }+ A8 C9 H3 @* s+ }
for (int k=0;k<ON;k++) 7 W1 y( H* I5 Z4 m4 L5 y- t' d
sigma=d_err[k]*V[k][j];1 X8 |3 ]* F, S$ c( u
}\" f9 l% m( G. }# H9 F
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差1 i: e\" a/ w7 d. b
}3 c% \( G+ |: a% C
return 1;
# d6 ?. x8 Y5 Z4 c1 U8 _
}//子程序Err_H_I()结束
/ R/ Z' h- u8 Q/ ]! M5 v8 A
////////////////////////////////////////////////////////
2 G+ ~' R/ I\" u6 t
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
) Z6 d+ e, B1 h
////////////////////////////////////////////////////////
5 a$ E. p2 R- n
Delta_O_H(int m,FILE* fp)9 y7 O2 E. J4 R9 t% ]: p) H
{4 {7 l# ^8 @8 c' @4 m. j
for (int k=0;k<ON;k++)( |* A* ~& f$ j: j
for (int j=0;j<HN;j++)
$ ^+ ]# y9 J `; ~ H: U
//cout<<"第"<
* H ]& D t4 L\" V* f; ]; L
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
4 j* a. }% r; z* O3 U8 ~) Y ^
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
' I r7 B9 ~# u3 C; R. C
}
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
! L8 m. g7 |6 |1 j/ ~- j7 m
}
& b/ _2 C7 `0 S# `1 C
return 1;
4 G7 Z/ n- e7 z/ P\" l
}//子程序Delta_O_H()结束
& b4 [3 T$ F* o
/////////////////////////////////////////////////////( ]5 F) _; [' x2 z+ S( y, H
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
% y1 O: p, P4 C( u+ k7 E
/////////////////////////////////////////////////////
: @8 |, D% f3 D5 A. `8 Y$ ~
Delta_H_I(int m,FILE* fp) \/ x) S! Q% _
{4 m: ]- y# N8 _2 ]% a( R
for (int j=0;j<HN;j++)
) c3 J( S0 F& `: R0 v6 i
for (int i=0;i<IN;i++) ' `3 p& n6 k: c+ {0 B1 ^
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
. N2 V2 C\" d' n$ \3 w: o
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整! k# Z# V3 Q: p9 ^! z
}
! y: B2 b6 [8 q- R& \7 }5 J
sita[j]+=beta*e_err[j];; j& F7 I\" {( b( A
}3 h\" L0 h( J, f9 n+ [/ V6 R1 V\" C
return 1;
+ s& ~5 x2 _3 ?+ u# Z% B( v) t5 \
}//子程序Delta_H_I()结束
: u L$ Z2 z' A
/////////////////////////////////
) L% f6 E1 |; X0 v+ w
//N个样本的全局误差计算子程序////3 R( K/ n8 c9 M* D1 {' C9 w
/////////////////////////////////
! o3 h\" m4 a+ V: [! ~% v6 V- f8 X
double Err_Sum()( t( V P1 a1 h, u- G3 i1 ]
{( J9 a7 M) e1 w1 p( Z5 |! a% b
double total_err=0;
0 H$ h8 r9 T+ b
for (int m=0;m<N;m++) 7 y4 S5 A. d _' u3 w9 i% ~9 i
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
) Z. z# ^$ f0 R. H& H- D
}
: [& x4 {. L1 [5 k7 r
return 1;
! T3 O& [; p E9 T
}//子程序Err_sum()结束\" D* Z) ^4 ?8 I ]
/**********************/
7 d\" J2 c1 ]. u' M9 D$ r/ D
/**程序入口，即主程序**/: w u j$ h3 y: s* R
/**********************/
6 ~8 y6 X% R2 `/ w0 {
main()
6 e( `& c3 A\" F2 K) |4 ]
{, M' s% l$ [$ O
FILE *fp;. _7 `3 c7 G; |
double sum_err;
1 Y2 C/ Q- b: {! c* E& n' u4 t0 J6 r
int study;//训练次数
* u4 U( ~! E1 l9 G+ f
if ((fp=fopen("bp.txt","a+"))==NULL)2 o' {* N5 F# }3 L
{& Y( ~% w& Q( Z- J
printf("不能创建bp.txt文件!\n");
7 e3 S7 U- I: q+ b9 t\" B
exit(1);
+ ^% w8 G- Q, p. N) c o$ N
}$ d) ~) {, _, }# D, o
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
& E* a\" W5 x8 g! p( a: I2 _' U
cin>>alpha;3 R8 G: S0 ?& `) O\" O
cout<<"请输入隐含层到输入层学习效率: beta=\n";& J7 V( d4 x! J$ W- E
cin>>beta;
' l, `! C: d. Y
int study=0; //学习次数7 e, B; j- _! G1 W2 T
double Pre_error ; //预定误差 c0 x2 K# F5 C2 x& v8 h5 V4 ?6 C
cout<<"请输入预定误差: Pre_error= \n";
4 Q1 A) B$ d# i6 k7 E8 K4 T
cin>>Pre_error; v- L% ]& W8 n6 K4 z h
int Pre_times;
3 v* k5 ~. o% B7 ^5 o' G
cout<<"请输入预定最大学习次数:Pre_times=\n";, ^, w/ z8 n( X) p
cin>>Pre_times;
/ e- p! a& h9 Y* T+ _
cout<<"请输入学习样本数据\n";
X' f5 Z# n: j. T6 C% J4 W3 c' ?
{
e5 }% m2 H: r: w( v0 z\" x% ?
for (int m=0;m<N;m++)
, v/ C( E9 S+ X) o7 p' m, E- t
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; ) @+ q4 h/ f3 W' l% [1 ]' r
for (int i=0;i<IN;i++)$ h2 B, M T9 @7 r
cin>>Study_Data[m]->input[i];
( m4 D+ T1 Y7 u7 C\" B1 m) B& _
}\" x$ B; ]0 P9 h4 s$ z
{
. [; D ^# i: ?8 [
for (int m=0;m<N;m++)
! B7 p, u1 Y7 S7 n, h
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; 9 _8 y& v5 P5 A9 D
for (int k=0;k<ON;k++)# o0 a2 c* m1 r, J; A4 ]6 [( N/ w- Q& D
cin>>Study_Data[m]->teach[k];\" W+ j6 q: b0 ]' U
}' l; v+ s2 P' `$ J
initial(); //隐层、输出层权、阈值初始化 (1)
# C! F! D$ |9 ?* }* T* ~
do8 V$ j, V0 J! b0 A
{
# S! s' t) d% U3 g l1 {
++study; ///???
5 p. S+ _* u( M% G: p: ` g' o
for (int m=0;m<N;m++) \" B( ~) c/ i5 j9 h% o
{
# m3 S8 a# O2 ]# ~* Z
input_P(m); //输入第m个学习样本 (2)( c! t, \/ i3 \9 s, m
input_T(m);//输入第m个样本的教师信号 (3): _3 Z, S; U1 w8 s( T$ U/ X
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)$ E5 S i2 L; y\" a4 T
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
! T8 G9 Q\" n+ d5 g+ Q
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) / R( c+ k% V3 n* O/ D1 N
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
( P: o. s) x+ F
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8) {9 h6 P% Y; L4 ]. Z
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)8 f1 P, X, u* i2 [, X
} //全部样本训练完毕1 U# ]$ ^4 T\" r
sum_err=Err_Sum(); //全部样本全局误差计算 (10)( V/ {$ e( S\" N) ]
{
+ P6 p7 h6 ?' T4 R3 [
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
! W5 C8 u1 ~( |5 F; @4 ~
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);. ? i a* x8 [1 Q+ b
}
# |6 c4 u+ D% @9 _/ l# M& b) B
while (sum_err > Pre_error) //or(study
3 J, N5 y H% Z* P' v8 P3 r& ]( B
{ //N个样本全局误差小于预定误差否？小于则退出 (11)' h, T- ^5 p6 q6 l4 k
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;6 \3 M* d8 Y8 Q3 K' S, F
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);+ n. H7 U P+ N
fclose(fp);7 v j- |( a9 t% K5 U! A
}
4 d7 c+ F! g0 G0 }
char s;& |( t& D- d/ O\" g- F5 U# o6 z- `
cout<<"请随便输入一个字符，按回车退出程序！\n";
/ |6 q3 J+ v0 E- ]
cin>>s;
) l; \0 x0 ^9 }8 G' Q8 {4 a
return 1;
# P. m6 J: n/ W. f5 N3 ]9 L+ [
}
7 H( l l8 |% A8 L$ n+ p( r$ k
6 v7 p9 x; Z1 s3 l) ?7 c7 w# V7 }