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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
% P! P' j- K% | }* V
#include "iomanip.h"/ s# D9 `% p, g0 u8 }
#define N 20 //学习样本个数
+ s3 P' v1 a( o2 R7 j
#define IN 1 //输入层神经元数目% K+ ~: l/ v* @' c& j
#define HN 8 //隐层神经元数目
4 j( j* j( P) K) a6 U& U
#define ON 1 //输出层神经元数目
% f+ g# |9 D) c2 m. q
double P[IN]; //单个样本输入数据4 i; l4 G8 s; L K
double T[ON]; //单个样本教师数据
( s! [4 I: }/ t
double W[HN][IN]; //输入层至隐层权值3 p W: m\" e1 ^0 W- j; }
double V[ON][HN]; //隐层至输出层权值
+ M1 ?) K( I# f+ J
double X[HN]; //隐层的输入# p/ J; N' {$ \: l a: u
double Y[ON]; //输出层的输入
0 e7 e% H) |0 f# O
double H[HN]; //隐层的输出
0 ~. _. ?& d3 Q! _$ _
double O[ON]; //输出层的输出
0 E. z. f% h2 N. F# N
double sita[HN]; //隐层的阈值* Z; d) c/ R, [
double gama[ON]; //输出层的阈值
+ t$ W, W4 m7 k, K& _
double err_m[N]; //第m个样本的总误差6 t, Q7 h, n8 R, u. W) \' E- W- X- |
double alpha; //输出层至隐层的学习效率
, g) d7 a! N$ k2 V* e9 R
double beta; //隐层至输入层学习效率
3 L: w4 m; |/ F( ]\" t0 R$ S
//定义一个放学习样本的结构6 g% D. d2 w$ C5 C# J; w, D\" ]9 ^ R
struct {: X\" A9 d) I1 d1 C
double input[IN];5 d% N2 [( }9 G8 R5 D\" n\" b: g( b) w
double teach[ON];
# q5 _# B5 I$ {. T* B
}Study_Data[N][IN];
; p4 y6 `$ b' h, P! [) _
. F2 H8 S& t& L) q\" z1 C( B
///////////////////////////
& I8 B* n6 v- J! q2 n$ R\" @+ \
//初始化权、阈值子程序/////' C) G9 ?\" M* P E
///////////////////////////- ]( j9 T7 a2 z6 I6 s' A. h
initial()
7 I6 P\" d* @) N$ @
{
% u( E- E: N y3 j g
float sgn; b0 p& C# b0 j. ]
float rnd;
2 S% @! X! y+ U {) L# i! @5 m. ]
int i,j;
& v3 W1 ]\" R\" a1 Z q1 v/ n
//隐层权、阈值初始化//
2 L4 W6 w: h. R X: o
{
7 Z- }+ y+ J1 R7 s+ z6 [
//sgn=pow((-1),random(100));
\" T2 p' Q. h* N7 v
sgn=rand();
, \* I+ q5 t: ~( }5 o* U7 H
rnd=sgn*(rand()%100);8 l- q! C' ^6 G$ n. d
W[j][i]= rnd/100;//隐层权值初始化。6 ^! v/ S$ r% S
}: e1 z! W s0 M0 h3 g4 N+ ~
//randomize();\" y: x$ n+ B, J/ |
{
: U0 Y+ K e& M, d6 x) `
//sgn=pow((-1),random(1000));
! I\" b! V* [\" ~' P. F8 m
sgn=rand();
9 d) c% k- D- ~: q+ k$ J
rnd=sgn*(rand()%1000);! [0 t2 v\" h- Y+ x: U
sita[j]= rnd/1000;//中间层阈值初始化. B* f3 @! w- e7 ~! y9 H8 G+ B
cout<<"sita"<<sita[j]<<endl;
`9 J8 |\" f' a
}- j5 `' F1 \- \$ H+ e
//输出层权、阈值初始化//
0 L; L/ o3 ^9 \) z
//randomize();
: g! j, w2 T/ D' Q( L4 Q
for (int k=0;k<ON;k++)
2 y4 G0 \0 B2 o. u9 `2 p
for (int j=0;j<HN;j++) 1 |6 y: x% p% O' K
{
2 C0 h1 o' [$ u# g+ g# v
//sgn=pow((-1),random(1000));2 f6 L3 Q$ g) Y( _7 O
sgn=rand();/ \* \: G$ r+ o M; ?
rnd=sgn*(rand()%1000);# r; m1 [9 Q/ U: N& ^7 b& `
V[k][j]=rnd/1000;//第m个样本输出层权值初始化; q3 b1 y; W. _7 Q
}
$ X4 I$ w6 d% T
//randomize();
- W/ W8 H1 Q- l7 H: d W
{
' {( X( y2 w- d& p' c\" D
//sgn=pow((-1),random(10));
8 q) h\" R$ W4 I& \( z; v% ?2 e
sgn=rand();2 q- j! B( j8 Q: |0 k) {0 \
rnd=sgn*(rand()%10);0 [) {; P/ V- _+ K0 V) {
gama[k]=rnd/10;//输出层阈值初始化
3 ?- S7 N ?+ z3 U( U
cout<<"gama[k]"<<endl;$ x% n6 A9 v. s
}0 Q( ]* N0 }, a% [; J. `# S! k; X
return 1;
, _, e\" o! M# a4 f! B$ F. e\" K
$ U4 {- z& w% z) Y I7 D
}//子程序initial()结束
* B$ k' L& {9 \* Q
) q/ h) ]9 e\" ~& i5 W; ^\" o- F b\" [
////////////////////////////////; \% ~: f5 k' v/ b2 j
////第m个学习样本输入子程序///7 W; J9 a& [9 b& `' r$ w- A\" |
///////////////////////////////) x( t! ]2 E6 O7 z) }
input_P(int m)
) Z3 I _5 `% z8 O# g
{
+ v: v; s( M4 i# q- c2 t
for (int i=0;i<IN;i++)
$ D9 u, Q% x. V6 W5 D0 S
P[i]=Study_Data[m]->input[i];
& A! Z3 h6 [\" }, }+ m
//获得第m个样本的数据( U) h\" T2 F2 @; G ?/ b, V
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：: j1 e4 q2 z' v* d
//P[%d]=%f\n",m,P[i]);8 O! l' M$ x6 M7 A
return 1;( Q( ] c. q7 w4 Q& [
}//子程序input_P(m）结束
% Z\" S: U) b- ~
/////////////////////////////$ u3 L/ U/ a0 D5 R8 L
////第m个样本教师信号子程序//
1 l. N! G: P! q' F9 d5 {
/////////////////////////////* @( U/ q' n7 t/ D& L3 Y
input_T(int m)! t, `( h w1 k% R7 X/ o
{
9 [0 q$ c! r\" I' j
for (int k=0;k<m;k++)$ E\" w D/ A C5 B( N% ~
T[k]=Study_Data[m]->teach[k];
Z1 q7 q' B, {4 G+ k
//cout<<"第"< //8 N f: r+ D2 l% k: U' o& g
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
+ H4 T) N# R7 _( \( Z1 } Q. F* d
return 1;0 t: U) U `\" p/ K/ z8 b& E$ L. U
}//子程序input_T(m)结束
\" [\" r0 o\" o* ^1 Z- H! S' X* E4 y
/////////////////////////////////! R$ ?) q1 C! \7 G' f, L
//隐层各单元输入、输出值子程序//// x K3 N- \' ]& c! P\" d% u
/////////////////////////////////6 b' H% }2 Y& V L! _
H_I_O(){* [& J& C* t# j) w0 f( X
double sigma;
3 V# i, D8 \' n6 I\" i: s% l
int i,j;
$ r% Z3 ?8 {0 B* X' a6 M( G. L/ z
for (j=0;j<HN;j++)
% D\" _% m; d/ t
sigma=0.0;
1 C# K2 _4 y7 o+ W, E
for (i=0;i<IN;i++)- W) l$ l* S' J& ?; k) ^( M
sigma+=W[j][i]*P[i];//求隐层内积% a7 q8 P6 J0 l# p4 @
}
: i+ E* s$ j: L
X[j]=sigma - sita[i];//求隐层净输入
2 |8 \! f' t, o9 {: k$ B ?
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
4 v/ F) \5 ~/ h3 _/ `
}\" p% f# r) j3 v6 |! H0 A5 f
return 1;
4 w\" {1 c' a8 a. C: z5 x$ G- R2 D4 @
}//子程序H_I_O()结束
8 `4 i: l s r5 _
///////////////////////////////////6 D ]* s6 ]/ N
//输出层各单元输入、输出值子程序///
/ r h- e' H! w3 U# w
///////////////////////////////////( Z4 Z; B$ T* b: {; E% M* I6 H
O_I_O()
! g8 h0 X) ~ E; |& ]$ J3 b
{1 B. F+ u) J6 M0 X
double sigma;# M/ @2 K1 i% P& U W: H
for (int k=0;k<ON;k++), {( r# v1 ?& c0 i9 ?) {# I
sigma=0.0;
' t( w' D w) [! Q
for (int j=0;j<HN;j++)8 B# o% ~$ [9 h7 D2 Y
sigma+=V[k][j]*H[k];//求输出层内积
- R* x, ?+ J+ N/ Y T; T7 K6 Q
}
$ e2 p/ B7 g& m! _) A
Y[k]=sigma-gama[k]; //求输出层净输入& t0 r0 n0 w, W4 a: i
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
; K. \% O. c+ d+ _* P! _+ f
}
- n( |/ Z& y' Z, d
return 1;
& `1 S+ i+ r8 [+ B2 j
}//子程序O_I_O()结束
5 ?% r2 F6 l7 {
////////////////////////////////////# ?( Q; I- _2 B! `& m
//输出层至隐层的一般化误差子程序////7 c: y' q9 m8 ~* M' A, R
////////////////////////////////////
: A+ E9 a3 ~3 c
double d_err[ON];7 T, j\" N\" \\" J8 ?* S
Err_O_H(int m)
% e r V6 I$ }7 Y
{
; X; L; z+ `4 _; n
double abs_err[ON];//每个样本的绝对误差都是从0开始的
6 h' t2 d5 W! e/ s
double sqr_err=0;//每个样本的平方误差计算都是从0开始的 f) n* \( V/ a+ @9 w: Y; K9 B
//for (int output=0;output<ON;output++) //output???( n; s+ v S+ p6 m
for (int k=0;k<ON;k++)+ ]7 Q& ^5 ]# J/ J# a
abs_err[k]=T[k]-O[k];
p5 p3 K& v$ ?: [3 q
//求第m个样本下的第k个神经元的绝对误差, V+ C8 t3 i1 F6 ]) W# {
sqr_err+=(abs_err[k])*(abs_err[k]);7 v3 p0 R, j% V. [
//求第m个样本下输出层的平方误差
0 E\" N0 C# [: p/ y; U
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
5 @2 X& E0 O* _ x- K\" p
//d_err[k]输出层各神经元的一般化误差
: r+ r& o( L' k' ]6 J+ W$ k
}/ j/ j C/ u1 J% W$ x) M& q
err_m[m]=sqr_err/2;
. c& f; H0 K% a5 z( t+ A
//第m个样本下输出层的平方误差/2=第m个样本的均方误差: O! Q9 G8 w/ }& d
return 1;\" U) R h) B- E* H
}//子程序Err_O_H(m)结束
$ ]4 x$ v# P& N. C Z6 \% E0 q
////////////////////////////////////! i- i$ M' c7 e\" _
//隐层至输入层的一般化误差子程序////
1 q+ O. r5 ^* w: }: p
////////////////////////////////////+ L: c, s) ?+ M1 C3 J) Q
double e_err[HN];
6 ?/ r' x8 J6 R! s( j d( t8 w
Err_H_I(){2 k6 N0 ]/ [+ n& q
double sigma;: k M! I1 M* S2 G; T
//for (int hidden=0;hidden1 T- S0 U* U! b1 |; k. t
for (int j=0;j<HN;j++)
- p4 G I$ w5 Q& D3 q
sigma=0.0;
! }) _; a5 G. F) y3 ?
for (int k=0;k<ON;k++)
4 Y* h6 |) A @1 [$ m
sigma=d_err[k]*V[k][j];
! M0 C$ f; H. H, R8 _
}' x1 ~. C6 R& u7 ^
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
2 V# O4 G3 h9 Q( F/ F
}
. Q$ F% N/ s, B* ?7 k; D
return 1;( D7 w( R1 m6 C' g8 _8 r
}//子程序Err_H_I()结束- f Y- c* }; U, R( i
////////////////////////////////////////////////////////
2 q% r2 ]$ B* ]( a- [' @3 m' J
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
X! p# J! W9 l v, [; u3 J q
////////////////////////////////////////////////////////
+ k0 F; U3 ]. t/ }
Delta_O_H(int m,FILE* fp)- @/ N0 i1 z. b; T* S+ p2 j* Q3 N
{
@- G# [$ w- h\" r+ R7 A7 V: v. i
for (int k=0;k<ON;k++)
% H0 F: K6 v4 l
for (int j=0;j<HN;j++)
+ G. F9 l* {. C, B2 V: E- u/ y
//cout<<"第"<
?; I& [3 h8 g\" M$ U8 C2 ^
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
1 I. E) g2 r. K2 h
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整0 Z& D4 u. l* y; B5 r1 B$ C6 v! R T
}/ P% {. ^# [3 X; i% t
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
! e2 A' h2 s' x% C
}- `6 ^: c4 @1 u, ~! X2 }. }
return 1;
0 t; o$ ^* ~# i6 {\" z( c w
}//子程序Delta_O_H()结束
. N- l% m2 Y\" L$ T, O1 M
/////////////////////////////////////////////////////; @4 z2 {& U$ Z7 \ |+ k# _
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
/ ?3 g& m4 A8 S, H! s, M
/////////////////////////////////////////////////////6 b H& c4 ~. I2 a
Delta_H_I(int m,FILE* fp)
8 x\" ]. K$ J1 h6 ~
{7 p2 R& ~' w$ e- _/ R
for (int j=0;j<HN;j++)8 C# I' D J: y2 M# G: K
for (int i=0;i<IN;i++)
5 p8 E5 u% ]+ V* u* X6 Y! h; U
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
7 d9 j& ~1 J6 \
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
8 K4 t3 Q* k4 u# z: ~0 b4 \( N
}+ Q, t9 {. w3 M. _7 C# ^# L
sita[j]+=beta*e_err[j];8 @+ v9 r\" m7 q3 \2 z2 z' s
}
\" k# ^, x( s8 H4 R# G
return 1;
! p# r+ D* }5 a
}//子程序Delta_H_I()结束- r; Q( C& x# L
/////////////////////////////////& m$ y# u! u5 _3 b9 A$ H
//N个样本的全局误差计算子程序////- B4 V. Q. T$ f\" e
/////////////////////////////////
\" C5 B$ H+ u+ T, C8 _
double Err_Sum()
' ~0 ^, F2 D% X! Z, }$ Y
{
5 j$ ~. p. o6 l) N4 W |% y
double total_err=0;
# H A5 W, a- E, U
for (int m=0;m<N;m++) ) O: X. N3 G2 \& y% d' W
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
0 M$ m+ o5 N7 A7 b! T
}) d4 X) R. `7 O9 q1 a: i\" A
return 1;7 X5 {9 ^8 t5 O1 ~
}//子程序Err_sum()结束
! R8 f% D, f4 } v0 v+ D# a
/**********************/( d; r& ?$ m4 u1 d$ G/ ~$ J4 o
/**程序入口，即主程序**/6 \3 L) g$ B) t$ \9 G
/**********************/
3 ]% ^) b\" ^1 a7 K' d
main()* _7 F\" y) \0 e; @' }1 N
{
) M\" Y( j; m0 i
FILE *fp;
! o; C, R( c: Q8 `5 y: V1 ^
double sum_err;! a, K' O9 w& O& p9 a
int study;//训练次数
$ ?) |3 c1 c- W: e3 B
if ((fp=fopen("bp.txt","a+"))==NULL)
( z$ Q\" l: s7 W. I3 o$ v( Y. K8 {0 D
{
+ {7 h7 m5 |. v2 r9 S
printf("不能创建bp.txt文件!\n");2 a: u1 k) n) Z, C
exit(1);3 B0 b9 Q\" H7 R3 |\" S
}6 T ?, `4 I5 q6 g9 R
cout<<"请输入输出层到隐含层学习效率: alpha=\n";+ @) S& I6 d, v& Z1 o2 ?\" F
cin>>alpha;/ v7 w. C2 d* d4 Z$ o& y
cout<<"请输入隐含层到输入层学习效率: beta=\n";
, d) L# a) u% X- E8 J6 J& ^
cin>>beta;! Z8 ^( {5 C, s+ r$ y$ ?
int study=0; //学习次数
2 B X2 E, X5 B
double Pre_error ; //预定误差3 E6 ?0 |( `9 T; f6 L
cout<<"请输入预定误差: Pre_error= \n";' ~8 |( l* Q) I+ d
cin>>Pre_error;
- P( M! ?* W+ \5 L% f/ x# I
int Pre_times;
# Q6 H: t2 m% o/ O
cout<<"请输入预定最大学习次数:Pre_times=\n";8 n5 T* \# J! Q
cin>>Pre_times;) l7 ~* r( ?% c0 H
cout<<"请输入学习样本数据\n";
; B5 b3 d% W( }1 Z3 @! B3 t
{/ J+ U& H: ]1 i( t( v6 ~+ D
for (int m=0;m<N;m++)6 e: w1 E! H6 u9 d% }3 m
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
8 o4 j# Z4 K9 m* `9 N
for (int i=0;i<IN;i++)* e0 p7 q2 }/ [* n
cin>>Study_Data[m]->input[i];7 |% I0 F0 g7 k3 p+ x- y
}
) J( b5 t0 O. s
{
S* P1 ?# l\" v$ v\" B+ s& ]
for (int m=0;m<N;m++)6 |4 q4 Y* A$ u
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
* H; Q# C: s7 U' w+ o+ {# s+ }
for (int k=0;k<ON;k++)1 x4 Q/ [/ ? Z# p
cin>>Study_Data[m]->teach[k];+ O% [8 C- T G8 S+ V/ k' b
}
# d1 a H) C3 A
initial(); //隐层、输出层权、阈值初始化 (1)
* I4 X% u/ N! i6 ~& ?
do
u7 J k: E3 a# W8 F: b\" c# w
{
8 K9 P8 b) Q1 e$ ]2 @9 z: o6 h- f2 N
++study; ///???
( h. w) u& g\" w' o ?* j
for (int m=0;m<N;m++)
, y/ [\" j) L9 m; n6 {, a% z: k
{
! a+ W% q* M8 D$ X$ `
input_P(m); //输入第m个学习样本 (2)+ Q% T; o P- p% L! \
input_T(m);//输入第m个样本的教师信号 (3)
6 `$ N8 N. y\" X
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
( |! S, O& V9 |+ @
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
\" C% u+ h8 q; U, g
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) + `$ A: ?\" }! ], ^* e
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)7 Z% {0 [) n p3 U- o; D |; n
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
% c! H9 |9 I0 y3 C7 h- v
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
5 k! p: o- e# W& L/ X* e7 b! b
} //全部样本训练完毕 I( |4 P/ t% B8 J# `9 B
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
+ s- r3 w* i5 B\" L$ e* e' `
{
( `( S* I# S\" K d2 r2 @: R
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
; a1 i+ o! u8 t- A7 A( n1 a! a
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);
: D! b) ], N2 `9 ^
}
4 Z! c8 J, L/ o9 P$ }3 H3 P
while (sum_err > Pre_error) //or(study
; ~6 y0 x+ |& I
{ //N个样本全局误差小于预定误差否？小于则退出 (11)( {\" |0 i. K( t$ N% G* }3 K
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;* G& Z, W6 j H
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
) o' J2 P3 D0 H8 C- y
fclose(fp);7 |: z5 n: k\" o8 t\" p* ?# m: y3 f
}
# x; x6 `( m! i+ ]& W5 \
char s;
9 ]3 l( K1 _3 A1 t: c) e7 X
cout<<"请随便输入一个字符，按回车退出程序！\n";
, g! {, l \9 |2 b, J1 K8 _
cin>>s;
# j. L3 ^$ P# N
return 1;+ q\" D' L% |9 l\" N3 F
}
4 e, I( K) G; L, R/ M5 [6 @9 Z
8 M3 l1 E1 j$ U0 }) T' B7 _