home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume28 / backprop / part04 / misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-23  |  17.2 KB  |  782 lines
  1. /* **************************************************** */
  2. /* file misc.c:  contains pattern manipulation routines */
  3. /*               and miscellaneous other functions.     */
  4. /*                                                      */
  5. /* Copyright (c) 1991 by Donald R. Tveter               */
  6. /*                                                      */
  7. /* **************************************************** */
  8.  
  9. #include <stdio.h>
  10.  
  11. #ifdef UNIX
  12. #include <malloc.h>
  13. #else
  14. #include <stdlib.h>
  15. #include <conio.h>
  16. #endif
  17.  
  18. #ifdef INTEGER
  19. #include "ibp.h"
  20. #else
  21. #include "rbp.h"
  22. #endif
  23.  
  24. /* an addition for large data sets */
  25.  
  26. extern INT32 g;
  27.  
  28. /* built-in function */
  29.  
  30. extern int rand();
  31.  
  32. /* homemade functions */
  33.  
  34. #ifdef INTEGER
  35. extern REAL unscale(), unscaleint();
  36. extern WTTYPE scale();
  37. #endif
  38.  
  39. extern short backoutput(), cbackoutput();
  40. extern void backinner(), cbackinner(), saveweights();
  41. extern WTTYPE rdr();
  42. extern void dbd_update(), periodic_update(), qp_update(), supersab();
  43. extern REAL readchar();
  44.  
  45. extern char backprop,emptystring,informat,outstr[],patform,ringbell;
  46. extern char summary, *testfile, update, up_to_date_stats, wtlimithit;
  47. extern int bad, benchmark,bufferptr,lastprint,lastsave,npats;
  48. extern int prevnpats,readerror,readingpattern,right,saverate,testpat;
  49. extern int totaliter,unlearned,wrong,wttotal;
  50. extern WTTYPE dbdeta, error, initialkick, toler, toosmall;
  51. extern REAL errorperunit, pct_right;
  52. extern UNIT *hlayer, *ilayer, *jlayer, *klayer;
  53. extern LAYER *last, *start;
  54. extern short skiprate;
  55. #ifdef INTEGER
  56. extern INT32 totaldiff;
  57. #else
  58. extern REAL totaldiff;
  59. #endif
  60.  
  61. void nullpatterns()  /* dispose of any patterns before reading more */
  62. {
  63. PATLIST *pl, *nextpl;
  64. WTTYPE *p;
  65.  
  66. if (start->patstart != NULL)
  67.  {
  68.   pl = start->patstart;
  69.   while (pl != NULL)
  70.    {
  71.     nextpl = pl->next;
  72.     p = pl->pats;
  73.     free(p);
  74.     pl = nextpl;
  75.    };
  76.   pl = last->patstart;
  77.   while (pl != NULL)
  78.    {
  79.     nextpl = pl->next;
  80.     p = pl->pats;
  81.     free(p);
  82.     pl = nextpl;
  83.    };
  84.  };
  85. start->patstart = NULL;
  86. last->patstart = NULL;
  87. npats = 0;
  88. prevnpats = 0;
  89. }
  90.  
  91. void resetpats()
  92. {
  93. start->currentpat = NULL;
  94. last->currentpat = NULL;
  95. }
  96.  
  97. void findendofpats(layer)  /* purpose is to set all layer->currentpat */
  98. LAYER *layer;              /* fields to end of pattern list so more   */
  99. {                          /* patterns can be added at the end.       */
  100. PATLIST *pl;
  101. pl = (PATLIST *) layer->patstart;
  102. while (pl->next != NULL) pl = pl->next;
  103. layer->currentpat = pl;
  104. }
  105.  
  106. int copyhidden(u,hidden,layerno)
  107. UNIT *u, **hidden;
  108. int layerno;
  109. {
  110. if (hidden == NULL)
  111.  {
  112.   sprintf(outstr,"ran out of hidden units in layer %d\n",layerno);
  113.   pg(outstr);
  114.   return(0);
  115.  }
  116. u->oj = (*hidden)->oj;
  117. *hidden = (*hidden)->next;
  118. return(1);
  119. }
  120.  
  121. int loadpat(command)
  122. char command;
  123. {
  124. UNIT *u, *hunit, *iunit, *junit, *kunit;
  125. hunit = hlayer;
  126. iunit = ilayer;
  127. junit = jlayer;
  128. kunit = klayer;
  129. readingpattern = 1;
  130. u = (UNIT *) start->units;
  131. while (u != NULL)
  132.  {
  133.   if (informat == 'r') u->oj = rdr(GE,(REAL) HCODE,command);
  134.   else u->oj = scale(readchar());
  135.   if (readerror) goto errorexit;
  136.   if (u->oj <= KCODE)
  137.    {
  138.     if (u->oj == HCODE)
  139.        {if (!copyhidden(u,&hunit,2)) goto errorexit;}
  140.     else if (u->oj == ICODE)
  141.        {if (!copyhidden(u,&iunit,3)) goto errorexit;}
  142.     else if (u->oj == JCODE)
  143.        {if (!copyhidden(u,&junit,4)) goto errorexit;}
  144.     else if (!copyhidden(u,&kunit,5)) goto errorexit;
  145.    };
  146.   u = u->next;
  147.  };
  148. readingpattern = 0;
  149. forward();
  150. return(1);
  151.  
  152. errorexit:
  153. readingpattern = 0;
  154. return(0);
  155. }
  156.  
  157. void nextpat()
  158. {
  159. if (start->currentpat == NULL)
  160.  {
  161.   start->currentpat = start->patstart;
  162.   last->currentpat = last->patstart;
  163.  }
  164. else
  165.  {
  166.   start->currentpat = (start->currentpat)->next;
  167.   last->currentpat = (last->currentpat)->next;
  168.  };
  169. }
  170.  
  171. void setoutputpat()
  172. {
  173. register WTTYPE *p;
  174. register UNIT *u;
  175. register short i, answer;
  176. PATLIST *pl;
  177.  
  178. if (patform == 'c' || patform == 'C')
  179.  {
  180.   pl = last->currentpat;
  181.   p = pl->pats;
  182.   answer = *p;
  183.   u = (UNIT *) last->units;
  184.   for (i=1;i<=last->unitcount;i++)
  185.    {
  186.     if (i == answer) u->tj = scale(1.0); else u->tj = scale(0.0);
  187.     u = u->next;
  188.    };
  189.  }
  190. else
  191.  {
  192.   pl = last->currentpat;
  193.   p = pl->pats;
  194.   u = (UNIT *) last->units;
  195.   while (u != NULL)
  196.    {
  197.     u->tj = *p++;
  198.     u = u->next;
  199.    };
  200.  }
  201. }
  202.  
  203. void setinputpat()
  204. {
  205. register WTTYPE *p;
  206. register UNIT *u;
  207. UNIT *hunit, *iunit, *junit, *kunit;
  208. PATLIST *pl;
  209.   
  210. hunit = hlayer;
  211. iunit = ilayer;
  212. junit = jlayer;
  213. kunit = klayer;
  214. pl = start->currentpat;
  215. p = pl->pats;
  216. u = (UNIT *) start->units;
  217. while (u != NULL)
  218.  {
  219.   if (*p > KCODE) u->oj = *p++;
  220.   else if (*p++ == HCODE)
  221.      {if (!copyhidden(u,&hunit,2)) return;}
  222.   else if (*p++ == ICODE)
  223.      {if (!copyhidden(u,&iunit,3)) return;}
  224.   else if (*p++ == JCODE)
  225.      {if (!copyhidden(u,&junit,4)) return;}
  226.   else if (!copyhidden(u,&kunit,5)) {p++; return;};
  227.   u = u->next;
  228.  };
  229. }
  230.  
  231. void setonepat() /* set input and output patterns */
  232. {
  233. register UNIT *u;
  234. register LAYER *innerlayers;
  235.  
  236. setinputpat();
  237. setoutputpat();
  238. innerlayers = start->next;
  239. while (innerlayers->next != NULL)
  240.  {  /* set errors on the inner layer units to 0 */
  241.   u = (UNIT *) innerlayers->units;
  242.   while (u != NULL)
  243.    {
  244.     u->error = 0;
  245.     u = u->next;
  246.    };
  247.   innerlayers = innerlayers->next;
  248.  };
  249. }
  250.  
  251. void clear()
  252. {
  253. LAYER *p;
  254. UNIT *u;
  255. WTNODE *w;
  256. int i;
  257.  
  258. if (toosmall != -1)
  259.  {
  260.   pg("cannot restart with the weights removed\n");
  261.   return;
  262.  };
  263. right = 0;
  264. wrong = npats;
  265. pct_right = 0.0;
  266. unlearned = npats;
  267. wtlimithit = 0;
  268. totaliter = 0;
  269. lastsave = 0;
  270. initialkick = -1;
  271. lastprint = 0;
  272. resetpats();
  273. for (i=1;i<=npats;i++)
  274.  {
  275.   nextpat();
  276.   if (last->currentpat->bypass > 0) last->currentpat->bypass = 0;
  277.   else if (last->currentpat->bypass < 0) last->currentpat->bypass = -1;
  278.  };
  279. p = start->next;
  280. while (p != NULL)
  281.  {
  282.   u = (UNIT *) p->units;
  283.   while (u != NULL)
  284.    {
  285.     w = (WTNODE *) u->wtlist;
  286.     while (w != NULL)
  287.      {
  288. #ifdef SYMMETRIC
  289.       if (w->next != NULL)
  290.        { /* skip threshold weight */
  291.         *(w->weight) = 0;
  292.         *(w->olddw) = 0;
  293.         *(w->eta) = dbdeta;
  294.        };
  295. #else
  296.       w->weight = 0;
  297.       w->olddw = 0;
  298.       w->eta = dbdeta;
  299.       w->slope = 0;
  300. #endif
  301.       w = w->next;
  302.      };
  303.     u = u->next;
  304.    };
  305.   p = p->next;
  306.  };
  307. }
  308.  
  309. #ifndef SYMMETRIC
  310.  
  311. void whittle(amount)    /* removes weights whose absolute */
  312. WTTYPE amount;          /* value is less than amount      */
  313. {LAYER *layer;
  314.  UNIT *u;
  315.  WTNODE *w, *wprev;
  316.  
  317. layer = start->next;
  318. while (layer != NULL)
  319.  {
  320.   u = (UNIT *) layer->units;
  321.   while (u != NULL)
  322.    {
  323.     w = (WTNODE *) u->wtlist;
  324.     wprev = (WTNODE *) NULL;
  325.     while (w->next != (WTNODE *) NULL)
  326.      {
  327.       if ((w->weight) < amount && (w->weight) > -amount)
  328.        {
  329.         if (wprev == NULL) (WTNODE *) u->wtlist = w->next;
  330.         else (WTNODE *) wprev->next = w->next;
  331.         wttotal = wttotal - 1;
  332.        }
  333.       else wprev = w;
  334.       w = w->next;
  335.      }
  336.     u = u->next;
  337.    }
  338.   layer = layer->next;
  339.  }
  340. }
  341.  
  342. #endif
  343.  
  344. void testcheck()  /* checks the testfile */
  345. {
  346. int class, best, count, tcright, tcwrong, testcount, printing;
  347. int tright, twrong, ch2;
  348. REAL pct, testerr, eperunit;
  349. WTTYPE max;
  350. UNIT *u;
  351.  
  352. pushfile(testfile);
  353. testerr = 0.0;
  354. testcount = 0;
  355. tcright = 0;
  356. tcwrong = 0;
  357. tright = 0;
  358. twrong = 0;
  359. if (patform == 'c' || patform == 'g') printing = 0; else printing = 1;
  360. ch2 = readch();
  361. while (ch2 != EOF)
  362.  {
  363.   bufferptr = bufferptr - 1;
  364.   if (!loadpat('t')) if (readerror == 2) goto summarize; else goto exit;
  365.   class = 0;
  366.   if (patform == 'c' || patform == 'C')
  367.    {
  368.     class = readint(1,last->unitcount,'t');
  369.     if (readerror) goto exit;
  370.     count = 0;
  371.     max = -MAXINT;
  372.     best = 0;
  373.    };
  374.   u = (UNIT *) last->units;
  375.   while (u != NULL)
  376.    {
  377.     if (class)
  378.      {
  379.       count = count + 1;
  380.       if (u->oj > max)
  381.        {
  382.         max = u->oj;
  383.         best = count;
  384.        }
  385.       if (count == class) u->tj = scale(1.0); else u->tj = scale(0.0);
  386.      }
  387.     else
  388.      {
  389.       u->tj = rdr(GT,(REAL) KCODE,'t');
  390.       if (readerror) goto exit;
  391.      };
  392.     u = u->next;
  393.    };
  394.   testcount = testcount + 1;
  395.   if (class)
  396.    if (best == class) tcright = tcright + 1; else tcwrong = tcwrong + 1;
  397.   if (printing)
  398.    {
  399.     sprintf(outstr,"%5d",testcount);
  400.     pg(outstr);
  401.    };
  402.   if (printoutunits(printing,last,1))
  403.    {
  404.     popfile();
  405.     return;
  406.    };
  407.   testerr = testerr + unscale(error);
  408.   if (bad) twrong = twrong + 1; else tright = tright + 1;
  409.   do ch2 = readch(); while (ch2 != '\n');
  410.   ch2 = readch();
  411.  };
  412.  
  413. summarize:
  414. pct = 100.0 * (REAL) tright / (REAL) testcount;
  415. if (pg("based on tolerance:\n")) return;
  416. sprintf(outstr,"   %6.2f%%,   (%d right,  %d wrong)",pct,tright,twrong);
  417. pg(outstr);
  418. eperunit = testerr / (REAL) (last->unitcount * testcount);
  419. sprintf(outstr,"   %7.5f error/unit\n",eperunit); pg(outstr);
  420. if (patform == 'c' || patform == 'C')
  421.  {
  422.   pct = 100.0 * (REAL) tcright / (REAL) testcount;
  423.   if (pg("based on maximum value:\n")) return;
  424.   sprintf(outstr,"   %6.2f%%,   %d right,   %d wrong\n",pct,tcright,tcwrong);
  425.   pg(outstr);
  426.  };
  427. popfile();
  428. return;
  429.  
  430. exit:
  431. sprintf(outstr,"error while reading pattern %d\n",testcount+1);
  432. pg(outstr);
  433. popfile();
  434. }
  435.  
  436. void stats(callfromrun)
  437. int callfromrun;
  438. {
  439.  if (callfromrun) wrong = unlearned;
  440.  right = npats - wrong;
  441.  if (testpat) right = right - 1;
  442.  errorperunit =
  443.     unscaleint(totaldiff) / (REAL) ((right + wrong) * last->unitcount);
  444.  pct_right = 100.0 * (REAL) right / (REAL) (right + wrong);
  445. }
  446.  
  447. int patcheck(first,finish,printoutputs,printerrors,sumup,printsumup,skip)
  448. int first,finish,printoutputs,printerrors,sumup,printsumup,skip;
  449. {
  450. int i;
  451.  
  452. if (skip && printoutputs == 0) goto shortcut;
  453. if (sumup)
  454.  {
  455.   totaldiff = 0;
  456.   wrong = 0;
  457.  };
  458. resetpats();
  459. for (i=1;i<first;i++) nextpat();
  460. for (i=first;i<=finish;i++)
  461.  { 
  462.   nextpat();
  463.   setonepat();
  464.   forward();
  465.   if (printoutputs) {sprintf(outstr,"%3d ",i); pg(outstr);};
  466.   if (printoutunits(printoutputs,last,printerrors)) return(1);
  467.   if (i != testpat && sumup)
  468.     {
  469.      wrong = wrong + bad;
  470.      totaldiff = totaldiff + error;
  471.     };
  472.  };
  473. if (printoutputs) lastprint = totaliter;
  474. if (sumup) stats(0);
  475.  
  476. shortcut:
  477. if (printsumup)
  478.  {
  479.   sprintf(outstr,"%5d iterations  ",totaliter); pg(outstr);
  480.   sprintf(outstr,"%6.2f%% right ",pct_right); pg(outstr);
  481.   sprintf(outstr,"(%1d right ",right); pg(outstr);
  482.   sprintf(outstr,"  %1d wrong)   ",wrong); pg(outstr);
  483.   sprintf(outstr,"%7.5f error/unit\n",errorperunit);
  484.   if (pg(outstr)) return(1);
  485.  }
  486. return(0);
  487. }
  488.  
  489. void oneset() /* go through the patterns once and update weights */
  490. { 
  491. int i;
  492. LAYER *layer;
  493. register UNIT *u;
  494. register WTNODE *w;
  495. short numbernotclose, attempted, passed;
  496.  
  497. layer = last;      /* make all b->totals = 0 */
  498. while (layer->backlayer != NULL)
  499.  {
  500.   u = (UNIT *) layer->units;
  501.   while (u != NULL)
  502.    {
  503.     w = (WTNODE *) u->wtlist;
  504.     while (w != NULL)
  505.      {
  506. #ifdef SYMMETRIC
  507.       *(w->total) = 0;
  508. #else
  509.       w->total = 0;
  510. #endif
  511.       w = w->next;
  512.      };
  513.     u = u->next;
  514.    };
  515.   layer = layer->backlayer;
  516.  };
  517. attempted = 0;
  518. passed = 0;
  519. if (testpat) unlearned = npats - 1; else unlearned = npats;
  520. resetpats();
  521. for(i=1;i<=npats;i++)
  522.  {
  523.   nextpat();
  524.   if (last->currentpat->bypass == 0)
  525.    {
  526.     setonepat();
  527.     forward();
  528.     attempted = attempted + 1;
  529.     if (update == 'c') numbernotclose = cbackoutput();
  530.     else numbernotclose = backoutput();
  531.     if (numbernotclose != 0)
  532.      {
  533. #ifndef SYMMETRIC
  534.       if (update == 'c') cbackinner(); else backinner();
  535. #endif
  536.      }
  537.     else /* this one pattern has been learned */
  538.      {
  539.       passed = passed + 1;
  540.       unlearned = unlearned - 1;
  541.       last->currentpat->bypass = skiprate;
  542. #ifndef SYMMETRIC
  543.       if (backprop) if (update == 'c') cbackinner(); else backinner();
  544. #endif
  545.      }
  546.    }
  547.   else last->currentpat->bypass = last->currentpat->bypass - 1;
  548.  };
  549. if (update == 'c') totaliter = totaliter + 1;
  550. if (up_to_date_stats == '+' && update == 'c') patcheck(1,npats,0,0,1,0,0);
  551. if (unlearned == 0) return;
  552. if (skiprate && (attempted == passed))
  553.  {
  554.   resetpats();
  555.   for (i=1;i<=npats;i++)
  556.    {
  557.     nextpat();
  558.     if (last->currentpat->bypass > 0) last->currentpat->bypass = 0;
  559.    };
  560.  };
  561. if (update == 'c') return;
  562. else if (update == 'd') dbd_update();
  563. else if (update == 'p') periodic_update();
  564. else if (update == 'q') qp_update();
  565. else if (update == 's') supersab();
  566. if (up_to_date_stats == '+') patcheck(1,npats,0,0,1,0,0);
  567. totaliter = totaliter + 1;
  568. }
  569.  
  570. void kick(size,amount) /* give the network a kick */
  571. WTTYPE size, amount;
  572. { 
  573. LAYER *layer;
  574. UNIT *u;
  575. WTNODE *w;
  576. WTTYPE value;
  577. WTTYPE delta;
  578. int sign;
  579.  
  580. layer = start->next;
  581. while (layer != NULL)
  582.  {
  583.   u = (UNIT *) layer->units;
  584.   while (u != NULL)
  585.    {
  586.     w = (WTNODE *) u->wtlist;
  587.     while (w != NULL)
  588.      {
  589. #ifdef SYMMETRIC
  590.       value = *(w->weight);
  591. #else
  592.       value = w->weight;
  593. #endif
  594.       if (value != 0) sign = 1;
  595.       else if ((rand() & 32767) > 16383) sign = -1;
  596.       else sign = 1;
  597.       delta = (INT32) sign * amount * (rand() & 32767) / 32768;
  598.       if (value >= size) value = value - delta;
  599.       else if (value < -size) value = value + delta;
  600. #ifdef SYMMETRIC
  601.       if (((UNIT *) w->backunit)->unitnumber != u->unitnumber &&
  602.          w->next != NULL)
  603.          *(w->weight) = value;
  604. #else
  605.       w->weight = value;
  606. #endif
  607.       w = w->next;
  608.      }
  609.     u = u->next;
  610.    }
  611.   layer = layer->next;
  612.  } 
  613. }
  614.  
  615. void newoneset() /* go through the patterns once and update weights */
  616. { int i;
  617.   LAYER *layer;
  618.   register UNIT *u;
  619.   register WTNODE *w;
  620.   short numbernotclose, attempted, passed;
  621.  
  622. begin:
  623.  layer = last;      /* make all b->totals = 0 */
  624.  while (layer->backlayer != NULL)
  625.   {
  626.    u = (UNIT *) layer->units;
  627.    while (u != NULL)
  628.     {
  629.      w = (WTNODE *) u->wtlist;
  630.      while (w != NULL)
  631.       {
  632. #ifdef SYMMETRIC
  633.        *(w->total) = 0;
  634. #else
  635.        w->total = 0;
  636. #endif
  637.        w = w->next;
  638.       };
  639.      u = u->next;
  640.     };
  641.    layer = layer->backlayer;
  642.   };
  643.  attempted = 0;
  644.  passed = 0;
  645.  unlearned = npats;
  646.  resetpats();
  647.  for(i=1;i<=npats;i++)
  648.   {
  649.    nextpat();
  650.    if (last->currentpat->bypass == 0)
  651.     {
  652.      setonepat();
  653.      forward();
  654.      attempted = attempted + 1;
  655.      if (update == 'c') numbernotclose = cbackoutput();
  656.      else numbernotclose = backoutput();
  657.      if (numbernotclose != 0)
  658.       {
  659. #ifndef SYMMETRIC
  660.        if (update == 'c') cbackinner(); else backinner();
  661. #endif
  662.       }
  663.      else /* this one pattern has been learned */
  664.       {
  665.        passed = passed + 1;
  666.        unlearned = unlearned - 1;
  667.        last->currentpat->bypass = skiprate;
  668. #ifndef SYMMETRIC
  669.        if (backprop) if (update == 'c') cbackinner(); else backinner();
  670. #endif
  671.       }
  672.     }
  673.    else last->currentpat->bypass = last->currentpat->bypass - 1;
  674.    if (g && (i % g == 0 || i == npats))
  675.     {
  676.      if (update == 'd') dbd_update();
  677.      else if (update == 'p') periodic_update();
  678.      layer = last;      /* make all b->totals = 0 */
  679.      while (layer->backlayer != NULL)
  680.       {
  681.        u = (UNIT *) layer->units;
  682.        while (u != NULL)
  683.         {
  684.          w = (WTNODE *) u->wtlist;
  685.          while (w != NULL)
  686.           {
  687.            w->total = 0;
  688.            w = w->next;
  689.           };
  690.          u = u->next;
  691.         };
  692.        layer = layer->backlayer;
  693.       }; /* end while */
  694.     };  /* end if g */
  695. }; /* end for i */
  696. if (update == 'c'|| g != 0) totaliter = totaliter + 1;
  697. if (up_to_date_stats == '+' && update == 'c') patcheck(1,npats,0,0,1,0,0);
  698. if (unlearned == 0) return;
  699. if (skiprate && (attempted == passed))
  700.  {
  701.   resetpats();
  702.   for (i=1;i<=npats;i++)
  703.    {
  704.     nextpat();
  705.     last->currentpat->bypass = 0;
  706.    };
  707.   goto begin;
  708.  };
  709. if (g == 0)
  710.  {
  711.   if (update == 'c') return;
  712.   else if (update == 'd') dbd_update();
  713.   else if (update == 'p') periodic_update();
  714.   else if (update == 'q') qp_update();
  715.   else if (update == 's') supersab();
  716.  };
  717. if (up_to_date_stats == '+') patcheck(1,npats,0,0,1,0,0);
  718. if (g == 0) totaliter = totaliter + 1;
  719. }
  720.  
  721. int run(n,prpatsrate)
  722. int n;            /* the number of iterations to run */
  723. int prpatsrate;   /* rate at which to print output patterns */
  724. {
  725. int i, wtlimitbefore;
  726. #ifndef UNIX
  727. int chx;
  728. #endif
  729.  
  730. if (pg("running . . .\n")) return(1);
  731. for (i=1;i<=n;i++)
  732.  {
  733.   totaldiff = 0;
  734.   wtlimitbefore = wtlimithit;
  735.   if (g == 0) oneset(); else newoneset();
  736.   stats(1);
  737.   if (wtlimitbefore == 0 && wtlimithit == 1)
  738.    {
  739.     sprintf(outstr,">>>>> WEIGHT LIMIT HIT <<<<< at %d\n",totaliter);
  740.     if (pg(outstr)) return(1);
  741.    };
  742.   if (unlearned == 0) /* training finished */
  743.    {
  744.     if (benchmark && testpat)
  745.      {
  746.       sprintf(outstr,"S  %d iterations",totaliter); pg(outstr);
  747.       sprintf(outstr," %9.5f error/unit\n",errorperunit); pg(outstr);
  748.       if (patcheck(testpat,testpat,1,1,0,0,0)) return(1);
  749.      };
  750.     if ((prpatsrate > 0 && lastprint != totaliter))
  751.      if (patcheck(1,npats,summary == '-',summary == '-',1,1,0)) return(1);
  752.     sprintf(outstr,"patterns learned to within %4.2f",unscale(toler));
  753.     pg(outstr);
  754.     pg(" at iteration");
  755.     if (ringbell == '+') putchar(7);
  756.     sprintf(outstr," %d\n",totaliter);
  757.     if (pg(outstr)) return(1);
  758.     if (benchmark && *testfile != emptystring) testcheck();
  759.     return(0);
  760.    };
  761.   if (benchmark && testpat && (prpatsrate > 0 && i % prpatsrate == 0))
  762.    {
  763.     if (unlearned == 1) pg("S"); else pg("F");
  764.     sprintf(outstr," %d iterations",totaliter); pg(outstr);
  765.     sprintf(outstr," %7.5f error/unit\n",errorperunit);
  766.     if (pg(outstr)) return(1);
  767.     if (patcheck(testpat,testpat,1,1,0,0,0)) return(1);
  768.    }
  769.   if (totaliter % saverate == 0) saveweights();
  770.   if ((prpatsrate > 0) && ((i % prpatsrate == 0) || (i == n)))
  771.    {
  772.     if (patcheck(1,npats,summary == '-',summary == '-',1,1,
  773.              up_to_date_stats == '-')) return(1);
  774.     if (benchmark && (*testfile != emptystring)) testcheck();
  775.    };
  776. #ifndef UNIX
  777.   if (kbhit() && getch() == 27 /* escape key */) return(1);
  778. #endif
  779.  };
  780. return(0);
  781. } 
  782.