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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
& V8 }1 f* N9 y' e+ N
#include "iomanip.h"
' _ q) N& J/ b. \8 c8 E# q
#define N 20 //学习样本个数
; p7 N4 Z- h; o0 X+ }7 g8 ~* D7 R
#define IN 1 //输入层神经元数目1 k3 F: z\" N+ `1 f* D$ G
#define HN 8 //隐层神经元数目
6 t8 \8 Y1 z8 T4 k4 u+ c
#define ON 1 //输出层神经元数目
/ [2 z7 ]# d! p+ A/ i
double P[IN]; //单个样本输入数据, m: c; S& E( h$ }3 y
double T[ON]; //单个样本教师数据
/ ^) X2 p6 z& [) B/ D3 N7 m/ p D
double W[HN][IN]; //输入层至隐层权值/ c* K+ @% w: q
double V[ON][HN]; //隐层至输出层权值5 F% a- V9 }! L$ G; a$ W+ U
double X[HN]; //隐层的输入2 x5 {( s. e% r
double Y[ON]; //输出层的输入
2 V- h' _6 K0 d% P
double H[HN]; //隐层的输出
0 G9 F! R0 r0 K! a+ G
double O[ON]; //输出层的输出
) ?) X: H# D, R& r& Y8 ~+ x
double sita[HN]; //隐层的阈值
# q2 j+ b0 ~! C. I1 n# \' ?
double gama[ON]; //输出层的阈值) l: X& q+ ^* K2 h+ C$ f# B
double err_m[N]; //第m个样本的总误差
& |\" e& h' @8 U4 q! B- p$ i
double alpha; //输出层至隐层的学习效率
$ H; q# h3 ^ ^; q6 r$ _: u4 {
double beta; //隐层至输入层学习效率9 U& l5 Q Y: i( \: b
//定义一个放学习样本的结构' a# n* ]2 d\" G2 A( ` w
struct {
2 |2 ^8 E: p4 ]9 w# _& f\" \& c
double input[IN];! q' B( `% W# b
double teach[ON];! J) s: `4 }: v9 ]
}Study_Data[N][IN];9 Q$ Y; e$ A0 z. c% C
' m' q7 T$ w' E3 g4 D( x
///////////////////////////
# U$ g6 I. |# {( H! s
//初始化权、阈值子程序/////5 b4 x\" w* M' e( n7 C
/////////////////////////// e& F\" c% b! ]
initial(), P; u2 v- {2 m
{- {- q* C+ h: ~4 ^2 [# m
float sgn;2 E7 N& {( U% V7 a4 ]2 p
float rnd;
8 ^; {: c \$ z$ R' E$ j
int i,j;# p5 u* u# K3 G$ U4 j0 m0 o8 ^
//隐层权、阈值初始化//
5 q' l' P& ^4 ]* J9 e\" m
{
; _; F( _; e% q& l8 _2 s
//sgn=pow((-1),random(100));
2 V' I5 ]\" ]9 L% r* z! \. {
sgn=rand();* R4 m& h& k- V' g
rnd=sgn*(rand()%100);
) v$ Z: {7 r. n P V# I- q6 r. K
W[j][i]= rnd/100;//隐层权值初始化。
- E# D5 A/ X! |- ~5 E L: R: g1 x
}7 J( T' C6 W2 E( e5 M1 G
//randomize();% F5 @* A/ w' ~+ u6 V2 k) B7 f
{8 ?# ~! E9 B6 u: H+ J+ k' X
//sgn=pow((-1),random(1000));6 ]; d8 @# J! {. u) K6 e
sgn=rand();
& q% R& i, s' U2 k/ W7 t' Z0 Q
rnd=sgn*(rand()%1000);
% c\" G* T- V1 j+ B* e/ U3 i
sita[j]= rnd/1000;//中间层阈值初始化/ o0 p* y0 o0 M: N; a
cout<<"sita"<<sita[j]<<endl;
! l( X# k5 u\" ?' O: t5 d
}
( ^% x& r8 L3 d% h8 p6 ^
//输出层权、阈值初始化//: ?, @7 O6 g) [* `* |\" H
//randomize();
& E$ g$ o& O/ ~6 z6 T
for (int k=0;k<ON;k++)' C8 }, |6 L& @! a0 E$ `: H
for (int j=0;j<HN;j++)
$ O\" p8 n: K. L. q# s3 N
{) i# t! P5 F$ Q, n) {2 l: Y. ]/ D
//sgn=pow((-1),random(1000));
\" g. u/ _2 V# p, |0 M9 k6 A
sgn=rand();8 y, \: M& r. e- H
rnd=sgn*(rand()%1000);7 O7 Y2 W* ~4 ~
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
: {* E& B' G @
}
& A! b: v7 }+ k8 Z, C
//randomize();7 s8 c6 _; z5 z* m$ M/ m
{
4 T- N$ [* K\" Q* M
//sgn=pow((-1),random(10));5 L3 D) e\" P/ @% ^' a7 F
sgn=rand();
# f6 t0 p/ \3 H6 M2 a- T: h# s, E
rnd=sgn*(rand()%10);8 b* g( @+ v( l s
gama[k]=rnd/10;//输出层阈值初始化8 t; Y& t8 O! T4 Q( |
cout<<"gama[k]"<<endl;
- ]\" N( M4 n5 ^% {2 @' P
}/ x9 g1 H: m- k
return 1;5 Y2 E9 `: c9 q& S( a\" h, i
' r& r; w% ~8 o* Y8 ?$ ^4 }
}//子程序initial()结束
Q\" i3 ?( k& i' k+ Q- |2 A
+ k& l! n4 C% _! z, u3 X1 r
////////////////////////////////
! K! t K6 d: L7 a' D# T
////第m个学习样本输入子程序///
! r$ d/ G* n+ T- W
///////////////////////////////
5 v- D# f: k; m
input_P(int m)
* Y1 @* Z: t) @1 `) u3 A
{
, Z6 h. ~\" c( L3 x% d; j& Z0 C
for (int i=0;i<IN;i++)5 i$ U2 K, S* S: m8 y' y
P[i]=Study_Data[m]->input[i];
- h: P; g( s |2 V# k [
//获得第m个样本的数据
. O; f6 \; @. M. [; ?/ ^9 b! O
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
//P[%d]=%f\n",m,P[i]);: S0 l, u7 _5 P' w0 Q- @
return 1;! Q# R$ R- U8 l
}//子程序input_P(m）结束
( [& B! G3 i9 V# H1 B6 y
/////////////////////////////
/ ~! b p( }! p/ o) y' l% ~% H6 l: C
////第m个样本教师信号子程序//
/ `( }, p6 v3 _; J2 ]
/////////////////////////////
# v. C/ D5 i8 C4 b# _$ K
input_T(int m)
* c3 P5 i ?$ s3 F
{9 Q2 m. D W9 b8 K' `7 W) T
for (int k=0;k<m;k++)
4 e5 \2 O/ h% u1 \\" Y
T[k]=Study_Data[m]->teach[k];7 F `- g+ X# j8 K$ J, T j
//cout<<"第"< //
5 U% {8 s* E\" K* p
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);% w8 m* v8 ]( \- R( B; R
return 1;
9 S( R3 Q' D5 g: ^. t
}//子程序input_T(m)结束
5 n\" K4 R% Q7 T7 Y2 u& G {
/////////////////////////////////4 f# i1 l\" a* N* h5 O# y2 w; `
//隐层各单元输入、输出值子程序///
% H5 g A k0 {! s9 I$ M+ p
/////////////////////////////////# ~- `0 t. v2 t# y' g7 c
H_I_O(){
. Z) u- m5 }7 q, O- @$ G5 W
double sigma;- ]* d2 t% i+ e3 [
int i,j;
5 L5 O5 K/ `2 C( @
for (j=0;j<HN;j++)
* S% Q- @! ]8 B% W a5 H5 w
sigma=0.0;
+ G. K, }\" T1 K! M0 g
for (i=0;i<IN;i++)
' E+ k( t$ N* F/ x
sigma+=W[j][i]*P[i];//求隐层内积
# Z n) E\" B. C% A, m4 n
}6 A& Q5 z: m6 L. @
X[j]=sigma - sita[i];//求隐层净输入
; A7 u+ x) q- S) u0 O
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
\" ]1 ~. ?( c5 m& L2 J) f
} o) u% m7 I- ]\" {
return 1;# s) M1 b5 J, D4 Z) ], ~
}//子程序H_I_O()结束
! c' J$ L; F f/ _& J2 |
///////////////////////////////////
\" T' e& x1 |- ]0 C; m
//输出层各单元输入、输出值子程序///
4 ^' d+ V P. K: g& H' ] R
///////////////////////////////////
7 c, ` k- J2 Y$ s% ^$ a) P0 m
O_I_O()
! Q# q1 h1 ]% }: x9 V. |6 ^3 I
{
3 S\" f% m% G' e: l
double sigma;# M' i% v) G1 Q2 e
for (int k=0;k<ON;k++)) c- [- M; O1 L/ t
sigma=0.0;3 A\" O. k) a( J6 E% }/ {
for (int j=0;j<HN;j++)& J! M0 O8 q6 Z/ K2 p
sigma+=V[k][j]*H[k];//求输出层内积
: O\" p0 U\" `1 h
}
6 b x7 C. Y8 e0 T$ o
Y[k]=sigma-gama[k]; //求输出层净输入
( B4 i t* V+ |
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出9 A, ~- @7 f8 Z3 v+ F& t6 @
}
4 n* `% \0 S/ Z3 y+ \
return 1;9 ]! S4 [; H; t/ G( h\" }
}//子程序O_I_O()结束
- s: z7 M p! x8 N7 ~1 s
////////////////////////////////////
) C/ W2 d% p\" K: R) ]
//输出层至隐层的一般化误差子程序////) _2 [2 m: c; w: h
////////////////////////////////////+ C9 `& S1 }' {8 L# \5 f! a/ u
double d_err[ON];7 P5 n1 o z# ] B
Err_O_H(int m)3 W5 \5 Q8 K% M- s8 j! U: W
{
0 q: W# K! b3 R* F4 _, x\" ? R
double abs_err[ON];//每个样本的绝对误差都是从0开始的4 ^- ^, I9 n2 i
double sqr_err=0;//每个样本的平方误差计算都是从0开始的/ L( C. n3 n% F) q0 K- o: w! z3 d
//for (int output=0;output<ON;output++) //output???
& \7 `7 G( I. o6 s! j
for (int k=0;k<ON;k++) l' y- Y# x2 [6 K\" I
abs_err[k]=T[k]-O[k];, i7 @; z. f5 G/ C& m6 k8 I
//求第m个样本下的第k个神经元的绝对误差
* N* o& B6 r0 u1 U! ^ v, N1 g
sqr_err+=(abs_err[k])*(abs_err[k]);
$ V, W. U9 u' s) C9 b* l
//求第m个样本下输出层的平方误差
, ]5 G- [3 N3 h/ ?\" `
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);1 E' X* w\" H7 \7 m! Z
//d_err[k]输出层各神经元的一般化误差
, G* S; N& u' O/ O8 i4 h8 O+ z
}; h. y9 m! ], Y0 w
err_m[m]=sqr_err/2;7 ]' p* L5 \* a9 ~- i% K& }
//第m个样本下输出层的平方误差/2=第m个样本的均方误差# c. T2 n9 A& k) g\" P8 n
return 1;
9 q7 J4 L+ L\" e5 m; ?
}//子程序Err_O_H(m)结束* m f \) [3 U! Y7 X# l9 [) u; v7 @
////////////////////////////////////8 [1 @. h% M( M) w% e
//隐层至输入层的一般化误差子程序////
/ F( Q) P( M! W
////////////////////////////////////
/ v! n4 n! r' t; }
double e_err[HN];
3 c9 u# f: V+ r( g# `( z\" c
Err_H_I(){ f- D, ?. C( n* P5 `
double sigma;
1 i- v7 r0 L1 O& ]
//for (int hidden=0;hidden) p% ^3 D2 v6 X1 f6 u: g
for (int j=0;j<HN;j++)
! X7 r- a\" E. X: C
sigma=0.0;) ^! S. I$ L* }) m. G
for (int k=0;k<ON;k++) 5 k+ Y- h7 A3 {5 G
sigma=d_err[k]*V[k][j];) i- Z; o7 p7 |% p* W E
}
* G$ d# M Y+ B\" O+ X, W4 M5 w U
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
F4 [6 Q7 H6 c5 i
}6 c- p! J) `; M5 X) Y1 Q6 ?
return 1;
& Z$ G* ~, c6 c! E3 }- h; a
}//子程序Err_H_I()结束7 t0 o# e\" T/ ~' x\" V: [* o
////////////////////////////////////////////////////////) z/ z$ ~; N$ }: G/ T
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
3 {7 k* `7 }) f* e& e4 t' X
////////////////////////////////////////////////////////
q' D, c) {4 L' Y
Delta_O_H(int m,FILE* fp)
* ~3 N$ I G* w. {) o& c
{8 h5 h\" k3 o% L\" j1 p
for (int k=0;k<ON;k++)
% ` s/ j I, y- M0 l# ~
for (int j=0;j<HN;j++)! b5 i\" x' B* b- V, Y
//cout<<"第"<
- u# j1 U9 d$ `' q
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
/ v3 _# o+ B, U, L7 |9 \
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整# N7 h0 M2 f7 a) v( O5 d9 T. _
}' F8 g& |& G9 G/ g9 e$ p9 ^
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整# K( e9 k: W! J/ S% T; m
}
3 N1 W7 _: u1 W
return 1;\" u8 d' U/ Y: ~0 g
}//子程序Delta_O_H()结束8 |0 d4 [$ j/ E\" W& P8 t
/////////////////////////////////////////////////////
5 V1 u$ W$ `& a9 s
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////2 Q! a- O( F' H* j' e
/////////////////////////////////////////////////////
: N. ^& @, k7 N% e' l1 T
Delta_H_I(int m,FILE* fp)
{
8 r F$ j, K8 ]/ n/ {
for (int j=0;j<HN;j++)' a) G3 r1 \4 k' B$ S* z3 m# p0 V& P
for (int i=0;i<IN;i++)
( Q\" t5 f/ F# O2 Y
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);1 p7 y' ^) k& ?1 d3 `9 ^
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整( G q- R- W/ T; _& |
}
\" C, _0 a+ |2 K! v$ u
sita[j]+=beta*e_err[j];
- r4 [; c' ^: z. a* y* f
}$ }( K$ U3 p9 m# W1 [
return 1;
2 F2 E D- D( Q6 @( n
}//子程序Delta_H_I()结束( a0 \/ x3 {& Z9 y5 M
/////////////////////////////////
0 [- U# ~\" H\" p0 U) V
//N个样本的全局误差计算子程序////2 O7 v6 N3 g4 a& f h\" S
/////////////////////////////////
) e8 @9 j. K7 h( C
double Err_Sum()1 L9 W) }! R9 z6 j+ h- \
{- C9 p, v O- C
double total_err=0;
4 c; _$ W9 X' I5 C
for (int m=0;m<N;m++)
G6 Y$ F0 D S1 A* z' l
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
3 P4 T9 T$ x7 D4 E* F; f( Y/ |
}
( m! @' ^9 R% V7 a
return 1;& L o1 W* E9 O. z+ I; o1 U
}//子程序Err_sum()结束
3 t O; q6 t0 w2 b5 W, r
/**********************/
8 a3 ]+ o& ~, D# D$ L, c
/**程序入口，即主程序**/0 U- k; _# ~- V7 k2 V: \
/**********************/3 Z. V: o! e\" U: {% W
main()
+ H\" O+ U) w8 o8 f1 P
{
5 S; u/ C! |; j5 u3 k$ M, i9 Q
FILE *fp;4 X1 n; n: W& ]8 h0 ^
double sum_err;
. h, `4 O6 _! R/ r6 x$ {\" [ Q0 O
int study;//训练次数0 ~# F6 _. j% q' P+ { v; p
if ((fp=fopen("bp.txt","a+"))==NULL)
8 o/ c2 z1 C( L( f$ d- P d/ v
{( y\" K* D6 W Q6 Z; C
printf("不能创建bp.txt文件!\n");. W- ^% ]5 f% z2 h- P
exit(1);+ ^: E* u2 q; G+ K- V. z
}
4 N9 w1 `# _1 m; y {+ V
cout<<"请输入输出层到隐含层学习效率: alpha=\n";; ?* h1 Q4 k3 T
cin>>alpha;
& Q! E* i Z% k) m\" O0 k6 l
cout<<"请输入隐含层到输入层学习效率: beta=\n";
: a. H1 P* j1 J7 Z/ g; \) z
cin>>beta;% K6 v3 d; s4 j
int study=0; //学习次数 l% `+ @9 G) p1 x* C# U1 k
double Pre_error ; //预定误差: b+ |8 U% ]1 d& Q, S3 W' e! w% G
cout<<"请输入预定误差: Pre_error= \n";
9 m) Q+ T5 t( L; O
cin>>Pre_error;- Y! c$ g u' e, ]5 ^/ J
int Pre_times;
6 c3 }* S2 i6 ~ V2 W2 u( l
cout<<"请输入预定最大学习次数:Pre_times=\n";\" E2 v) ~% W1 m+ k V+ ]
cin>>Pre_times;
4 P9 Y) x. X- }' x2 a
cout<<"请输入学习样本数据\n";
$ d! A9 Y; l\" ^7 ]\" C8 v
{
& y; u0 H G. r! G% S# k
for (int m=0;m<N;m++)
, b0 k: d9 ], G7 s9 k4 Y8 _
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
. g9 {, Q- v8 U' E4 r# N+ a
for (int i=0;i<IN;i++)+ c( q) u5 a1 z& C( m7 V2 X# s
cin>>Study_Data[m]->input[i];
) x a9 X& ?0 K; f# r
}2 N5 B; S3 K$ U5 Z. o. x: D; u
{
- u+ L# v: i5 m
for (int m=0;m<N;m++)9 V5 f. q2 d3 ^7 ^( E
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; 2 g9 n2 x& q\" C$ t) O
for (int k=0;k<ON;k++)$ ]$ e' B/ u; V/ h& E
cin>>Study_Data[m]->teach[k];
\" E/ T# Y2 b- K
}
- U- u' y B8 @' E
initial(); //隐层、输出层权、阈值初始化 (1)
6 `* |' I' S- b6 @
do% x) c0 p7 M8 g. {$ z) M
{
1 T s, g. Y* ]
++study; ///???
8 j7 V, F4 i+ @7 P. p2 ?% p
for (int m=0;m<N;m++)
6 t/ Y: F- V8 v$ ?
{
4 G8 ?\" \! J# @9 B
input_P(m); //输入第m个学习样本 (2)& p' B6 [, K1 @4 L\" _* `/ A
input_T(m);//输入第m个样本的教师信号 (3)
- ?\" F6 q) @5 d& Z7 ]' m( c4 Z
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)' ^2 N0 ]( o( |8 @' \) z, Y% ]$ E
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
$ |7 F5 t/ |( q3 G- P
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) % i& }4 L- t; [' Z y
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)8 S/ C& t: i1 G6 v6 c5 {/ w
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
% h$ @; u4 o0 V; u, A
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
8 r: {- K& I$ W: T
} //全部样本训练完毕& w5 @' E3 u Y0 ]3 x, M+ e# H& {/ r
sum_err=Err_Sum(); //全部样本全局误差计算 (10)$ d e6 w3 P1 {+ E2 ]
{
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;2 m, N% _6 G; W9 U* R% @9 Q
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
9 O\" d9 P' L: N8 z2 D3 s/ i9 l
}% E+ ?% Q Z' o+ _% ~6 o
while (sum_err > Pre_error) //or(study
P\" Z& G2 t5 B1 P* J9 m+ P' K
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
; D' E/ c# n2 e
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
, e! R7 K) \) z
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);# x+ ?' T0 g8 o2 S* \, _
fclose(fp);\" {9 Q; h* M& i: |. [' h
}. F7 N/ a0 ?4 y# d
char s;2 ^- ^5 L8 m* G- s0 K
cout<<"请随便输入一个字符，按回车退出程序！\n";# t1 x, {4 h; ^( ~* ^
cin>>s;$ i% Y2 b8 ?- Y- o/ D6 ]. S. K( ?) {
return 1;
$ X$ p, P( \8 r7 ?
}
* n- e( n$ d2 h+ w! T+ b/ c j# q
5 t8 z2 r3 Y/ E! c* \/ g