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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"7 a8 i\" [. c/ Y+ l
#include "iomanip.h"* ]( V9 w5 ?% y/ f. g2 n
#define N 20 //学习样本个数! W' ?\" ^* K- R$ k# A( |
#define IN 1 //输入层神经元数目
$ K$ c6 F% ]( c5 L# m
#define HN 8 //隐层神经元数目
% L% B4 U1 U3 C6 D* h8 [2 W7 \
#define ON 1 //输出层神经元数目; o9 I0 L/ T- B3 y% Z
double P[IN]; //单个样本输入数据
! e2 n H: d- q
double T[ON]; //单个样本教师数据( u% h* |0 k' ~# m* Y
double W[HN][IN]; //输入层至隐层权值
; r* u& s% l( J( }0 {
double V[ON][HN]; //隐层至输出层权值% |0 l1 Z0 [- {- d6 [1 N, _
double X[HN]; //隐层的输入
% z' q& H: [' P: Z N2 R8 f/ H
double Y[ON]; //输出层的输入; d! a; b- q- K/ }8 \7 {4 J# `8 b* i0 a
double H[HN]; //隐层的输出
3 M- v2 K7 p$ Q+ L. z4 j- h; ?
double O[ON]; //输出层的输出
! |\" ] d: p5 y& S! u. l3 n
double sita[HN]; //隐层的阈值
% f. S2 \/ i' b: T\" o1 G1 n6 u* a
double gama[ON]; //输出层的阈值
) l. L* R5 ~0 Z$ A, t1 U n& l4 d
double err_m[N]; //第m个样本的总误差
: I5 q+ g\" n7 X `
double alpha; //输出层至隐层的学习效率
$ u+ C! l; @4 z1 {
double beta; //隐层至输入层学习效率9 Q0 `- y$ @& L
//定义一个放学习样本的结构\" w- w# m ]5 g
struct {
. T% Q0 L! f' M. G; \* _2 I6 N# p
double input[IN];
1 o3 e5 ]3 y% @6 J; _
double teach[ON];
. g' I. g' \* |\" A! o5 Y
}Study_Data[N][IN];- ?, m1 `+ S& Q' J+ T$ Q
, D# _# d0 }9 N4 a9 i `7 o* D+ y; a
///////////////////////////, U# O. m6 {* d3 |\" E# q, T# ^
//初始化权、阈值子程序/////% M1 Q& I$ C) {- \/ d, @
///////////////////////////$ d( ?+ f) Q\" x u' _- r
initial()
! K; Q& v\" z; n, |) V
{
& ~4 A5 e5 H# @\" t
float sgn;! \ \. N/ H2 Z\" ?3 }
float rnd;
\" Z9 K9 X1 ]/ n% O; w4 f i3 Z0 T
int i,j;5 c, F\" b l\" h4 c
//隐层权、阈值初始化//
8 N9 d( U# F# \+ T
{) U: Y8 t7 t8 m \. I) ]5 X
//sgn=pow((-1),random(100));
0 Q7 V+ T8 O# p- q r# `
sgn=rand();
$ M7 `; q+ b. ^: I+ \0 E/ c- y8 G
rnd=sgn*(rand()%100);
& n! I2 |8 {& w* Z
W[j][i]= rnd/100;//隐层权值初始化。
9 c; f; G9 C$ o\" j3 V
}
& V1 d& d/ d0 X
//randomize();\" E% a! e+ {. H o# u3 ~( b
{( m2 s9 i& g+ ?9 v4 M& C! J# S' v
//sgn=pow((-1),random(1000));
+ @' {, C! E% b1 |
sgn=rand();# Z% T; {5 A2 j4 C( B
rnd=sgn*(rand()%1000);
; p, E7 L$ H$ c0 C
sita[j]= rnd/1000;//中间层阈值初始化
9 w/ f, I! Q+ j% }7 w% D1 a7 S
cout<<"sita"<<sita[j]<<endl;; [' r9 j$ i ?2 y$ f H9 L
}: | ]8 z0 G3 F' @; V
//输出层权、阈值初始化//6 O2 {8 d, Y( f% u6 h
//randomize();
9 n: l. W2 w; i8 w7 L6 j; F* T3 N6 c/ V
for (int k=0;k<ON;k++)' H\" N/ `& K& x! m/ @/ ]) m: N5 h5 V
for (int j=0;j<HN;j++) - {( q N( k$ N
{
\" d( L: g g; x( b! d2 K- l
//sgn=pow((-1),random(1000));5 V8 S% M/ w7 b; l5 L
sgn=rand();7 Q! A\" l\" b+ u* X
rnd=sgn*(rand()%1000);
1 G* O; q3 M% V# [
V[k][j]=rnd/1000;//第m个样本输出层权值初始化' O\" G3 v2 t\" ?1 O+ c
}
$ n/ o- z! I7 z& W) x/ `
//randomize();
; ^6 u% A- z% @9 c# j$ U' ~
{
% ~0 G) f3 G% O# w5 t, e* C
//sgn=pow((-1),random(10));
0 P8 x- n5 |- a9 x$ c2 S
sgn=rand();
& l3 `* a5 B6 l4 t\" f8 h7 A
rnd=sgn*(rand()%10);7 G0 L: _1 l' J0 E2 B7 e( G
gama[k]=rnd/10;//输出层阈值初始化; v* ?/ D. k5 Y8 ?, l0 h# V
cout<<"gama[k]"<<endl;
/ m6 Z) z2 w\" L' e7 L- z8 U; \3 t
}6 e9 c' ]8 l0 k$ ^ e+ l/ K
return 1;
* {0 p7 \1 M8 N6 D9 Y) M9 t; S- ] l
4 L/ A, j4 K+ t c! t1 }
}//子程序initial()结束
, ~! j$ i& \+ v4 y# i
- V8 w% a& y2 g: J
////////////////////////////////5 @# m/ |8 N( ]* H# V1 n* s. w7 M
////第m个学习样本输入子程序///
( Q9 A/ x. b% G( K# i. `
///////////////////////////////
8 e1 G |8 `: @/ `9 G* I
input_P(int m)% P- f, Q) e$ U1 U! e4 ]8 f
{. ]1 e8 r+ N, j/ L3 ^. A1 w
for (int i=0;i<IN;i++)2 M+ H. @7 b$ {% D. p5 S: {
P[i]=Study_Data[m]->input[i];. j$ I+ _; \% _
//获得第m个样本的数据
' N- K/ q% Q6 M# \2 |
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：\" ~( T0 h% u, r3 f$ _/ Y
//P[%d]=%f\n",m,P[i]);6 v2 S' C; M8 N W# X; ]) b
return 1;2 O4 K: i( z1 y
}//子程序input_P(m）结束
! R) _. v' u1 `
/////////////////////////////( E! W( x8 N1 ?4 H! d* z* c5 w
////第m个样本教师信号子程序//\" {% w& v ^' m) i( o
/////////////////////////////
$ H; y2 N% O# E9 z7 [( l; S
input_T(int m)
9 \( }1 K) v2 o
{& H3 R6 } Q) q9 B' m
for (int k=0;k<m;k++)\" d' a& U/ l* p- {# \ I- [8 w
T[k]=Study_Data[m]->teach[k];/ p$ M0 ^+ q7 A+ ] u6 m! N3 b6 F
//cout<<"第"< //& p' P) d) @# k! e
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
% H& n( V5 n' f) l
return 1;8 z: ~/ p& p+ X. R6 T6 U
}//子程序input_T(m)结束
; K( n! D! T- i n# I# w8 g# T
/////////////////////////////////6 ^2 f+ C* O- m! Z3 k& R
//隐层各单元输入、输出值子程序///
\" f* C: s5 K' |1 v\" R
/////////////////////////////////4 T* J( D2 c# q/ }# H4 k8 K$ Q0 N
H_I_O(){8 d% i. u9 v7 ]5 r5 N5 L
double sigma;
1 j. m+ \5 o3 i! S9 U
int i,j;
1 V, c: @5 ^% L0 x
for (j=0;j<HN;j++)% Z/ k6 ]; o. Y0 |/ s. a
sigma=0.0;7 F( H5 |( O( w
for (i=0;i<IN;i++)
1 |; @, M1 R! P\" |* s\" f, M
sigma+=W[j][i]*P[i];//求隐层内积! ~* b1 o, r. r% ~8 p\" n
}
1 c6 W5 L, p4 z' ]! _+ B+ p9 c
X[j]=sigma - sita[i];//求隐层净输入- Z; c\" O1 I; J8 c% h
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
3 d' Q1 _! T, _ o$ f
}4 J+ o8 m6 y\" ]0 u2 _; a3 |5 Z6 f
return 1;2 A f# O' d, m. Y7 r
}//子程序H_I_O()结束8 f/ q a1 A5 a\" ~/ E
///////////////////////////////////- N! E9 C8 I! Y- O
//输出层各单元输入、输出值子程序///0 s3 w* W& i3 s\" i' s7 X4 j2 n2 d
///////////////////////////////////
& m\" z! I: m4 k, X8 B0 n& q& ~
O_I_O()
7 Z# A3 z k/ }. r2 m
{( k1 d- |* J' J8 t\" O1 [; M0 [
double sigma;4 t2 d; ~. r8 ~- k0 i, {
for (int k=0;k<ON;k++)
% d6 B6 R! d2 s\" A
sigma=0.0;
\" L5 t5 J2 q* c3 z. D' }
for (int j=0;j<HN;j++)% v5 D @ g$ l8 j
sigma+=V[k][j]*H[k];//求输出层内积
' ~ n+ W+ O6 b% U! z- c& j
}
& z7 z6 k2 i( I% r& \; L
Y[k]=sigma-gama[k]; //求输出层净输入9 N5 e2 \- P! F, r: T+ S4 ]. ~6 p
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
2 U6 m' Z! I9 X6 P0 j\" X
}6 \. _% l' M7 l. Z, U; U! i9 q# I
return 1;+ l! m/ y8 {3 ~: D! A6 Q1 s5 }
}//子程序O_I_O()结束
; e7 ]; M! ]5 r Y3 G
////////////////////////////////////+ {* y0 A! N7 m8 R6 u0 y d
//输出层至隐层的一般化误差子程序//// S1 v8 n. A$ E. {/ o+ @
////////////////////////////////////+ N. [ T. ^- H0 P+ T- R8 B% f
double d_err[ON];
S8 w6 l& `( v; L. o' V1 u
Err_O_H(int m)
% h; _7 S; K, l9 q( X$ }2 U4 \6 \
{
) {1 w/ J1 E0 R% K6 h4 _$ r
double abs_err[ON];//每个样本的绝对误差都是从0开始的0 {# _1 @1 _- @& I1 K. H8 y, ~
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
- d) Y X; T0 W( | ]7 x
//for (int output=0;output<ON;output++) //output???5 w% {2 g# E4 c$ B' W
for (int k=0;k<ON;k++)
% z6 Y2 c4 F8 Z+ J5 e
abs_err[k]=T[k]-O[k];$ a7 Q) R+ z! t; o, A4 ~& b
//求第m个样本下的第k个神经元的绝对误差
+ V6 M& Z\" ~: I! u3 y6 S6 X
sqr_err+=(abs_err[k])*(abs_err[k]);
& \6 B8 Z) o) o
//求第m个样本下输出层的平方误差' a( q. b( ~4 ? @1 }3 S
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);: b& T4 S. T4 `7 R! h7 r
//d_err[k]输出层各神经元的一般化误差
7 ?1 \2 _0 N: s# W
}
) t0 l3 o$ T+ E! n! k) u
err_m[m]=sqr_err/2;* z1 a/ S+ }\" z9 z5 n: l, E+ n& J
//第m个样本下输出层的平方误差/2=第m个样本的均方误差% h) N8 [* y) T& B/ ]2 M4 j
return 1;
# j: @! [! B. r6 z& X
}//子程序Err_O_H(m)结束
1 S\" b6 j3 o) S/ W0 [6 c
////////////////////////////////////
2 V. X% b% x\" _$ T$ d
//隐层至输入层的一般化误差子程序////
& z& h6 M3 h; B7 ]
////////////////////////////////////
3 @; E: o/ L9 l6 [8 b1 P
double e_err[HN];# L& B, @0 R9 `7 I9 x5 O
Err_H_I(){ ]# i L7 F5 f/ g
double sigma;
! o2 ]9 @5 i8 r) W
//for (int hidden=0;hidden
$ C$ A' T' u' R; z2 }
for (int j=0;j<HN;j++)
, C2 f% m\" s9 I1 V
sigma=0.0;0 A. E& R0 s' U9 B) K\" N {: ]
for (int k=0;k<ON;k++) : X' H/ h* Z2 ] H
sigma=d_err[k]*V[k][j];
( Z; w5 ]\" ^& A/ O& o! K
}
3 q! k* u: [1 K. c
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差8 c# |: O Y7 v( b ]2 V
}. \ m9 q; E8 H, G) f7 c! M( h
return 1;5 X, m, n$ h4 @( c$ ^, C# X5 V0 n
}//子程序Err_H_I()结束
1 F9 `4 w9 r+ D
////////////////////////////////////////////////////////! x: b\" `) |; X/ i
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
\" d. A9 _3 d' H6 F% k, J
////////////////////////////////////////////////////////. f! Z4 ~ N9 Y8 n: Z: u
Delta_O_H(int m,FILE* fp)# t6 t0 }* O: W
{
/ k+ q2 P: u. A; A9 d' D$ M
for (int k=0;k<ON;k++)
4 P# ?0 X* R) a( Y- c+ N
for (int j=0;j<HN;j++)
5 o$ w4 Z$ `* w' ^7 z0 D
//cout<<"第"< / o0 `* u\" r9 S, t
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
\" V) z) u! {5 I- x3 V
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
5 w8 G7 W; D) f7 R
}$ H+ }7 Q, H* v3 Z2 [$ ~
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整6 B5 i3 ]7 q+ x
}
2 E; k$ N& F- U; R: z: j' P
return 1;
7 M! w9 g, D3 w2 ?) e
}//子程序Delta_O_H()结束) T( D4 ~; f( F( {# b4 S/ s* l* p
/////////////////////////////////////////////////////
% f U6 H! q% G) b( ^
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
$ B) s, a9 y/ U
/////////////////////////////////////////////////////; q' ~# X, r( n2 k) E4 `2 _
Delta_H_I(int m,FILE* fp)) m# k4 @7 w\" f' F% ]2 d
{; W0 W+ \$ \ v2 p) P
for (int j=0;j<HN;j++), e* {* c$ i2 u! W6 D
for (int i=0;i<IN;i++)
9 Y: e! v' s9 L+ h
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
( l8 U$ N0 S- Z, R# P& a
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整, I( ]- I8 S2 y# U/ [& D Z8 W
}
1 u/ z8 s0 b8 V8 T* v |# C# H
sita[j]+=beta*e_err[j];
L6 } i( J6 S+ q1 @' u
}! M% {: C/ f: z: ^' h1 g
return 1;$ W1 M+ Z' e\" w v: Y2 A* N. y
}//子程序Delta_H_I()结束 \/ H: H4 f& l. c0 [$ ^9 K4 ?
/////////////////////////////////
9 z\" p% K, w8 v. G3 k! K
//N个样本的全局误差计算子程序////( I5 P: I1 n, D& j\" n
/////////////////////////////////1 [8 V' J% J+ U8 g- y
double Err_Sum()
' D. C- Y3 \2 S* b) f; p
{( j, u( ]9 ]* Q$ o
double total_err=0;
) \0 _ z8 c( J. S9 {
for (int m=0;m<N;m++) # `. a. ]( W y% C# E6 g6 {. J
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
' ?4 o& n' F. S; F3 s& i
}
* `2 b& Y3 X. b
return 1;
\" E- a1 v, @, Q2 w
}//子程序Err_sum()结束: U+ V7 i$ X- z2 N4 X, ^\" `
/**********************/
2 n/ s- R4 |/ g- E
/**程序入口，即主程序**/% j: \% A# z# v; X7 A1 @
/**********************/# E8 n3 e. h+ ~# Q E& z2 m
main()
% s) v& B4 p2 D4 U$ y
{
5 @2 x% j9 X5 C\" y4 D) I( D) p
FILE *fp;
; @) K( `! B! e\" G
double sum_err;4 D$ K, O+ e2 F
int study;//训练次数4 M# s0 }, r: l# j# u
if ((fp=fopen("bp.txt","a+"))==NULL)
H1 L4 t, f t8 j) W
{
% i, \ g# ]' G\" u. m2 n/ ?& ^1 D
printf("不能创建bp.txt文件!\n");
7 e5 {5 h3 F% Y; _
exit(1);. |! B3 K! e' q2 b
}* m. _5 B3 K0 Z/ \ l. j3 |
cout<<"请输入输出层到隐含层学习效率: alpha=\n";, e- A( W1 l; I. }( h
cin>>alpha;* p& @* K! d; P! f1 A\" [! B! F
cout<<"请输入隐含层到输入层学习效率: beta=\n";
4 V. k( `, I! E+ e; l }
cin>>beta;
9 G2 O) z! P8 A\" Z
int study=0; //学习次数, O. s8 ]- M( z5 s' L/ M) d. {: o
double Pre_error ; //预定误差
0 h6 S/ t: S( Y4 M$ U
cout<<"请输入预定误差: Pre_error= \n";\" A$ I% G) H% N! z. F9 p; l
cin>>Pre_error;
% O: ^/ ^ t e3 L/ c
int Pre_times;3 |* A\" ~3 s% Q: t
cout<<"请输入预定最大学习次数:Pre_times=\n";
; X, v4 ^6 u, a) j
cin>>Pre_times;# C6 \) @1 D8 o' X) O3 D ^/ N: w
cout<<"请输入学习样本数据\n";
9 l! _/ I+ Q/ H2 \* Q
{9 z. ]/ v: ~/ ~% g+ [* N. ?
for (int m=0;m<N;m++)
1 A& R- {% h/ q\" l2 v8 h# Y2 w: k
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; - q1 c! o5 ~4 h. z
for (int i=0;i<IN;i++)1 s3 K& \* y& ?8 A9 P; i' B2 f% d( {
cin>>Study_Data[m]->input[i];
% b6 H% m/ u& S. c# k
}
: H. v+ U4 q+ M4 Z. K, _, m# d7 O
{
* p! F3 }4 i9 d5 K! d
for (int m=0;m<N;m++)9 f8 K0 Z! k' R$ [! r) I( Q2 Z
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
! Q5 j/ y! x, |5 r# D\" U4 M
for (int k=0;k<ON;k++)5 L\" }5 `. y& A
cin>>Study_Data[m]->teach[k];
: z, R$ R# X; k/ }
}
1 c* I& l1 [+ ~7 d
initial(); //隐层、输出层权、阈值初始化 (1)
/ R; _& O$ o. g. v; O
do
2 a. ^! w5 |0 k, \3 O
{! v! H( K& [: X9 N Y9 B
++study; ///???
8 \. `6 R1 i\" @& k. @! G- m9 J
for (int m=0;m<N;m++)
9 s9 t. q1 ]$ Z8 I$ B\" v
{
2 e0 h% u/ `7 c, \
input_P(m); //输入第m个学习样本 (2)
8 b3 @; t& f) L% l2 e0 x C
input_T(m);//输入第m个样本的教师信号 (3)6 V G' b! E f% B; ~ F\" R; t
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
( u7 e- }1 i4 I+ D2 `
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5). G. k; u* u4 w) r$ k
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
& a) h I& P\" u7 j' C8 s5 I! a
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)1 f( p' u, Z% j/ {& x
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)9 t1 `. I2 e1 r ~# B& W
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)& }( x7 y1 r; T8 ?
} //全部样本训练完毕
: P3 Q s( x% Q4 g+ ]8 Q2 a9 ^
sum_err=Err_Sum(); //全部样本全局误差计算 (10)5 _6 ]% A# U0 G' o
{
' W& K5 O; O- m$ i4 [$ _
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;\" p- k5 E9 i3 Q7 z
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);$ d\" L N2 k, T& C
}
- |7 r/ U9 v7 M9 U
while (sum_err > Pre_error) //or(study0 m: i1 A0 K\" d0 I
{ //N个样本全局误差小于预定误差否？小于则退出 (11)0 N! }( {: E; c1 O. T' I& z
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
b7 P; s% b7 w6 s9 M' y( |) V
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
. u- _9 C$ C' `4 P
fclose(fp);
0 Z, |6 G& Z- c# a) x- [) S$ K5 d) d
}
+ n\" k6 v% C: }
char s;
6 S9 E) \7 [: M: {* A: y
cout<<"请随便输入一个字符，按回车退出程序！\n";
& P6 C9 Z, F2 R8 T; o
cin>>s;4 ?7 E( ]: A! b0 k2 b/ |
return 1;( M- j\" ?6 e! r2 o& _ T
}
; M4 `, V5 G, X3 _! Y1 {8 |1 g X
: X: Z) @- F5 K. i$ z6 ~* w