misc.c

#ifdef INTEGER #include "ibp.h" #else #include "rbp.h" #endif /* built-in C functions */

largest = scale(-30.0);
largestunit = 0;
unitnumber = 1;
pl = last->currentpat[TRAIN];
targetptr = pl->pats;
u = last->units;
while (u != NULL)
 {
  if (targetptr->val > 0) answer = unitnumber;
  if (u->oj > largest)
   {
    largest = u->oj;
    largestunit = unitnumber;
   };
  unitnumber++;
  targetptr++;
  u = u->next;
 };
if (answer == largestunit) s[MAX][TRAIN].right++;
else s[MAX][TRAIN].wrong++;
}

void errors(list,rowsum,tok,mok,answer,largestunit)
int list;
REAL *rowsum;
char *tok,*mok;
int *answer,*largestunit;
{
register WTTYPE absdiff;
/* sum should probably be WTTYPE but Zortech C 3.1 has a bug */
#ifdef INTEGER
register INT32 sum;
#else
register WTTYPE sum;
#endif
register UNIT *u;
WTTYPE largest;
PATNODE *targetptr;
int notclose, unitnumber;
PATLIST *pl;

notclose = last->unitcount;
if (probtype == 'c')
 {
  unitnumber = 0;
  largest = scale(-31.0);
  *largestunit = 0;
 };
sum = 0;
pl = last->currentpat[list];
targetptr = pl->pats;
u = last->units;
while (u != NULL)
 {
  u->tj = targetptr->val;
  targetptr++;
  if (probtype == 'c')
   {
    unitnumber = unitnumber + 1;
    if (u->tj > 0) *answer = unitnumber;
    if (u->oj > largest)
     {
      largest = u->oj;
      *largestunit = unitnumber;
     };
   }; /* end if (probtype ... */
  absdiff = u->tj - u->oj;

  if (absdiff < 0) absdiff = -absdiff;
  if (absdiff < toler) notclose = notclose - 1;
  sum = sum + absdiff;
/*sprintf(outstr,"sum = %d\n",sum); pg(stdout,outstr);*/
  u = u->next;
 }; /* end while (u != NULL) */
*rowsum = unscaleint(sum);
/*sprintf(outstr,"*rowsum = %f\n",*rowsum); pg(stdout,outstr);*/
if (notclose == 0) *tok = 1; else *tok = 0;
if (probtype == 'c')
 {if (*answer == *largestunit) *mok = 1; else *mok = 0;}
else *mok = 0;
}

void initnet()
{
 UNIT *u;
 LAYER *l;
 l = start;
 while (l != NULL)
  {
   u = l->units;
   while (u != NULL)
    {
     u->oj = unknown;
     u = u->next;
    };
   l = l->next;
  };
}

int evalone(patnum,list,printing,recurrentclass)
int patnum,list,printing,recurrentclass;
{
int i,answer,largestunit;
REAL rowsum;
char tok,mok;

resetpats(list);
if (!recurrentclass)
 {
  for (i=1;i<=patnum;i++) nextpat(list);
  setonepat(list);
  forward();
 }
errors(list,&rowsum,&tok,&mok,&answer,&largestunit);
if (printing)
 {if (printoutunits(patnum,last,list,rowsum,tok,mok)) return(1);}
else return(0);
}

int eval(list,printing)
int list, printing;
{ 
int i, j, patcount, class, best, nclasses, ipct, *addr, patnum;
REAL sum, rowsum;
char mok,tok;

sum = 0.0;
s[TOL][list].iterno = totaliter;
s[TOL][list].right = 0;
s[TOL][list].wrong = 0;
if (probtype == 'c')
 {
  s[MAX][list].iterno = totaliter;
  s[MAX][list].right = 0;
  s[MAX][list].wrong = 0;
  nclasses = last->unitcount;
 };
patcount = s[TOL][list].npats;
if (list == TRAIN && recurinit == '+') initnet();
resetpats(list);
for (i=1;i<=s[TOL][list].npats;i++)
 {
  nextpat(list);
  setonepat(list);
  forward();
  errors(list,&rowsum,&tok,&mok,&class,&best);
  sum = sum + rowsum;
  if (tok) s[TOL][list].right++; else s[TOL][list].wrong++;
  if (probtype == 'c')
   {
    if (mok) s[MAX][list].right++; else s[MAX][list].wrong++;
   };
  if (printing)
   {if (printoutunits(i,last,list,rowsum,tok,mok)) return(1);};
 };  /* end for */
s[TOL][list].uncertain = 0;
s[MAX][list].uncertain = 0;
s[TOL][list].off = 0;
s[MAX][list].off = 0;
s[TOL][list].pctright = 100.0 *
   (REAL) s[TOL][list].right / (REAL) patcount;
s[TOL][list].avgerr = sum / ((REAL) patcount * last->unitcount);
s[MAX][list].avgerr = s[TOL][list].avgerr;
if (probtype == 'c')
 {
  s[MAX][list].pctright = 100.0 *
     (REAL) s[MAX][list].right / (REAL) patcount;
  s[MAX][list].avgerr = sum / ((REAL) patcount * last->unitcount);
  s[TOL][list].avgerr = s[MAX][list].avgerr;
 };
return(0);
}

void evalr(list,printing,n) /* in a recurrent network, given n */
int list, printing, n;      /* inputs predict the nth output   */
{
PATLIST *sfront, *sback, *lback, *pat;
UNIT *u;
LAYER *l;
int i, juststarted, patnum, answer, largestunit, tolright, maxright;
char tok, mok;
REAL rowsum, totalerror, avgerr, pctright;

totalerror = 0.0;
tolright = 0;
maxright = 0;
resetpats(list);
nextpat(list);
sback = start->currentpat[list];
sfront = sback;
for (i=1;i<=n;i++) if (sfront != NULL) sfront = sfront->next;
lback = last->currentpat[list];
patnum = n - 1;
while (sfront != NULL)
 {
  patnum = patnum + 1;
  initnet(); /* initialize network unit values to the unknown */
  juststarted = 1;
  last->currentpat[list] = lback;
  start->currentpat[list] = sback;
  pat = sback;
  while (pat != sfront)
   {
    if (juststarted) juststarted = 0; else nextpat(list);
    setonepat(list);
    forward();
    pat = pat->next;
   };
  errors(list,&rowsum,&tok,&mok,&answer,&largestunit);
  totalerror = totalerror + rowsum;
  if (tok) tolright = tolright + 1;
  if (mok) maxright = maxright + 1;
  if (printing) printoutunits(patnum,last,TEST,rowsum,tok,mok);
  lback = lback->next;
  sback = sback->next;
  sfront = sfront->next; 
 };
avgerr = totalerror / (s[TOL][list].npats - n + 1) / last->unitcount;
pctright = tolright * 100.0 / (s[TOL][list].npats - n + 1);
sprintf(outstr," TOL: %6.2f %% ",pctright); pg(stdout,outstr);
if (probtype == 'c')
 {
  pctright = maxright * 100.0 / (s[TOL][list].npats - n + 1);
  sprintf(outstr," MAX: %6.2f %% ",pctright); pg(stdout,outstr);
 };
sprintf(outstr," ERROR: %f\n",avgerr);
pg(stdout,outstr);
}
  
int compactstats(s,recurrentclass)
DATA s[2][2];
int recurrentclass;
{ /* training patterns */
 if (up_to_date_stats == '-' && offby1 == '-') eval(TRAIN,0);
 sprintf(outstr,"%5d ",totaliter); pg(stdout,outstr);
 if (s[TOL][TRAIN].off == -1) pg(stdout,"-1 "); else pg(stdout,"   ");
 sprintf(outstr,"%6.2f %% ",s[TOL][TRAIN].pctright); pg(stdout,outstr);
 if (probtype == 'c')
  {
   sprintf(outstr,"%6.2f %% ",s[MAX][TRAIN].pctright); pg(stdout,outstr);
  };
 sprintf(outstr,"%7.5f ",s[TOL][TRAIN].avgerr); pg(stdout,outstr);
 if (s[TOL][TRAIN].uncertain == 1) pg(stdout,"? "); else pg(stdout,"  ");
 if (s[TOL][TEST].npats > 0)  /* if testing patterns exist */
  {
   if (s[TOL][TEST].iterno != totaliter) eval(TEST,0);
   if (saveonminimum == '+' && s[TOL][TEST].avgerr < minimumsofar)
    {
     saveweights();
     lastsave = s[TOL][TEST].iterno;
     minimumsofar = s[TOL][TEST].avgerr;
    };
   sprintf(outstr,"  %6.2f %% ",s[TOL][TEST].pctright); pg(stdout,outstr);
   if (probtype == 'c')
    {
     sprintf(outstr,"%6.2f %% ",s[MAX][TEST].pctright); pg(stdout,outstr);
    };
   sprintf(outstr,"%7.5f ",s[TOL][TEST].avgerr); pg(stdout,outstr);
  };
 if (s[TOL][TRAIN].pctright == 100.0 ||
     s[TOL][TRAIN].avgerr < toloverall)
  {
   pg(stdout," DONE");
   if (ringbell == '+') putchar(7);
  };
 if(pg(stdout,"\n")) return(1); else return(0);
}
 
void kick(size,amount) /* give the network a kick */
WTTYPE size, amount;
{ 
LAYER *layer;
UNIT *u;
WTNODE *w;
WTTYPE value, delta;
int sign;

layer = start->next;
while (layer != NULL)
 {
  u = (UNIT *) layer->units;
  while (u != NULL)
   {
    w = (WTNODE *) u->wtlist;
    while (w != NULL)
     {
#ifdef SYMMETRIC
      value = *(w->weight);
#else
      value = w->weight;
#endif
      if (value != 0) sign = 1;
      else if ((rand() & 32767) > 16383) sign = -1;
      else sign = 1;
      delta = (INT32) sign * amount * (rand() & 32767) / 32768;
      if (value >= size) value = value - delta;
      else if (value < -size) value = value + delta;
#ifdef SYMMETRIC
      if (((UNIT *) w->backunit)->unitnumber != u->unitnumber &&
         w->next != NULL)
         *(w->weight) = value;
#else
      w->weight = value;
#endif
      w = w->next;
     }
    u = u->next;
   }
  layer = layer->next;
 } 
}

void oneset() /* go through the patterns once and update weights */
{ int i;
  LAYER *layer;
  register UNIT *u;
  register WTNODE *w;
  short numbernotclose;

 layer = last;      /* make all w->totals = 0 */
 while (layer->backlayer != NULL)
  {
   u = (UNIT *) layer->units;
   while (u != NULL)
    {
     w = (WTNODE *) u->wtlist;
     while (w != NULL)
      {
#ifdef SYMMETRIC
       *(w->total) = 0;
#else
       w->total = 0;
#endif
       w = w->next;
      };
     u = u->next;
    };
   layer = layer->backlayer;
  };
 wrong = s[TOL][TRAIN].npats;
 s[MAX][TRAIN].right = 0;
 s[MAX][TRAIN].wrong = 0;
 resetpats(TRAIN);
 for(i=1;i<=s[TOL][TRAIN].npats;i++)
  {
   nextpat(TRAIN);
   setonepat(TRAIN);
   forward();
   if (update == 'c') numbernotclose = cbackoutput();
   else numbernotclose = backoutput();
   if (numbernotclose != 0)
    {
     if (probtype == 'c') maxerrors();
#ifndef SYMMETRIC
     if (update == 'c') cbackinner(); else backinner();
#endif
    }
   else /* this one pattern has been learned */
    {
     if (probtype == 'c') s[MAX][TRAIN].right++;
     wrong = wrong - 1;
#ifndef SYMMETRIC
     if (update == 'c') cbackinner(); else backinner();
#endif
    }
 if (update == 'C' || update == 't' || update == 'T')
  {
   if (update == 'C') periodic_update();
   else tdupdate(0,0.0);
   layer = last;      /* make all w->totals = 0 */
   while (layer->backlayer != NULL)
    {
     u = (UNIT *) layer->units;
     while (u != NULL)
      {
       w = (WTNODE *) u->wtlist;
       while (w != NULL)
        {
#ifdef SYMMETRIC
         *(w->total) = 0;
#else
         w->total = 0;
#endif
         w = w->next;
        };
       u = u->next;
      };
     layer = layer->backlayer;
    }; /* end while */
  };  /* end if update == 'C'*/
}; /* end for i */
if (update == 'C' || update == 'c' || update == 't' || update == 'T')
 {
  totaliter = totaliter + 1;
  if (up_to_date_stats == '+')
   {
    eval(TRAIN,0);
    wrong = s[TOL][TRAIN].wrong;
   }
  else
   {
    stats();
   };
  return;
 };
if (up_to_date_stats == '-') stats();
if (wrong == 0) return;
if (s[TOL][TRAIN].avgerr < toloverall) return;
if (update == 'q') qp_update();
else if (update == 'd') dbd_update();
else if (update == 'p') periodic_update();
totaliter = totaliter + 1;
if (up_to_date_stats == '+')
 {
  eval(TRAIN,0);
  wrong = s[TOL][TRAIN].wrong;
 };
}

void initialize_etas(thevalue)
WTTYPE thevalue;
{
LAYER *p;
UNIT *u;
WTNODE *w;

p = start->next;
while (p != NULL)
 {
  u = (UNIT *) p->units;
  while (u != NULL)
   {
    w = (WTNODE *) u->wtlist;
    while (w != NULL)
     {
#ifdef SYMMETRIC
      *(w->eta) = thevalue;
#else
      w->eta = thevalue;
#endif
      w = w->next;
     }
    u = u->next;
   }
  p = p->next;
 }
}

int run(n,prpatsrate)
int n;            /* the number of iterations to run */
int prpatsrate;   /* rate at which to print output patterns */
{
int i, wtlimitbefore;

if (runningflag == '+') {if (pg(stdout,"running . . .\n")) return(1);};
if (totaliter == 0)
 {
  if (update == 'd') initialize_etas(dbdeta);
  eval(TRAIN,0);
  minimumsofar = MAXINT;
 };
for (i=1;i<=n;i++)
 {
  totaldiff = 0;
#ifdef INTEGER
  wtlimitbefore = wtlimithit;
#endif
  if (recurinit == '+') initnet();
  oneset();
/*  if (up_to_date_stats == '-') stats(); why is this here? */
  if (wrong == 0) s[TOL][TRAIN].off = 0;
  if (totaliter % saverate == 0) saveweights();
#ifdef INTEGER
  if (wtlimitbefore == 0 && wtlimithit == 1)
   {
    sprintf(outstr,">>>>> WEIGHT LIMIT HIT <<<<< at %d\n",totaliter);
    if (pg(stdout,outstr)) return(1);
   };
#endif
  if ((i % prpatsrate == 0) || (i == n) || (wrong == 0) ||
      (s[TOL][TRAIN].avgerr < toloverall))
   {
    if (summary == '+') if (compactstats(s,0)) return(1);
   };
  if (s[TOL][TRAIN].avgerr < toloverall) return(0);
  if (s[TOL][TRAIN].wrong == 0) return(0);
#ifndef UNIX
  if (kbhit() && getch() == 27 /* escape key */) return(1);
#endif
 };
return(0);
}