📄 bp.c
字号:
/* Note:Your choice is C IDE */
#include "stdio.h"
#include <graphics.h>
#include <dos.h>
#include <stdlib.h>
#include <fcntl.h>
#include <io.h>
#include <conio.h>
#include <math.h>
/*#include <stat.h>*/
/*-------------------------*/
#define locate(x,y) printf("\xlb[%d;%dh",(y)+1,(x)+1)
#define clsdp() clearviewport()
#define ocolor(x) printf("\xlb[43m%6.2lf\xlb[0m",(x))
#define scolor(x) printf("\xlb[33m%6.2lf\xlb[0m",(x))
#define wcolor(x) printf("\xlb[33m%6.2lf\xlb[0m",(x))
#define fcolor(x) printf("\xlb[33m%6.2lf\xlb[0m",(x))
#define IN 2 /* input */
#define HN 2 /* hiden */
#define ON 1 /* output */
#define LAY 3 /* number of lay */
#define LW_IN_HD 2*2
#define LW_HD_OT 2*1
#define LCW_HD 2
#define LCW_OT 1
#define SZ_BOX 20.0
#define BOX 20
#define SIG0_0 0.01
#define SIG0_1 0.99
#define SIG1_0 0.00001
#define SIG1_1 0.99999
/*------------------------------------------------------*/
double u0; /*constant of sigmoid */
double sigmf(flag,u) /*sigmoid function */
int flag;
double u;
{ double su;
su=u/u0;
su=0.5*(1.0+tanh(su));
if (flag)
{
if (su>SIG1_1) return SIG1_1;
else if (su>SIG1_0) return SIG1_0;
else return(su);
}
else
{
if (su>SIG0_1) return SIG0_1;
else if (su<SIG0_0) return SIG0_0;
else return(su);
}
}
/*-------------------------------------------------------------------*/
double OT_IN[IN]; /*output of I layer */
double OT_HD[HN]; /*output of H layer */
double OT_OT[ON]; /*output of O layer */
double W_IN_HD[HN][IN]; /* weight between hidden and input layer*/
double CW_HD[HN]; /*offset of output layer unit*/
double W_HD_OT[ON][HN]; /*weight between hidden and output layer*/
double CW_OT[ON]; /*offset of output layer unit*/
double DW_IN_HD[HN][IN]; /*weight between hidden and iutput layer*/
double DCW_HD[HN]; /*offset of hidden layer unit*/
double DW_HD_OT[ON][HN]; /*weight between hidden and output layer*/
double DCW_OT[ON]; /*offset of output layer unit*/
double OW_IN_HD[HN][IN]; /*weight between hidden and iutput layer*/
double OCW_HD[HN]; /*offset of hidden layer unit*/
double OW_HD_OT[ON][HN]; /*weight between hidden and output layer*/
double OCW_OT[ON]; /*offset of output layer unit*/
double TEACH[ON]; /*teacher signal */
double DEL_OT[ON]; /*error of output layer */
double DEL_HD[HN]; /*error of hidden layer */
double alpha; /*coefficient for weight update */
double beta; /*coefficient for offset update */
double inival,ru0; /*buffer,2/u0 */
char otfile[20]="wgtfile"; /*fixed output weight file name*/
struct { int input[2]; /*input date */
int tch[1]; /*teach date */
}indata[4]={{1,0,1},{0,1,1},{0,0,0},{1,1,0}};
/*---------------------------------------------------------------------------------------*/
main(argc,argv)
int argc;
char *argv[];
{
int i,j,k,m,t,twi,times,epoch,xp,xps,yp;
int ival,non,loop,loopl,text,chpara,sig;
char filenm[20],ctt;
double error,erlimit,wk,wkb,moment;
double dmoment,intwgt,intoff;
g_init();
chpara=twi=0;
text=non=1;
sig=1;
for(t=1;t<argc;t++)
if(argv[t][0]=='-')
{
switch(argv[t][1])
{
case 'l':twi=t;break; /*input weight from file */
case 'c':chpara=1;break; /*parameter change */
case 'n':non=0;break; /*no learning */
case 'g':text=0;break; /*graphic display */
case 'f':sig=0;break; /*output of sigmoid function limit*/
default:break;
}
}
/* initial weights */
if (twi==0)
{
if(chpara)
{
clsdp();
printf("weight initial value[-1,0,1,0]");
printf("=(?)");
scanf("%lf",&intwgt);
printf("%5.3lf\n",intwgt);
}
else intwgt =0.2;
wgtinit(W_IN_HD,LW_IN_HD,intwgt,0);
wgtinit(W_HD_OT,LW_HD_OT,intwgt,0);
if(chpara)
{
printf("threshold value[0.0,1.0]");
printf("*(+-?)");
scanf("%lf",&intoff);
printf("%5.3lf\n",intoff);
}
else intoff=0.2;
wgtinit(CW_HD,LCW_HD,intoff,0);
wgtinit(CW_OT,LCW_OT,intoff,0);
}
else
{
strcpy(filenm,&argv[twi][2]);
loadwgt(filenm,W_IN_HD,LW_IN_HD,LCW_HD,W_HD_OT,LW_HD_OT,CW_OT,LCW_OT);
intoff=0.2;
intwgt=0.2;
}
if (chpara)
{
printf("Sigmoid slot?");
scanf("%lf",&u0);
printf("5.3lf\n",u0);
printf("learn.para.(')?");
scanf("%lf",&alpha);
printf("%5.3lf\n",alpha);
printf("learn.para.(a)?");
scanf("%lf",&beta);
printf("%5.3lf\n",beta);
printf("the init.Moment(<0.9)");
scanf("%lf",&moment);
printf("the init.Dmoment(<0.9)");
scanf("%lf",&dmoment);
printf("%5.3lf\n",dmoment);
printf("Max.error?");
scanf("%lf",&erlimit);
printf("%5.3lf\n",erlimit);
printf("max.learn number?");
scanf("%lf",×);
printf("%5.3lf",times);
printf("Display interval?");
scanf("%lf",&epoch);
printf("%5.3lf\n",epoch);
for (i=0;i<1000;i++);
}
else
{
u0=0.7;
alpha=0.7;
beta=0.8;
erlimit=0.03;
times=2000;
epoch=10;
moment=0.6;
dmoment=0.05;
}
ru0=2.0/u0;
loop=0;
/* initial for matrix */
for (k=0;k<HN;k++)
{
OCW_HD[k]=0;
for(m=0;m<IN;m++)
OW_IN_HD[k][m]=0.0;
}
for(k=0;k<ON;k++)
{
OCW_OT[k]=0;
for(m=0;m<HN;m++)
OW_HD_OT[k][m]=0.0;
}
clsdp();
/*-----display for initial state of network----*/
locate(28,0);
printf("\xlb[lm * * BACK PROPAGATION * * \xlb[0m");
locate(4,2);
printf("sigmoid slot[%4.2lf]",u0);
printf("ini.weight value");
printf("[-%4.2lf,+%4.2lf]",intoff);
printf("ini.ofst.[0,+%5.3lf]",intoff);
locate(4,3);
printf("learn const[alpha %4.2lf beta+%4.2lf]",alpha,beta);
printf("ini.moment[%4.2lf]",dmoment);
if(text)
{
locate(5,4); printf("output layer");
locate(19,5); printf("weight");
locate(31,5); printf("ofset.");
locate(41,4); printf("hid.layer");
locate(55,5); printf("wegt.");
locate(65,5); printf("ofst.");
locate(71,4); printf("inplay");
locate(3,5); printf("output");
locate(11,5); printf("input");
locate(39,5); printf("output");
locate(47,5); printf("input");
locate(1,19);
printf("\xlb[limit.sate\xlb[0m");
for(k=0;k<HN;k++)
{
locate(53,k+19);
wcolor(W_IN_HD[k][0]);
wcolor(W_IN_HD[k][1]);
fcolor(CW_HD[k]);
}
for(k=0;k<ON;k++)
{
locate(17,k+19);
wcolor(W_HD_OT[k][0]);
wcolor(W_HD_OT[k][1]);
fcolor(CW_OT[k]);
}
}
else
{
locate(0,5);
printf("\xlb[31moutput layer\xlb[0m");
locate(0,7);
printf("\xlb[32mhidden layer\xlb[0m");
locate(0,9);
printf("\xlb[33minput layer\xlb[0m");
locate(0,11);
printf("\xlb[37msumb.of layer\xlb[0m");
locate(55,24);
printf("\xlb[31mnumb.of layer\xlb[0m");
locate(3,17);printf("1.0");
locate(3,22);printf("0.0");
line2(63,280,65,280,WHITE);
line2(64,200,64,360,WHITE);
line2(64,360,639,630,WHITE);
for (i=0;i<600;i+=20)
line2(i+64,360,i+64,366,WHITE);
locate(9,23); printf("20 100");
}
while(loop++<times)
{
error=0.0;
if((loop%epoch==0)||(non==0))
{
if(text==0)
for(loopl=0,xps=0;loopl<4;loopl++,xps+=100)
{
drawrect(xps+94,80,BOX,BOX,BLUE);
drawrect(xps+80,112,BOX,BOX,BLUE);
drawrect(xps+112,112,BOX,BOX,BLUE);
drawrect(xps+90,114,BOX,BOX,BLUE);
drawrect(xps+112,114,BOX,BOX,BLUE);
}
}
for(k=0;k<HN;k++)
{DCW_HD[k]=0.0;
for (m=0;m<IN;m++)
DW_IN_HD[k][m]=0.0;
}
for(k=0;k<ON;k++)
{DCW_OT[k]=0.0;
for(m=0;m<HN;m++)
DW_HD_OT[k][m]=0.0;
}
locate(55,24);
printf("\xlb[33mnumber.of learn \xlb[0m");
printf("\xlb[lm%4d\xlb[0m",loop);
/*-------------------------------------------*/
for(loopl=0,xps=80;loopl<4;loopl++,xps+=100)
{
for(k=0,yp=144,xp=0;k<IN;k++,xp+=32)
{
if(sig)
OT_IN[k]=(indata[loopl].input[k])?SIG1_1:SIG1_0;
else
OT_IN[k]=(indata[loopl].input[k])?SIG0_1:SIG0_0;
if(loop%epoch==0)
{
if(text)
{
locate(73,3*loopl+k+6);
ocolor(OT_IN[k]);
}
else
{
ival=val_rect(OT_IN[k],SZ_BOX);
drawrect(xp+xps,yp,ival,WHITE);
}
}
}
/* hedden layer */
for (k=0,yp=112,xp=0;k<HN;k++,xp+=32)
{
inival=0.0;
for(m=0;m<IN;m++)
inival+=(W_IN_HD[k][m]*OT_IN[m]);
inival+=CW_HD[k];
if(loop&epoch==0)
{
if(text)
{locate(37,3*loopl+k+6);
ocolor(OT_HD[k]);
locate(45,3*loop+k+6);
scolor(inival);
if(loopl==0)
{locate(53,3*loop+k+6);
wcolor(W_IN_HD[k][0]);
wcolor(W_IN_HD[k][1]);
fcolor(CW_HD[k]);
}
}
else
{
ival=val_rect(OT_HD[k],SZ_BOX);
drawrect(xp+xps,yp,ival,WHITE);
}
}
}
/* output layer */
for(k=0,yp=80,xp=14;k<ON;k++,xp+=32)
{
ival=0.0;
for(m=0;m<HN;m++)
inival+=CW_OT[k];
inival+=CW_OT[k];
OT_OT[k]=sigmf(sig,inival);
if(loop%epoch==0)
{
if(text)
{
locate(1,3*loopl+k+6);
ocolor(OT_OT[k]);
locate(9,3*loopl+k+6);
scolor(inival);
if(loopl==0)
{
locate(17,3*loopl+k+6);
wcolor(W_HD_OT[k][0]);
wcolor(W_HD_OT[k][1]);
fcolor(CW_OT[k]);
}
}
else
{
ival=val_rect(OT_OT[k],SZ_BOX);
drawrect(xp+xps,yp,ival,WHITE);
}
}
}
/*----------------------back procagation*/
/*delta caclulate */
for(m=0;m<ON;m++)
{
if(sig)
TEACH[m]=(indata[loopl].tch[m])?SIG1_1:SIG1_0;
else
TEACH[m]=(indata[loopl].tch[m])?SIG0_1:SIG0_0;
wk=OT_OT[m];
wkb=TEACH[m]-wk;
error+=(fabs(wkb));
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -