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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"
' o* _, H\" d& x0 m
#include "iomanip.h"
2 {8 l7 t( e. m( b+ O( h
#define N 20 //学习样本个数 T9 W6 V7 `# C. }& @7 |% A
#define IN 1 //输入层神经元数目
8 t& y2 o2 t: v; r
#define HN 8 //隐层神经元数目
& |( f5 c @; X/ T
#define ON 1 //输出层神经元数目( \) o( U7 X( w\" A+ s; u
double P[IN]; //单个样本输入数据5 E* h0 @7 M& W1 w3 q5 T
double T[ON]; //单个样本教师数据
, M& d# ]' L; o/ g% e4 @; H
double W[HN][IN]; //输入层至隐层权值
2 r- j/ ?! d$ k( K/ {
double V[ON][HN]; //隐层至输出层权值$ ]0 l. l, U/ K6 i
double X[HN]; //隐层的输入
: k0 [' I K% Y* J
double Y[ON]; //输出层的输入: \\" n# N: `+ ~. o8 m6 w
double H[HN]; //隐层的输出
1 T' ]; I, w' W0 L% J
double O[ON]; //输出层的输出
. P\" N/ w/ q8 w6 v+ O# }6 }
double sita[HN]; //隐层的阈值, {; @7 ^5 X4 D\" {' `
double gama[ON]; //输出层的阈值, m5 Y% k$ g& i0 d, I
double err_m[N]; //第m个样本的总误差. P% }& V3 o, C k6 ?9 A
double alpha; //输出层至隐层的学习效率
) K) B\" j* ?, h& }) G7 V
double beta; //隐层至输入层学习效率8 p U, F2 W' g- G/ d, ~
//定义一个放学习样本的结构% q3 s3 i# t: }0 n( k& Z+ I4 e
struct {1 }6 m% `0 Z. r
double input[IN];
4 G\" N4 D) o8 A9 ^5 A
double teach[ON];
. I3 r; [6 W6 \9 C# k J
}Study_Data[N][IN];% R H$ q8 X! J* }& Q\" O# n
( l: `4 Q9 B6 N8 f1 ?6 t; ^
///////////////////////////
; f+ p; h' J\" U4 |. a7 {5 x
//初始化权、阈值子程序/////
\" l/ d5 \+ @4 Z4 G. I
///////////////////////////
+ y) s# h8 o% P/ b/ m
initial()& K# x. t; C& a$ @; A
{
+ v$ J' U/ R s3 Y% p: q
float sgn;
7 F* \8 x! b8 j
float rnd;; P% `1 }8 Y9 p( @\" I+ |6 Y, ^
int i,j;% ]\" j5 X9 c. H* {7 a5 d0 o) P3 u
//隐层权、阈值初始化//
5 A% `9 q7 w, ^: t6 ~5 I
{
% y8 d3 J; I# }, I4 D6 B
//sgn=pow((-1),random(100));, J9 D( j/ r\" q* q/ l+ \' [
sgn=rand();
4 p3 u' z5 B1 S
rnd=sgn*(rand()%100);
7 a# x* g0 ]. d
W[j][i]= rnd/100;//隐层权值初始化。
( U4 z$ Y6 e, x3 ] j) J
}) g2 c/ n3 V8 q0 j+ ^4 }+ o
//randomize();( j8 V8 ^\" k. S3 p+ ^
{
* p; o4 ~$ B( G8 o$ d0 \. ^\" ~6 p
//sgn=pow((-1),random(1000));/ C' S6 F# [5 q5 z3 x9 e3 K3 J
sgn=rand();
8 ?, v( X& Z, V6 i
rnd=sgn*(rand()%1000);
( n\" v1 B4 X5 q+ P S% F
sita[j]= rnd/1000;//中间层阈值初始化
! _$ l4 E% f1 d* b( T1 e
cout<<"sita"<<sita[j]<<endl;
3 I/ q. Z, C: N' N( w5 x& I
}
$ S\" E) w( ? E' g% j, G0 _0 {: J
//输出层权、阈值初始化//- l/ X% r1 u8 R& M( {
//randomize();( @# {/ C2 N' @: H
for (int k=0;k<ON;k++)' ~2 j5 n) G) I* }5 o3 V5 p$ f0 C3 \
for (int j=0;j<HN;j++)
T: [ y. o' t: |2 Z. O6 l4 S
{
3 z5 g- ]4 _8 z; E
//sgn=pow((-1),random(1000));& t4 w: Y6 ^! |) j E
sgn=rand();
8 l2 [! Z/ E, c U H5 m) D
rnd=sgn*(rand()%1000);% x' ]( \, L$ O. L1 J- _5 V$ D
V[k][j]=rnd/1000;//第m个样本输出层权值初始化
0 s: ]2 W\" G. R% E0 m, q& u
}
3 p( W R$ R$ S: V' i/ A0 v& I$ z* B
//randomize();
0 K0 N( z2 E2 r4 [7 [\" l) R
{4 h/ H& v& t2 ~9 H7 L! d
//sgn=pow((-1),random(10));
0 Z! L2 ], I a# s, ^
sgn=rand();
# ^2 m: q$ F A* W
rnd=sgn*(rand()%10);
9 l! ]. D; c- G8 ]
gama[k]=rnd/10;//输出层阈值初始化
5 J# f' P8 s4 M9 c
cout<<"gama[k]"<<endl;\" d8 y/ I! s) o- m7 ~$ \* m
}
: D, h8 I* l; R) [5 y7 {9 U: B5 R
return 1;
( ~( b9 d% U: F% U
. L: ~8 X% P' c) n
}//子程序initial()结束
8 g1 Z1 c( k; B
\, x, X; _+ q: b% W
////////////////////////////////
/ y- K; a% e. z: }+ @) u. X; q
////第m个学习样本输入子程序///3 I8 n4 @\" k8 W/ [/ N* t
///////////////////////////////
% K: D! X\" G$ s- N b$ \# s0 E
input_P(int m)- j& f( c. Y3 g2 W* k* p6 S
{
2 K& q; U3 A( J8 I
for (int i=0;i<IN;i++)
% g9 B3 E% U9 @) T. Q\" A
P[i]=Study_Data[m]->input[i];( q8 R% ~; }: {& Y/ J3 M, u r4 o' J0 k
//获得第m个样本的数据% `6 C5 |& A/ a8 ~+ Z ?) u: C
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：( }* A7 t7 e5 h0 p
//P[%d]=%f\n",m,P[i]);
8 J( [8 f1 t( w% L
return 1;6 b: Y2 Y5 g. v4 h2 p
}//子程序input_P(m）结束( o2 l2 P& H# n c' ^3 A
/////////////////////////////& z6 w+ }8 D8 l0 h# k6 M
////第m个样本教师信号子程序//
: U& ~* o. v) a- K' l' U( T
/////////////////////////////' B3 N* O- U# N/ z
input_T(int m)
Q2 A+ |( x# M4 e0 y; s
{\" Q! f* t# {7 V\" L; X
for (int k=0;k<m;k++)( N. J0 H$ B6 ?
T[k]=Study_Data[m]->teach[k];& |+ b1 S( @! {% Y% [
//cout<<"第"< //+ Z# s: |( T. ?& W2 B
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);
2 O( P5 P6 M; r\" f- y( b8 q
return 1;+ w2 u* M R6 ^- \7 L\" s
}//子程序input_T(m)结束
# k- i: W+ `9 \\" a
/////////////////////////////////% \: e9 C: j3 v; @, |6 l4 i* P# _
//隐层各单元输入、输出值子程序///5 M( e# j$ T4 A+ z\" a% R1 u
/////////////////////////////////4 T X0 T, }9 y8 s4 e\" b* c
H_I_O(){
; ]9 @\" B: c4 `7 W1 _& x, @
double sigma;( p, R* @# E3 x2 T2 a
int i,j;
7 H; c0 c, Q4 a: Q4 z. |. A
for (j=0;j<HN;j++)8 G% \( [: S5 a
sigma=0.0;
2 A! O- m: A) S; s9 @% q( Z
for (i=0;i<IN;i++)0 v3 J# E8 d0 z. R9 {\" P( a; e
sigma+=W[j][i]*P[i];//求隐层内积
) e2 T- o. n9 z1 M
}
1 B* t8 K/ Y: X! s; o
X[j]=sigma - sita[i];//求隐层净输入
4 ?; d; ~& e; c6 f# b
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出$ o9 F; Z( @. x0 H% {& s& m8 B
}5 u7 J, W% Q6 j: x6 r1 J; f
return 1;
+ B& ^0 N, O( D$ }
}//子程序H_I_O()结束
; Q S, ^# n/ t% l4 n6 J' Y6 u
///////////////////////////////////
& A+ _' R' j/ C
//输出层各单元输入、输出值子程序///
! Z# A* X* B, n5 I( A6 \
///////////////////////////////////
9 d8 a+ i0 M$ d$ s S; n
O_I_O()
6 a+ ?, L; ~9 d# G' V
{$ {. `, Q' k\" _+ E* O$ p
double sigma;: }0 ?2 g5 W- d. J8 B, I! q9 q/ N
for (int k=0;k<ON;k++)1 `( W. a. ?) B6 m# E- N: q, e! d
sigma=0.0;
- S7 k0 a1 Y: C) y0 v, ?+ }0 L
for (int j=0;j<HN;j++)
* \# C7 C2 `* h, R4 P# u
sigma+=V[k][j]*H[k];//求输出层内积
3 q% x8 i0 K+ ?5 _7 i r3 t8 O
}
\" o\" C& Y- }0 Y3 _
Y[k]=sigma-gama[k]; //求输出层净输入# S3 E4 ^6 {% I& Q$ X\" M
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
! v3 _8 V. ]+ j1 N8 X/ u
}* {# d; ^6 U' _* l: p3 s
return 1;4 d9 H4 V( ?9 a- s6 v$ j
}//子程序O_I_O()结束 d# @; W* W# u+ h
////////////////////////////////////6 V$ y$ r& I# T/ R9 G7 U% n
//输出层至隐层的一般化误差子程序////4 J$ A, V0 r\" c# V: r& A
////////////////////////////////////6 ]+ Y$ a, D1 v\" j
double d_err[ON];1 d# g1 _) k* q
Err_O_H(int m)4 U3 a# F9 o8 c# x2 J c' i) Q3 E
{; f5 o( j4 u% F
double abs_err[ON];//每个样本的绝对误差都是从0开始的\" R; b( d% S E; \
double sqr_err=0;//每个样本的平方误差计算都是从0开始的6 P/ c/ {. K1 t! {- {- A$ q
//for (int output=0;output<ON;output++) //output???
# P- K4 S+ j; \
for (int k=0;k<ON;k++)
/ X! w: {+ N- Z ]* q5 j
abs_err[k]=T[k]-O[k];5 v( b) X6 T) f7 V( i5 M
//求第m个样本下的第k个神经元的绝对误差2 `2 _- w) E/ s u u' H, D; G
sqr_err+=(abs_err[k])*(abs_err[k]);3 E U, s, |\" I0 Q: e
//求第m个样本下输出层的平方误差
3 ?+ e1 J3 [' _1 _5 T( C, O, P/ a% `
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);
1 t T/ O3 W8 N7 f2 R; d3 z1 t
//d_err[k]输出层各神经元的一般化误差
0 X- _9 Z3 y8 X. O; ^; V
}
- V6 ]. N2 w9 V* T
err_m[m]=sqr_err/2;\" E, X7 y* F. [) t
//第m个样本下输出层的平方误差/2=第m个样本的均方误差# N# V7 s$ E, ?. e, ]
return 1;
4 @\" n% \$ f/ K1 k
}//子程序Err_O_H(m)结束; U: u- R; H: N' Z. N
////////////////////////////////////5 L% F/ e) _* k0 ?' ]4 a+ Q
//隐层至输入层的一般化误差子程序////
5 m6 d, w\" n( K
////////////////////////////////////
& M/ { T3 j' n! y$ G1 L8 \# B: h! X
double e_err[HN];
, P' `: u7 t7 R# }$ e/ S, b
Err_H_I(){4 n3 |8 R8 Q/ W8 v/ i' u- i
double sigma;3 a( T1 A( ~2 @
//for (int hidden=0;hidden
9 ^, r. x' v\" z\" G$ \
for (int j=0;j<HN;j++) * I, ^) S k8 F+ L
sigma=0.0;& g# R4 F: e. [1 F. H! w3 x1 m& l
for (int k=0;k<ON;k++) * ^! j6 @ A. y. Y
sigma=d_err[k]*V[k][j]; F7 _) J7 l) Q$ ^$ n0 Y
}
. I\" }, r4 ?- c3 O5 \' \
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差2 C. }- \8 l/ w- A* d
}2 V' Y: ]! h7 L. L$ F5 n- z
return 1;
. {$ g$ m- N, E! w6 H7 e
}//子程序Err_H_I()结束
2 Z! k' J/ j3 e; R3 q D
////////////////////////////////////////////////////////
' P2 m2 ]\" N6 D Y- q
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////8 }$ X& c2 r( ?\" N# u
////////////////////////////////////////////////////////
! V. ]7 f; r& a
Delta_O_H(int m,FILE* fp)6 G; R% m' F2 I! w' B$ [0 Z' I
{
1 i( e4 S6 [* X, Z4 D' j
for (int k=0;k<ON;k++)! p/ X2 X, L$ U! ^
for (int j=0;j<HN;j++)\" l6 `# w: ~* _5 U
//cout<<"第"< ) u5 \1 t) l0 K& f\" Y+ S
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
$ n7 h3 `+ ?3 z! }7 m3 i/ W
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整
' D& b2 ~ h+ H( p\" x
}
. |- C0 c/ L; |
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整' a3 V; s6 I+ y/ b- T3 e
}
6 U0 b8 `5 `8 y1 w
return 1;
/ F# q5 m0 {- a! c. k. a0 X a
}//子程序Delta_O_H()结束4 y6 M, `% J# m7 B( J: O
/////////////////////////////////////////////////////* Z% r r2 L9 H& h$ m8 o3 K
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
# h ^4 j8 V\" O7 v
/////////////////////////////////////////////////////
. \) g: e0 q) E\" }' y
Delta_H_I(int m,FILE* fp)
; P$ c, }# Y$ [/ \8 ^
{
) }$ j; p2 X% \- L) W7 y: U! l R
for (int j=0;j<HN;j++)
, C: {0 k- {% j, \' e
for (int i=0;i<IN;i++) 3 A& K/ l- \& b* ^9 S
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
8 H! y) T$ x* S1 d3 _5 i& t
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整$ O E. ?1 S8 z
}, `0 n, [* M3 l
sita[j]+=beta*e_err[j];
& Z& s9 a+ Z+ y% t% E& m
}
\" k! D# f0 G! O! ~0 ^: @
return 1;! D9 p( V\" _ U5 @/ d
}//子程序Delta_H_I()结束
3 i E* k! U$ @$ B
/////////////////////////////////
: J& `2 u! V. f1 k
//N个样本的全局误差计算子程序////
! q% L2 [3 J3 J4 v4 C: a# l
/////////////////////////////////
6 ?# v b$ \: ^5 [\" b
double Err_Sum()$ `9 A$ b2 J- a( m' K, ]5 o
{& x' u1 L' N% |% f: m4 R7 y
double total_err=0;4 r, G. _* Z1 Z$ _/ \- w
for (int m=0;m<N;m++)
. E! K& M$ c' E B
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差4 {) g* ~( a; |* }; Q
}
6 U& d' {, H' `/ @) V; s
return 1;
# ~2 A, }8 T7 D2 e, U, S$ ~6 O
}//子程序Err_sum()结束
5 n0 D( ^! _4 Z/ u6 ^2 x& t
/**********************/4 I( ?\" @ _ S# m) E\" m ^
/**程序入口，即主程序**/
3 C# g# `& q( O$ S8 g+ O
/**********************/* h& J2 F3 l4 G8 R1 m/ n% e8 ~# f
main()6 m' r4 y* H9 Z2 V) ?8 K. ~3 m, ?
{
9 a5 p2 `# y9 C: X8 | O
FILE *fp;
3 j; m0 v0 W9 P/ x
double sum_err;# b, w u; ]( i\" P1 V# T
int study;//训练次数% T& _2 x1 V9 A( ?+ i
if ((fp=fopen("bp.txt","a+"))==NULL)
; s2 [% m* o1 w- q: r
{6 e) P: N; [! _3 E. S
printf("不能创建bp.txt文件!\n");; G8 Y! Y\" R) ?# I3 X- k2 C\" W
exit(1);
, y! t0 f# d h5 C
}
0 A. W' c# a! M! _9 r+ b5 H& I J2 x
cout<<"请输入输出层到隐含层学习效率: alpha=\n";
' d: m& s( S9 p+ ~, y( K& t\" R! V) |
cin>>alpha;/ I. {; b\" L! d, ?3 ]& D8 M
cout<<"请输入隐含层到输入层学习效率: beta=\n";
6 s( x+ @/ _1 q$ R
cin>>beta;
5 U- _! k( R. e$ X1 H4 R
int study=0; //学习次数
$ `0 T7 h# I\" P# I
double Pre_error ; //预定误差
5 x* G; r+ X1 k( m# d
cout<<"请输入预定误差: Pre_error= \n";
( C( f7 v+ g6 T* V* ?- y
cin>>Pre_error;9 i% o& U; E9 X% w( f
int Pre_times;
4 o- {/ g5 f, E
cout<<"请输入预定最大学习次数:Pre_times=\n";
: n! i$ H2 A# \) K
cin>>Pre_times;
7 O) H7 \4 V! L
cout<<"请输入学习样本数据\n";8 [% {\" q- c( M- f
{
$ ?% g1 r- I: q: t. O\" W
for (int m=0;m<N;m++)
6 X7 a. u9 z& q2 i$ C# f* Q
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
+ `% q( P0 \% ]1 a7 K; e* D; n
for (int i=0;i<IN;i++)
/ ?8 g F5 [ O- Y# V* i) S1 g
cin>>Study_Data[m]->input[i];0 `# J7 F7 p. n+ }6 a
}' g) Z% p3 ^/ c4 h0 G. K3 h7 C
{
\" l. A/ d) m# m/ }1 w. i
for (int m=0;m<N;m++)' {! K' S+ M$ E, A6 ~
cout<<"请输入第"<<m+1<<"组教师样本"<<endl;
* Z7 ^5 c( q) K7 c
for (int k=0;k<ON;k++)
( p/ z' W+ c, x$ i/ D; l
cin>>Study_Data[m]->teach[k];
4 l; B+ c' f( s
}
9 ^! f. N3 Q3 }/ S
initial(); //隐层、输出层权、阈值初始化 (1)
6 a& l7 G+ w7 b0 d; ~
do
: b' j; v O1 y6 _
{\" W0 J% n2 G' y+ P8 n
++study; ///???
8 n( P7 e2 o! A$ y5 R' [1 y( N
for (int m=0;m<N;m++)
7 J1 ?+ J' Q1 ?3 ~4 `$ a0 z8 [4 w& @
{$ {- V) X5 V/ V: r: r
input_P(m); //输入第m个学习样本 (2)7 ^8 P3 i L0 @1 I
input_T(m);//输入第m个样本的教师信号 (3)+ G9 X8 L8 n4 W# v
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)
) W$ _! {9 x1 j
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5), O4 K, P. a& w
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6) ( r9 Y, _9 A/ q
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)0 S! e2 P5 Z* j( k
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8)
+ F& ?% q2 ^, Z& Q' A; u/ \9 K
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)8 g* _# M2 y( [) l$ a/ Z( {
} //全部样本训练完毕5 l! ~6 A& {5 [# Z7 I
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
% u6 n\" d( } s: B* h
{\" a: A8 E& I1 I q2 l
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;3 U$ k: w: L/ y
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);5 p0 |2 d: \$ d% C7 ]
}
4 h- `1 z, F5 E/ x$ c; @5 @# L
while (sum_err > Pre_error) //or(study
\" W$ ?; L' z e+ G* E\" t3 _
{ //N个样本全局误差小于预定误差否？小于则退出 (11)- _1 b- S7 f% y+ k\" e5 v( g
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
8 m5 q6 [. H( l8 T
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);. k2 u& M% K* w* E! R# |
fclose(fp);
\" n+ v6 H, F/ ^2 K; e1 r: B0 c/ P1 [
}8 m% j) M8 e5 o: l) }7 H2 ^' R; T
char s;
) t$ T. e1 U; b\" d. g) F4 d' D. Y
cout<<"请随便输入一个字符，按回车退出程序！\n";# i+ x. _8 Y7 R- N' {! j( u
cin>>s;
/ t+ W ~1 h0 T+ ~5 b0 D2 g
return 1;6 U, r# t F8 L* Z
}8 g+ U\" f% }# |# x
$ N. Z; d* ^. _5 w9 x0 Y; d, l