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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"4 V8 u! f* y3 r7 R' q! Q
#include "iomanip.h": u [( f: t: o% X3 N
#define N 20 //学习样本个数
- M! w+ h0 H' J6 g) q4 y
#define IN 1 //输入层神经元数目
* ? A/ v) b6 z\" H\" _3 j9 b
#define HN 8 //隐层神经元数目- Y: r4 b( @1 T* Y9 O\" a9 h
#define ON 1 //输出层神经元数目
) i9 E4 c8 Y2 z
double P[IN]; //单个样本输入数据 a\" Q7 J- r1 T, d# Y* M; [
double T[ON]; //单个样本教师数据
; Q) j3 L9 M( x5 `- \$ Z& x
double W[HN][IN]; //输入层至隐层权值
6 s$ q; N0 @; h' o) t( L
double V[ON][HN]; //隐层至输出层权值
# R4 v2 n$ m: {2 V, S0 Q
double X[HN]; //隐层的输入
3 A# A9 b3 L9 n/ y\" `
double Y[ON]; //输出层的输入
* s+ x7 b! U4 B3 k1 W5 G* a( }1 B
double H[HN]; //隐层的输出
s0 }9 M+ |* y$ ]
double O[ON]; //输出层的输出
& `+ d& \$ ^+ q& C3 j
double sita[HN]; //隐层的阈值
2 n% ~8 Q8 Z* @
double gama[ON]; //输出层的阈值/ Z& Y1 T, E3 g0 d\" a9 P
double err_m[N]; //第m个样本的总误差8 b) N+ p: d8 J7 A7 k4 _! Y\" n
double alpha; //输出层至隐层的学习效率
6 D' P0 Y/ A6 Q$ K9 Q
double beta; //隐层至输入层学习效率% O1 ~8 _( g& l, @2 {0 a# I( j
//定义一个放学习样本的结构- _, X8 R! S- t+ D; _; {
struct {
9 c& }% g. G& y
double input[IN];
4 [5 P: d\" y\" B
double teach[ON];- w2 Z0 @4 u\" H$ E
}Study_Data[N][IN];2 X- N0 M# P4 E& `
: P\" f) o* k( U& n, @2 B, }( V' Z
///////////////////////////8 K9 @\" U9 q: i* j4 Q2 Q# ~
//初始化权、阈值子程序/////: v, M3 Y+ I! S B* n7 X7 v
///////////////////////////! [1 r$ \. W8 {0 e. l
initial()# z. O7 a3 l5 r
{
7 U4 |1 ]2 t' r: x$ d1 f; V' Y
float sgn;* M: w& C1 T* M5 R
float rnd; v4 b7 k$ m\" R9 E Z8 I
int i,j;2 k+ \) ~0 J- r& B
//隐层权、阈值初始化//% ?4 `! y4 }) Z4 M9 R1 s
{
1 P7 H1 \7 u8 l5 n: t
//sgn=pow((-1),random(100));
, b0 I1 F) Y' T3 }: r/ x5 Z
sgn=rand();
I5 y+ P% S2 L& i z
rnd=sgn*(rand()%100);% t\" b3 W3 Z\" W- E
W[j][i]= rnd/100;//隐层权值初始化。1 O* n0 I' W6 F; E; R
}* H) l' A0 w' t' e+ p\" c6 G
//randomize();
# U+ i3 U* E' u* f\" I6 \' U
{3 y' l; F, J* \
//sgn=pow((-1),random(1000));
# D) R7 }3 X% G' m7 s9 c( V) y
sgn=rand();) P/ V' b( E4 f R8 j
rnd=sgn*(rand()%1000);
+ ^: N0 |' ^9 y; x' i6 {
sita[j]= rnd/1000;//中间层阈值初始化
cout<<"sita"<<sita[j]<<endl;6 D$ T, [/ O. p7 q' _
}
8 P4 | J! k L. e
//输出层权、阈值初始化//
1 _$ b2 e. f% ]4 j0 X
//randomize(); j' g- a' j\" |
for (int k=0;k<ON;k++)
! q; U; M2 Q2 F. x4 R) \ W
for (int j=0;j<HN;j++)
\" r; `0 g* M: x+ `
{6 j# D9 R X3 H- j9 G5 g$ Q\" w
//sgn=pow((-1),random(1000));
# ~6 b# b! b# h/ Y! [5 F* _; w# d
sgn=rand();$ j8 ^* R) D$ i
rnd=sgn*(rand()%1000);
6 {4 A& ^, v! x0 f, \& _
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
6 P\" z4 G+ F\" E% j+ r
}
+ s6 Z' J8 D1 m\" r7 d: a
//randomize(); p% f: b( _: l1 }
{0 Y; |! K! i2 P! d9 ^' p) K; i7 f5 @
//sgn=pow((-1),random(10));/ M, [6 Q, X0 o
sgn=rand();
6 M% m( o% b! Z& L
rnd=sgn*(rand()%10);
; A7 H- M' [- P) h4 f1 `6 Q\" K
gama[k]=rnd/10;//输出层阈值初始化
$ z' o0 A0 P0 v
cout<<"gama[k]"<<endl;
' Q4 Q* D) ~- l
} |- U- ?$ E9 w# \) _+ c/ v
return 1;4 G$ T1 c$ D4 @# U% h3 \
1 R: K1 g% U+ c2 K! Y; ]8 l
}//子程序initial()结束7 a. `, J' ~+ v
$ B0 t. w% u\" u% ~( u
////////////////////////////////
' s s% P' G* R
////第m个学习样本输入子程序///6 u1 ^1 q1 J0 k$ n7 ]+ u. G
///////////////////////////////
& b, U4 ^% [' Z
input_P(int m)5 M\" D5 ~, w2 c
{9 I; F G. b* D; Z% E
for (int i=0;i<IN;i++)
9 y6 j4 k$ V4 ?: \1 L2 v
P[i]=Study_Data[m]->input[i];4 G8 l# C5 W- v
//获得第m个样本的数据7 ^ J* A( L! K2 j8 M
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入： P& v+ T( {\" {# s
//P[%d]=%f\n",m,P[i]);. ?4 j( D% s3 O
return 1;9 c6 g* J# }5 r
}//子程序input_P(m）结束
7 l# O0 m# _% I7 W8 Q
/////////////////////////////+ m4 x0 c9 ]% c; q* p% @4 h
////第m个样本教师信号子程序//
M9 O2 r3 I* h8 f. I0 R3 N0 Q, Y2 U
/////////////////////////////0 a0 g5 q0 ^& c! @) S# `8 f+ t
input_T(int m)
' Z! l7 V\" Q, L/ a8 {
{
5 z\" s7 }& G, H# o; \5 m
for (int k=0;k<m;k++)9 P* X' D+ R5 K e5 z Y, H3 A
T[k]=Study_Data[m]->teach[k];
, ?% n\" U+ g3 m& |* l, E. ?9 Y
//cout<<"第"< // x: C. X5 o. v\" v1 K\" G
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
/ W/ Z8 U& V% k6 D: u\" j\" s
return 1;
; S8 J$ E! b+ J2 r
}//子程序input_T(m)结束- i# O6 K\" `: Z, x* v2 d) A$ F
/////////////////////////////////
7 X* h( f+ G$ g6 H* G/ f7 n
//隐层各单元输入、输出值子程序///4 O$ u/ {5 ~4 V _2 `
/////////////////////////////////\" z( c. D4 w7 q
H_I_O(){
# Y# r5 W8 b; L$ [/ D
double sigma;, r8 ~2 m8 m- G% }
int i,j;2 m9 v) g4 a8 N% j# K9 M5 T2 J
for (j=0;j<HN;j++), a! E3 C8 q6 _6 D9 ]( N
sigma=0.0;
+ }3 ^4 W1 U\" A% H' [
for (i=0;i<IN;i++)/ ]: T+ q& Z) w& H% d! S
sigma+=W[j][i]*P[i];//求隐层内积4 B0 [8 @ n$ m. H/ Z
}
2 ^. g2 h' [8 l6 Z. u8 }5 c\" d) ?
X[j]=sigma - sita[i];//求隐层净输入
1 A& W. q) q6 q/ E
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
6 B+ j7 `( q2 u
}
+ K! T: [* W3 x* O% I3 c$ I
return 1;! y2 l& A' ~) H$ G8 | M
}//子程序H_I_O()结束( D# l- L$ V' q) j! ?3 r
///////////////////////////////////3 s3 @2 {7 s% o# H
//输出层各单元输入、输出值子程序///5 o: l' b; U2 M1 Y- I. c
///////////////////////////////////' h; i/ t; x, t: W
O_I_O()
7 n( e o$ q# m. t
{' t/ ^. o) r5 y E! S+ ^7 p
double sigma;* M* c. E; @. `/ j2 h; r
for (int k=0;k<ON;k++)
6 O9 @' u8 U# {1 X% p
sigma=0.0;
, c+ z8 g' G; X, _
for (int j=0;j<HN;j++)! f6 q4 i+ H- E; C- A5 G
sigma+=V[k][j]*H[k];//求输出层内积
( n\" ?5 q' C+ r0 z; @
}
) I3 m' r: U6 y/ j6 |. b, ?* v6 L
Y[k]=sigma-gama[k]; //求输出层净输入( `8 y* r8 P+ P) _- K& j
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出- w9 E; U/ J5 A
}
0 Q$ R, G; u% s% k! J5 d. e
return 1;0 t, |) l3 u7 c4 ]9 ?
}//子程序O_I_O()结束4 F\" B5 ^: Y. M' r* |; h3 q3 ?
////////////////////////////////////
& _0 a# p3 H# ^8 Z6 F- n
//输出层至隐层的一般化误差子程序////! s+ o. z, |9 X6 w$ L\" B$ E) `1 ~' z
////////////////////////////////////
5 h' X, L( o- K2 B4 o8 l
double d_err[ON];
* W) n# M, q* Y0 ~
Err_O_H(int m)! e& {7 G( ?# s/ C8 {
{
9 M, Q( n' h/ E2 n0 E! m
double abs_err[ON];//每个样本的绝对误差都是从0开始的
2 D- E% T& K$ i
double sqr_err=0;//每个样本的平方误差计算都是从0开始的
7 R\" }+ r3 m, C& }
//for (int output=0;output<ON;output++) //output???
! u3 `4 J$ ]5 ]# d! T7 {
for (int k=0;k<ON;k++)6 [\" L3 x; ~, z8 ]
abs_err[k]=T[k]-O[k];
% v; w8 Y* l d' k. Z1 P
//求第m个样本下的第k个神经元的绝对误差
: V% p3 o& M& \4 f
sqr_err+=(abs_err[k])*(abs_err[k]);, ~; _- T5 U* l' `8 ^
//求第m个样本下输出层的平方误差$ G8 W2 @) O6 P w9 U3 W j
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
7 m3 u* | P2 k2 @4 Q( u
//d_err[k]输出层各神经元的一般化误差% n: n$ [! j7 Q. Q6 {# E4 }
}4 i5 B' L* Z& i3 }$ u( S: P
err_m[m]=sqr_err/2;! v' a( V! ~\" g+ d\" U\" n, R
//第m个样本下输出层的平方误差/2=第m个样本的均方误差
: P: T\" \- }- j$ e
return 1;
; [2 z* n* m. M& r0 x' h; q1 h
}//子程序Err_O_H(m)结束
+ O! a7 U\" @/ z8 t% v
////////////////////////////////////
+ }% j7 z8 V/ n; s, s
//隐层至输入层的一般化误差子程序////
\" A. C9 A* [\" d
////////////////////////////////////
) v* L2 u: G6 [9 {6 I N+ ?
double e_err[HN];+ p+ j( U5 y$ e9 M. u( T$ @
Err_H_I(){
$ D' X: [( \# A' m( \0 j
double sigma;5 \\" h2 E, {& ]$ l, t
//for (int hidden=0;hidden3 a/ |1 S: f& P% z2 V
for (int j=0;j<HN;j++)
6 z7 ]( a1 j7 ^/ \9 l
sigma=0.0;$ v# N/ K% B; i
for (int k=0;k<ON;k++) 3 e1 Y0 |5 x. e9 U: U- w9 N* h
sigma=d_err[k]*V[k][j];* c# @- r' V+ l8 D$ q s
}: V5 d( }. V$ P, c7 ]
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差7 |$ `- M8 a! g\" y5 X
}8 \% N! `3 y4 m$ K
return 1;
}//子程序Err_H_I()结束
6 v/ h, Y/ o# K) y
////////////////////////////////////////////////////////
5 M' a1 N i$ Y$ d
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
* `- l' I9 j: j; Q$ d
////////////////////////////////////////////////////////8 t. N% x( j. B\" E
Delta_O_H(int m,FILE* fp)
' ^, \3 k1 ^\" W N' V% F. _2 r
{5 s9 O2 d: ~9 q$ s4 J, X
for (int k=0;k<ON;k++)
0 N( G7 q: c( X7 q r7 o2 ^
for (int j=0;j<HN;j++)$ V6 |3 c9 R0 Z8 c6 s# n2 a
//cout<<"第"<
@- J% q: n; c; i
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
; Y. Y- ?2 t1 ~! w3 ~
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整. k' \\" _\" S2 r% r# L) Q+ Q4 W& S
}1 a( Q* V) L: M% `4 L/ ^. O0 D) l
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
$ Q. ^' [7 m# Q J
}
# i) f: D\" h8 i- s
return 1;, h7 V. |# X7 s2 v+ j- v$ d
}//子程序Delta_O_H()结束
/////////////////////////////////////////////////////
0 q) B5 v: Z+ U% B% H
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////$ o2 `7 M: u `3 P5 i
/////////////////////////////////////////////////////
3 Y& Q) }( Y+ `: }
Delta_H_I(int m,FILE* fp)2 b% C( f9 B$ C7 V; m) B/ r: Y
{' @& w& ?* ]8 r( q
for (int j=0;j<HN;j++)
\" f' {( k0 y4 {1 ?; k9 u' j( Q
for (int i=0;i<IN;i++) ; q: \! v/ @9 s9 e) E# Y\" v
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
$ r4 L# m1 y. }# n
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
+ x8 h% C4 f. C
}
% B( O7 T+ [9 T
sita[j]+=beta*e_err[j];8 L; U$ O3 h' B5 ]! j9 s# L
}
& I) h' |1 _ x( h( k0 u3 j\" @
return 1;
8 Q9 h8 G+ m. o5 w/ Q
}//子程序Delta_H_I()结束4 O0 J6 H O& d; ^( E2 ?3 E
/////////////////////////////////
8 ?3 p0 n; e7 r4 Y9 H) s& G
//N个样本的全局误差计算子程序////7 J2 [0 l: C* j# c3 ` v
/////////////////////////////////1 W( R( h$ c' e0 ], s
double Err_Sum()
2 V9 H! S, D1 G8 {7 l0 Q
{9 e- q2 h7 d$ v7 M7 S- ~
double total_err=0;9 T$ j6 ]+ D( N. ]# h/ k/ d
for (int m=0;m<N;m++) , k, d4 m' A7 V) S$ a9 L# E
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差; b+ {8 ]8 K( p, F% M% W0 o
}3 k; q. o. s/ E( T2 b
return 1;
+ }# w8 `1 Q5 F6 A
}//子程序Err_sum()结束
! ?; P; b/ M1 I1 d, @& K
/**********************/
8 O5 c1 k& H# I6 {* f' k( B$ b; G
/**程序入口，即主程序**/: E( b# a. g/ X: s' H
/**********************/
% e7 l6 m0 b+ f1 }8 D2 K
main()
0 N! ^* T- B, y m; A2 W
{* V- G5 a( r/ W2 n% Y
FILE *fp; z! f5 J Z$ o
double sum_err;% j* x0 O9 @# ?/ v4 n% H1 d
int study;//训练次数% k4 ^# i) f/ x+ [6 j
if ((fp=fopen("bp.txt","a+"))==NULL)* K% F( b; A) {9 g; t
{
\" b0 t- V \# R* x; y8 \0 [' ]$ F$ M
printf("不能创建bp.txt文件!\n");
7 P( ~: B# V; o+ i1 u$ ?( w0 y$ P
exit(1);
9 a Q5 v\" s, R
}7 ?: G2 B* j3 a& M
cout<<"请输入输出层到隐含层学习效率: alpha=\n";# V# U! F' W, y2 y$ T
cin>>alpha;
7 {$ B$ W# \( Q# N& s
cout<<"请输入隐含层到输入层学习效率: beta=\n";- ^% j: j* R% Y& Q% L1 B\" {6 {\" m
cin>>beta;! F) g& C5 [\" M. S# x6 {
int study=0; //学习次数- O# l e0 a5 x7 ]$ ]5 g; f% }
double Pre_error ; //预定误差7 s4 S0 S+ ~) T9 U8 c6 v
cout<<"请输入预定误差: Pre_error= \n";
0 p6 T3 _, n1 m! C/ P
cin>>Pre_error;2 k# w, ], Y+ `. b\" v* X
int Pre_times;
; X# G- a\" S2 ]& Q' o1 U# h
cout<<"请输入预定最大学习次数:Pre_times=\n";
$ g+ s3 ]3 }# p/ ^, H; E! v1 p
cin>>Pre_times;1 K\" @/ S) y: f( ~/ d' `% E5 p
cout<<"请输入学习样本数据\n";: | \0 X& l0 \$ O p
{) X+ g( J, s% d+ R
for (int m=0;m<N;m++). R1 _5 r2 z$ ]$ q' O F
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; ( q0 k/ C5 ?9 M1 Y; _0 o6 i# d
for (int i=0;i<IN;i++)/ O5 ~& ~7 S$ I+ F3 O2 H
cin>>Study_Data[m]->input[i];5 k0 |+ `! k S7 b. z6 f0 z
}
0 \; X8 Z5 N! @) Z$ k V
{
* t' B9 Z, Z) u9 I8 f
for (int m=0;m<N;m++)
8 j0 G ^. M9 c- k* ]! _2 u
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
2 ?! n' B/ R V5 B, G
for (int k=0;k<ON;k++)
9 ?7 U7 w( ^& W* M8 ?4 P
cin>>Study_Data[m]->teach[k];. @, M* \9 m9 o6 l6 N' z8 J
}# f. E8 |; j% x1 Q
initial(); //隐层、输出层权、阈值初始化 (1)
) ^& B% O2 N/ H; D) w1 t
do* x$ o& Y6 q% f2 l. d
{
+ S8 R7 L9 b9 `# P$ G8 L/ B1 q
++study; ///???
! v, V1 r: Q8 I$ J, w; D; _
for (int m=0;m<N;m++) % Q6 m' m2 @$ ~\" K( o$ C- a
{
0 n6 ]# W9 a p; m$ G
input_P(m); //输入第m个学习样本 (2)
s$ d( ]5 H/ U3 a& R
input_T(m);//输入第m个样本的教师信号 (3)$ {) a4 z9 Z# S, L
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
+ b$ j8 m( X( |\" o\" X
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)' Z$ a! l) g J8 P x* Y, z
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) # b# P2 m) D% G) f, w) K4 n4 ~( `
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7), _5 C V* F9 o: ]5 t3 r9 O
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8): P$ R\" c. g- H B$ g# c% r
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
7 M. q/ d' l# X/ o$ m; g
} //全部样本训练完毕+ V7 Q2 i* v s+ M, M* Q
sum_err=Err_Sum(); //全部样本全局误差计算 (10)\" i5 W, H6 H7 D' f' |
{
# g' I\" O, K1 ]6 X+ g) E4 B: ?
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;* w! Z8 e( }\" W
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
7 M: L# u5 C9 U- O1 \5 C
}
# O: ^& w3 [/ m+ m$ M
while (sum_err > Pre_error) //or(study
* y+ b# K. A2 m! ~1 f2 f6 a
{ //N个样本全局误差小于预定误差否？小于则退出 (11)$ f) l, A. C: b& L+ T1 A, d% p
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;9 a# ]8 E% J+ d2 c2 \( J- w
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
9 V& ^: x2 f5 v
fclose(fp);
) W6 ?9 \. c5 o. `2 @/ \
}
% N' x; u1 _ E
char s;7 w; l+ V. K, J. g8 J& g
cout<<"请随便输入一个字符，按回车退出程序！\n";# c5 x$ M- n$ s7 z! _0 R& F
cin>>s; F e1 C0 R+ w3 k, W \4 q4 p. r
return 1;8 x: ?. S7 a\" J/ F! @- W
}2 V' V$ i# v' l# A9 l) b; }
: \+ ]4 M6 Q0 h+ y