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