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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
; H6 c\" u& d2 D
#include "iomanip.h"
4 h- F$ {' d/ T
#define N 20 //学习样本个数
* i) b+ Q; S2 D9 l; d# Z: @
#define IN 1 //输入层神经元数目
+ v9 S: i9 z\" X! U }
#define HN 8 //隐层神经元数目
1 C, U9 w2 `' H7 j/ L# \
#define ON 1 //输出层神经元数目3 L5 Z% s+ U- ^8 m W; l3 a9 \: D
double P[IN]; //单个样本输入数据
$ q! s9 _# u5 m* t% q
double T[ON]; //单个样本教师数据
. R6 B6 W% O5 E% F& M7 g
double W[HN][IN]; //输入层至隐层权值
: h2 o& l# I; \; c* H
double V[ON][HN]; //隐层至输出层权值5 ~1 m: D; q' P/ J M: N5 F+ Q; m H
double X[HN]; //隐层的输入6 k2 n/ k0 I' _
double Y[ON]; //输出层的输入( C1 U3 y$ \$ l _2 v' f
double H[HN]; //隐层的输出7 N- Z; }- l5 n# G) G/ O) i( z4 J
double O[ON]; //输出层的输出
3 ]1 Q) n6 S) \. h4 i
double sita[HN]; //隐层的阈值, ?3 M/ h* \% ^* G0 P2 ]
double gama[ON]; //输出层的阈值3 y9 ?. w2 b! p, E v; ]
double err_m[N]; //第m个样本的总误差+ |1 w' B% _* ^3 K+ A8 [
double alpha; //输出层至隐层的学习效率. v5 c& j% [$ H: ?5 M( R
double beta; //隐层至输入层学习效率
5 z! y6 V+ n; a6 J
//定义一个放学习样本的结构
# u0 y4 O- u7 m& `
struct {3 E0 E0 y3 y( Q# ?
double input[IN];
4 w6 ?: P) N. P# h* X6 B
double teach[ON];
- Y' k$ X3 ?# Q4 D, ~
}Study_Data[N][IN];+ i1 n) I5 [ q( Y+ e7 }: Q
' m8 p! E\" v1 o6 O( ^
///////////////////////////! r$ k/ s( Q( s# e7 ^( w( Q
//初始化权、阈值子程序/////
+ ]: G1 |/ Z7 O' I& U6 i# m
///////////////////////////
8 k9 C; n+ O6 H\" s# M7 _
initial() Q0 k' ]% A( ~1 h\" |
{
1 L# _8 o* U# d2 z3 O& j9 [+ |
float sgn;' N) q5 d2 ^, t2 w9 s! ~
float rnd;
6 c, T. D0 q* Y+ V# x. w0 ]3 g
int i,j;9 L& F, ]9 R c3 f! W# ]& K& c
//隐层权、阈值初始化//
X! b- J( k% W: |
{
( A @\" `, ~( x5 g$ q
//sgn=pow((-1),random(100));
1 o' g O5 ]8 s5 ]& [
sgn=rand();% b0 j( S! ^! c7 I P5 p5 X, X! f
rnd=sgn*(rand()%100);* K2 B$ y9 i8 n, Z5 h8 s i
W[j][i]= rnd/100;//隐层权值初始化。3 J# f% L\" ~; V# F2 o
}
# S2 K |, Y# C* m
//randomize();
9 ~: `. `' m) j+ I
{
6 c; F1 n/ y% x. i2 L
//sgn=pow((-1),random(1000));
& Z) k/ p2 R, p$ U2 b
sgn=rand();
* o) a9 p& a5 ?( O5 o
rnd=sgn*(rand()%1000);
. N, O' A' B/ |) h$ c
sita[j]= rnd/1000;//中间层阈值初始化* ~8 |+ b/ |9 R9 ` l% h
cout<<"sita"<<sita[j]<<endl;
' E4 G% }- e6 C. y: E4 b
}
( F0 N, z v2 Z( G, }' Z0 T1 p\" N
//输出层权、阈值初始化//
1 l9 B\" o: b* p; y
//randomize();
& _# i. V) a& T# V\" J4 E/ R
for (int k=0;k<ON;k++)
) l( `3 b6 P3 n- p\" k: ~3 K
for (int j=0;j<HN;j++) 6 `/ m1 v' ?* l$ P6 V* v
{
9 B* a$ P* s/ j, z
//sgn=pow((-1),random(1000));
: c9 e. h. q# a
sgn=rand();
2 ?+ k4 x% C5 i, p
rnd=sgn*(rand()%1000);; S6 _8 ^- w9 ^
V[k][j]=rnd/1000;//第m个样本输出层权值初始化' I) n! ?6 g8 V6 ^7 M
}
: O3 P\" ~! I4 }1 L
//randomize();$ ` T$ x5 ^3 Q- h
{1 ?/ U( \! ?& q- Q; `5 h- m
//sgn=pow((-1),random(10));- _4 V0 a% d8 }: ~% D1 Y( Y9 S
sgn=rand();
; w* y; w( L2 l: |$ g9 l `
rnd=sgn*(rand()%10);! q, J) c; |- S8 H. m- J
gama[k]=rnd/10;//输出层阈值初始化$ C% Q) {* v! }# K: O
cout<<"gama[k]"<<endl;
6 q* x1 f3 j3 e4 f7 {
}, W( D3 C7 v% }5 V& I' b
return 1;6 V+ Q8 c3 n; |- |3 C% V
4 h% z- y) V3 z' ^# s
}//子程序initial()结束7 K; F5 ^& k% G3 e7 Z
! ^\" C\" C# s! G, t/ i
////////////////////////////////
4 O& j( `4 Z0 D. z+ S! n
////第m个学习样本输入子程序///0 e. E( e. c, Y; N# n, ~) U
///////////////////////////////
0 P+ R) ^; z% S/ O; a
input_P(int m)% I4 w3 G6 e. b9 A9 y% x7 Z
{' e% w$ T, [9 u
for (int i=0;i<IN;i++)
* f1 |$ X( L1 I/ a9 Q( N
P[i]=Study_Data[m]->input[i];$ Q& t4 ~+ e/ r& q+ j5 `
//获得第m个样本的数据
3 J# p) T% J) q) b9 M: v
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：# l7 A& h' ]' ^1 U) A4 R, A
//P[%d]=%f\n",m,P[i]);- R% l K( ~' I3 K+ K
return 1;
& @$ j- H# w\" A
}//子程序input_P(m）结束
& n+ a6 E; ^5 U5 F( L3 H
/////////////////////////////
8 Q- |: B, R. f2 a$ Y% y% h3 [
////第m个样本教师信号子程序//
; L3 n0 u) Q1 d$ O# ^: j; ~7 K
/////////////////////////////
9 i( N' V6 N( i% f( ~: K
input_T(int m)
- H9 I3 k8 V2 I
{
7 h* R) X* ~3 E, M9 G1 V
for (int k=0;k<m;k++)
3 V6 i! J$ y# _0 q
T[k]=Study_Data[m]->teach[k];
3 o0 ~8 q) c) r7 M$ l
//cout<<"第"< //
0 R% Q8 l) ?2 |& N- u
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
4 a, I( w- X6 s+ w
return 1;0 }- Q6 X \5 q: s+ s3 R
}//子程序input_T(m)结束
# R; k. Y1 f6 _7 |% F* j6 M
/////////////////////////////////0 v; V2 s8 w6 m2 f
//隐层各单元输入、输出值子程序///
; P; z! K5 x1 w) `
/////////////////////////////////
# \$ Q; K3 ?* E3 [
H_I_O(){+ x5 G. ]% E; V
double sigma;( q' ]\" L, ]/ t
int i,j;
' v% o9 G\" O. _, `6 c& {7 |7 |
for (j=0;j<HN;j++)
$ t5 z8 M! i2 I
sigma=0.0;
0 L2 |9 X. ~! q2 l0 }8 g
for (i=0;i<IN;i++)
1 R/ D3 _9 G, `# [
sigma+=W[j][i]*P[i];//求隐层内积
- d# f5 _; h: x# p3 g
}
. v% j; M9 o- [
X[j]=sigma - sita[i];//求隐层净输入
+ e; K! z @1 {2 m
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出6 J3 W% P/ m& f; k
}
. Y; y- ~4 Q! [) v7 }
return 1;3 {6 _9 y$ s' g* e% h |6 Z& e
}//子程序H_I_O()结束
2 [\" I2 u5 d5 U0 J3 K- T
///////////////////////////////////
: B% j1 T1 q! q8 w/ {; G, p
//输出层各单元输入、输出值子程序///( ~* j* ~! S: u3 |7 Y. _
///////////////////////////////////3 I5 A$ X6 P3 J: S v- s. {
O_I_O()' v$ J: G, K: }7 M$ |
{
) n5 N\" v% O* k# {( w# P6 P6 ?
double sigma;+ c- a) I( T) N
for (int k=0;k<ON;k++)- |5 ]- `* O$ j8 E7 Z/ n, t& n' l
sigma=0.0;
& f D8 U8 \0 I. `- s\" J/ I1 A3 r
for (int j=0;j<HN;j++)
\" h8 v* f, {/ n% ?1 V4 t5 Z
sigma+=V[k][j]*H[k];//求输出层内积\" s: U6 n) g# x, D8 ]# d+ L5 z+ Y
}/ ]9 ]- x& \) v) O( K( X/ `$ B
Y[k]=sigma-gama[k]; //求输出层净输入
* E5 O6 e/ p8 C9 P3 N* W; n& P }
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
. [5 Q/ s, u! ]' s
}+ Q# U! i4 h; }; H6 _\" j) y
return 1;& h2 [* A+ z$ b
}//子程序O_I_O()结束\" q: ^5 ?' s4 T+ o
////////////////////////////////////
! Q' p\" o$ p+ t9 E# z
//输出层至隐层的一般化误差子程序////: t6 {/ z, j6 o, o* \0 z
////////////////////////////////////
4 r5 \( ?( ~! n: I* ~$ X
double d_err[ON];
; A, i6 n# k% |
Err_O_H(int m)# X0 L9 B9 u\" r: |8 h/ ]+ s& T
{1 p: T% p0 P9 T) k; E
double abs_err[ON];//每个样本的绝对误差都是从0开始的
8 z: b' w1 t6 P6 |1 h\" W9 G
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
1 F* [& [/ [4 o& O& e n
//for (int output=0;output<ON;output++) //output???0 T; w& q5 v6 f2 s\" a. w
for (int k=0;k<ON;k++)
n& I# s8 I9 ~1 K
abs_err[k]=T[k]-O[k];
; V$ J$ z: H3 c9 c8 `% ?* h8 r
//求第m个样本下的第k个神经元的绝对误差
7 T7 `. H! }; u) \
sqr_err+=(abs_err[k])*(abs_err[k]);
$ Z* {, y& r5 Q$ Z8 a. O
//求第m个样本下输出层的平方误差6 ]. e6 k( _' L3 |$ F6 k/ G, g
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
! t1 F% ?- s. L( H; y
//d_err[k]输出层各神经元的一般化误差
. r4 P# i; L0 Z+ w9 ` x
}, S' s! P$ y& x/ ]! |
err_m[m]=sqr_err/2;
, @4 x7 s, |, u, s# M9 ] p3 e3 F9 V
//第m个样本下输出层的平方误差/2=第m个样本的均方误差: o8 N3 E$ }5 F8 A4 ]) l0 _/ Q, J) l
return 1;
6 |6 N5 W9 Q9 P4 I' ?0 _, ~$ V- q
}//子程序Err_O_H(m)结束
7 B. [% m. p0 m5 o2 |' T' L
////////////////////////////////////
% V0 E! S3 y2 _1 N\" d. X7 [
//隐层至输入层的一般化误差子程序////8 L( G; s9 r$ O. w9 C2 h
////////////////////////////////////
! l: U4 g, g5 X! ]\" Q7 s2 P$ x6 B
double e_err[HN];
) m0 ~7 @7 G! C: ]- W5 W
Err_H_I(){
9 {\" t# v3 j8 }# `+ S# o
double sigma;
1 p* @/ Y2 a; j
//for (int hidden=0;hidden
2 N8 J4 G3 G, D' ?; w; M
for (int j=0;j<HN;j++)
\" x2 v1 t. L8 r6 K, N- E
sigma=0.0;9 A! p) v\" f' D) t
for (int k=0;k<ON;k++)
6 u& W$ n5 v# X, D* X! e) Q
sigma=d_err[k]*V[k][j];
2 {8 a& `\" M6 t4 |5 r
}
% ]! e, a3 E% B
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
) Y# o/ [1 x R6 F! W2 j- `4 k
}
! _# h) ~+ R8 b' C B; k
return 1;\" {( I2 K. d1 b7 n& J
}//子程序Err_H_I()结束) C/ @/ G- Y% ?: p; w% E& B+ G5 R
////////////////////////////////////////////////////////
\" C0 E* W4 _2 n8 {4 B
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
- @. X p% G' l7 r/ a+ W* Y0 h3 N
////////////////////////////////////////////////////////. [' S' G* U8 V\" u8 z [+ k
Delta_O_H(int m,FILE* fp)
- _, D\" r g% Q$ H
{\" _0 d' {' O# }$ w
for (int k=0;k<ON;k++)# Z% ~: T: V: B
for (int j=0;j<HN;j++)' d3 [3 q: B( }0 j0 E( D0 N
//cout<<"第"< # l\" ]6 Z6 ~2 _* v
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);) @, [+ V. Q n$ L6 b
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整( E1 n- q6 i: |# t t
}
, `; u) N- {1 S
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整! w# R8 p6 z1 D4 y; I3 U% [2 z
}
6 Z, s: a7 b9 e% ~
return 1;
' H1 j. w. G+ |
}//子程序Delta_O_H()结束
/ r4 g! ?\" m4 n1 b
/////////////////////////////////////////////////////
+ [# P9 }; V2 N1 v
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
; s+ }/ Q, p+ c1 |7 {, P
/////////////////////////////////////////////////////0 |4 f, L3 z7 S
Delta_H_I(int m,FILE* fp)) f! N$ k; C) n# ]$ i
{/ b: B0 Z( l: H$ [5 A
for (int j=0;j<HN;j++)0 \# w- V8 i\" L. y$ q8 }' c% O
for (int i=0;i<IN;i++) 4 g$ @) t$ z) J, J: p: k) d6 E
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);, f' g) F7 C7 }+ N
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
9 q\" P8 R i/ g7 L9 `% J2 @
}& c, e4 F\" F' x( g' V1 R4 j2 g
sita[j]+=beta*e_err[j];1 n) P3 K- |; H! C
}
3 R5 j6 v( n3 L; o) i
return 1;
S+ A+ s( t; x! C1 [\" h- L! y
}//子程序Delta_H_I()结束( o+ f: Y& O, f! v6 p' n9 I' m
/////////////////////////////////4 T% M\" [ z% |8 U8 \8 q
//N个样本的全局误差计算子程序////
, G- r- V' K) X1 [0 r6 I, c9 u
/////////////////////////////////1 e+ K7 r4 ]3 w/ y( _
double Err_Sum()
2 n( F* H1 z& ]+ w( o
{/ t$ a! U8 l3 ^! [* g9 c
double total_err=0;. t+ z, ~: X# {1 q1 J9 o* X
for (int m=0;m<N;m++) & V& y% C% E- t+ x1 Q& M7 r# w
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
- |! w, o2 G6 C7 N9 ?
}
9 K3 Z: B8 m( U6 a/ ]
return 1;( u$ T. h* ]0 J' r! l* ?1 \
}//子程序Err_sum()结束
3 t( `- P4 u8 n0 p! K
/**********************/. q2 Y+ m+ {# ?8 R
/**程序入口，即主程序**/\" n9 |: V) s: I3 H! S, z% m {
/**********************/0 f& Z3 d/ [, O! m: q
main(), j, N# U9 j- u& a! k$ t
{/ l8 N% |+ q+ n! h( x5 z9 g6 l4 u$ E
FILE *fp;
! H: m) r5 g; E6 ?5 u- F
double sum_err;
/ a( w$ s1 A. k. h\" J
int study;//训练次数
; [5 S6 e# X. E
if ((fp=fopen("bp.txt","a+"))==NULL) ]) Y# W- w: J6 J3 E
{
2 f3 k- _' V4 b$ V( C6 h7 Q
printf("不能创建bp.txt文件!\n");2 ~$ j1 c, h2 O7 f# _( k
exit(1);\" |6 m' U) n6 }+ ?4 N% V) P
}5 @/ p5 `% e6 d1 |( Z Q
cout<<"请输入输出层到隐含层学习效率: alpha=\n";0 V% t' B( D& O6 o% s0 G
cin>>alpha;* |: s# c2 N3 q$ ?( K\" |
cout<<"请输入隐含层到输入层学习效率: beta=\n";
. b% `5 {& s3 J5 Z6 ~ ?
cin>>beta;5 N) v; z- U3 d( s
int study=0; //学习次数
+ N$ r0 T* r: L
double Pre_error ; //预定误差
6 r- a; J7 e. G0 ]7 }; K
cout<<"请输入预定误差: Pre_error= \n";; k1 X& ^* i$ g$ T1 C2 ^\" b+ i
cin>>Pre_error;
4 z$ P% i* M0 m2 o. C* R
int Pre_times;0 p% t4 O! K# N1 ?1 Y
cout<<"请输入预定最大学习次数:Pre_times=\n";
h8 r% b$ g2 Q
cin>>Pre_times;
% h4 n3 y. B0 Y7 ~$ t' Y
cout<<"请输入学习样本数据\n";, a0 e9 U, G6 T\" F* q% ?
{
D\" d z+ R! a; L8 ?! ^
for (int m=0;m<N;m++)
5 N. u! I( J2 {! b7 b( Z9 s
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
9 O! L& x/ ~) V8 |% W9 L$ K/ x Q
for (int i=0;i<IN;i++)
/ A! V# p+ v6 A b' a: c
cin>>Study_Data[m]->input[i];
1 J6 g3 g* X) K* n/ e
}
7 G: P- T5 u; p7 u$ J4 V4 D
{
3 J2 i) e/ n8 s) H
for (int m=0;m<N;m++). G5 }6 K- }7 F$ Y
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; r2 N* V; y) U
for (int k=0;k<ON;k++)4 a\" y1 `. v# [; A( O
cin>>Study_Data[m]->teach[k];
9 s, Y9 E1 n. W/ ^6 I
}
- T* F$ C) _9 C6 P0 q( ]
initial(); //隐层、输出层权、阈值初始化 (1) ) `( c6 l6 n) H2 x: W
do& d\" g! \* |; e# ^3 z |
{9 J) p4 V0 x9 u* a3 T
++study; ///???# M) X( U5 l\" B
for (int m=0;m<N;m++) ; R' }, S' @' x) C3 \
{# ~( U% J+ }! O5 Z/ _- C- I. o( `
input_P(m); //输入第m个学习样本 (2)% I$ r5 W+ P% F5 |
input_T(m);//输入第m个样本的教师信号 (3)
/ F% l, V6 W0 Y
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
* e8 W4 M5 E+ `. w
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5), t7 i6 ^ f$ o; ?
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
! ~7 I5 Q/ y6 Q
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
# [$ u6 x: z5 Y2 P
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8) p) l\" ]1 E& u6 s1 W/ h* g
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
: g0 {0 ]; Q6 o1 v
} //全部样本训练完毕
0 y- G' `) u8 }( d6 p; g/ l0 K
sum_err=Err_Sum(); //全部样本全局误差计算 (10)! `5 Q( A+ a8 J( ^3 g
{6 k! j0 b+ r# E* R; B2 X( e( v. L
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
, C, [( [/ ^2 [
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);4 j) m5 B( ?$ s' N
}) G\" I& ~( {; k6 u\" N
while (sum_err > Pre_error) //or(study/ t9 l3 p5 y, F8 U% T\" Y
{ //N个样本全局误差小于预定误差否？小于则退出 (11)6 }% J2 E8 Q# C& F
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
2 B$ X6 z; f0 u* \ g
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
2 u3 f9 l2 w2 p7 A/ S( [$ ^
fclose(fp);
% p( g2 y$ \\" x% ~2 C
}
; Z# X# h5 w/ o+ y+ `! P8 d; }. Z
char s;) }- w\" v( _; u1 D s, i\" s z4 l
cout<<"请随便输入一个字符，按回车退出程序！\n";: `2 M% c! s1 M\" e% ~) |; z
cin>>s;
6 e; G5 T7 j5 R, F
return 1;/ X: e' ^: u1 Y& \, \/ i& s
}
: B/ \% w) o1 _8 Y
# f& Q4 J7 w' O8 o; S