home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume28 / backprop / part04 / int.c next >
Encoding:
C/C++ Source or Header  |  1992-02-23  |  14.0 KB  |  491 lines
  1. /* *********************************************************** */
  2. /* file int.c:  Contains the network evaluation and weight     */
  3. /*              adjustment procedures for the integer versions */
  4. /*              bp and sbp.                                    */
  5. /*                                                             */
  6. /* Copyright (c) 1991 by Donald R. Tveter                      */
  7. /*                                                             */
  8. /* The code here has been optimized for use with the Motorola  */
  9. /* MC 68010 processor and version 3.5 of the UNIX (tm) PC      */
  10. /* C compiler where UNIX is a trademark of Bell Laboratories.  */
  11. /* *********************************************************** */
  12.  
  13. #include "ibp.h"
  14. #include <stdio.h>
  15.  
  16. extern char activation, backprop, deriv, wtlimithit;
  17. extern WTTYPE alpha, D, decay, eta, eta2, etamax, kappa, noise;
  18. extern WTTYPE theta1, theta2, toler;
  19. extern LAYER *last, *start;
  20. extern INT32 totaldiff;
  21.  
  22. void forward()             /* computes unit activations */
  23. { 
  24. register INT32 sum, x, intpart;
  25. register WTNODE *w;
  26. register UNIT *u, *predu;
  27. LAYER *layer;
  28. register short fract, val;
  29.  
  30. layer = start->next;
  31. while (layer != NULL)
  32.  {
  33.   u = (UNIT *) layer->units;
  34.   while (u != NULL)
  35.    {
  36.     sum = 0;
  37.     w = (WTNODE *) u->wtlist;
  38.     while (w != NULL)
  39.      {
  40.       predu = (UNIT *) w->backunit;
  41. #ifdef SMART
  42. #   ifdef SYMMETRIC
  43.       sum = sum + (INT32) *(w->weight) * predu->oj / 1024;
  44. #   else
  45.       sum = sum + (INT32) w->weight * predu->oj / 1024;
  46. #   endif
  47. #else
  48. #   ifdef SYMMETRIC
  49.       x = (INT32) *(w->weight) * predu->oj;
  50. #   else
  51.       x = (INT32) w->weight * predu->oj;
  52. #   endif
  53.       if (x >= 0) sum = sum + (x >> 10); else sum = sum - ( (-x) >> 10);
  54. #endif
  55.       w = w->next;
  56.      };
  57.     sum = (INT32) D * sum / 1024;
  58.     if (activation == 'p' || activation == 't')
  59.      {
  60.       if (sum > 0) x = sum; else x = -sum;
  61.       intpart = x >> 10;
  62.       fract = x & 01777;
  63.       switch (intpart) {
  64. case 0:  val = 512 + (((INT32) 237 * fract) >> 10);       /* 0 <= x < 1 */
  65.          break;
  66. case 1:  val = 748 + (((INT32) 153 * fract) >> 10);       /* 1 <= x < 2 */
  67.          break;
  68. case 2:  val = 901 + (((INT32) 73 * fract) >> 10);        /* 2 <= x < 3 */
  69.          break;
  70. case 3:
  71. case 4:  val = 976 + (((INT32) (x - 3072) * 20) >> 10);   /* 3 <= x < 5 */
  72.          break;
  73. default: val = 1024;                                      /* x >= 5 */ };
  74.          if (sum < 0) u->oj = 1024 - val; else u->oj = val;
  75.          if (activation == 't') u->oj = (u->oj - 512) * 2;
  76.      }
  77.     else if (activation == 'l') u->oj = sum;
  78.     u = u->next;
  79.    };
  80.     layer = layer->next;
  81.    };
  82. }
  83.  
  84. short backoutput()  /* computes weight changes from the output layer */
  85. {
  86. register short deltaj, temp2, temp3;
  87. register INT32 temp;
  88. register UNIT *bunit, *u;
  89. register WTNODE *w;
  90. register short adiff, notclose;
  91.  
  92. notclose = last->unitcount;
  93. u = (UNIT *) last->units;
  94. while (u != NULL)
  95.  { 
  96.   temp3 = u->oj;
  97.   temp2 = u->tj - temp3;
  98.   if (temp2 > 0) adiff = temp2; else adiff = -temp2;
  99.   if (adiff < toler) notclose = notclose - 1;
  100.   totaldiff = totaldiff + adiff;
  101.   if (adiff >= toler || backprop)  /* then compute errors */
  102.    {
  103.     if (deriv == 'd') /* diff. step size method */
  104.        deltaj = temp2;
  105.     else if (deriv == 'f' || deriv == 'F') /* Fahlman's derivative */
  106.      {
  107.       if (activation == 't') temp3 = temp3 / 2 + 512;
  108.       temp = (INT32) temp2 * ((INT32) 104448 + (INT32) temp3 * ((short)(1024 - temp3)));
  109.       if (temp > 0) deltaj = (INT32) (temp + 524288) >> 20;
  110.       else deltaj = -((INT32) (524288 - temp) >> 20);
  111.      }
  112.     else /* the derivative in the original formula */
  113.      {
  114.       if (activation == 't') temp3 = temp3 / 2 + 512;
  115.       temp = (INT32) temp2 * ((INT32) temp3 * ((short)(1024 - temp3)));
  116.       if (temp > 0) deltaj = (INT32) (temp + 524288) >> 20;
  117.       else deltaj = -((INT32) (524288 - temp) >> 20);
  118.      }
  119.     w = (WTNODE *) u->wtlist;
  120. #ifdef SYMMETRIC
  121.     while (w->next != NULL)  /* skips threshold unit at end */
  122. #else
  123.     while (w != NULL)
  124. #endif
  125.      {
  126.       bunit = (UNIT *) w->backunit;
  127. #ifdef SYMMETRIC
  128.       *(w->total) = *(w->total) + (INT32) deltaj * bunit->oj;
  129. #else
  130.       w->total = w->total + (INT32) deltaj * bunit->oj;
  131.       if (bunit->layernumber > 1)
  132.          bunit->error = bunit->error + (INT32) deltaj * w->weight;
  133. #endif
  134.       w = w->next;
  135.      }
  136.    };
  137.   u = u->next;
  138.  };
  139. return(notclose);
  140. }
  141.  
  142. #ifndef SYMMETRIC
  143.  
  144. void backinner()             /* Computes slopes and passes back */
  145. {                            /* errors from hidden layers.      */
  146. register short deltaj, temp3;
  147. register INT32 temp;
  148. register UNIT *bunit, *u;
  149. register WTNODE *w;
  150. LAYER *layer;
  151.  
  152. layer = last->backlayer;
  153. while (layer->backlayer != NULL)
  154.  {
  155.   u = (UNIT *) layer->units;
  156.   while (u != NULL)
  157.    {
  158.     if (activation == 't') temp3 = u->oj / 2 + 512; else temp3 = u->oj;
  159.     if (deriv == 'f') /* Fahlman's derivative */
  160.        temp = (INT32) (((short)(((INT32) temp3*((short)(1024-temp3))+512) >> 10))
  161.               + 102) * u->error;
  162.     else /* either for the original or diff. step size */
  163.        temp = (INT32) ((short)(((INT32) temp3*((short)(1024-temp3))+512) >> 10))
  164.           * u->error;
  165.     if (temp > 0) deltaj = (INT32) (temp + 524288) >> 20;
  166.     else deltaj = -((INT32) (524288 - temp) >> 20);
  167.     w = (WTNODE *) u->wtlist;
  168.     while (w != NULL)
  169.      {
  170.       bunit = (UNIT *) w->backunit;
  171.       w->total = w->total + (INT32) deltaj * bunit->oj;
  172.       if (bunit->layernumber > 1)
  173.          bunit->error = bunit->error + (INT32) deltaj * w->weight;
  174.       w = w->next;
  175.      };
  176.     u = u->next;
  177.    };
  178.   layer = layer->backlayer;
  179.  };
  180. }
  181.  
  182. #endif
  183.  
  184. #ifdef SYMMETRIC
  185. void dbd_update() {pg("symmetric dbd update no longer supported\n");}
  186. #else
  187. void dbd_update() /* the delta-bar-delta method for weight updates */
  188. {
  189. register short rkappa, temp2, dbarm1, rdecay;
  190. register INT32 temp;
  191. register UNIT *u;
  192. register WTNODE *w;
  193. LAYER *layer;
  194.  
  195. /* w->olddw is used for delta-bar minus 1 */
  196.  
  197. rkappa = kappa;
  198. rdecay = decay;
  199. layer = last;
  200. while (layer->backlayer != NULL)
  201.  {
  202.   u = (UNIT *) layer->units;
  203.   while (u != NULL)
  204.    {
  205.     w = (WTNODE *) u->wtlist;
  206.     while (w != NULL)
  207.      {
  208.       if (w->total > 0) temp2 = (INT32) (w->total + 512) >> 10;
  209.       else temp2 = -((INT32) (512 - w->total) >> 10);
  210.       dbarm1 = w->olddw;
  211.       temp = (INT32) theta2 * temp2 + (INT32) theta1 * dbarm1;
  212.       if (temp > 0) w->olddw = (INT32) (temp + 512) >> 10;
  213.       else w->olddw = -((INT32) (512 - temp) >> 10);
  214.       if (temp2 > 0 && dbarm1 > 0) w->eta = w->eta + rkappa;
  215.       else if (temp2 < 0 && dbarm1 < 0) w->eta = w->eta + rkappa;
  216.       else if (temp2 > 0 && dbarm1 < 0)w->eta = ((INT32) w->eta * rdecay) >> 10;
  217.       else if (temp2 < 0 && dbarm1 > 0)w->eta = ((INT32) w->eta * rdecay) >> 10;
  218.       if (w->eta > etamax) w->eta = etamax;
  219.       temp = (INT32) temp2 * w->eta;
  220.       if (temp > 0) temp2 = (INT32) (temp + 512) >> 10;
  221.       else if (temp < 0) temp2 = -((INT32) (512 - temp) >> 10);
  222.  
  223.       else if (w->slope == 0)
  224.          {if (w->total < 0) temp2 = noise; else temp2 = -noise;}
  225.       w->slope = temp2;
  226.  
  227.       temp = (INT32) w->weight + temp2;
  228.       if (temp > MAXSHORT)
  229.        {
  230.         wtlimithit = 1;
  231.         w->weight = MAXSHORT;
  232.        }
  233.       else if (temp < MINSHORT)
  234.        {
  235.         wtlimithit = 1;
  236.         w->weight = MINSHORT;
  237.        }
  238.       else w->weight = temp;
  239.       w = w->next;
  240.      };
  241.     u = u->next;
  242.    };
  243.   layer = layer->backlayer;
  244.  };
  245. }
  246. #endif
  247.  
  248. void periodic_update()   /* update weights for the original method */
  249. {                        /* and the differential step size algorithm */
  250. register short reta, ralpha;
  251. register INT32 temp;
  252. register short temp2;
  253. register UNIT *u;
  254. register WTNODE *w;
  255. LAYER *layer;
  256.  
  257. ralpha = alpha;
  258. layer = last;
  259. while (layer->backlayer != NULL)
  260.  {
  261.   if (layer == last) reta = eta; else reta = eta2;
  262.   u = (UNIT *) layer->units;
  263.   while (u != NULL)
  264.    {
  265.     w = (WTNODE *) u->wtlist;
  266.     while (w != NULL)
  267.      {
  268. #ifdef SYMMETRIC
  269.       if (((UNIT *) w->backunit)->unitnumber > u->unitnumber)
  270.        {
  271.         if (*(w->total) > 0) temp = (INT32) ((INT32)(*(w->total) + 512) >> 10) * reta 
  272.            + (INT32) ralpha * *(w->olddw);
  273.         else temp = (INT32) -(((INT32) 512 - *(w->total)) >> 10) * reta
  274.            + (INT32) ralpha * *(w->olddw);
  275.         if (temp > 0) temp2 = (INT32) (temp + 512) >> 10;
  276.         else temp2 = -(((INT32) 512 - temp) >> 10);
  277.         *(w->olddw) = temp2;
  278.         temp = (INT32) *(w->weight) + temp2;
  279.         if (temp > MAXSHORT)
  280.          {
  281.           wtlimithit = 1;
  282.           *(w->weight) = MAXSHORT;
  283.          }
  284.         else if (temp < MINSHORT)
  285.          {
  286.           wtlimithit = 1;
  287.           *(w->weight) = MINSHORT;
  288.          }
  289.         else *(w->weight) = temp;
  290.        };
  291. #else
  292.       if (w->total > 0)
  293.         temp = (INT32) (((INT32) w->total + 512) >> 10) * reta + (INT32) ralpha * w->olddw;
  294.       else
  295.         temp = (INT32) -(((INT32) 512 - w->total) >> 10) * reta + (INT32) ralpha * w->olddw;
  296.       if (temp > 0) temp2 = (INT32) (temp + 512) >> 10;
  297.       else temp2 = -(((INT32) 512 - temp) >> 10);
  298.       w->olddw = temp2;
  299.       temp = (INT32) w->weight + temp2;
  300.       if (temp > MAXSHORT)
  301.        {
  302.         wtlimithit = 1;
  303.         w->weight = MAXSHORT;
  304.        }
  305.       else if (temp < MINSHORT)
  306.        {
  307.         wtlimithit = 1;
  308.         w->weight = MINSHORT;
  309.        }
  310.       else w->weight = temp;
  311. #endif
  312.       w = w->next;
  313.      };
  314.     u = u->next;
  315.    };
  316.   layer = layer->backlayer;
  317.  };
  318. }
  319.  
  320.  
  321. void qp_update() {pg("quickprop not yet finished\n");}
  322. void supersab() {pg("supersab not yet finished\n");}
  323.  
  324. short cbackoutput()          /* The continuous update version */
  325. {                            /* of back-propagation */
  326. register short deltaj;
  327. register INT32 etadeltaj, temp, temp2;
  328. register short temp3, adiff;
  329. register UNIT *bunit;
  330. register WTNODE *w;
  331. register UNIT *u;
  332. register short ralpha, reta, notclose;
  333.  
  334. ralpha = alpha;
  335. reta = eta;
  336. notclose = last->unitcount;
  337. u = (UNIT *) last->units;
  338. while (u != NULL)
  339.  { 
  340.   temp3 = u->oj;
  341.   temp2 = u->tj - temp3;
  342.   if (temp2 > 0) adiff = temp2; else adiff = -temp2;
  343.   if (adiff < toler) notclose = notclose - 1;
  344.   totaldiff = totaldiff + adiff;
  345.   if (adiff >= toler || backprop)
  346.    {
  347.     if (deriv == 'd') /* the differential step size method */
  348.       deltaj = temp2;
  349.     else if (deriv == 'f' || deriv == 'F') /* Fahlman's derivative */
  350.      { /* deltaj = (u->tj - u->oj) * [0.1 + u->oj*(1.0 - u->oj)] */
  351.       if (activation == 't') temp3 = temp3 / 2 + 512;
  352.       temp = (INT32) temp2 * ((INT32) 104448 + (INT32) temp3 * ((short)(1024 - temp3)));
  353.       if(temp > 0) deltaj = (INT32) (temp + 524288) >> 20;
  354.       else deltaj = -(((INT32) 524288 - temp) >> 20);
  355.      }
  356.     else /* the original derivative */
  357.      { /* deltaj = (u->tj - u->oj) * u->oj * (1.0 - u->oj) */
  358.       if (activation == 't') temp3 = temp3 / 2 + 512;
  359.       temp = (INT32) temp2 * ((INT32) temp3 * ((short)(1024 - temp3)));
  360.       if(temp > 0) deltaj = ((INT32) temp + 524288) >> 20;
  361.       else deltaj = -(((INT32) 524288 - temp) >> 20);
  362.      };
  363.     etadeltaj = (INT32) deltaj * reta;
  364.     w = (WTNODE *) u->wtlist;
  365. #ifdef SYMMETRIC
  366.     while (w->next != NULL)
  367. #else
  368.     while (w != NULL)
  369. #endif
  370.      { /* get a slope for each weight */
  371.       bunit = (UNIT *) w->backunit;
  372.       temp = (INT32) etadeltaj * bunit->oj;
  373.       if(temp > 0) temp = (INT32) (temp + 524288) >> 20;
  374.       else temp = -(((INT32) 524288 - temp) >> 20);
  375. #ifdef SYMMETRIC
  376.       temp2 = (INT32) ralpha * *(w->olddw);
  377. #else
  378.       temp2 = (INT32) ralpha * w->olddw;
  379. #endif
  380.       if (temp2 > 0) temp3 = temp + (((INT32) temp2 + 512) >> 10);
  381.       else temp3 = temp - (((INT32) 512 - temp2) >> 10);
  382. #ifdef SYMMETRIC
  383.       *(w->olddw) = temp3;
  384. #else
  385.       w->olddw = temp3;
  386. #endif
  387.       /* w->weight = w->weight + w->olddw */
  388. #ifdef SYMMETRIC
  389.       temp = (INT32) *(w->weight) + temp3;
  390.       if (temp > MAXSHORT)
  391.        {
  392.         wtlimithit = 1;
  393.         *(w->weight) = MAXSHORT;
  394.        }
  395.       else if (temp < MINSHORT)
  396.        {
  397.         wtlimithit = 1;
  398.         *(w->weight) = MINSHORT;
  399.        }
  400.       else *(w->weight) = temp;
  401. #else
  402.       temp = (INT32) w->weight + temp3;
  403.       if (temp > MAXSHORT)
  404.        {
  405.         wtlimithit = 1;
  406.         temp3 = MAXSHORT;
  407.        }
  408.       else if (temp < MINSHORT)
  409.        {
  410.         wtlimithit = 1;
  411.         temp3 = MINSHORT;
  412.        }
  413.       else temp3 = temp;
  414.       w->weight = temp3;
  415.       if (bunit->layernumber > 1)
  416.          bunit->error = bunit->error + (INT32) deltaj * temp3;
  417. #endif
  418.       w = w->next;
  419.      }
  420.    }
  421.   u = u->next;
  422.  }
  423. return(notclose);
  424. }
  425.  
  426. #ifndef SYMMETRIC
  427.  
  428. void cbackinner()
  429. {
  430. register short deltaj;
  431. register INT32 etadeltaj, temp, temp2;
  432. register short temp3, reta, ralpha;
  433. register UNIT *bunit;
  434. register WTNODE *w;
  435. register UNIT *u;
  436. LAYER *layer;
  437.  
  438. reta = eta2;
  439. ralpha = alpha;
  440. layer = last->backlayer;
  441. while (layer->backlayer != NULL)
  442.  {
  443.   u = (UNIT *) layer->units;
  444.   while (u != NULL)
  445.    {
  446.     if (activation == 't') temp3 = u->oj / 2 + 512;
  447.     else temp3 = u->oj;
  448.     if (deriv == 'f')  /* Fahlman's derivative */
  449.        temp = (INT32) ((((INT32) temp3 * ((short)(1024 - temp3)) + 512) >> 10) + 102)
  450.                * u->error;
  451.     else  /* diff. step size and original derivative */
  452.        temp = (((INT32) temp3 * ((short)(1024 - temp3)) + 512) >> 10)
  453.                 * u->error;
  454.     if (temp > 0) deltaj = (INT32) (temp + 524288) >> 20;
  455.     else deltaj = -(((INT32) 524288 - temp) >> 20);
  456.     etadeltaj = (INT32) reta * deltaj;
  457.     w = (WTNODE *) u->wtlist;
  458.     while (w != NULL)
  459.      {
  460.       bunit = (UNIT *) w->backunit;
  461.       temp = (INT32) etadeltaj * bunit->oj;
  462.       if (temp > 0) temp = (INT32) (temp + 524288) >> 20;
  463.       else temp = -(((INT32) 524288 - temp) >> 20);
  464.       temp2 = (INT32) ralpha * w->olddw;
  465.       if (temp2 > 0) temp3 = temp + ((INT32) (temp2 + 512) >> 10);
  466.       else temp3 = temp - (((INT32) 512 - temp2) >> 10);
  467.       w->olddw = temp3;
  468.       temp = (INT32) w->weight + temp3;
  469.       if (temp > MAXSHORT)
  470.        {
  471.         wtlimithit = 1;
  472.         temp3 = MAXSHORT;
  473.        }
  474.       else if (temp < MINSHORT)
  475.        {
  476.         wtlimithit = 1;
  477.         temp3 = MINSHORT;
  478.        }
  479.       else temp3 = temp;       
  480.       w->weight = temp3;
  481.       if (bunit->layernumber > 1)
  482.          bunit->error = bunit->error + (INT32) deltaj * temp3;
  483.       w = w->next;
  484.      };
  485.     u = u->next;
  486.    };
  487.   layer = layer->backlayer;
  488.  };
  489. }
  490. #endif
  491.