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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h") o) V# w8 n\" P V. q
#include "iomanip.h"
' L0 S. C% m5 P4 T% j# D
#define N 20 //学习样本个数) ]8 k- _' o; I! d
#define IN 1 //输入层神经元数目5 B0 U. y) p) x( K; _5 Q5 \* n
#define HN 8 //隐层神经元数目0 ?; k% d; S; A7 e: a5 w
#define ON 1 //输出层神经元数目# k1 C, }) j, m7 e' a, `1 W& I6 I
double P[IN]; //单个样本输入数据
+ W* w' I+ y U' u1 E& N+ M' b
double T[ON]; //单个样本教师数据' V# p) F4 j0 `
double W[HN][IN]; //输入层至隐层权值) E2 ~% ]7 U. b5 J& P: x- ^3 l( L
double V[ON][HN]; //隐层至输出层权值
. _+ b% q7 l\" e) O, D, \7 W. ?
double X[HN]; //隐层的输入
& E5 S, x5 R! I9 Z
double Y[ON]; //输出层的输入6 _& r- n/ ], H8 A+ T* Z
double H[HN]; //隐层的输出
4 Z0 b# b# \# ~ {
double O[ON]; //输出层的输出
$ j2 |4 G* p6 C4 I8 g0 d
double sita[HN]; //隐层的阈值) L8 Y1 U! A- q. t- e0 s
double gama[ON]; //输出层的阈值& i3 Z g3 U& M! h E\" h9 c* R
double err_m[N]; //第m个样本的总误差0 y: P* c( o) a( r2 A; k3 _* Q
double alpha; //输出层至隐层的学习效率
2 f1 b; N- P1 V4 {+ Z5 w# I
double beta; //隐层至输入层学习效率
; r2 q& F- V Z* U\" R
//定义一个放学习样本的结构
3 z1 f: e( h( t9 r; h, ~
struct {
4 V\" I1 v1 j7 Y3 S: R+ n
double input[IN];
! E- `! T, s; Z: U' u\" D
double teach[ON];+ r6 U\" h: q& K% l; j8 U
}Study_Data[N][IN];4 M% N$ k! S\" q
$ i1 ]5 R- l\" B1 u' K
///////////////////////////$ [; ]4 b, M8 f8 y\" S- q& O
//初始化权、阈值子程序/////0 U2 B5 ]/ n, M* L' B\" t
///////////////////////////6 t1 D! C- q# f6 T k- P0 z4 X
initial()
1 [% W, }& q4 H& F H
{
' \1 O9 b+ p/ l! d9 T/ d+ Z
float sgn;
/ z# c* A- C% G) w- J8 i7 s3 o
float rnd;
# C8 h6 U0 W+ B, d
int i,j;/ w4 C* Q7 M$ S1 [
//隐层权、阈值初始化//; g9 J. O, G0 |' Q2 q$ I
{6 T+ B5 I' @. U6 v
//sgn=pow((-1),random(100));
C& J& x' f a2 \6 V3 Q5 x
sgn=rand();
! X; I0 D, l( \
rnd=sgn*(rand()%100);
5 X: E9 B0 |) y, b, ]
W[j][i]= rnd/100;//隐层权值初始化。
6 I: s6 C2 i, b
}7 x/ A: e k) F. @
//randomize();
: P8 g' M' z( i% {3 z0 D! J+ b/ C
{
0 U! {. F( s) W
//sgn=pow((-1),random(1000));
9 c. m: S! O- c. v* I k
sgn=rand();
) c- i6 g+ d& _\" B/ P* [; E/ E
rnd=sgn*(rand()%1000);. t9 |7 S8 Y8 T. W1 l# U
sita[j]= rnd/1000;//中间层阈值初始化
\" D0 b' t( {8 u/ E% l4 r
cout<<"sita"<<sita[j]<<endl;
% j% A( `: A- }% G
}
! x% c; q E( G. s2 |
//输出层权、阈值初始化//
- |6 _! D/ G) B$ a. u' U9 }
//randomize();
: F; t! ~' N# }3 R( F
for (int k=0;k<ON;k++)
& |8 z K. N6 t7 D
for (int j=0;j<HN;j++)
f8 z* n9 p$ s2 D
{
7 O: ? ?# v4 h& a) z: v$ {, g
//sgn=pow((-1),random(1000));
, U8 F5 ^0 S/ u
sgn=rand();6 G4 n$ y1 T( r. p
rnd=sgn*(rand()%1000);7 q% j$ i0 B; t& J) ^ X+ J
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
8 u# C\" v3 g' O6 m/ m! x
}
7 M/ t1 x0 ]; \
//randomize();
) r8 k; }* p; b& ]( l
{
' s. x3 {! e\" Z9 ?
//sgn=pow((-1),random(10));$ Y) x8 Q3 E8 h) j# |+ n
sgn=rand();
, e) x: h0 _' M7 X, K! [
rnd=sgn*(rand()%10);) s' C* H4 n\" B0 r3 F
gama[k]=rnd/10;//输出层阈值初始化8 u2 \( z* M2 F$ Z\" j/ p- l\" q
cout<<"gama[k]"<<endl;8 n3 ^) ]+ R- L5 U8 l2 W7 b
}
+ W\" ~. f( D0 U6 z, P k+ @. A' q
return 1;
8 n; j; T7 z( W ]: q
1 I5 D7 ?* t, D\" d _- O. Z Z8 [
}//子程序initial()结束
! ]5 z. h) {5 m, b6 D, J0 c9 F
, }6 Q! c/ X7 v w7 m) @
////////////////////////////////
5 ~6 p- V5 H! e
////第m个学习样本输入子程序///; d5 O# h) U/ {$ F7 Q! W: c0 X8 M, g
///////////////////////////////+ r# u! [9 X$ S7 r) h% D\" A a9 K
input_P(int m)
, U- s+ W1 w$ J% U1 [) q2 P\" A* t
{
\" d' i' A, m( F( l3 L* c/ k; G
for (int i=0;i<IN;i++)- E' `2 N: n- z
P[i]=Study_Data[m]->input[i];
% ]4 m+ w* W- ~- I& h1 w
//获得第m个样本的数据 |/ {0 D\" D3 `! w: ^, s
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：( [' S8 m1 i( f' h
//P[%d]=%f\n",m,P[i]);, ~' r! y# i5 S# k I% P* x
return 1;
1 W1 a9 a5 \3 B5 l- A+ j% D1 A
}//子程序input_P(m）结束\" Z) O9 g2 G# \8 S
/////////////////////////////
5 a+ y7 x8 c2 e) U/ R
////第m个样本教师信号子程序//
3 J& i- b7 |: x; E( @
/////////////////////////////2 M$ E- T1 g\" ]$ o) Z5 ~9 M
input_T(int m)
1 N\" P% n7 S. ]1 N' B5 |4 {
{: e& x. q& y8 O
for (int k=0;k<m;k++)
& ^* J; f# q+ U; T8 W, Y
T[k]=Study_Data[m]->teach[k];
+ x# C0 E- B: ]
//cout<<"第"< //
' L- x0 u3 x0 c# v9 m
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);\" k/ r( _9 K5 V
return 1;
F: _# M d\" k% o4 f! y
}//子程序input_T(m)结束
; M+ r! B+ k2 Q6 j0 S
/////////////////////////////////
, B# T$ z9 F7 r1 v% k- `9 i/ a7 ^
//隐层各单元输入、输出值子程序///% R- l; T. G! A6 q! f$ _0 p! r
/////////////////////////////////
, v) N- b& b7 f
H_I_O(){
- Q8 d2 S8 n) i8 R, W\" u
double sigma;
3 \. q* F& j* y
int i,j;
! j( |0 k! S6 n3 s9 g3 N
for (j=0;j<HN;j++)
% U- D5 @: a! I6 J O\" t Y4 e) m
sigma=0.0;
& q' g8 x) w& v% `5 b
for (i=0;i<IN;i++)% K% l/ V2 x\" @, @. r
sigma+=W[j][i]*P[i];//求隐层内积
: a: j\" g9 B8 U9 y. v
}
5 C# D' Y6 X4 Q) r- x: D
X[j]=sigma - sita[i];//求隐层净输入
) Z6 J# L4 O! x* T
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
6 ~3 _ q) u4 z7 C
}* l2 a, F8 Y\" G: r
return 1;
; K6 p3 F. }9 R9 ~& `0 a2 H
}//子程序H_I_O()结束
' H7 @2 O* I, z/ I
/////////////////////////////////// @, N6 g2 c: P) V) s
//输出层各单元输入、输出值子程序///: W( W3 w0 }1 j5 J# N, L- y
///////////////////////////////////5 K# j, C& N* C8 r0 x+ D2 b8 R
O_I_O()0 t5 M# L# O0 X
{
\" ~& P3 F\" r- T0 T
double sigma;; z2 g. X$ k5 j; Z5 {
for (int k=0;k<ON;k++)7 x2 M# I. Q8 O; {, s5 Q7 \
sigma=0.0;% h- f1 }( a: H# e; d9 a! W
for (int j=0;j<HN;j++)4 |- q* ]. h1 }1 x2 ^
sigma+=V[k][j]*H[k];//求输出层内积# k/ G1 s& w8 W, Q7 X5 z& k9 q
}
+ v( R; u5 w6 n3 p
Y[k]=sigma-gama[k]; //求输出层净输入
, t( J* g- [% S9 `+ P7 {: z
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出( {. l5 d' h: F5 b; n8 j) u/ l\" e
}9 R' l. ~+ N X( B2 m% K
return 1;
}//子程序O_I_O()结束+ K+ K2 f4 k; A
////////////////////////////////////
% s# @! W) l4 m! V. I% g7 H( H
//输出层至隐层的一般化误差子程序////0 D3 }5 P) }) K6 `
////////////////////////////////////
6 f! e; ^6 j5 ?( T
double d_err[ON];
8 B, G: @0 F& s8 ^ B
Err_O_H(int m)& m, e1 T0 g. P8 p
{$ Z- B0 x4 q4 r( W {& n: x: A8 E
double abs_err[ON];//每个样本的绝对误差都是从0开始的9 P# Q0 I. L( b8 p4 S: m! [% v
double sqr_err=0;//每个样本的平方误差计算都是从0开始的6 Z6 E5 _* c; y3 O4 S# q! [% o+ M u
//for (int output=0;output<ON;output++) //output???- g5 A y% I+ M. W/ y/ u2 U
for (int k=0;k<ON;k++)' t; L1 K. m6 P
abs_err[k]=T[k]-O[k];9 d; S, ~4 z2 b
//求第m个样本下的第k个神经元的绝对误差
, s4 I- z. q* o8 u$ p% [; p% f
sqr_err+=(abs_err[k])*(abs_err[k]);
( w- Z& R5 m O3 d! Q% T8 ^
//求第m个样本下输出层的平方误差
1 I4 e4 A$ \\" e+ i
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);& C J+ v( i8 b2 w7 D3 N T
//d_err[k]输出层各神经元的一般化误差' t/ G/ s0 L: W) X$ d h
}
+ K$ e) u5 k- ^! N+ G0 O) r4 I\" |
err_m[m]=sqr_err/2;
4 t d. g3 @9 E9 l1 U: i& R( k q
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
\" v8 y& C; Q) b! E+ `: u
return 1;
5 {; b8 T4 f [* P
}//子程序Err_O_H(m)结束
4 T# B\" Z1 v A4 M: j3 ]* H& ?
////////////////////////////////////
* J' M\" c7 B$ A1 ]) y
//隐层至输入层的一般化误差子程序////
* L. c- J4 }9 v% |+ S3 v
////////////////////////////////////
7 J( P0 P+ C! H Z+ {6 X; k5 o$ ?
double e_err[HN];3 {% h) {$ k, A\" h
Err_H_I(){; w6 c% i; S) r7 i7 w# ?5 \: F
double sigma;
- d8 W) L& ]; z- I% i) D
//for (int hidden=0;hidden. t7 D, O( S6 u. e
for (int j=0;j<HN;j++) 2 p7 \! q3 J0 h5 a, _
sigma=0.0;2 `9 W. [& `( F9 ^8 _3 B* ^
for (int k=0;k<ON;k++)
\" \. y O# F4 B8 u# \
sigma=d_err[k]*V[k][j];( w! F8 E/ N) V\" `\" K
}
$ P, `9 F [/ m( J+ K/ Z& A' e6 [7 y
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差( W6 }, D* Y4 Y$ x* Y/ b* x3 g
}
5 O5 @$ G7 }/ ^! V, T
return 1;# ^5 p1 W$ I2 I9 G& H
}//子程序Err_H_I()结束
9 R, L\" l\" t4 G$ p
////////////////////////////////////////////////////////
1 p v- [' E0 I
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
% A, G! J# ^* r0 v* v
////////////////////////////////////////////////////////
( G/ w, i) G8 c# D! T* h8 t
Delta_O_H(int m,FILE* fp). F6 ?- D. m) @7 ] P% t0 K: n1 j\" W
{+ M/ K% M% J7 W8 D, H9 A
for (int k=0;k<ON;k++)) R: |1 m7 z1 g+ o8 Q3 S/ w
for (int j=0;j<HN;j++): |3 ~ E/ R- D9 ?& M! G( E
//cout<<"第"< % ^( V4 r9 X. q8 ^9 Z2 _# y\" F v
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);: U2 }( V# Z) f% F6 _
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整- a @$ s1 Y( _3 c! X# v
}% S% y9 o# W\" j$ A4 @# ^& b8 y
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整. D& [ M* O T. \ o; o( M3 [
}( g& Y7 q+ X2 M5 c( E7 a\" m
return 1;
2 m8 O! k: k! P\" n
}//子程序Delta_O_H()结束$ C$ K- e6 r: J: {/ G% D' w
/////////////////////////////////////////////////////2 n- _- l; o; z& l R/ x
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////- `3 M( W B8 K\" T! |
/////////////////////////////////////////////////////3 b% C: s$ v! \
Delta_H_I(int m,FILE* fp)# b3 R w& c- ]1 H6 \, }* ^
{
/ [- h- ]+ j7 V0 E6 [0 s# P
for (int j=0;j<HN;j++)! [# P4 R( O. m6 W- @9 l+ k
for (int i=0;i<IN;i++)
. |! ?# E& o& `5 S1 a! [
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
8 a2 X+ s& A! q- p# g1 U7 y% X \, v
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
+ R9 W! a) F: {8 d( v9 j# y2 o
}
. a' p' T5 n7 z# Z8 F- J
sita[j]+=beta*e_err[j];
& m1 p& Y2 C* R: H6 ?- V
}1 Z9 N- ^! I9 r7 f, n
return 1;. R3 T& @\" M* s. b. j; _3 _: r8 z
}//子程序Delta_H_I()结束
8 a( i/ ]: x# z# O0 |) A8 F5 k
////////////////////////////////// o9 F. s/ }1 V Z$ k
//N个样本的全局误差计算子程序////: }9 A4 o; a$ _
/////////////////////////////////2 z% C; w( j$ G: q/ B5 Z. P+ m# \
double Err_Sum()4 n- M$ j/ E3 y9 Q5 X n: R/ b8 a L$ E
{
+ l/ Q# s; m6 B% T) r
double total_err=0;
/ a, n\" e# t6 N8 b
for (int m=0;m<N;m++) ; V: ^$ r8 k8 x3 O1 z& r
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差: x C\" n, p! ?0 q6 T3 k7 C
}: n0 O' o/ M, E$ E% z' M
return 1;& Q {0 c% Z. y% P* X
}//子程序Err_sum()结束$ z* j' J6 [7 q, A V* ~
/**********************/4 h5 o0 p& m2 J$ a* u4 R
/**程序入口，即主程序**/
/ i) ?+ w, B* |( W
/**********************/
. z6 e0 U8 w) O
main()& R% U6 a Q4 p3 w2 o% I3 j
{$ E3 U$ }) [3 i6 N% x9 ^; H
FILE *fp;
/ L6 w7 j- a, n2 z* J; H
double sum_err;
7 c, h1 E. u6 a b( ?' R1 ~; B7 E6 }
int study;//训练次数
, `8 N% T8 |9 B* J3 e% j* S
if ((fp=fopen("bp.txt","a+"))==NULL)
! X# H$ ]7 ]/ ~4 W. ~
{/ i3 |9 l7 @& E2 U3 K- s$ [: c: m
printf("不能创建bp.txt文件!\n");5 |: m4 O4 O# \ ^. U# u; y$ @
exit(1);
! _% R) Y# H. u/ X1 I* ]
}; K8 o6 D; g) U6 P; }) M
cout<<"请输入输出层到隐含层学习效率: alpha=\n";3 B/ Z7 m; W4 h/ u4 K/ L
cin>>alpha;
4 W7 z* N) r+ C5 I9 ^\" z& O- n
cout<<"请输入隐含层到输入层学习效率: beta=\n";& L( J' X; K- V; @) V' n
cin>>beta;
0 r, e0 W/ R+ X& D
int study=0; //学习次数2 Y$ c: J' N) ^$ Q
double Pre_error ; //预定误差
q' T7 s\" Y( m. j1 r\" R) T; U
cout<<"请输入预定误差: Pre_error= \n";3 P0 z5 i _9 d
cin>>Pre_error;( x! D$ k( J\" J; s7 s\" k O
int Pre_times;
]' H\" `( P\" {2 P: c8 b$ ~
cout<<"请输入预定最大学习次数:Pre_times=\n";: m! o+ @3 v r6 p
cin>>Pre_times;
) p4 w r9 b) h: h' y& z0 }
cout<<"请输入学习样本数据\n";
9 R, y5 }1 e o2 G6 [5 k
{
4 Y\" n3 R9 i- g\" h3 x( Q6 X
for (int m=0;m<N;m++)2 C! e* R# L C2 D' t; M$ G
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
( k7 D2 x* W+ Z& x: ]- ?$ [3 n. H9 n
for (int i=0;i<IN;i++)2 y* G8 J0 d' F `, h# _\" z
cin>>Study_Data[m]->input[i];- f+ _3 F: u0 c# ]. {
}9 S5 w$ z3 u; I5 `
{
: [1 W4 F# w, T0 ] F4 U
for (int m=0;m<N;m++)
, R5 {# Q; r! V, i7 j7 C7 p
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
4 C8 N- Z8 y( C, @' l% }# z. v% ~3 Q
for (int k=0;k<ON;k++)
# {+ R! [4 c# q: X7 ^0 A
cin>>Study_Data[m]->teach[k];
2 B0 x0 n! P7 z6 g9 ^
}
: X2 ]. w* V: t( S! w; g
initial(); //隐层、输出层权、阈值初始化 (1)
7 A/ V6 \+ b y& S6 A# H/ |
do
& r. w! {+ C' k% v+ v7 X
{9 x ]# W: Y# g4 s9 Z8 x* d
++study; ///???
+ ~+ Y\" k! Z# Q. s3 i
for (int m=0;m<N;m++)
: q/ ?6 \& F: o5 y
{
$ s' t) R4 m$ H5 r
input_P(m); //输入第m个学习样本 (2); T$ K8 i; z( c- L* y
input_T(m);//输入第m个样本的教师信号 (3)$ U* b7 k: b2 U- T6 c
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)% u% L) G1 ~ M5 C$ f5 z9 @
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)% x J8 x+ U8 M/ f* A8 q. |! z\" N. ]
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
/ X1 ]) @. a! l4 L
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)\" z: J/ M: U9 X9 {) ~( d5 F. Y
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
+ n- @: M W0 W7 f% q6 R' ^
} //全部样本训练完毕2 D. l7 ?' d7 u# Z' y2 v' z6 c
sum_err=Err_Sum(); //全部样本全局误差计算 (10)3 d$ {1 ~\" E' b! C- T
{
# |3 [! T; z0 \6 Q7 ]; K
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;1 @$ K: h+ Y4 v+ G: q' j
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
0 ?# k) h3 P8 H\" z' {% [
} n9 D* N. L5 `
while (sum_err > Pre_error) //or(study
3 x9 k% u+ k, \
{ //N个样本全局误差小于预定误差否？小于则退出 (11)) Y# ?$ u3 @. f
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;2 W7 l: q+ V8 [& G0 N
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);) @5 G+ r2 ^( t& V( H! Y2 F9 \
fclose(fp);# t) j7 ]3 Q/ `, F
}; X W0 R- V\" H
char s;/ m9 r6 w' t' x
cout<<"请随便输入一个字符，按回车退出程序！\n";
9 D. x% Z) G# f. F! @' w7 j
cin>>s;& A2 N* V0 ? O' |1 \
return 1;0 Y6 u- H* F }( [, g
}, D. \\" f+ k. Z' \
( }# a7 P' x% U R* n