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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h", i3 E8 z' O1 e, E- ~
#include "iomanip.h"
; \* ~2 `$ ?9 P
#define N 20 //学习样本个数$ G6 d% N7 n; O* l* i
#define IN 1 //输入层神经元数目
. S4 A0 a; \! Z3 i. y. T
#define HN 8 //隐层神经元数目7 ?- b! _4 s* e
#define ON 1 //输出层神经元数目
0 w6 \/ e* |% x5 b
double P[IN]; //单个样本输入数据
k& E2 _# \! _- z; v: @* ^
double T[ON]; //单个样本教师数据
3 y' u' f3 X8 |- b& A* S7 F
double W[HN][IN]; //输入层至隐层权值
) G' t. t3 m% l( B/ ]
double V[ON][HN]; //隐层至输出层权值2 l5 E) I2 Q; Z
double X[HN]; //隐层的输入
) s0 I+ Q- d! O
double Y[ON]; //输出层的输入
8 o# M1 M4 c5 r, [' d9 Q\" l
double H[HN]; //隐层的输出
\" l- \. F. _9 Q3 z I
double O[ON]; //输出层的输出0 n\" f# d0 i' W, o
double sita[HN]; //隐层的阈值: s1 p\" V* J; M, d/ c4 A. c+ ^
double gama[ON]; //输出层的阈值
h% b* U# C/ a\" D& i. q& O
double err_m[N]; //第m个样本的总误差
8 S2 _; a+ W; w# S1 p2 H3 F
double alpha; //输出层至隐层的学习效率; }7 l/ q' P) A, f# F
double beta; //隐层至输入层学习效率
. ]. ?; `8 F, ~* D, C* ^
//定义一个放学习样本的结构
: R. w: { \\" K* [( ~4 V
struct {
1 E6 q7 S8 X+ W\" a! o
double input[IN];
0 ~# i/ x+ |& s! ^
double teach[ON];
# G2 y' O\" L' x# t. `. ?
}Study_Data[N][IN];5 M! z* [+ S; n. P7 H9 @
4 N$ e! a3 f+ H9 ]
///////////////////////////, r. w$ M( _0 |, P$ }8 N
//初始化权、阈值子程序/////
4 A3 I4 ?' f$ U/ g, s
///////////////////////////
) t* B1 W N- R! I2 e; d+ \
initial()7 c5 v* n8 ]' [/ N: N' \
{
% L' D\" [5 a+ O p& p% q/ k4 @
float sgn;
$ N$ |' p' U6 n* q. b# F
float rnd;* \$ g' ^( Z( X' u& ]6 F' z
int i,j;
- P9 \7 f: b2 }; I$ ]
//隐层权、阈值初始化//! {, F' T# U& O: K* V- d# n5 |
{/ N' ]6 i8 ]8 e! ^4 ^; C, _
//sgn=pow((-1),random(100));
- W& [. |' J* Q) j
sgn=rand();% Z+ D) Z, S5 q$ X% p0 ~
rnd=sgn*(rand()%100);* w5 {/ c: p, E, a, c* X1 K
W[j][i]= rnd/100;//隐层权值初始化。
& D0 E7 Q2 V& p/ C$ j! t6 n+ E
}# ?' r+ f/ Q' @+ ~& ^* m$ l% r
//randomize();3 ?/ z) Z5 q( m V
{7 G+ t/ C/ o Y
//sgn=pow((-1),random(1000));: E4 d# X2 e% C Y' H3 z; x) h9 W
sgn=rand();
- U1 H7 |' ?( O* [7 b0 {. ^9 I& k
rnd=sgn*(rand()%1000);/ F) `2 Q h% ?+ w\" Q e ], D5 F
sita[j]= rnd/1000;//中间层阈值初始化
/ n$ v8 L2 I k6 j$ a\" p5 I
cout<<"sita"<<sita[j]<<endl;% i: k2 b. q2 B) C& b! ~8 _. P
}
% c1 q( ~' r, |% S2 m+ ^
//输出层权、阈值初始化/// N* J% Q2 d) O\" Q8 ]' A$ B% {
//randomize();+ c M' b; ^ o( ^6 t8 A\" X3 Y\" E* z
for (int k=0;k<ON;k++)
8 k: q5 ^# G1 Q+ q: i* _ S
for (int j=0;j<HN;j++)
8 ^& O2 X1 E$ B$ j\" T
{( }, ]4 o! I9 X7 g
//sgn=pow((-1),random(1000));
7 c) d* O: A+ V' ~
sgn=rand();3 M1 S\" p+ L2 k3 {2 L& ~\" p
rnd=sgn*(rand()%1000);# b2 J' f! o2 f\" ^
V[k][j]=rnd/1000;//第m个样本输出层权值初始化; D4 H* ]\" @! Z
}: G1 h. K, d7 b& H! n
//randomize();8 K' s# @$ |8 n, ?
{9 J* Z* u2 i. S
//sgn=pow((-1),random(10)); ]+ P i) W7 M) D# W8 M
sgn=rand();
% x1 L- ^1 E1 o3 s7 C o; w
rnd=sgn*(rand()%10);* x% p7 l5 _+ m( Y! k
gama[k]=rnd/10;//输出层阈值初始化* W6 h5 l* t6 _* \; u1 M, r
cout<<"gama[k]"<<endl;9 r% [\" s5 M* W9 w& D, S: s\" K$ d
}7 j- R% x2 b2 j8 N# F\" g
return 1;0 d- }0 O& g5 ^2 _. w
+ x5 d& T( r6 ]; w# y9 p
}//子程序initial()结束: _: ~ [! x3 Y, q* u7 m
7 @( R6 n; F U- P4 \/ s* y8 {+ F
////////////////////////////////( D6 h0 d# Z( F( Z
////第m个学习样本输入子程序/// b' f2 G# D# i$ B
///////////////////////////////+ u\" T0 r9 X2 |/ \
input_P(int m)
0 T/ o. X\" ]% V( s1 \
{1 X' N& i6 _. K6 Y8 Y5 t
for (int i=0;i<IN;i++)
! z/ z3 N8 ^9 G# c3 |6 U
P[i]=Study_Data[m]->input[i];
! \% n3 \3 E- ~\" n\" a
//获得第m个样本的数据
6 y4 v' L/ [/ v$ o\" H, v6 l8 t& Y
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
# I. q6 N4 g% t- ?
//P[%d]=%f\n",m,P[i]);7 [! a- v: T. U, Z; w2 I+ P
return 1;( o* g3 E1 a# P\" {\" E, t* u
}//子程序input_P(m）结束
1 N7 }2 u\" q5 Z% V\" E\" m D8 [
/////////////////////////////
! p! h; Q2 m7 L9 C, @5 o' H
////第m个样本教师信号子程序//
4 T4 i0 Z/ `) P- U
/////////////////////////////. o5 Z! e' [- E9 W$ P8 G
input_T(int m)
' [ K3 ?- W) w: H; D* `
{ L. G2 K9 B1 t. a# P. C% i
for (int k=0;k<m;k++)
6 M7 r' x; N$ K' a' c8 r# A* F! ?
T[k]=Study_Data[m]->teach[k];! }% j: M# }% R6 i+ b* r! e6 u* S/ z
//cout<<"第"< //( h! Z\" q/ D, M$ l; |
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);( i; c- i\" ~( D. _0 `\" n
return 1;: ]/ f( {\" l! U9 d2 ^$ j8 p
}//子程序input_T(m)结束
- x0 x; l( q. J: f: u+ Z) z9 v- l
/////////////////////////////////
0 h0 b; j$ Q m' k
//隐层各单元输入、输出值子程序///2 f' w8 M\" G\" e) R$ ]5 W3 J% F: H6 z
/////////////////////////////////
! t7 s& m\" e: d( T
H_I_O(){5 G; }1 J+ x0 \. X
double sigma;1 r$ ?' L. O2 f7 F6 Z* _* y
int i,j;, }/ ~% u6 R# D5 L0 ?
for (j=0;j<HN;j++)+ M+ p6 _0 w) j
sigma=0.0;
$ w1 b8 ^/ |; [8 p9 M* p( U Z! @
for (i=0;i<IN;i++)
, |. K* w; u$ G- R0 t
sigma+=W[j][i]*P[i];//求隐层内积0 J' ]& Z: I- b, o
}
3 y; s+ E7 O2 S4 [
X[j]=sigma - sita[i];//求隐层净输入
9 ~% I; j, i, |' v+ ?
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出1 T3 Z9 I$ { b7 x6 |
}
; ? f3 k\" a* Q& p
return 1;
# `# H\" |. V5 J* ^5 ^3 d
}//子程序H_I_O()结束
& k1 W; l% C, g7 w
///////////////////////////////////
6 ] I7 M\" u1 w; a$ ~# w
//输出层各单元输入、输出值子程序///
0 s: p1 T# ^: j% ?9 H# \$ c
///////////////////////////////////
9 c* ~9 \/ W6 ?% J2 J1 @4 o
O_I_O()
- ]+ G- u+ E9 T0 _6 j& _
{
$ |1 S0 _8 h* L# _
double sigma;
: i) I' P' j s' p' }( q, X
for (int k=0;k<ON;k++)
% v; m1 P. C6 M5 \+ L8 N
sigma=0.0;
3 e: o. T, E/ ~: J6 y3 e+ Q
for (int j=0;j<HN;j++)
. u8 k% @\" v. z5 W$ L8 t+ w
sigma+=V[k][j]*H[k];//求输出层内积7 Z% C4 s% {; p7 ~! S\" n: I
}
\" X. ~# S. s }) Z! S; q7 \0 E' ~
Y[k]=sigma-gama[k]; //求输出层净输入) h8 d+ Y2 [4 t9 f6 Q+ F9 b: }
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出\" j' h. h3 d* E
}
; x8 J3 D- @1 ~, f
return 1;
6 E. d$ i- z3 h9 [
}//子程序O_I_O()结束
2 N& T7 |: Z! x% a6 ]
////////////////////////////////////
* p- V1 R) ]3 n
//输出层至隐层的一般化误差子程序////
8 ]) T: h4 ?& B% g
//////////////////////////////////// n- D\" m' B1 d( t\" D
double d_err[ON];\" d3 ~, p8 y$ W [# I9 p
Err_O_H(int m)( I j/ n+ ]# k& x\" q& \( u
{; _$ `5 K7 ` p
double abs_err[ON];//每个样本的绝对误差都是从0开始的
2 Z6 I& n7 S; ~. b6 f
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
8 V# X; z. m3 S3 w$ \' A
//for (int output=0;output<ON;output++) //output???* y4 R1 r F9 z& I, Y$ k
for (int k=0;k<ON;k++)% E' @ i0 W5 f6 t( F$ \3 [% i
abs_err[k]=T[k]-O[k];% n/ l\" f- p* E- Y
//求第m个样本下的第k个神经元的绝对误差\" N) A# J( M/ L4 E6 X. T
sqr_err+=(abs_err[k])*(abs_err[k]);1 [) ^, F, g( d0 n, P5 L' \8 ]) ? K
//求第m个样本下输出层的平方误差
! _% w R' ~; G, | W. s; _
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);1 p* v2 I& H2 ~$ s+ J& p
//d_err[k]输出层各神经元的一般化误差- @. ]) G( o* ~6 [
}
1 M+ X5 A) B\" R: v
err_m[m]=sqr_err/2;
1 b, d6 h5 u5 S+ ^
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
; w+ b0 U6 N; ^/ I# A5 t& e; Y
return 1;2 m+ s X# d; ~. y( C3 N7 j
}//子程序Err_O_H(m)结束' t7 F. F) y9 Z( c) o/ i& v+ v' I
////////////////////////////////////
# ^: ?/ x) c) _2 ^. F\" g
//隐层至输入层的一般化误差子程序////
! ]& W' m* T3 l G- K
////////////////////////////////////- }; b+ s+ z) c2 j0 S* m+ [
double e_err[HN];
% X& f3 q+ z) L! |& S* Z/ _: P, [
Err_H_I(){) S) [# r C$ S; T
double sigma;& A1 w# ]$ k\" {+ M8 ~7 n/ t7 d
//for (int hidden=0;hidden
\" I8 x8 f+ j7 _# w, p$ g
for (int j=0;j<HN;j++)
: U l1 P& Y$ ]' ]
sigma=0.0;
& K7 j9 U/ Q0 m9 `! J
for (int k=0;k<ON;k++)
4 q1 ~9 }5 x- z, }1 G
sigma=d_err[k]*V[k][j];
0 B+ K4 n) G1 O- ~4 z4 @2 |
}
' c, L2 j6 R+ m& V' e+ U! b
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
9 {: Q, ]$ _. Y% z
}
/ S9 F% ]5 D: r4 U7 G
return 1;9 p K. Y2 c# w0 J, ]
}//子程序Err_H_I()结束7 T6 g- ?5 Y6 X( x8 e
////////////////////////////////////////////////////////0 q- @\" _; N2 ?! N& ^' n
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////; k E9 h9 x' C# w9 q
////////////////////////////////////////////////////////\" J( |0 D) Q1 F$ m( g! J
Delta_O_H(int m,FILE* fp)
; a. U( J- b2 g( J
{
, i. }; B/ b' e7 U
for (int k=0;k<ON;k++)6 M& {7 h) M- V( {/ `$ H5 V
for (int j=0;j<HN;j++)
% s/ R0 T+ T7 I
//cout<<"第"<
0 ^7 C8 m e: g9 V4 T$ H3 _2 W5 P2 o
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
. {. U g' s: m, I, X3 S, z' c
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
+ [# H3 \# T+ L. d$ u; K4 @
}, K& ]* D1 V* f2 G/ w
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整# r- Y& I I& C5 B
}: \! K( a8 N: ^0 w
return 1;
8 H# i0 k8 S9 e9 [7 S# p1 d# X
}//子程序Delta_O_H()结束5 ]/ ?2 A/ O p4 ^& z$ N+ G' a! j
/////////////////////////////////////////////////////( T/ b. h) @0 `: z( ]- y: s
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////- O7 z$ d' A3 A1 o' g. m8 G: P
/////////////////////////////////////////////////////
: E m( t\" u7 N9 t
Delta_H_I(int m,FILE* fp), s+ i8 C U2 t! e1 @% x; F
{
$ Z- T9 G, o' m# v1 Y
for (int j=0;j<HN;j++)+ p% {- J, N# }2 A' p7 ~
for (int i=0;i<IN;i++)
- `+ M+ e/ l$ x7 h
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
# Y2 S' U) E. _/ G
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
) O; a7 z; @' c* o/ ~
}
: `' J0 S' C\" u: u5 G V
sita[j]+=beta*e_err[j];& ?8 v: h, O% S8 x
} b& c9 d4 m U, s0 D0 l2 @4 }! p
return 1;
6 _+ E; i* G, \$ M
}//子程序Delta_H_I()结束6 v' Y' Q! @- x0 d& k( f
/////////////////////////////////9 d; O. }: m! p0 e; K
//N个样本的全局误差计算子程序////: R8 i* o* o1 P* G/ N8 Y1 [
/////////////////////////////////
( _9 q3 Z W\" f
double Err_Sum(); `2 s2 ^ X, g, G\" {7 i; _, L( _
{
0 H- i\" z6 E8 L! G$ }- g4 h, W
double total_err=0;
4 e B. y% ]/ H; }
for (int m=0;m<N;m++)
, }& _& c3 l5 V
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差/ I- x, s! |2 A/ Q3 x1 \* V J; Q
}
8 q5 d8 D% w; H6 b; w2 i
return 1;
8 W: s4 i\" u: Q& L
}//子程序Err_sum()结束
8 t# y Q4 f; c6 `. z5 W
/**********************/4 ~) R0 J\" r5 p5 ~3 l; [
/**程序入口，即主程序**/7 q5 B W0 I. w# ]# ?
/**********************/) N2 U+ y3 S' D* C
main(), X$ O\" b6 e2 ]
{) I5 R) H) I! z, x) V1 q5 [+ i6 F
FILE *fp;
6 E3 ^/ q* }\" f8 D& |
double sum_err;
/ D7 d/ q# m6 k
int study;//训练次数/ x3 [$ Z0 G; ^\" Q\" A7 S) b
if ((fp=fopen("bp.txt","a+"))==NULL)+ E: Q% X9 u5 y0 F9 v& d% U
{- P# d( u2 X' Y3 p: Z\" n, N ~
printf("不能创建bp.txt文件!\n");
# |2 Z$ Y$ t, b$ O: a5 L
exit(1);; B, Q l7 l$ L
}3 ]. L9 b1 r4 l4 w3 y
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
/ F5 r$ |6 w! G( w0 p
cin>>alpha;* O) o* k! l. K2 }' P; Q
cout<<"请输入隐含层到输入层学习效率: beta=\n";
9 a6 R* k# U ?. S
cin>>beta;
J\" I, m- A1 N9 S6 Z
int study=0; //学习次数
! S# J$ L6 z) D% |
double Pre_error ; //预定误差6 c% B6 X0 Q7 A* r; d
cout<<"请输入预定误差: Pre_error= \n";
# [6 C* J7 |6 B0 f
cin>>Pre_error;: w5 c) w1 e9 p+ k% ?# x( E
int Pre_times;) g4 b3 v m) o: U& s( e8 g( ~
cout<<"请输入预定最大学习次数:Pre_times=\n";
L( T' r) I; l
cin>>Pre_times;
\" k) D3 d9 H) l
cout<<"请输入学习样本数据\n";
8 q1 i/ h8 f- I5 `* ?& J) {
{, R8 t& @! D: _- d. [7 F
for (int m=0;m<N;m++)
* @\" }8 G( |. {5 S# i
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; . _ H9 T% g& [9 o' ~- {% Y, e; o
for (int i=0;i<IN;i++)
5 B: Q; r( v# A6 M: z; }
cin>>Study_Data[m]->input[i];' W\" r8 O% [ Y( c( ]
}0 H/ T2 Q) ?% U$ m. J) x+ {5 J' \
{
2 B8 a+ T5 K. s/ l
for (int m=0;m<N;m++)# {4 L. }4 B* Q! k8 Z! w' I$ s
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; - E0 u0 Y\" U1 z5 P3 Z6 b3 o
for (int k=0;k<ON;k++)
/ {+ N7 Y) E8 ~( w
cin>>Study_Data[m]->teach[k];
6 c$ Z/ n8 Y$ Y, [7 I
}! `8 |0 q9 @% _& i. D! I
initial(); //隐层、输出层权、阈值初始化 (1) ' {0 W3 R4 k6 S C; _
do
/ \; [: c Y7 P! D @' E8 v; s
{/ V- q( R2 y3 g
++study; ///???
: D+ N ^( J6 F0 t& w4 }' p
for (int m=0;m<N;m++)
* P% i2 }, |+ Y& R, u
{
9 U( q; b3 R\" _\" a& U, n2 X
input_P(m); //输入第m个学习样本 (2)1 y* n. y7 f& c
input_T(m);//输入第m个样本的教师信号 (3)
6 _! I/ [3 n5 C6 h0 A
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)/ X2 ^: b9 f4 B; c- Z
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)& G, u+ E% N- [) x
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) $ A. ]0 }; h2 P8 W) F, P, ~
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
2 P, U# r) r( v
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)9 ?+ `$ T$ A# l3 Q$ L# f0 }: y+ j
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
, W5 M+ R l; j+ r
} //全部样本训练完毕7 @/ D- r$ B% a/ _2 c u! k. z
sum_err=Err_Sum(); //全部样本全局误差计算 (10): H\" e- F0 ]; K, g& V
{
+ q. y, Z! k\" Z/ a- N! |6 |3 Y; x
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;7 E5 ^8 w+ u8 m& `) i2 I/ X0 j( P
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);% j& `& [6 @3 i% p) v
}6 ^$ k\" k1 y/ o2 G2 G
while (sum_err > Pre_error) //or(study& t- j2 G8 P: o
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
M3 e/ @* z- `
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;. a# s$ R2 \5 E* E. z
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);% i% l& w J( U% ]5 b0 Y$ B( N
fclose(fp);
: E: N( n% Z' e. R U% K\" \. u8 b
}
# O3 o1 y6 m1 E# ?# s: I
char s;: G3 p( H! y/ H# T
cout<<"请随便输入一个字符，按回车退出程序！\n";( c- a- H' x1 M& {% p
cin>>s;
. @% f7 B6 e) X6 k. B( V5 H6 [
return 1;
' |! X% G+ {) M& w
}
1 v2 N v% o# Z\" r2 I8 f% D4 V
& g# T# M. B/ H( D9 ^