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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"2 ?& @2 g, P+ |' h; v3 {\" C' c; ~$ V
#include "iomanip.h"
, D, O# n% t3 `9 J) K
#define N 20 //学习样本个数/ A\" Y6 H7 L. h+ C% u- c\" B1 E
#define IN 1 //输入层神经元数目, H. ?8 U g( P
#define HN 8 //隐层神经元数目. G- Y7 M2 }1 s' S% V7 P/ r: a
#define ON 1 //输出层神经元数目* ~8 _6 {3 d, T- D8 T
double P[IN]; //单个样本输入数据
- Z4 e2 V, I; u\" u7 F+ R/ z( D; k8 s
double T[ON]; //单个样本教师数据
0 |$ b, X9 P9 R8 \. ~- x
double W[HN][IN]; //输入层至隐层权值
. |. g& P2 Y8 ^( B/ ^. H
double V[ON][HN]; //隐层至输出层权值
1 F1 q! [0 O. [' l
double X[HN]; //隐层的输入# z. D X- g: B& Z% W
double Y[ON]; //输出层的输入# g4 g I) x$ s* D7 k7 x
double H[HN]; //隐层的输出
5 R9 @2 L) S, f* _
double O[ON]; //输出层的输出. N. a. I M3 X4 @! @3 B- ?: s, w
double sita[HN]; //隐层的阈值
% h\" S: A5 B9 z7 }* a+ H
double gama[ON]; //输出层的阈值
9 ^) X6 Z& A5 r
double err_m[N]; //第m个样本的总误差\" V% u\" s( {8 c5 Z5 S$ W9 X, B
double alpha; //输出层至隐层的学习效率- ^. d) g8 F9 o2 Q; O3 Y% p+ W
double beta; //隐层至输入层学习效率8 j% z) V* b5 T1 G0 w
//定义一个放学习样本的结构( I9 f- [9 l5 P9 @* V0 B
struct {& C( b+ p# s\" U
double input[IN];
0 F& @) K) e* [! G/ b8 C' T+ j& o
double teach[ON];7 s( R* n$ a: l; s
}Study_Data[N][IN];
6 o- ^9 a\" S4 G& z5 y8 ~1 V
$ r- q3 a/ j9 Q+ ~5 \( x
//////////////////////////// I( j7 t$ v/ l$ z
//初始化权、阈值子程序/////# b+ X$ [\" o& y8 H
///////////////////////////; F. ]1 C6 ?$ j! z$ X5 q+ X
initial()
0 e1 r2 |) G( L, w
{
4 N0 O9 _& d) u: M+ D; x
float sgn; x- g: @# f4 B. {/ l% v* C* z3 Q
float rnd;
1 A% a, Z9 p2 K5 K3 N# t1 I
int i,j;
' b/ [% g2 m4 V* z
//隐层权、阈值初始化//( n( Q\" m0 e: U2 U- a# U5 o: ~
{\" _) z4 C% A9 ]2 V
//sgn=pow((-1),random(100));+ P5 D\" Y: E1 E* g2 X
sgn=rand();
2 P7 Q6 P3 T\" g, o+ E
rnd=sgn*(rand()%100);% y2 q) a8 C0 H/ o' q
W[j][i]= rnd/100;//隐层权值初始化。
, f* e4 A0 S6 I* I6 T z4 h4 W
}/ z q3 S3 F; M
//randomize();
' n; L* d/ C. r& V
{
. b3 | h( J9 r5 h6 |4 x
//sgn=pow((-1),random(1000));\" M5 l: u2 h M\" D; U: G) U
sgn=rand();
- c! {0 g9 r7 S% ?% B2 l# Q8 S
rnd=sgn*(rand()%1000);
8 @* Y0 q* B$ m6 v9 K4 q) B5 o5 J& b
sita[j]= rnd/1000;//中间层阈值初始化5 C. K6 g' X8 u# E
cout<<"sita"<<sita[j]<<endl;
: S) Q* J8 i4 @9 D2 `* M7 _: w
}1 c, l5 ]# i, ?9 F! }
//输出层权、阈值初始化//6 f3 ]\" f+ M2 A9 ]
//randomize();, W, i& ^: `4 ~9 C/ C
for (int k=0;k<ON;k++)
6 ^1 [# `2 ?: w0 t
for (int j=0;j<HN;j++) . T S& }$ o3 e. B% p
{
4 ]$ W8 M\" g) i: a# _( z
//sgn=pow((-1),random(1000));! V4 W+ K\" l3 w* b5 x
sgn=rand();( n% {& R0 S' C$ W4 |
rnd=sgn*(rand()%1000);3 Y$ Z\" d; O% _/ M+ u
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
0 h9 k; W! j _( v# r& V
}
7 n) k2 C/ H6 Q# V% E9 }7 N
//randomize();
7 @- F8 {\" V7 R/ g
{6 W/ K: c: _. [8 k
//sgn=pow((-1),random(10));
. C' a) o( q% v
sgn=rand();
' G# Q+ ^9 ^( P5 ]. j& k8 X) P O3 N
rnd=sgn*(rand()%10);5 @& j1 }! _9 Y4 g' ~% ]* [
gama[k]=rnd/10;//输出层阈值初始化9 G0 U# J& S+ X' m5 J
cout<<"gama[k]"<<endl;1 @7 N* x/ i2 l! V; Q* W; y
}4 Q ]% M# T, n$ P' X9 d6 ]: m
return 1;
) c& \8 q& s# \$ l& F
: i0 N8 [+ q# R j0 F4 {' F
}//子程序initial()结束
7 h\" ~$ ^( G( `\" i
9 w) Y6 U7 E$ X1 e5 k, d
////////////////////////////////
) y& G1 L: g; m\" o0 e
////第m个学习样本输入子程序///
* C/ H. T* Z+ @$ t
///////////////////////////////
& N8 K; w+ u; E0 b6 `
input_P(int m)
; j: j5 h1 G- d- V5 Z& [/ Z
{
0 q% h9 H; X. _\" c
for (int i=0;i<IN;i++)
! {$ j7 l) h$ H# }0 |# A( e) \
P[i]=Study_Data[m]->input[i];# D, e) O l0 p' y$ X w7 F
//获得第m个样本的数据
- @, D1 _- ~) J! R# H/ u
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：5 e! |# O! |5 t7 U$ @2 x1 r# U/ H0 `
//P[%d]=%f\n",m,P[i]);
+ G$ G# S8 h* H8 e9 g/ z- A
return 1;
7 Y4 s: _6 i4 |
}//子程序input_P(m）结束; c6 n6 M( x; U) k7 d3 k: O/ j
/////////////////////////////
7 c) C4 c4 B. K8 f\" g* v
////第m个样本教师信号子程序//
1 D+ z8 `; ]# x% k- y# G
/////////////////////////////
3 L; K/ ?5 ~9 q
input_T(int m)- N! a8 n3 ?+ ^# G) c0 T' z% F
{7 P4 T* z/ W; ]. i# |4 J5 f: S
for (int k=0;k<m;k++)4 O$ V( I8 _$ z9 e2 R: i
T[k]=Study_Data[m]->teach[k];& D* Y2 D. o2 ?# f+ L; R1 Z
//cout<<"第"< //2 p% A* x( ~. H+ C! K# @
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
* y9 o4 b: q+ G7 X
return 1;
! B) n0 i8 ~( Q3 b2 L
}//子程序input_T(m)结束( }0 B/ R4 `/ E: U
/////////////////////////////////
' |! k; [: w# O% |) v
//隐层各单元输入、输出值子程序///% D# A [! M( x# [
/////////////////////////////////
\" n+ B' i! z! K$ F+ N: ~ m' |7 x
H_I_O(){\" G\" U9 Y; f7 F7 Y\" k: M8 S' S
double sigma;4 \3 r, s* [1 M& s
int i,j;5 ^ u' z% h3 v
for (j=0;j<HN;j++)
# u, v4 O7 U r* o
sigma=0.0;
2 K* h: D) R$ G0 E& w$ \. h1 U2 Z
for (i=0;i<IN;i++)
9 s3 V! E/ J$ V# O
sigma+=W[j][i]*P[i];//求隐层内积# Y$ t\" e4 d: p' Y6 I
}
! ^, g0 d, V4 T( X6 ?
X[j]=sigma - sita[i];//求隐层净输入
3 ]+ t# I/ x* `
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出0 J3 g3 _9 Z+ z! p
}0 i- D# }- D6 f% d9 y
return 1;' L/ x1 s: T2 M/ E9 j/ l) l+ `
}//子程序H_I_O()结束* s( u, Z8 l8 L( h' Y: q
///////////////////////////////////8 n, h7 v0 N+ ~, D. s( k
//输出层各单元输入、输出值子程序///0 Q8 S% q) G5 M9 X\" d; K
///////////////////////////////////4 P( I, v5 B3 X) w, Q
O_I_O()+ o3 e0 Q. c* E6 [5 F, y: X
{( K$ d u: q. V
double sigma;
( A4 z) k% d\" }. G
for (int k=0;k<ON;k++)& M5 X4 M! V: d+ H
sigma=0.0;/ ~% S$ j\" m- b6 M9 P( Z
for (int j=0;j<HN;j++)
' I4 K* \! E5 q5 E4 Q. N' [! G
sigma+=V[k][j]*H[k];//求输出层内积7 N4 z4 ~9 O; s$ Z! s' @! {9 j P
}
( R+ Y9 \6 Z! W% i
Y[k]=sigma-gama[k]; //求输出层净输入
' d, N/ O3 l4 H% b
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
: X; ?' G3 m4 ~! Z
}
, q C* ?; b( C$ G\" v# P/ f
return 1;
L; g# d. v6 \9 \7 w1 i- w
}//子程序O_I_O()结束
/ q7 n( U* h/ Z7 E: K, K
////////////////////////////////////% [* w' \, ^! N$ S! Y6 s# j8 F
//输出层至隐层的一般化误差子程序////
n3 i, {5 R, n- P! @8 G( h: S
////////////////////////////////////
% z1 V+ u. G O% J6 {% C% {
double d_err[ON];' X! U) ?& b% g: p4 f Y3 A
Err_O_H(int m)
- M, _\" b. E5 n, @! H
{/ L5 L: B! g* O1 Q* e
double abs_err[ON];//每个样本的绝对误差都是从0开始的7 ]5 Q; S- @% m; q7 j
double sqr_err=0;//每个样本的平方误差计算都是从0开始的6 }% L& e* `/ P% B
//for (int output=0;output<ON;output++) //output???
3 m\" j* v+ }3 r, p3 O\" I
for (int k=0;k<ON;k++)
' ^! C( Q5 {0 V
abs_err[k]=T[k]-O[k];: e5 d- [& G, p+ K+ T/ j$ R2 s
//求第m个样本下的第k个神经元的绝对误差* P# R4 X& n& B9 Y6 C- E
sqr_err+=(abs_err[k])*(abs_err[k]);8 z, w/ S& k+ |1 M1 x4 M
//求第m个样本下输出层的平方误差4 c0 Q6 U* r N6 ]: X4 R
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);- A$ e/ m3 T6 r, k5 Z% b. a- t5 h
//d_err[k]输出层各神经元的一般化误差7 J7 V3 Y1 R7 q4 A
}6 C: ]( F7 l6 E$ W9 t
err_m[m]=sqr_err/2; V9 o: a0 N) v9 N5 q3 u8 a! G
//第m个样本下输出层的平方误差/2=第m个样本的均方误差\" v( u1 s1 L7 j& }: B7 P7 P
return 1;4 y0 U' R$ S7 ?) \
}//子程序Err_O_H(m)结束
8 Y% ?$ V, g# |& m
////////////////////////////////////
: v& A, f1 \( A0 A0 A- G1 g, B
//隐层至输入层的一般化误差子程序////1 m# C, w) C2 p4 T, f/ N0 w8 R
////////////////////////////////////
b. v4 y7 k3 E$ S
double e_err[HN];
& V$ p% M6 ~$ n- b( S9 q
Err_H_I(){
2 u# ~7 A% Z, ~% o, `9 ~
double sigma;
4 f* G ]/ u% W; V
//for (int hidden=0;hidden
( `' L2 ? g4 p; a& P
for (int j=0;j<HN;j++) 0 G/ L, O' z/ A5 y& l
sigma=0.0;' \! b8 _/ Z3 S1 a' X8 X
for (int k=0;k<ON;k++) ( H+ h3 ^\" n) B2 ?\" {- z
sigma=d_err[k]*V[k][j];
}
+ B; U, @, j. b; Y& ]9 p
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
' ]. K0 K* h& p; B$ w0 G: l5 {! v# X
}1 d+ Q$ u* q- Q, L9 F I
return 1;
\" D0 L& R' t7 G) A
}//子程序Err_H_I()结束\" F& H- @( w/ K) g! O
////////////////////////////////////////////////////////( r; v M- }3 F, w+ z
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
2 ~# R8 \ W$ {
////////////////////////////////////////////////////////
7 s3 [: Y) X$ r8 Y* m
Delta_O_H(int m,FILE* fp)0 D, u. s: X- |/ G6 J& S\" _
{6 _$ h* c5 m) {) p+ T3 c2 E
for (int k=0;k<ON;k++)2 F6 B9 l7 o: P2 s7 D
for (int j=0;j<HN;j++)2 g) w9 C' ]6 M+ a
//cout<<"第"<
\" n7 N0 Z\" Y+ |, @. M9 x
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
& |( ?\" o8 o. R) ~- ]3 M$ w1 `
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
4 q- N& [% P+ Q( U% P
}7 y/ v& N$ t2 L0 M
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
* R! J! t; ]\" S6 r. X/ h( ^
}
& V; l& j\" _8 k8 Y\" \0 n
return 1;
. v! a/ {\" d. ?
}//子程序Delta_O_H()结束
7 a1 }% q/ V% {; v6 c' A8 y
/////////////////////////////////////////////////////3 @( y, I5 R D3 ^+ m; J' e; k- z
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
' p p7 Z+ D9 q+ @) ~
/////////////////////////////////////////////////////, x' Y* \8 H* {/ w0 ~3 T. Z8 B
Delta_H_I(int m,FILE* fp): g8 z1 J8 t L, k* ]$ h; B2 f5 a
{8 B' P3 l6 D8 d* Q- \
for (int j=0;j<HN;j++)
) g* M& [2 T7 E; y- k H1 N
for (int i=0;i<IN;i++)
+ Z% h: q) J0 _1 v+ H3 l$ t: T4 [
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
0 X- q2 T3 m. a% |! f; X) m* e
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整( q# g4 a! H$ U! @: y. g8 X
}0 G& v- i: v* J' Q9 }2 M
sita[j]+=beta*e_err[j];! v* V M$ n5 n2 A+ X' `
}
) J5 V) s4 @& ~9 J- u9 _+ _4 y/ Q\" e
return 1;
4 D0 p2 V: E( @. o$ m( h
}//子程序Delta_H_I()结束
# `' q1 O { `: y% c+ K7 K `
/////////////////////////////////! e) a: d, v' ]/ G$ J7 X' L
//N个样本的全局误差计算子程序////
1 O% T9 Y$ g/ O\" F
///////////////////////////////// c$ O. |! S\" _+ w' g* k
double Err_Sum()6 P2 n1 ]( @$ d0 W4 N9 X
{/ G! V* D- p ^1 Q1 r
double total_err=0;
: `- H h6 r7 C F, P
for (int m=0;m<N;m++)
7 {9 v b2 A\" `, T$ c. E
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差8 M' b1 v7 t8 ^9 l: F( y. @
}+ N- \8 k3 K1 U( r8 ~# F, ?+ v1 w
return 1;
$ C8 ?4 a% {5 ?/ s9 Q
}//子程序Err_sum()结束
, k5 |: J' W: X: \. W
/**********************/7 P: E6 Z8 p\" j3 p5 B: J# n
/**程序入口，即主程序**/1 m* x0 y$ D* z9 `$ H8 |8 x
/**********************/% w: f+ ]% M0 c: p- D
main()+ J4 u7 q% T/ e\" K$ ^& [; M- y
{\" K$ A3 A8 G/ {9 r8 Z( v' v% E+ \ h
FILE *fp;
1 X7 N7 g6 k; ?' W$ |7 c4 z
double sum_err;4 k. p5 I' L7 i/ M\" a. o4 J0 H# o) }1 q
int study;//训练次数
5 K$ h, X+ J5 @ z; E
if ((fp=fopen("bp.txt","a+"))==NULL)
9 [1 w( Q; f; z$ K
{1 d7 a1 I& K: f5 K! M5 ?
printf("不能创建bp.txt文件!\n");+ k5 W* R# f+ t; L! d
exit(1);$ l; }+ X+ _% U; x8 r1 S& ~
}$ h3 c* U8 H% B1 E
cout<<"请输入输出层到隐含层学习效率: alpha=\n";- f% W$ _# T4 E. x# K9 U
cin>>alpha;
3 T5 X7 k+ I9 P; c& Y* k$ _4 s' `
cout<<"请输入隐含层到输入层学习效率: beta=\n";
0 x, \$ T* u$ [
cin>>beta;' g) ^9 d3 r# c6 T
int study=0; //学习次数
/ j2 w, H5 E2 o\" f# f1 g0 }( b
double Pre_error ; //预定误差
9 u+ a3 K% }* C3 R
cout<<"请输入预定误差: Pre_error= \n";- |1 q( V/ c; B1 f- {- R! e
cin>>Pre_error;$ t/ i- Z2 Y# y2 y& x6 Z
int Pre_times;
! \: H. t8 w6 Y\" b% b5 u) {9 ]
cout<<"请输入预定最大学习次数:Pre_times=\n";
4 F- a2 [, D' e# a: c# d
cin>>Pre_times;5 K. S' \3 [- W8 C1 M
cout<<"请输入学习样本数据\n";
& t$ @1 N* L# S5 {. j0 ^0 F; w
{
# n0 n& B; @- T8 s5 Z
for (int m=0;m<N;m++)
; Z3 [2 l3 F/ N, _+ |
cout<<"请输入第"<<m+1<<"组学习样本"<<endl; * x, w5 R1 N/ K- T
for (int i=0;i<IN;i++)
5 O, Z4 ]3 o3 V8 r6 d6 p& P& t8 j
cin>>Study_Data[m]->input[i];) Y- m& m$ H! {5 O
}! O5 G1 }3 s7 w, H9 q
{ ! v. k7 U7 M' w; V7 O
for (int m=0;m<N;m++)& f0 W7 ]) A& p: }* c
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
- c/ A! J6 y2 c
for (int k=0;k<ON;k++)
& {, C& q5 T5 x J4 F5 r# b0 Q. u, A
cin>>Study_Data[m]->teach[k];$ n8 Y% X9 _4 n! N# R\" u7 q R
}
4 {6 |* b) J0 P
initial(); //隐层、输出层权、阈值初始化 (1) $ `8 [5 [: h\" n6 R+ ~
do+ x( ~! L- j8 E1 t
{
++study; ///???
4 B) b, Y3 g7 i u0 E/ e
for (int m=0;m<N;m++) 9 _+ J/ V4 a k9 r( L
{
9 j* U! A$ y8 l. @1 `) e\" G; i
input_P(m); //输入第m个学习样本 (2)8 {9 f$ m' Q5 m1 C5 C l
input_T(m);//输入第m个样本的教师信号 (3)
$ h5 h% C* y/ t' s/ r: W
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
' G( S+ f& I$ h. D6 K$ E
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)
1 q: e V/ } ?4 A& `$ m& O$ k
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
$ e1 y, {+ ^ G* U! P
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)0 d) O9 K4 m1 z2 A9 ]6 u7 q# M
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
# V- N% R6 t' j
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
. \* U( D/ N. c( |! x/ M. Y
} //全部样本训练完毕
\" S' A. f7 H\" o4 \( K% [4 {
sum_err=Err_Sum(); //全部样本全局误差计算 (10)+ s$ B) t\" q\" R2 ]. E
{
5 I* e+ V; M+ X$ m. J6 t
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
0 _; c; [+ `+ i; l: d
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);4 E6 Y' j Z- M( h
}
4 Q8 p1 R/ J7 X, n
while (sum_err > Pre_error) //or(study
$ C0 @7 P7 O9 o* w
{ //N个样本全局误差小于预定误差否？小于则退出 (11)0 _: a. N2 W w) h7 U8 G2 C$ ^/ d
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;7 j' ?$ c9 j9 s6 ^+ V
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
& t& o! c% n; [; \2 z( C% b6 ^
fclose(fp);* w, Z$ O E' p* x$ M' g\" n
}6 m O# G' {\" \' v8 z, ^1 B+ t
char s;
+ z) ?% U8 _. t/ {% E
cout<<"请随便输入一个字符，按回车退出程序！\n";9 y7 C$ Z; y `6 V6 \
cin>>s;
5 x: L8 R3 p1 f0 E; T9 P
return 1;3 g1 G# S1 s9 z\" u4 f
}
6 ?' Y) J ~9 o
+ l) X$ @+ H$ F) B7 ~9 p