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

[复制链接]

字体大小: 正常放大

ebookSharing

33 主题	8 听众	31 积分

升级 27.37%

该用户从未签到

电梯直达

1^#

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

|招呼Ta 关注Ta

#include "iostream.h"0 a/ V- Z\" E; V% K' O/ F- y. q
#include "iomanip.h"9 D+ [8 t, E- s8 d4 n; B
#define N 20 //学习样本个数
; z: Z, e; _# T6 A! X6 y
#define IN 1 //输入层神经元数目$ S0 C, D+ g* u! J
#define HN 8 //隐层神经元数目
; Z. i9 _7 j) B( g0 f) N
#define ON 1 //输出层神经元数目8 U i2 R8 P8 F
double P[IN]; //单个样本输入数据
+ ^3 _\" p# m! f& k: G$ a( P, ?
double T[ON]; //单个样本教师数据
. |8 c8 U. ]9 i+ L\" t
double W[HN][IN]; //输入层至隐层权值
8 D3 b- N( L1 I5 p( M; L; n2 Z; \
double V[ON][HN]; //隐层至输出层权值
# |8 d9 d. t# i( [: f$ q
double X[HN]; //隐层的输入0 l+ D' P8 R6 f% o
double Y[ON]; //输出层的输入1 ]% N' j6 U( X* F
double H[HN]; //隐层的输出# b& h1 J; j) r3 l$ M. Y
double O[ON]; //输出层的输出7 b! ~& D8 H3 B) n
double sita[HN]; //隐层的阈值
1 {7 i/ O1 }7 b8 O0 q
double gama[ON]; //输出层的阈值
}6 @( z6 k* H' ^& \ D; o. f
double err_m[N]; //第m个样本的总误差9 C }2 R/ c2 i
double alpha; //输出层至隐层的学习效率' M8 z9 ^9 W1 b\" O4 r
double beta; //隐层至输入层学习效率
5 g' c5 S8 y u3 }3 L! p
//定义一个放学习样本的结构
- ]7 k4 H4 Q# P( c
struct {
& I$ e+ C0 h, d1 G! I
double input[IN];) \6 s+ L! a* \, g
double teach[ON];% M8 ~( J4 v/ m( V/ h1 ]- X5 Q
}Study_Data[N][IN];
/ ?: V W$ L+ s1 Z
4 d3 t1 y( S! N1 G# z+ t' P
///////////////////////////
2 ^# p2 `0 ~# [5 y9 V* @6 g7 ~\" g
//初始化权、阈值子程序/////
0 D6 y# _% W* i
///////////////////////////; ~; ^6 y2 J6 i3 T
initial()
{
, p. q2 Q1 R1 @
float sgn;
: b7 Y0 R ~' x. H
float rnd;% {# D1 C3 I7 ~8 L9 V2 Y
int i,j;9 [/ n\" g% Q {* B% S
//隐层权、阈值初始化//
7 L4 I3 {* T0 J, `
{
( @9 k0 m) Y0 W$ h+ Y
//sgn=pow((-1),random(100));. z. O+ f6 r5 W8 E
sgn=rand();
7 a5 A, D+ D6 ^! \7 j3 c+ i
rnd=sgn*(rand()%100);
! |2 Z( y, v& v( u4 W
W[j][i]= rnd/100;//隐层权值初始化。0 Y\" W0 i# Y, I) S
}
% e1 f. C( C+ A# `( w
//randomize();
: v3 H( j) U7 J; y# D& e
{
* s8 D! h% i% B+ J- N
//sgn=pow((-1),random(1000));6 {! r4 {# V' N
sgn=rand();( I( q; k+ \1 K/ Q+ j
rnd=sgn*(rand()%1000);6 W: |3 E6 [9 s
sita[j]= rnd/1000;//中间层阈值初始化
\" }( U! {+ C2 E$ \( `& m\" h
cout<<"sita"<<sita[j]<<endl;6 |7 ?. |1 x* y1 t$ w
}3 s7 W& C5 ]5 ?, n% L& Z! t0 k
//输出层权、阈值初始化//
\" |4 z' b* P0 Q9 A6 Y2 Q0 e
//randomize();! g- |$ [: ?$ E B( g' e, o
for (int k=0;k<ON;k++)
) ]% A7 {3 @1 R& O
for (int j=0;j<HN;j++)
* o x8 K% X {\" f. b: X6 P
{
! f' q\" S0 n! h$ v+ |& g/ ^
//sgn=pow((-1),random(1000));6 y/ E* o+ k+ @0 i. C4 H! I
sgn=rand();
7 m+ X$ e4 \7 ^
rnd=sgn*(rand()%1000);
; M; _9 }( N5 s\" ] ~5 R( u
V[k][j]=rnd/1000;//第m个样本输出层权值初始化 D) P- C6 V5 a4 l! o/ ~- n
}9 \, N* o' D1 y* w$ x* P: g* g
//randomize();
7 f0 a# v4 p% k, ?
{4 ]7 r7 Q2 E: M/ x$ v2 x: ~( ?2 M# v( n& `
//sgn=pow((-1),random(10));
# o, Y1 k F+ t6 u) q3 s, {( t h
sgn=rand();\" a6 ^( d5 D\" N* w B8 v
rnd=sgn*(rand()%10);
! R) E\" e0 `\" k/ ` q2 C$ ?
gama[k]=rnd/10;//输出层阈值初始化0 ^/ g# w: }0 U8 O/ K+ m
cout<<"gama[k]"<<endl;
( e) g/ G9 S, k' A
}
$ _$ L$ R$ V' E( z9 M8 B& @
return 1;; d2 y3 J' r7 V4 U& F$ d3 k
: E0 j/ S3 {6 O' v8 N, @( p7 P
}//子程序initial()结束& H' s# ?. n, M' ~ L0 {
[: U7 G( ^7 d9 o2 o( ^$ J
////////////////////////////////) w! J0 H6 d k1 m$ P q! H+ j
////第m个学习样本输入子程序///8 ?. c& t7 ^ M, n( C, G
///////////////////////////////- n& U# T) r3 c& ]5 g
input_P(int m)$ v! O+ O4 Q8 L9 P
{
* Q1 Y! ^ X9 t5 R0 w- k
for (int i=0;i<IN;i++)- `+ t\" P: T, n
P[i]=Study_Data[m]->input[i];
5 \- g$ f, [+ c0 j
//获得第m个样本的数据
# s: d# l1 c4 z! | O
//cout<<"第"< //fprintf(fp,"第%d个样本的学习输入：
* h6 c, n9 ?2 B$ c1 V5 q
//P[%d]=%f\n",m,P[i]);
6 U+ W' O) r9 _( R
return 1;
, x2 w2 o3 t1 J* {7 j/ q( m
}//子程序input_P(m）结束
2 h9 o; t T! e. M' g0 X! V
/////////////////////////////
* r- q/ _* W9 g! L
////第m个样本教师信号子程序//3 F/ g! I+ {4 \! Z
/////////////////////////////4 @) `+ _& K% F% `! M( \
input_T(int m)
* c# `9 F0 L/ _
{
, {\" p7 f( ]! s8 l& [# D( r
for (int k=0;k<m;k++)8 O1 w B0 T/ l! \3 D
T[k]=Study_Data[m]->teach[k];
8 o8 r: ? Z4 ]9 u' A
//cout<<"第"< //
: L5 V! w3 u. r6 O: Z
fprintf(fp,"第%d个样本的教师信号：T[%d]=%f\n",m,T[k]);0 a' X( T) P: S+ ^\" |2 H/ U1 k' |* b
return 1;1 e) N, x/ a, S# i2 d6 m
}//子程序input_T(m)结束! Q3 e, o/ B K
/////////////////////////////////7 H: d/ [+ q\" f4 D1 {4 X& b; ^8 `! Z
//隐层各单元输入、输出值子程序///8 f' d1 i$ v\" B
/////////////////////////////////, R- o7 N( e q# O4 T
H_I_O(){
6 m' k# f4 T' P7 l- Q- F3 i
double sigma;0 j' P+ K! L/ Y. a. p4 G! O
int i,j;! ^' M \0 l$ h. i
for (j=0;j<HN;j++)) [2 o! P4 ?+ ]! y' p) [
sigma=0.0;
; y2 Q( \9 w1 ]) F7 K5 {- n& z
for (i=0;i<IN;i++)0 s* s; x G. ?$ z! Y1 i
sigma+=W[j][i]*P[i];//求隐层内积
: O6 c8 x. |5 w* `! B/ ]6 R
}
: ]1 H7 X3 f+ M9 r3 P* Q( s: k
X[j]=sigma - sita[i];//求隐层净输入( Y, ~\" E& C$ l5 p
H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出8 k |) A+ h2 O, ?
}0 `2 A# G* U6 h5 i
return 1;
, `& v! x. N; y7 b9 ~, \8 K& h
}//子程序H_I_O()结束2 ^% |) O9 A% c' [1 b
///////////////////////////////////% }: |+ d* [* H7 {
//输出层各单元输入、输出值子程序///
$ K; E. v' S) u3 p( w; R3 |
///////////////////////////////////
' [) \9 u: d `1 D# B
O_I_O()
+ L4 n1 W/ u% b\" Z
{! S$ F s/ \/ [! z
double sigma;
$ W- v1 x2 f& R& j
for (int k=0;k<ON;k++)0 w: I6 q, z4 M& H, g0 {
sigma=0.0;
+ {% r* d- P\" I, r9 ]& }; s
for (int j=0;j<HN;j++)1 [4 B/ C( p& f8 D
sigma+=V[k][j]*H[k];//求输出层内积
3 Y# v' M, }) J6 o, }) t
}
3 d/ L' y+ O q6 q
Y[k]=sigma-gama[k]; //求输出层净输入
1 t/ F: v) t4 M \
O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出; B/ @# c% u8 ^4 J; H# K
}5 X4 z, ^& ]2 Q8 _% s- Q\" s
return 1;
; B; ]/ N$ g$ e, }8 k: i9 U3 F
}//子程序O_I_O()结束
; g8 [: s. _/ x+ _
////////////////////////////////////
( d, w, N9 n# j! j2 J I6 E
//输出层至隐层的一般化误差子程序////
6 r- ]) ~. w) k
////////////////////////////////////- \4 y$ U' F8 H& | }% K9 ?
double d_err[ON];
& M5 N0 q' m4 e: w3 x
Err_O_H(int m)
0 `( M3 L7 w/ \2 C' o+ r+ X
{) y& i8 J. M9 E, h# D7 F5 O
double abs_err[ON];//每个样本的绝对误差都是从0开始的+ H$ i$ ]9 }! l3 q! M, m' W% w* `0 S
double sqr_err=0;//每个样本的平方误差计算都是从0开始的. L( [- R/ M2 f: R7 M b: Z4 ~
//for (int output=0;output<ON;output++) //output???, F+ ?3 ?$ E, M9 q- ]( @( n Y
for (int k=0;k<ON;k++)3 G* f% s9 q: |$ h$ ^ P
abs_err[k]=T[k]-O[k];( V, |+ [. w2 D, N9 v- u
//求第m个样本下的第k个神经元的绝对误差
! g4 i+ K* M/ Q( p7 i4 {$ [+ a1 e
sqr_err+=(abs_err[k])*(abs_err[k]);
. e' g( M* \/ ~9 V2 |2 ]6 R
//求第m个样本下输出层的平方误差0 v0 `- K5 @! y$ o
d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);$ `' e# }/ Y( _0 @; I
//d_err[k]输出层各神经元的一般化误差( c\" e% ~: j. N\" z\" W# w
}8 [) x- C* b: x9 {' S7 o
err_m[m]=sqr_err/2;
& z$ s+ u% j7 d9 h0 }
//第m个样本下输出层的平方误差/2=第m个样本的均方误差- R# A4 [\" q) z! z
return 1;# j9 C/ \' b! V4 a\" T
}//子程序Err_O_H(m)结束
! {/ c! y3 O* m8 v
////////////////////////////////////
; _, h* r6 q3 [3 N& k
//隐层至输入层的一般化误差子程序////
, [ }7 w1 T1 h/ d# v; a+ w3 R
////////////////////////////////////* M: r, w' l\" ]0 E\" T# E7 F; |. l
double e_err[HN];
$ n0 c6 _* O) s, e, Y3 w
Err_H_I(){
4 V7 v$ U' P\" A# Z/ H7 z6 u0 c4 L
double sigma;
\" ~0 O% J- v; k F0 t$ c g- [
//for (int hidden=0;hidden
4 q5 c+ d4 I9 ~\" J
for (int j=0;j<HN;j++) 0 q\" E, Z1 |8 V. T
sigma=0.0;
) z/ k; k2 w. M
for (int k=0;k<ON;k++)
5 A* ~. J, h, ?7 N0 k( p2 y- z) f( |
sigma=d_err[k]*V[k][j];( n) t0 q0 P# Q9 f0 Y; W
}1 n% J O: ?! Y# `\" [( O- `$ {2 o& f
e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差9 h. l8 G1 t; q% d# L* n! x
}& y6 u' s. I* t! i. I: p! G9 d
return 1;; G0 d4 }+ R- z9 U
}//子程序Err_H_I()结束* n- [/ c% F8 G$ v; J
////////////////////////////////////////////////////////
. b) f) Q* z\" n* o
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////9 Z' F& D- A1 t& m
////////////////////////////////////////////////////////7 m/ ]9 y1 D, ~1 L6 p\" {+ L# k# @2 L
Delta_O_H(int m,FILE* fp)1 ]5 ^7 T9 m9 ^\" ]6 L$ G6 d1 X- g
{
) `2 f) V( C4 J/ L: p! D
for (int k=0;k<ON;k++)
4 F2 ?0 B6 O6 A, i: [9 r
for (int j=0;j<HN;j++)
8 b; `7 A C% g7 O) D
//cout<<"第"< 6 C0 @6 H' m( _3 S0 B6 i: z
fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);- _ f6 }% z' U7 G1 N
V[k][j]+=alpha*d_err[k]*H[j];//输出层至隐层的权值调整# y! [0 n3 F. P# c3 q
}( v\" ~. X. r2 V3 w
gama[k]+=alpha*d_err[k];//输出层至隐层的阈值调整
3 l: W' ]& b9 w8 Y
}
8 a/ @3 |\" D: r
return 1;
5 g5 }' c$ c- X0 E. E4 r, m. ^
}//子程序Delta_O_H()结束
7 i% l\" e2 `: N6 @% i+ ~7 \' i4 [1 }
/////////////////////////////////////////////////////0 K9 E& e# ]8 m5 J, p8 a\" K
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
. [ T/ d x. q
/////////////////////////////////////////////////////
$ i$ Z _3 N+ g7 A1 l A2 H
Delta_H_I(int m,FILE* fp)' u6 N K& Z; p$ Y$ t4 K6 X
{
0 q0 A$ b- p7 U5 ^ h5 t0 N* N) |
for (int j=0;j<HN;j++)
% t o2 d. J6 E9 d) p4 B# |
for (int i=0;i<IN;i++)
3 }% h* s& H\" k; n5 h, Z d8 \* }
//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
9 R; y; y/ H0 V0 R
W[j][i]+=beta*e_err[j]*P[i];//隐层至输入层的权值调整
3 o7 y3 Z4 j9 A3 @\" i
}
; l0 O N+ @$ m: F- v
sita[j]+=beta*e_err[j];: E3 |/ X, u5 ?
}
. X, Y4 X/ O! S9 _& V
return 1;
5 f5 ]! X, L2 D\" q& o D1 N
}//子程序Delta_H_I()结束, G& E5 ]! i0 q/ S* O
/////////////////////////////////
) S, `+ ]; h3 O3 @1 l* B0 m* l1 d
//N个样本的全局误差计算子程序////; u/ b! ?9 g$ @9 _$ u0 b
/////////////////////////////////
4 S$ S' e2 k1 v7 d; B: \6 P/ s) U\" y
double Err_Sum()
% G\" ^) U( \& T
{0 s6 J% M' Z, u! J
double total_err=0;
7 R5 U\" ~! P* F: U, ]
for (int m=0;m<N;m++) . X1 c- E; p$ e3 j, C+ j
total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
8 ^) y: _( \& {/ F8 c\" r
}$ y8 N8 k+ \1 I$ j& t# Y) E
return 1;
, S1 ]/ _$ m+ }( C' q% u
}//子程序Err_sum()结束
0 t8 E5 D2 ]* M5 }* @ A) A
/**********************/
- v# d6 `) }7 Y, q4 [' E8 Y
/**程序入口，即主程序**/1 Q0 @2 A# }# s3 c' T8 G$ b
/**********************/5 j Y( {4 H9 P- Z
main()& j* x( C& t7 a- G
{1 T, C5 A5 q: e8 ?\" L& b
FILE *fp;
6 m- z: b0 X8 a
double sum_err;$ b+ b7 Y8 }1 I R# }) T
int study;//训练次数
- W5 x! W e/ b2 M0 ~ d5 }
if ((fp=fopen("bp.txt","a+"))==NULL) d8 t+ r! W [% Q8 }. w
{\" j\" q; A1 }$ d
printf("不能创建bp.txt文件!\n");
& \/ U2 V1 {& I+ [; v- b3 F
exit(1);/ g% R# X5 P2 N! ? E. A
}# N% X6 y# u) E; L, }
cout<<"请输入输出层到隐含层学习效率: alpha=\n";) o }. L+ ]\" c! q- `7 Q
cin>>alpha;
* B9 y, Y$ ^; o/ R! h! |# L( g
cout<<"请输入隐含层到输入层学习效率: beta=\n";
\" }/ r+ W( l/ `1 A8 L$ j
cin>>beta;
, A& @\" O& K: D ^9 _7 _
int study=0; //学习次数) A% f: _; K\" W: _9 o3 \) X/ V
double Pre_error ; //预定误差
5 {* S9 N6 p' J$ ~
cout<<"请输入预定误差: Pre_error= \n";! Y# Q+ a1 G0 \( \2 S3 F* O, |* k
cin>>Pre_error;. R$ `1 x4 a; v8 ^
int Pre_times;/ U% j\" P( K, x\" z o/ d$ Q
cout<<"请输入预定最大学习次数:Pre_times=\n";) J3 n2 T0 i! g9 H6 L
cin>>Pre_times;( t \; ?+ S7 a( N: k0 b J
cout<<"请输入学习样本数据\n";0 a\" l% V4 S: D8 E0 E! V5 T
{$ Q$ i. z% L- B3 L! T5 S% j( n, c
for (int m=0;m<N;m++)
! d4 z& w\" L, m0 }; o# i
cout<<"请输入第"<<m+1<<"组学习样本"<<endl;
\" j# U; a8 M- M- D; Z' T# h
for (int i=0;i<IN;i++)
$ `0 q% B3 N: z: v% T( C$ `
cin>>Study_Data[m]->input[i];
# X: x2 O/ C4 M\" M0 S# M3 l
}2 }5 G5 w! F; I\" p
{ ' U/ K* ]) @2 b& ?- Z) Z
for (int m=0;m<N;m++)5 X9 U- S/ s: Q$ f- X/ G* i% Y$ m& H
cout<<"请输入第"<<m+1<<"组教师样本"<<endl; ; a% w+ T2 b) e4 z
for (int k=0;k<ON;k++)
6 a. g, m( b6 ^8 l' [; t
cin>>Study_Data[m]->teach[k];
2 B' x' Y; W; C h7 |, _
}
, w, g( M% i- I' Q2 j
initial(); //隐层、输出层权、阈值初始化 (1) 2 F' w\" R1 Q4 M* n
do
2 N( w. U: t+ | }
{\" p7 O- P1 \- |# {9 f4 Z
++study; ///???! g0 U e5 H0 h- F$ k, \ u2 e6 s
for (int m=0;m<N;m++) . w7 ?) h* B: \) v* H
{
- v1 q$ |4 G1 S* P# |; p
input_P(m); //输入第m个学习样本 (2)
, F% _- ~* S$ ~
input_T(m);//输入第m个样本的教师信号 (3)
: A1 H- k. Z5 H
H_I_O(); //第m个学习样本隐层各单元输入、输出值 (4)+ I+ M. O7 Y$ i' h6 k
O_I_O(); //第m个学习样本输出层各单元输入、输出值 (5)6 [9 N1 c; B; c0 T# q$ e
Err_O_H(m); //第m个学习样本输出层至隐层一般化误差 (6)
# w) d4 h0 ^0 h3 O
Err_H_I(); //第m个学习样本隐层至输入层一般化误差 (7)
- L$ b+ a: q+ d
Delta_O_H(m,fp); //第m个学习样本输出层至隐层权阈值调整、修改 (8): ?- X( \0 \ |
Delta_H_I(m,fp); //第m个学习样本隐层至输入层权阈值调整、修改 (9)
2 H( v; g1 T e
} //全部样本训练完毕- {8 O5 B X- ^# C' f3 {
sum_err=Err_Sum(); //全部样本全局误差计算 (10)
* f3 N# k3 e$ Q3 v; F1 }
{
% ]8 {7 [1 W9 n* R# y8 K
cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
! J, }9 M3 J1 J% ^
fprintf(fp,"第%d次学习的均方误差为：%f\n",study,sum_err);0 m3 g8 }. y* J `; g) k
} e/ K8 F9 u) J W1 \/ x; t
while (sum_err > Pre_error) //or(study( C$ \7 `: R1 B9 p8 U9 U
{ //N个样本全局误差小于预定误差否？小于则退出 (11)
% [( C0 K% E- `; l0 P4 _
cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;8 R( k1 `' S! ?
fprintf(fp,"网络已经学习了%d次，现在的全局误差为：%f\n",study,total_err);
; p: h6 I\" b& c& z, _
fclose(fp);
0 y, y- _/ S/ E4 R
}8 `7 z# N! R: H2 c6 i$ `' D
char s;9 x: j7 m9 P+ A. w/ ?7 Z
cout<<"请随便输入一个字符，按回车退出程序！\n";1 m( x) @; `9 P3 ~9 Y
cin>>s;
/ @& C9 n# o: g
return 1;
3 q4 m\" H& ]7 Q7 o\" M, I) D: m
}
) O5 V& h( e% L. W1 D, \3 W' N
& V) j/ Q0 N D% S+ Y! ]