home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / COMPUSCI / NNUTL101.ZIP / NNWHERE / NNLOADIN.C < prev    next >
Text File  |  1993-07-12  |  3KB  |  77 lines
  1. /*-----------------------------------------------------------------------*
  2.  * Greg Stevens                                                   6/24/93*
  3.  *                              NNLOADIN.C                               *
  4.  *                                             [file 5 in a series of 6] *
  5.  *                                                                       *
  6.  * This file loads the inputs into the net and feeds the values forward. *
  7.  *                                                                       *
  8.  *-----------------------------------------------------------------------*/
  9. #include "nndisply.c"                   /* links to rest of nn*.c utils  */
  10. #include <math.h>                       /* for the exp() function        */
  11.  
  12. /* Function Prototypes */
  13. NNETtype UpDateInputAct( PATTERNtype ptn, int p, NNETtype oldn );
  14. NNETtype UpDateLayerAct( NNETtype oldn, int L );
  15.  
  16. /* Function Definitions */
  17. NNETtype UpDateInputAct( PATTERNtype ptn, int P, NNETtype oldn )
  18. {
  19.    NNETtype n;                          /* for output net                */
  20.    int u;                               /* unit counter (in each pattern)*/
  21.  
  22.    n = oldn;                            /* transfers current weight      */
  23.                             /* values in the net to be out-  */
  24.                                         /* putted.                       */
  25.  
  26.    for (u=0;(u<INPUT_LAYER_SIZE);++u)   /*for each node in input layer...*/
  27.     {
  28.       n.unit[0][u].state = ptn.p[P][u]; /* loads each element of the     */
  29.                                         /* input pattern into the input  */
  30.                                         /* layer's activation state      */
  31.     }
  32.  
  33.    return( n );                         /* return net w/ new input layer */
  34. }
  35.  
  36.  
  37. NNETtype UpDateLayerAct( NNETtype oldn, int L )
  38. {
  39.   NNETtype n;                           /* to hold the updated network   */
  40.   int u, v;                             /* unit looping counters         */
  41.   float act;                            /* for holding activation states */
  42.  
  43.   n = oldn;
  44.  
  45.   if (L<1)
  46.     {
  47.       printf( "YOU FUCKED UP!" );
  48.       return(n);                       /* if input layer, return ERROR   */
  49.     }
  50.  
  51.   if (L>=NUMLAYERS)
  52.     {
  53.       printf( "YOU FUCKED UP!" );
  54.       return(n);                       /* if not a layer, return ERROR   */
  55.     }
  56.  
  57.   for (u=0; (u<NUMNODES[L]); ++u )     /* for each node in the layer...  */
  58.    {
  59.      act = n.unit[L][u].thresh;               /* set act to neg. thresh  */
  60.      for (v=0; (v<NUMNODES[L-1]); ++v)        /* then sum weighted inputs*/
  61.        {
  62.          act += n.unit[L-1][v].state * n.unit[L][u].weights[v];
  63.        }
  64.  
  65.      if (n.unit[L][u].actfn==0)               /* if its linear...        */
  66.        {
  67.          n.unit[L][u].state = act;
  68.        }
  69.      else if (n.unit[L][u].actfn==1)          /* if its logistic...      */
  70.        {
  71.          n.unit[L][u].state = 1.0 / (1.0 + exp( 0.0 - act ));
  72.        }
  73.    }
  74.  
  75.    return( n );
  76. }
  77.