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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
a% e& a# u( T; V+ g c2 x9 J
#include "iomanip.h"& h+ o j( X2 l& a* K
#define N 20 //学习样本个数
$ v/ U) R& S$ D3 ]3 O9 R
#define IN 1 //输入层神经元数目
! v/ A' {& ^' `% v( N' Z( J$ N1 `
#define HN 8 //隐层神经元数目4 `- [$ g8 b6 I1 c# R\" }
#define ON 1 //输出层神经元数目
$ |! m8 S: B5 v% e
double P[IN]; //单个样本输入数据/ u t. w! J! ] b
double T[ON]; //单个样本教师数据) {' o: P, A. A9 q U+ A
double W[HN][IN]; //输入层至隐层权值
% \6 j# C4 ^\" x& I; |
double V[ON][HN]; //隐层至输出层权值
- W: N9 p- X7 f5 V2 [
double X[HN]; //隐层的输入
( t\" X# Z1 U0 e5 [( ~- u* Z) j
double Y[ON]; //输出层的输入
6 c% o; T. @8 H+ x
double H[HN]; //隐层的输出 u5 z/ m! Z- X0 v+ ]2 k
double O[ON]; //输出层的输出3 o3 p' c! Z: S3 h: l
double sita[HN]; //隐层的阈值1 E( i4 R6 f+ p. C
double gama[ON]; //输出层的阈值\" [& _+ T+ y7 L. J; T. P
double err_m[N]; //第m个样本的总误差
9 |2 N; I V8 i3 z7 [
double alpha; //输出层至隐层的学习效率) g) v# [+ L$ e+ R) E
double beta; //隐层至输入层学习效率
\" c7 I) H# c7 j5 V: |
//定义一个放学习样本的结构
! L2 C5 L\" g0 N+ S
struct {/ o3 i( U% v0 _, W# S( _$ g
double input[IN];9 @5 \9 q% k# p- i
double teach[ON];
' z8 g1 t3 L1 U) }' D2 ]% N+ J\" M
}Study_Data[N][IN];
% k o R- j: B4 {1 {; J3 |
2 I/ p\" o* S4 E# Y3 a+ ^+ h
///////////////////////////
- s3 Y4 P+ }) c. g9 y
//初始化权、阈值子程序/////
. L4 a/ b/ B8 @3 q
///////////////////////////
1 A$ i9 @6 O% P1 I* U) c! t
initial()
9 t, v6 B4 X, ], m/ U1 o
{' y' i/ F n3 Z
float sgn;
% b8 B! K3 H! j' S' k
float rnd;
0 l2 k9 O' q& f/ z1 l# I2 i
int i,j;
5 B' D% b# w# L# {
//隐层权、阈值初始化//' k. y- z2 t; c) Z9 X' J
{! D! j0 M! \* f! Y
//sgn=pow((-1),random(100));0 a) u) @+ M2 G5 e7 O; N5 G& e7 n
sgn=rand();; e! y/ F/ C5 m* y9 y
rnd=sgn*(rand()%100);5 z/ o/ ~* i- f, H1 I( p
W[j][i]= rnd/100;//隐层权值初始化。
$ ^# _) l, ~# q4 V! @
}; H* O6 Q$ k& P
//randomize(); K+ y, H: @& O {4 I
{
i5 H& n1 p: u9 ]
//sgn=pow((-1),random(1000));
4 v) m- T2 b- Y- v! |3 W: p
sgn=rand();& o5 f9 O4 J+ ^/ `5 c
rnd=sgn*(rand()%1000);
* o: ^8 [/ @' w
sita[j]= rnd/1000;//中间层阈值初始化% N1 K, W! W' m7 [( {9 _. w& ?
cout<<"sita"<<sita[j]<<endl;
. S# q |( x- L/ K
}3 Q% M- A+ _$ }( S K* B6 P
//输出层权、阈值初始化//
9 v2 g2 J9 N8 k6 L9 Z
//randomize();
6 k( y& Z; j1 S: |6 G
for (int k=0;k<ON;k++)# E6 ^2 t; i+ p* Y$ Y' b _+ R
for (int j=0;j<HN;j++)
* b6 \/ v2 X- S0 I, d
{ O; {\" `7 y' ~ J
//sgn=pow((-1),random(1000));
2 ^\" D. J+ ^( F( [% d
sgn=rand();
: V$ Y/ U! I* Q9 Y/ _5 T: o
rnd=sgn*(rand()%1000);! x5 n% g* I' @! B' L& f
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
6 W- T3 u' q, L
}0 a7 v! P& C* ~/ L. m
//randomize();! i# v; |, Q. X5 ?6 Y. B
{
& e& R* R9 ]( t2 ~
//sgn=pow((-1),random(10));
\" K: q# }8 O3 [/ K* s( ~, q
sgn=rand();
' x* }' a, K\" b
rnd=sgn*(rand()%10);
n1 ?# Q5 v o
gama[k]=rnd/10;//输出层阈值初始化5 N( w! q! j, |( s7 L
cout<<"gama[k]"<<endl;
% i! y, n7 k; h
}
, N+ J( I' ?& f8 E\" |) g
return 1;
# k2 D( n' u& q; V; w& b\" O% L
/ h6 A; g4 z& Z0 B
}//子程序initial()结束
~2 x8 ?$ }\" E\" j. j4 W1 a
6 y5 [1 y. t3 H- I0 o7 n6 }
////////////////////////////////8 n, W! Q- A\" n: q, ~& k, q1 i
////第m个学习样本输入子程序///# k4 }4 v# U' ^% c
///////////////////////////////
% [ g% [6 |) F
input_P(int m)+ S/ m, C1 a7 q, o# A$ k: Z; ^* c5 F
{
2 M/ Q9 s, M1 L+ e( [
for (int i=0;i<IN;i++)1 s) I4 x. H% G6 \% {- K
P[i]=Study_Data[m]->input[i];+ [( m* ]3 B, o+ ?3 [5 s
//获得第m个样本的数据\" v' m: S1 y' Y
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：. u4 B\" n0 e2 }* O* G3 {, l' e
//P[%d]=%f\n",m,P[i]);
6 [# Q- {& u, r4 e- A/ t
return 1;
& a\" r( z8 v% X! N
}//子程序input_P(m）结束% W6 R+ b( O, I* n0 l! d
/////////////////////////////
! W9 Q: I4 [1 h\" o! H% J
////第m个样本教师信号子程序//8 s$ l# _# i* E. `+ K% j1 L5 |* I3 Z
/////////////////////////////
8 ]2 y. ~; {% [9 j
input_T(int m)' x; q( O# d. v/ z% t1 _3 ^/ t
{
- n2 W& w; u3 a
for (int k=0;k<m;k++)
5 x\" G7 j\" B3 ?* P$ g
T[k]=Study_Data[m]->teach[k];
% V! s! l# ?* X% P+ O% O
//cout<<"第"< //( B6 |2 K9 s o9 X( E
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
$ Z$ r\" ^ m* B' q( |0 |+ x Y
return 1;, C9 {. E5 w$ w& x' L
}//子程序input_T(m)结束8 v! E' k6 q6 A9 W3 Z
/////////////////////////////////
% K1 @0 ?- M1 a+ h$ X7 ]- P0 y2 N
//隐层各单元输入、输出值子程序///
# z\" B: ]5 f9 y$ _& ?' `3 k+ A; Q
/////////////////////////////////' v0 C# T! M. n: v
H_I_O(){: P( a\" E$ W$ O# s7 U1 `
double sigma;/ r/ x/ E8 \\" C
int i,j;
2 k: `, G& |& G G- e4 W' k
for (j=0;j<HN;j++)
; m& y0 y% w+ y/ n7 ?
sigma=0.0;; s# a' p* N\" ?* \) R* U
for (i=0;i<IN;i++)( S P6 I$ l$ {6 q+ ~; l/ h8 z
sigma+=W[j][i]*P[i];//求隐层内积
+ i: r- r. s' b( q$ q
}: H% G a9 ^1 k\" `2 P# r* V
X[j]=sigma - sita[i];//求隐层净输入' a! P\" S; X6 k1 a' i/ b& l9 v
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出& T2 F+ [; m3 j8 y
}, R8 ?5 V6 S5 N% u
return 1;
( A) L; d; x+ J0 m2 ]+ E3 r
}//子程序H_I_O()结束
9 ?; w/ K5 H% q$ R
///////////////////////////////////
( x; v3 t# E/ f\" D
//输出层各单元输入、输出值子程序///* L. \3 H# x6 ]: |1 g: W
///////////////////////////////////) e2 L# h9 R* o, g0 e
O_I_O()
% E0 w# |3 `9 U
{. N1 E8 i5 y2 ~
double sigma;
' [1 a/ @* o/ `) y6 _. o7 z+ p2 |
for (int k=0;k<ON;k++)
; k; S+ [4 @. F& d% ]5 @
sigma=0.0;0 Z! B+ V4 v9 c$ b9 `8 q
for (int j=0;j<HN;j++)* E7 ], y2 i/ o\" A& F/ F
sigma+=V[k][j]*H[k];//求输出层内积# X* D/ u* K+ \. [* a u& w4 z
}
; J( G) A2 Z1 o8 ^
Y[k]=sigma-gama[k]; //求输出层净输入& ?+ y9 g$ u( t5 S& x0 e
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出: y- `8 p# J' [1 P, f
}
* U4 `! }7 D: M# Z
return 1;3 Y- T: S% N- j0 E( N; ?
}//子程序O_I_O()结束
3 k) m! k8 A, Z: e9 V& J. G' J
////////////////////////////////////
' M7 L) ^% T! S9 k/ F- t* M
//输出层至隐层的一般化误差子程序////7 b8 {$ @2 t9 F% ^9 a
////////////////////////////////////* i: W& Y8 L. G) u* {% C
double d_err[ON];
- g. w# @* \4 G' b$ F0 j# @
Err_O_H(int m)
: v* e- ~8 o3 F# ^$ ~) H
{; B5 H; ?* y9 u9 r. q7 }2 {
double abs_err[ON];//每个样本的绝对误差都是从0开始的0 O/ N. |+ z) R9 f
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
$ `. r: V0 [\" b; {
//for (int output=0;output<ON;output++) //output???, k. i6 e\" V3 A6 j, M& I j5 A
for (int k=0;k<ON;k++)
- H+ v# f, D9 n. y9 U. C( ~( z
abs_err[k]=T[k]-O[k];
5 w* ]( M+ W: }# O6 h i# {
//求第m个样本下的第k个神经元的绝对误差) ?, G0 j. h( t% ~# T' n& Y# k
sqr_err+=(abs_err[k])*(abs_err[k]);+ C: q8 W2 d\" S& j& w
//求第m个样本下输出层的平方误差
+ N1 q$ L! c4 F\" I, H- d
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
+ L i( b. y, I) N6 p
//d_err[k]输出层各神经元的一般化误差
2 W( T, ]8 }6 T% z; {* G1 d
}
0 K6 s; ]( o9 ]' G
err_m[m]=sqr_err/2;# B! m: w1 i- [8 ]( F
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
\" |( v! f3 }3 I8 Q: ^4 D0 k
return 1;% I0 n+ ~+ z+ o8 P, z
}//子程序Err_O_H(m)结束
/ n* R( c' b! x) ?
////////////////////////////////////. p, c7 t. x5 Q
//隐层至输入层的一般化误差子程序////! G- V- y1 H1 s6 u* o. T0 R8 ^
////////////////////////////////////
6 P3 A! [2 ?5 C- r4 @, X& q0 x2 I( W
double e_err[HN];
. v. ^/ q/ `) w, { d
Err_H_I(){
; _\" _$ \3 _. ?) R p
double sigma;
. `7 [3 n- k7 \4 d/ M5 z
//for (int hidden=0;hidden
\" O+ n$ @5 f, d$ w
for (int j=0;j<HN;j++) # O% U5 a/ E4 K9 T+ |
sigma=0.0;
: V p4 t) E/ @: Y3 p( g1 Q
for (int k=0;k<ON;k++)
5 M1 h, Y$ e# f3 k0 L9 g) t5 h* u& x
sigma=d_err[k]*V[k][j];- ~4 e' G0 k% W. R9 I0 u\" w( e
}+ l8 }% \8 E* n! c4 z1 y
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差% T. e$ d2 _; z
}
0 ~. \0 ` Q) R Y( `\" U7 z
return 1;8 T: p1 x1 k; T+ i6 T5 t3 O7 s: C
}//子程序Err_H_I()结束3 F2 e0 h6 N; e# U! ~; D5 K, v. O
////////////////////////////////////////////////////////7 u2 ]+ g3 {1 C' X\" q2 t& ?: [
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////! {; T% `3 ?! G: \+ N; O
////////////////////////////////////////////////////////: v# L7 Q4 Q- j8 O# z
Delta_O_H(int m,FILE* fp)- ^# H2 g% Z0 Q, a
{3 ]: d/ j% Y! Z7 W\" i, r\" w/ a
for (int k=0;k<ON;k++)
# n' Z: y# C% S# [2 p
for (int j=0;j<HN;j++)
( ~7 a' x R4 \. l$ R9 y9 N% M. ~! g
//cout<<"第"<
1 O- m6 p/ N1 o) K, h
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);0 w& f% {0 r; I) {) G
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整: n! M0 {\" N9 s
}) `2 I1 q0 b/ n. h) C) o
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
$ j+ l7 P2 x0 b0 r+ W
}& x7 E2 N+ o; C1 X$ W3 E
return 1;
$ s- T3 v8 H i! ^/ \# h
}//子程序Delta_O_H()结束
3 K; Y& P1 x7 a) l
/////////////////////////////////////////////////////
6 f9 @5 s0 o) K6 M/ y1 M: z. B. O' L
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
! g3 y# v6 ^+ h
/////////////////////////////////////////////////////* W+ V3 @4 ?! `+ f
Delta_H_I(int m,FILE* fp)! }' f4 K- b% J6 D. i! e/ a
{
8 }. P l, G: e X# P5 n: ^3 ^
for (int j=0;j<HN;j++)\" S! t6 L7 e& |. U
for (int i=0;i<IN;i++)
+ T6 ?% Q& H% o5 Y
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);& W* V& y! R! A, Y0 u+ V/ i
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
0 V% z# f! d+ o5 M, _& X) R
}, X4 ]3 w+ h2 g9 Y
sita[j]+=beta*e_err[j];: R9 I, r6 e3 r
}
7 n8 t& C1 D3 V2 Q9 N& I
return 1;
1 `8 h/ S7 l3 j2 Y& ~8 k
}//子程序Delta_H_I()结束
, J# q( ` l' X% s9 c9 K
/////////////////////////////////
/ i0 e/ v1 }, t+ _
//N个样本的全局误差计算子程序////\" J2 b: r _+ s4 b
/////////////////////////////////
5 E' M$ q5 [; m6 K8 n @, r$ F
double Err_Sum()6 d+ k( [$ `+ ~8 ]9 @3 l7 M$ G6 [
{
$ u# v, j( _' }% H M; X
double total_err=0;2 J3 _# f* Z4 I8 w! b) h2 Y: U( ]
for (int m=0;m<N;m++)
] k4 Q* v7 s; r
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
# a t9 V) s( r* v
}4 F E2 M5 g: `
return 1;1 ?8 P\" H+ l/ [1 r7 k0 Z
}//子程序Err_sum()结束. r4 z( n+ [6 v2 x6 h( L
/**********************/5 w* }# g% C; `4 |# L5 E
/**程序入口，即主程序**/- m' _. z8 ]6 _4 z1 Q
/**********************/& b, A7 H r+ n7 l6 v
main(): B& o0 h: m: m; _: k3 E9 K
{
6 m& G9 a6 E4 `2 R( n0 ]
FILE *fp;$ A# w\" w9 j a5 S
double sum_err;
# P& f$ A1 y- V# X
int study;//训练次数; J$ J3 M% {* }3 y; F4 Z3 ~7 P
if ((fp=fopen("bp.txt","a+"))==NULL)6 X8 t* Y# [' J) r+ S C
{. _9 K, [6 p3 n& B7 V* D& Z8 R0 _
printf("不能创建bp.txt文件!\n");
- q, o N& t7 G x
exit(1);
7 b. O! `+ {\" X0 F$ f% W0 {
}3 l9 W/ p& ]- _6 s7 a
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
, W' B& ~! h% O' f% `6 F+ {
cin>>alpha;' w9 w! Q V, Z5 V\" c1 L3 W
cout<<"请输入隐含层到输入层学习效率: beta=\n";
; `% _3 Y x# F$ D7 t4 K
cin>>beta;
! N# q* U# | t. j
int study=0; //学习次数: U4 `5 U. T0 s
double Pre_error ; //预定误差
% A# M6 V\" Z! O$ D( u) q
cout<<"请输入预定误差: Pre_error= \n";7 s$ H2 \1 o. N% V. k\" r
cin>>Pre_error;
8 z+ D8 \1 v* ]+ d* J& ]
int Pre_times;0 F1 w& m9 v0 I\" _4 ?* x
cout<<"请输入预定最大学习次数:Pre_times=\n";+ t* y\" D8 g( N. q, h
cin>>Pre_times;' u* o/ K8 V% O, z
cout<<"请输入学习样本数据\n";\" w! V- g1 ~9 M$ h5 j. F9 w3 Y7 U
{4 ^4 U( g0 c6 `! m* _/ @3 V, `2 C' G
for (int m=0;m<N;m++)7 C9 \) U0 ~) D, l! w6 m
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; Q) A) l$ g' o* D6 G* @* x
for (int i=0;i<IN;i++)3 F% u# X! ]; I: x$ q4 k- }5 J
cin>>Study_Data[m]->input[i];
$ T2 O; G2 \4 b% C
}) W+ U+ b) ^' Q& x; Q8 |7 ~
{ 3 s+ P5 }# l3 Y! B) K
for (int m=0;m<N;m++)7 S1 c( P$ }# Z' g; {4 ]
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
, C4 f\" d8 j2 v; j3 I3 h; |& i
for (int k=0;k<ON;k++)
4 E2 ~+ \' G# x; _& O, Y1 }
cin>>Study_Data[m]->teach[k];
, f/ E* E, ^$ w3 O, k. m
}4 o( v) T5 R( U ]
initial(); //隐层、输出层权、阈值初始化 (1)
+ O; q7 u3 X. f% T: V
do; Q8 @& X+ J6 l' c/ o8 h! h8 P! w
{7 d0 j5 k2 x4 z6 r9 a
++study; ///???
\" P3 v/ U4 l! Z% [* O5 F0 f
for (int m=0;m<N;m++)
0 @6 J5 s9 O' ~9 J3 [+ {. Z
{( z+ { O S' D\" @6 N- K- z' Q' N
input_P(m); //输入第m个学习样本 (2)
- H$ r- q6 U* h- d1 r' f. ?
input_T(m);//输入第m个样本的教师信号 (3)
: k# d0 d6 E5 Y
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)\" ^3 P+ `& @# t! p- \9 w
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
- \2 ?\" ~( `/ Q\" H
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
( X2 ]\" Z, Y2 e4 l! s
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)+ l* C) \, p+ b! X- \
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)8 {: l0 k. N5 y) N5 k- O
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
; r' k: R' j( |8 a
} //全部样本训练完毕9 L, ^) t6 N0 }/ t$ o. y, ?+ u
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
; @( U+ \: c8 _& k! A+ l
{
; L& d2 l& @0 T# z) _\" i! I
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
$ F, h. ?( {3 `. k8 K9 _3 O
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
8 J. o4 o9 b6 r8 U3 ~# y5 j
}
% }- z3 _+ R* F$ u\" i
while (sum_err > Pre_error) //or(study: i! `\" }/ r) {
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
! d% i* M3 M# x6 s$ q, D
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;2 Y7 y9 d; g* y& A
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);$ m6 H# I: l( e, M
fclose(fp);5 Q! P I( \( v$ Z( X5 _\" S
}
\" H9 e) V/ _5 `' G- Z- f+ _4 s
char s;8 x6 B& Q# V5 c* _2 b1 P0 E
cout<<"请随便输入一个字符，按回车退出程序！\n";
% g$ z% C* G0 A7 U: ?) n* L
cin>>s;& g/ E) m& x4 `. a; ~- b: w+ Z# ^
return 1;! w& P* k: P/ v
}\" p* a: a1 u! C n
6 ^- m; u q- F