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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

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

|招呼Ta 关注Ta

#include "iostream.h"
/ A$ K5 ?7 e7 A/ M
#include "iomanip.h"5 b6 r# W6 {- P6 N, k
#define N 20 //学习样本个数2 W0 k) c\" G& Q/ E9 W
#define IN 1 //输入层神经元数目% R7 Q! q2 Y# r; C3 }$ P0 }! J
#define HN 8 //隐层神经元数目' R0 `; h; F7 Q' v5 Z$ Z
#define ON 1 //输出层神经元数目
% ~2 O; j2 H1 ~0 r% S: U
double P[IN]; //单个样本输入数据. Z: X7 m$ B- R3 @$ O0 j
double T[ON]; //单个样本教师数据
double W[HN][IN]; //输入层至隐层权值
3 B/ W- R: g4 S# c9 e5 @
double V[ON][HN]; //隐层至输出层权值
. a# Y* R3 y1 D$ a, n5 C
double X[HN]; //隐层的输入
3 A' F% l2 A0 O, J
double Y[ON]; //输出层的输入! B7 D k0 g+ y* g1 ?# F
double H[HN]; //隐层的输出
5 D6 N4 R! j\" \3 _5 d+ C3 ]# @1 `
double O[ON]; //输出层的输出- E! |9 W7 ` F. c. f8 N$ d
double sita[HN]; //隐层的阈值
4 y7 i$ @0 {( L; x' a
double gama[ON]; //输出层的阈值
# \3 b8 } P0 _+ l8 Y7 R
double err_m[N]; //第m个样本的总误差3 a7 k4 C\" y E% }) ?0 |. Q( `
double alpha; //输出层至隐层的学习效率
- ~3 p. u$ R1 u* p9 t
double beta; //隐层至输入层学习效率
( `% a. k5 [. h3 l2 h ^
//定义一个放学习样本的结构
+ m4 Y B6 U9 y4 B o/ V7 Q; V
struct {, c0 P' r' Q M+ A+ j0 M6 f1 S; Z
double input[IN];
. }; l3 X5 V& `' a4 H q
double teach[ON];5 y. J) M, V7 J: w3 q! h1 R
}Study_Data[N][IN];\" T) z$ n\" @7 b* g: o( I
: g$ b+ E) k: `3 v
///////////////////////////
; }5 x* C' l: D
//初始化权、阈值子程序/////
1 S, w( q' f5 `- d3 v6 c# v, v- o
///////////////////////////
1 O# |) s- Z\" N7 G- S' P3 r; b
initial() b( |% l C, B! w
{
5 U; ^* z4 | X7 f4 u4 O% I
float sgn;
# \4 @! o4 m0 O9 }) X( Q
float rnd;6 j1 K) _* K8 J( }
int i,j;0 @) c8 d u2 i$ D5 e
//隐层权、阈值初始化//
% d! x7 C3 w0 e( U
{' V$ G. g# c, A9 u9 s. Q- j. k8 k
//sgn=pow((-1),random(100));
9 m2 ~7 n5 M9 T' G* i
sgn=rand();
& o8 a9 `7 R$ L2 C% U8 U
rnd=sgn*(rand()%100);2 m e4 }1 a7 O: T
W[j][i]= rnd/100;//隐层权值初始化。
w7 L% L* ~6 a; N* v
}$ ~! O. q; {2 t5 A
//randomize();
+ U1 t$ D2 L1 q8 z5 V- Z
{
- H2 [4 J! H5 ~. W0 P9 H0 O
//sgn=pow((-1),random(1000));1 z6 S2 d, Q8 w1 q& p( O+ [\" i) R
sgn=rand();. y0 h+ Y. J& e% f\" j
rnd=sgn*(rand()%1000);% E) n' A$ I7 |5 ^! U1 E! K
sita[j]= rnd/1000;//中间层阈值初始化
# ~( s# V1 y k7 B& b
cout<<"sita"<<sita[j]<<endl; n, E, f- z; x
}
& N# m0 J3 n4 l6 ?/ t/ X; ^' }/ M# n
//输出层权、阈值初始化//6 f+ J. C& b' G' M5 ?) X
//randomize();( `( E7 B9 a4 d$ h* r; D
for (int k=0;k<ON;k++)
5 N, [# U' l c\" E
for (int j=0;j<HN;j++)
7 |: g/ J: J/ f* D' F+ Z
{
9 v6 m) k; c9 C5 _0 N) V
//sgn=pow((-1),random(1000));
* P$ M\" c& R2 B, _
sgn=rand();! U) t- D: r\" u T# }4 e6 r
rnd=sgn*(rand()%1000);2 j- n5 M' T/ _8 v
V[k][j]=rnd/1000;//第m个样本输出层权值初始化: U/ X\" |* b7 |( Q# Z
}
! m1 z$ t\" [7 r7 i F9 ~: k
//randomize();5 k; M$ v6 n/ v) Q
{; y6 y5 i/ ~! S, M
//sgn=pow((-1),random(10));
+ o% E t, P; _8 [6 o
sgn=rand();4 t- s& r) ^8 @4 W* m
rnd=sgn*(rand()%10);. z$ \6 [4 U$ r' K
gama[k]=rnd/10;//输出层阈值初始化
9 z4 t( C3 k* h0 K Y; n
cout<<"gama[k]"<<endl;
* ^4 d t\" }9 [1 @9 l, S0 [7 M
}6 r2 A1 H( p' n; `3 Z
return 1;9 |: ^8 `( [, K, I4 h
. @! y6 E$ ?8 \ z: w3 f2 Q8 Q
}//子程序initial()结束
' }) K7 |2 C2 e7 S$ K\" T, C6 f
, K h+ M' F, {9 l+ L' \2 x
////////////////////////////////; { H' w# x& f( ^( v3 u
////第m个学习样本输入子程序///
, k\" N; z1 Y% `/ h+ U
///////////////////////////////
7 w6 ^2 w, I7 y; a$ _! V4 \
input_P(int m)& n1 i) P! n6 g' r& v$ w3 w
{
) B8 }4 |7 H0 |! z/ j
for (int i=0;i<IN;i++): |: S! ~0 f1 z
P[i]=Study_Data[m]->input[i];
L7 T- H% i( E
//获得第m个样本的数据: j\" R9 D\" _4 [8 M4 F8 P. ]
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
% \: F, {. A; m' `& k
//P[%d]=%f\n",m,P[i]);
# p' a% B8 p% b% j2 s9 j0 D
return 1;
m/ F; d; c5 F7 F- d6 D+ W: L
}//子程序input_P(m）结束% a# g4 T7 f0 R, L7 ~0 S$ x3 D- a! q
/////////////////////////////9 z3 f' R: F( M5 l; L. C
////第m个样本教师信号子程序//
% [( |5 @3 m- Y- r, P; B6 V
/////////////////////////////
$ X8 }* j$ S9 G$ {; W# l
input_T(int m)% q1 k& {\" H' K7 B! M1 s
{ }$ D {8 e7 g& V0 K3 ?/ R( d1 y. L
for (int k=0;k<m;k++)$ N5 [9 `9 l$ m9 [( n4 m0 c
T[k]=Study_Data[m]->teach[k];) P0 N! b( M+ y5 j' j: P
//cout<<"第"< //5 K9 s) d\" _0 Z/ I2 H
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);+ F1 `$ |/ u8 [. C) L
return 1;
. x7 w( `) s6 k3 z
}//子程序input_T(m)结束0 \- C9 [) z$ G; t
/////////////////////////////////2 s0 R, Y4 S* V3 g% y2 Z4 _
//隐层各单元输入、输出值子程序///7 b, x2 w; s1 s3 o# P; b9 f
/////////////////////////////////
7 p8 _+ v0 }- x
H_I_O(){\" }# H9 X* l: c' [4 ?0 { b
double sigma;
, W2 m$ \( U C- k
int i,j;% A( Q6 c0 k _; }$ K6 M9 k
for (j=0;j<HN;j++)( n7 F/ b# m! Z5 J- n
sigma=0.0;* z4 H0 c* U8 @. Y% P, O
for (i=0;i<IN;i++)
! c$ m& A6 B; g- t7 F
sigma+=W[j][i]*P[i];//求隐层内积
X, J- A9 w0 N4 H\" O
}2 O% z U6 u# {. ~
X[j]=sigma - sita[i];//求隐层净输入, n2 J' {' P* h1 T
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
1 a6 f3 k6 P( i5 d( @3 B
}
: [\" }1 F1 `/ p# W
return 1;
0 [( [( Y. n4 A: ]
}//子程序H_I_O()结束
6 z, z, `$ a6 H, V# T+ R
///////////////////////////////////
//输出层各单元输入、输出值子程序///2 f( a4 C, x1 c0 } R* J/ `
///////////////////////////////////, f8 }7 j* z& }
O_I_O()
$ G, s& x( B\" m3 l
{
/ a4 H5 Y' m$ h- @8 D8 ]
double sigma;
$ W3 j8 W* h+ a\" R3 i. c+ T5 N
for (int k=0;k<ON;k++)0 f# r* K5 [9 `
sigma=0.0;
8 ~, C0 ?* y( {) b% n1 [
for (int j=0;j<HN;j++)
8 q( ?; W& R! Z7 C$ S
sigma+=V[k][j]*H[k];//求输出层内积
+ n: `1 J, \' c
}
* M/ u p8 D) s5 m- s& S
Y[k]=sigma-gama[k]; //求输出层净输入
* r* r; J6 I \7 E' Z
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
8 Y& S+ b5 r+ J1 ^3 I! z: R
}
. U* B2 G3 N9 v7 A1 x
return 1;9 q O- Q\" u) u7 ?, R% D
}//子程序O_I_O()结束
3 a; |$ C3 p& J/ \7 E* i/ K- E
////////////////////////////////////4 J3 U/ U! T3 u+ z# {6 @: s
//输出层至隐层的一般化误差子程序////' _2 @8 K: t# t( B$ Y7 s# s- O# D
////////////////////////////////////
- v2 T0 R$ W9 K
double d_err[ON];$ L, y% W( m8 `7 I, Z6 _+ j. X
Err_O_H(int m), I) \9 G; G2 l+ k# B
{) y$ Q8 c# \- i1 n) j7 L: T# b
double abs_err[ON];//每个样本的绝对误差都是从0开始的 V% ?; W- l$ L\" [* s( c) k1 s
double sqr_err=0;//每个样本的平方误差计算都是从0开始的' e/ g( I, X. T6 c
//for (int output=0;output<ON;output++) //output???
) Y& ~, d8 o$ m\" n5 a
for (int k=0;k<ON;k++)
9 U. S. |# A6 b1 _
abs_err[k]=T[k]-O[k];
0 K3 A' i0 ^! X
//求第m个样本下的第k个神经元的绝对误差% @# K. q4 g* Q; w+ ]0 U' j
sqr_err+=(abs_err[k])*(abs_err[k]);6 c R4 |6 x\" y; A/ e0 P' j
//求第m个样本下输出层的平方误差
c! K2 K* X- k- R
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
% B p# ~# \' N
//d_err[k]输出层各神经元的一般化误差
5 j# y6 ?\" u0 O; V
}
7 b7 `( Z! D: g7 z2 C8 s; q+ t% R& g
err_m[m]=sqr_err/2;, I( N3 `3 b) U) `
//第m个样本下输出层的平方误差/2=第m个样本的均方误差3 y$ k: Q! J$ y: ^* o
return 1;6 i ?9 s0 ]; O/ B0 G# a
}//子程序Err_O_H(m)结束
' r/ p* M6 t/ \7 v: J
////////////////////////////////////
; L* C% N\" ]9 }4 A- g
//隐层至输入层的一般化误差子程序////; U' i* t2 H\" x' Z; M; [
////////////////////////////////////
j5 k5 d- C/ k% [) ]5 J! Z
double e_err[HN];( G: c1 L- W9 l$ U8 k* b `' J# E4 Q
Err_H_I(){
5 ?5 D* A9 s) l, _7 ~5 c' b$ y
double sigma;- L c! u: `1 s\" m
//for (int hidden=0;hidden( E7 Q: t! Y- v: o G
for (int j=0;j<HN;j++) + K* O; C5 Y3 [6 D
sigma=0.0;: V# W, x$ `+ u) e/ s& n8 R; Z
for (int k=0;k<ON;k++) ' d. Y; b, S0 K- z$ |
sigma=d_err[k]*V[k][j];
4 ]* ?* G }- x l
}* o B+ Y7 T: d' d7 P
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
7 O$ M+ U7 f* r ^; p; Z
}& v0 W# @# j. a# U* @5 H1 j* I
return 1;
* o9 y V- \& L, |
}//子程序Err_H_I()结束; c E; A% ?; {# L' I. M
////////////////////////////////////////////////////////
( @$ \2 `* _4 J9 J- R- Q; h3 I
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
4 U, u( g- v7 b1 M0 C) K5 ^* C
///////////////////////////////////////////////////////// o- [. x. k: \) D* d( v+ t
Delta_O_H(int m,FILE* fp)) W7 S- R2 J0 K4 |! R6 J
{
5 a, s0 i; e7 X& e9 d9 c7 _, ]. z8 ]
for (int k=0;k<ON;k++)+ @% H# ^9 H+ u8 h3 v, ?
for (int j=0;j<HN;j++)/ E; G6 p. P& U
//cout<<"第"<
! D0 \6 D: S/ w0 A
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
% g7 o/ T\" a, [# f; h- n6 S; r
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整; t$ B1 m. U6 b, p
}# l3 i/ G' k4 e( ^+ K! H. }) O. R' ?
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
+ |0 C% F1 X( t( L
}
/ l: z& `: H# q7 w6 S
return 1;7 Z- o! M/ \; q$ E( J+ ` ~9 S U* M
}//子程序Delta_O_H()结束( n( r\" y, G# T& B+ D+ \, R
/////////////////////////////////////////////////////\" |8 `' [7 h2 y- q/ O0 O; C) v: p1 k
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
% d% k8 E& {0 q x8 _
/////////////////////////////////////////////////////
3 L3 q8 N0 ~* U% P/ }
Delta_H_I(int m,FILE* fp)4 q- P) O g i
{
4 t/ J3 m5 l; p I
for (int j=0;j<HN;j++): p) P% K0 { [3 m$ g: g& i# Z
for (int i=0;i<IN;i++)
1 u+ X( K% A5 r0 `1 r: G
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);: ~ ]+ M [* s
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
6 ^% `1 @$ e# z% k2 d' b
}
$ g3 a( z- d- q7 h
sita[j]+=beta*e_err[j];; g4 \- T( ^/ z+ L. t# @9 G- w
}
/ h+ v) o( D( F* k* Z6 S0 R: B( R! |
return 1;
) ? r) [8 Q. M- J- C. V7 H
}//子程序Delta_H_I()结束( m2 t( l4 } T+ M' b
/////////////////////////////////
/ v f3 C% K/ a( Q% k- L) X
//N个样本的全局误差计算子程序////
7 K0 Q# L# Z' w* x
/////////////////////////////////' E& Q% P* c5 P, K# i' ?! _
double Err_Sum()
/ t8 T! ~6 p7 K( j2 ]
{) N6 y9 H$ b: O G
double total_err=0;2 E8 d4 E E4 f% _
for (int m=0;m<N;m++)
+ j& Q+ w4 }! |7 L! D
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差% O: C2 P/ j0 _7 z F/ o6 E
}$ [! @; I0 J( T) t
return 1;6 e* E! J3 p7 A& T$ K; [8 a z0 \, y* T
}//子程序Err_sum()结束: X5 y+ f) u! R( e; R
/**********************/ {7 y: i1 A/ n: U# X2 T
/**程序入口，即主程序**/
D# {* a4 T\" a0 _, V\" O
/**********************/+ R! v. h) N5 v) s$ M' V' U
main()$ B6 Y5 g/ Y) u! k' u: y0 N
{) L3 o9 X4 ?1 T7 F2 W! R8 h
FILE *fp;: c; q7 T: N, l3 u; M1 Y
double sum_err;% _* c, P* a\" z
int study;//训练次数, _ B( S! y8 v' X' R: n+ X
if ((fp=fopen("bp.txt","a+"))==NULL)
/ u1 I$ v1 u/ f- G% Z0 A q
{: e1 B\" O7 l9 y5 X6 `\" w) Z
printf("不能创建bp.txt文件!\n");
2 Y6 u: p$ j. L, }( Z
exit(1);8 }& M) |: b4 x4 q, w/ P/ I2 `
}8 @8 l* Z |6 e1 L1 z: b+ f
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
; |7 j, k/ B$ Y1 Y
cin>>alpha;$ X6 n! z- T' q) W( f- |
cout<<"请输入隐含层到输入层学习效率: beta=\n";
/ E- r. r: ^& C# \. O' O
cin>>beta;\" }9 U. P% w. t8 K( z\" |, c* ^0 z
int study=0; //学习次数
& _- Y7 c2 o- O0 A8 o) x% j9 h
double Pre_error ; //预定误差
* T9 F! j. u\" m0 V
cout<<"请输入预定误差: Pre_error= \n";
) Y+ r8 w' B9 H0 J. P
cin>>Pre_error;
/ @3 H/ K) [* { d: q
int Pre_times;7 r/ F4 ?* _& \7 H' W. @
cout<<"请输入预定最大学习次数:Pre_times=\n";
\\" R/ B9 `: K' k
cin>>Pre_times;
; q0 p% i7 K% X% k5 E
cout<<"请输入学习样本数据\n";
, H) y5 p6 a9 | q$ y
{
/ s7 j- |3 f- N3 u, X! k2 I
for (int m=0;m<N;m++); H0 l2 m\" U1 V' C/ {
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; 7 ?\" W: X/ l7 r/ v' F- h6 g- y
for (int i=0;i<IN;i++)' z/ D) ~- i; i, ~- V1 d: [3 K
cin>>Study_Data[m]->input[i];, z( h8 a+ v9 J6 b. S& h) L | `1 g
}
& B- |- U* U$ J( l; F/ `. }' e R
{
, \1 K* ~! h' k1 e2 r
for (int m=0;m<N;m++)8 A) v% T& C# |' U% q3 s
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; 0 c. s. i2 \; b3 V
for (int k=0;k<ON;k++) G, E+ J7 L. ]3 z- {
cin>>Study_Data[m]->teach[k];$ u1 D/ d0 O- N* v! j1 m# v
}* d* t& v% Z: P: K
initial(); //隐层、输出层权、阈值初始化 (1) / P9 G( `$ y4 j) J; q
do
6 d7 c$ ~0 s% K, @: {7 S7 @! v
{% v' {\" V2 B6 w, T0 B% C
++study; ///???
* u1 i1 U7 y4 z* D# _3 q- w
for (int m=0;m<N;m++) * T' _6 N* U- f9 i1 F- f
{
7 K' K& Q7 \( Y9 U
input_P(m); //输入第m个学习样本 (2)
0 Q\" M4 p7 Z+ x& ?5 g
input_T(m);//输入第m个样本的教师信号 (3)- `( m. X/ q4 A) A% L! G t
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)( t. k6 {% s( S1 t k# ]- t
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)& s4 f, e* i+ E. E
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
1 v& P7 A3 S4 C$ q4 h4 ?8 @
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
: e8 L/ p C/ n9 W0 Y
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
! ]5 C9 d1 o; k$ S d+ r, j
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)& y4 a: A7 g# L\" x1 c: _
} //全部样本训练完毕+ U/ r9 r! e$ P) w, Q' L+ b% D
sum_err=Err_Sum(); //全部样本全局误差计算 (10)$ [! b3 l8 }, j
{' ]$ I2 t! K( T+ ]' i& x' ~
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
: J: E( Q# w% v7 U; _7 l6 x- l
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
}! s6 N& N# u2 D2 C4 K8 {1 j\" e
while (sum_err > Pre_error) //or(study/ v- z( {, m+ B) |6 P
{ //N个样本全局误差小于预定误差否？小于则退出 (11)3 }+ [) X4 T5 m/ K3 j
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;8 o( H' o# h5 E! L$ @
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);/ ]! s5 f2 x6 w/ A
fclose(fp);
6 m( c7 o, g9 z- f- U
}
4 s9 |. W! l9 E v
char s;
! w, f; |9 l; G$ @
cout<<"请随便输入一个字符，按回车退出程序！\n";2 t1 m3 d2 @2 b
cin>>s;
% g1 C& t) G5 T/ Q* H3 K
return 1;
/ T, g, j* q5 N4 v8 x! s# R
}. I. P, |6 W( j
9 r8 @* y! _* S8 D4 _