home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / aijournl / 1988_11 / outstar.c < prev    next >
Text File  |  1988-11-07  |  25KB  |  804 lines
  1.  /***********************************************************
  2.     OUTSTAR Simulator
  3.      
  4.         ⌐Maureen Caudill
  5.         Adaptics
  6.         16776 Bernardo Center Drive
  7.         Suite 110 B
  8.         San Diego, CA  92128
  9.         (617) 451-3752
  10.          July, 1988
  11.  
  12.     Written in Lightspeed C (v. 2.15) on Macintosh
  13.     Version 1.0
  14.     
  15.     This outstar learns to reproduce a specified pattern
  16.     on a grid of border neurodes.  The pattern to be learned
  17.     is read from an external text file called "pattern"
  18.     
  19. ---------------------------------------------------------------------------------
  20.         OPERATION OF THIS SIMULATOR
  21.         
  22.         Read AI Expert Article, November, 1988 for discussion of Grossberg
  23.         Learning, Activation Equations and Instar/Outstar.
  24.         
  25.         This simulator models a biological system.  The outstar neurode stimulates
  26.         each of a 7x10 grid of neurodes at the same time as an external pattern
  27.         stimulates the grid.  The initial weight connections between the outstar
  28.         and the grid neurodes are randomly set between -0.5 and +0.5.  The initial
  29.         activity in the grid is also randomly set to activity between 0.0 and 0.5.
  30.         
  31.         To run the simulator, you need to have a pattern file which contains the
  32.         pattern you want the grid to learn to reproduce when stimulated by the outstar.
  33.         The program begins by initializing the weights, activations, reading the data
  34.         file and so on.  Then the values of the Grossberg learning/activation constants
  35.         are checked, with default values assumed initially. I suggest that you leave 
  36.         these values as they are until you are sure you understand the learning laws.
  37.         
  38.         The menu gives you four choices.
  39.             1.  Train the network for some specified number of time units.
  40.             2.  Allow the activation in the grid to decay for some number of time units
  41.             3.  Test the network by having the outstar stimulate the grid for some number
  42.                 of time units.
  43.            -1.  Reset the network (and possibly change the network constants) to either
  44.                    quit or start over.
  45.          When asked to enter the number of time units (for 1 or 2 or 3), remember that
  46.          a negative number will only display the grid activation after that number of time
  47.          units has passed, while a positive number displays the grid activation after each
  48.          time unit.
  49.          
  50.          The proper operation of the simulator is as follows:
  51.              train the network for some number of time periods.  Remember that the
  52.                  transmission constant t0 determines how many time units must pass before
  53.                  the grid even sees the outstar's stimulus (the external pattern is applied
  54.                  immediately).  Thus, if the t0 constant is 3, you should do NOTHING in less 
  55.                  than 4 time units (3 to travel, and 1 to have an effect on the grid).
  56.              allow the grid activation levels to decay to zero.  No weight changes occur
  57.                  during this time (why?), so you are effectively just "clearing the slate".
  58.              test the network (again for t0+1 time units).  If the performance is inadequate,
  59.                  train again for additional time periods, then allow decay, then test.
  60.     Have fun!
  61.     -----------------------------------------------------------------------------------------    
  62.     
  63. ---------------------------------------------------------------------------------
  64.                             STRUCTURE OF THIS FILE
  65.     
  66.     include files
  67.     constant definitions
  68.     general global storage
  69.     Grossberg activation/learning constant storage (global)
  70.     
  71.     ╤╤ Major functions ╤╤
  72.     initialize()                ;; initialize network operations
  73.     train()                        ;; train the grid for a specified time
  74.     decay()                        ;; allow grid activation to decay a specified time
  75.     test()                        ;; test the grid for a specified time
  76.     ╤╤ Utility functions ╤╤
  77.     compute_activation()        ;; compute current activation for a grid neurode
  78.     change_weight()                ;; modify weight of a grid neurode
  79.     read_pattern()                 ;; read pattern from data file
  80.     parseline()                  ;; parse one line of data from file 
  81.     randomize_wts()                ;; randomize weights on grid neurodes
  82.     randomize_activity()        ;; randomize activity of grid neurodes
  83.     set_constants()                ;; set Grossberg equation constants
  84.       show_constants()            ;; show current values of learning/activity constants
  85.     show_wts()                    ;; print current weights on grid neurodes
  86.     displaygrid()                ;; print the current grid activation
  87.     print_menu()                ;; print menu of operator choices (train, test, decay, quit)
  88.     ╤╤ Main control function ╤╤
  89.     main()                        ;; main control function
  90. ------------------------------------------------------------------------------------
  91. *****************************************************************************************/    
  92.     
  93. #include <math.h>
  94. #include <stdio.h>
  95.  
  96. #define        ROWSIZE        7
  97. #define        COLSIZE        10
  98. #define        STRINGSIZE    80
  99. #define        QUIT        -1
  100. #define        STIMMASK    1
  101. #define        ACTIVATION  1
  102. #define        LEARNING    2
  103. #define        DISPLAYON    1
  104. #define        DISPLAYOFF    2
  105. #define        STIM        1
  106. #define        NOSTIM        0
  107.  
  108. /************* General Global Storage ***************************************************/
  109. double        gridwts[ROWSIZE][COLSIZE];     /*     this stores only the weights from the
  110.                                                single outstar neurode to the grid of rim
  111.                                                neurodes. */
  112. int            pattern[ROWSIZE][COLSIZE];  /*    this contains the pattern to be impressed
  113.                                             on the grid of rim neurodes */
  114. double        activity[ROWSIZE][COLSIZE]; /*    this contains the current activation levels
  115.                                             of each grid neurode */               
  116. int            curtime;                    /*     current time (in integral units)  */
  117. double        outstar;                    /*  activation level of outstar */
  118. char        *inpath = "pattern";        /*  file containing pattern to be learned */
  119. unsigned int    outstar_save;            /*    saves history of outstar's output */
  120.  
  121. /*****************************************************************************************/
  122.  
  123. /************* Grossberg Activation Constants (set by user or default values) ************/
  124. double        A  =  0.9;        /* activation decay constant */
  125. double        T  =  0.0;        /* threshold */
  126. int            t0 =    1;        /* transmission time between neurodes */
  127. double        F  =  0.01;        /* forgetting constant for long term memory */
  128. double        G  =  0.2;        /* learning constant for Hebbian learning term */
  129.  
  130. /*************************************************************
  131.     initialize()
  132.         initializes the system by:
  133.             1.  reading in the pattern file
  134.             2.    randomizing the weights
  135.             3.    setting the current time to 0
  136.             4.    establishing the activation/learning constants
  137. **************************************************************/
  138. initialize()
  139. {
  140.     read_pattern();                /* read in training pattern from file */
  141.     randomize_wts();            /* randomize weights to grid neurodes from outstar */
  142.     randomize_activity();        /* randomize activity of grid neurodes */
  143.     show_wts();                    /* display resulting grid neurode weights */
  144.     curtime = 0;                /* reset current time to 0 */
  145.     displaygrid(curtime);        /* display the initial activity of the grid */
  146.     set_constants();            /* set the constants to user specified values */
  147.     return;
  148. }
  149. /*************************************************************
  150.     train(duration)
  151.         trains the outstar and grid for "duration" timeunits. 
  152.         weights are modified during this training period
  153.         After each synchronous update of the grid, the
  154.         activations are displayed.
  155.         
  156.         If training time is negative, only the grid status after
  157.         all "duration" time units will be displayed.
  158.         
  159. **************************************************************/
  160. train()
  161. {
  162.     int        duration, displayflag;
  163.     int        stoptime;
  164.     int        i,j;
  165.     int        stim_grid, stim_outstar;
  166.  
  167.     /* ask how many time units to train */
  168.     printf("\n How many time units do you want the network to train?  ");
  169.     printf("\n (Integer value < 32767, negative suppresses all but final display)  ");
  170.     scanf("%d", &duration);
  171.  
  172.     displayflag = DISPLAYON;
  173.  
  174.     if (duration<0)
  175.     {
  176.         duration = -duration;
  177.         displayflag = DISPLAYOFF;
  178.     }
  179.     stoptime = curtime+duration;
  180.     for ( ; curtime<stoptime; curtime++)
  181.     {
  182.         stim_grid = STIM;
  183.         stim_outstar = STIM;
  184.         printf("\n Current time = %d",curtime);
  185.         save_outstim(stim_outstar);
  186.         for (i=0; i<ROWSIZE; i++)
  187.         {
  188.             for (j=0; j<COLSIZE; j++)
  189.             {
  190.                 compute_activation(i,j,stim_grid, stim_outstar);
  191.                 change_weight(i,j,stim_outstar);
  192.             }
  193.         }
  194.         if(displayflag == DISPLAYON)
  195.             displaygrid();
  196.     }
  197.     curtime--;          /* decrement to avoid using an extra time unit */
  198.  
  199.     /* when complete, if have not been updating display, do a final display of status */
  200.     if (displayflag == DISPLAYOFF)
  201.         displaygrid();
  202.         
  203.     return;
  204. }
  205.  
  206. /*************************************************************
  207.     decay(duration)
  208.         allows grid activation to decay for "duration" timeunits. 
  209.         no weights are modified during this period, since
  210.         stimulations from the outstar are 0.0
  211.         After each synchronous update of the grid, the
  212.         activations are displayed.
  213.         
  214.         If decay time is negative, only the grid status after
  215.         all "duration" time units will be displayed.
  216.         
  217. **************************************************************/
  218. decay()
  219. {
  220.     int        duration;
  221.     int        displayflag;
  222.     int        stoptime;
  223.     int        i,j;
  224.     int        stim_grid, stim_outstar;
  225.  
  226.     /* ask how many time units to decay */
  227.     printf("\n How many time units do you want the network to decay?  ");
  228.     printf("\n (Integer value < 32767, negative suppresses all but final display)  ");
  229.     scanf("%d", &duration);
  230.         
  231.     displayflag = DISPLAYON;
  232.     if (duration<0)
  233.     {
  234.         duration = -duration;
  235.         displayflag = DISPLAYOFF;
  236.     }
  237.  
  238.     stim_grid = NOSTIM;            /* during decay, no external stimulation of grid */
  239.     stim_outstar = NOSTIM;        /* during decay, the outstar does not stimulate grid */
  240.  
  241.     stoptime = curtime+duration;
  242.     for ( ; curtime<stoptime; curtime++)
  243.     {
  244.         printf("\n Current time = %d",curtime);
  245.         save_outstim(stim_outstar);
  246.         for (i=0; i<ROWSIZE; i++)
  247.         {
  248.             for (j=0; j<COLSIZE; j++)
  249.             {
  250.                 compute_activation(i,j,stim_grid, stim_outstar);
  251.             }
  252.         }
  253.         if(displayflag == DISPLAYON)
  254.             displaygrid();
  255.     }
  256.     curtime--;
  257.     /* when complete, if have not been updating display, do a final display of status */
  258.     if (displayflag == DISPLAYOFF)
  259.         displaygrid();
  260.         
  261.     return;
  262. }
  263.  
  264. /*************************************************************
  265.     test(duration)
  266.         tests the outstar and grid for "duration" timeunits. 
  267.         weights are not modified during this training period
  268.         After each synchronous update of the grid, the
  269.         activations are displayed.
  270.         
  271.         If testing time is negative, only the grid status after
  272.         all "duration" time units will be displayed.
  273.         
  274. **************************************************************/
  275. test()
  276. {
  277.     int        duration, displayflag;
  278.     int        stoptime;
  279.     int        i,j;
  280.     int        stim_grid, stim_outstar;
  281.         
  282.     /* ask how many time units to test */
  283.     printf("\n How many time units do you want the network to test?  ");
  284.     printf("\n (Integer value < 32767, negative suppresses all but final display)  ");
  285.     scanf("%d", &duration);
  286.  
  287.     displayflag = DISPLAYON;
  288.     if (duration<0)
  289.     {
  290.         duration = -duration;
  291.         displayflag = DISPLAYOFF;
  292.     }
  293.     
  294.     stim_grid = NOSTIM;        /* no external stimulation of grid during testing */
  295.     stim_outstar = STIM;    /* outstar does stimulate grid during testing */
  296.  
  297.     stoptime = curtime+duration;
  298.     for ( ; curtime<stoptime; curtime++)
  299.     {
  300.         printf("\n Current time = %d",curtime);
  301.         save_outstim(stim_outstar);
  302.         for (i=0; i<ROWSIZE; i++)
  303.         {
  304.             for (j=0; j<COLSIZE; j++)
  305.             {
  306.                 compute_activation(i,j,stim_grid, stim_outstar);
  307.             }
  308.         }
  309.         if(displayflag == DISPLAYON)
  310.             displaygrid();
  311.     }
  312.     curtime-- ;         /* decrement to avoid using an extra time unit */
  313.  
  314.     /* when complete, if have not been updating display, do a final display of status */
  315.     if (displayflag == DISPLAYOFF)
  316.         displaygrid();
  317.         
  318.     return;
  319. }
  320. /****************************************************************************
  321.     save_outstim(stimout)
  322.         Parameter stimout either has the value STIM (1) or NOSTIM (0).
  323.         save_outstim keeps a 16-time-unit historical record of
  324.         the outputs of the outstar by modifying the global unsigned
  325.         integer "outstar_save".
  326.         Each time unit the outstar is stimulating the grid is represented
  327.         by a "1" in outstar_save; if there is no stimulus, outstar_save has
  328.         a "0".  The 0th bit has the most recent record, the 15th bit has
  329.         the oldest record.
  330. *****************************************************************************/
  331. save_outstim(stimout)
  332. int        stimout;
  333. {
  334.     outstar_save = outstar_save << 1;        /* left shift one bit.  A zero fills
  335.                                                the lowest order bit, and the oldest
  336.                                                (highest order bit) is lost         */
  337.     outstar_save += stimout;                /* add current stimulus value 
  338.                                                 (0 if no stim, 1 if stim)           */
  339.     return;
  340. } 
  341.     
  342. /**************************************************************
  343.     compute_activation(row,col,grid_on,out_on)
  344.         compute the current activation for the specified
  345.         grid neurode
  346.         Parameter "grid_on" is a flag to tell whether or not
  347.         the external stimulus is impressing the pattern on
  348.         the grid.  
  349.         Parameter "out_on" is a flag indicating whether the
  350.         outstar is currently stimulating the grid.
  351.         
  352.         Note that differential equation is calculated as an
  353.         incremental difference equation.
  354. ***************************************************************/
  355. compute_activation(row,col,grid_on,out_on)
  356. int        row,col,grid_on,out_on;
  357. {
  358.     double            change;
  359.     unsigned int    status;
  360.     int                outstim;    /* effective outstar stimulation at current time */
  361.     
  362.     change = -A*activity[row][col] ; /* no matter what, activity will tend to try to decay */
  363.     if (grid_on == STIM)             /* if there is external stimulus, it will counter decay */
  364.         change += pattern[row][col];
  365.     if (out_on == STIM)                 /* if there is outstar stimulus... */
  366.     {
  367.         status = outstar_save;                /* Be sure not to change the global version */
  368.         status = status >> t0;                /* right shift by t0 time units to allow for
  369.                                                transmission time from outstar           */
  370.         outstim = status & STIMMASK;
  371.         change += gridwts[row][col]*outstim - T;
  372.     }
  373.     activity[row][col] += change;            /* new activity = old plus incremental change */
  374.     return;
  375. }
  376.  
  377. /**************************************************************************************
  378.     change_weight(row,col,out_on)
  379.         modify the weight of the specified grid neurode synapse
  380.         Parameter "out_on" is a flag indicating whether or not
  381.         the outstar is currently stimulating the grid.
  382.  
  383.         Note that differential equation is calculated as an
  384.         incremental difference equation.
  385.  
  386. ***************************************************************************************/
  387. change_weight(row,col,out_on)
  388. int        row,col, out_on;
  389. {
  390.     double            change;        /* the incremental change to this weight */
  391.     unsigned int    status;        /* local copy of global outstar output history */
  392.     int                outstim;    /* effective stimulus from outstar at this time */
  393.     
  394.     change = -F * activity[row][col];
  395.     if (out_on == STIM)
  396.     {
  397.         status = outstar_save;                /* Be sure not to change the global version */
  398.         status = status >> t0;                /* right shift by t0 time units to allow for
  399.                                                transmission time from outstar           */
  400.         outstim = status & STIMMASK;
  401.         change += G * activity[row][col] * (outstim - T);
  402.     }
  403.     gridwts[row][col] += change;
  404.     return;
  405. }
  406.  
  407. /*******************************************************************
  408.     read_pattern()
  409.         Read in the input data file and store the patterns in
  410.         in_pats and out_pats.
  411.         
  412.         The format for the data file is as follows:
  413.         line#   data expected
  414.         -----   -----------------------------
  415.         1        In-X-size,in-y-size
  416.         2        1st X row of 1st pattern
  417.         3..        following rows of 1st pattern
  418.         etc.
  419.         
  420.         Each row of data is separated by commas or spaces.
  421.         The data is expected to be ascii text corresponding to
  422.         either a +1 or a 0.  
  423.         
  424.         Sample input for a pattern file (The comments to the
  425.         right may NOT be in the file unless more sophisticated
  426.         parsing of the input is done.):
  427.         
  428.         5,7                        input is 5x7 grid
  429.         0,1,1,1,0                  beginning of pattern for "O"
  430.         1,0,0,0,1
  431.         1,0,0,0,1
  432.         1,0,0,0,1
  433.         1,0,0,0,1
  434.         1,0,0,0,0
  435.         0,1,1,1,0
  436.         
  437.         Clearly, this simple scheme can be expanded or enhanced
  438.         any way you like.
  439.         
  440.         Returns -1 if any file error occurred, otherwise 0.
  441. ********************************************************************/
  442. read_pattern()
  443. {
  444.     FILE    *infile;
  445.     
  446.     int        xinsize,yinsize;
  447.     int        rownum, numcols,x;
  448.     int        value, vals_read, status;
  449.     char    instring[STRINGSIZE];
  450.     
  451.     printf("\n Opening and retrieving data from file.");
  452.     
  453.     infile = fopen(inpath, "r");
  454.     if (infile == NULL)
  455.     {
  456.         printf("\n error in opening file!");
  457.         return -1 ;
  458.     }
  459.     vals_read =fscanf(infile,"%d,%d",&xinsize,&yinsize);
  460.     if (vals_read != 2)
  461.     {
  462.         printf("\n Should read 2 items in line one; did read %d",vals_read);
  463.         return -1;
  464.     }
  465.     if ((xinsize != ROWSIZE) || (yinsize != COLSIZE))
  466.     {
  467.         printf("\n\n ERROR:  Pattern file is invalid!");
  468.         printf("\n Pattern is a %d by %d grid instead of %d by %d",
  469.             xinsize, yinsize, ROWSIZE, COLSIZE);
  470.         return -1;
  471.     }
  472.     numcols = ROWSIZE;
  473.     for (rownum = 0; rownum<COLSIZE; rownum++)
  474.     {
  475.         status = fscanf(infile,"%s",&instring);
  476.         if (status == -1)
  477.         {
  478.             printf("\n  ERROR:  Insufficient data in file!");
  479.             return -1;
  480.         }
  481.         value = parseline(instring,numcols,rownum);
  482.         if (value == -1)
  483.             return -1;
  484.     }
  485.     printf("\n Closing the input file now. ");
  486.     fclose(infile);
  487.     return 0;
  488. }
  489.  
  490. /*******************************************************************
  491.     parseline(string,numele,row)
  492.         parse line of text to derive elements from pattern string.
  493.         Parameters
  494.          "string" is a pointer to string to be parsed.
  495.          "numele" specifies number of elements contained in "string"
  496.          "row" is pointer to correct row of "pattern" for elements.
  497.         Elements in the string must be either "0", "1", <space>, ","
  498.          0,1 puts appropriate values in pattern array
  499.          "<space>", or "," is ignored
  500.          
  501.          Notice that this is an extremely primitive parsing routine.
  502.          This can (and should) be improved or modified as desired.
  503.          
  504.         Return:
  505.          -1 if error, 0 else.
  506. ********************************************************************/
  507. parseline(string,numele,ygrid)
  508. char    string[];
  509. int        numele,ygrid;
  510. {
  511.     int        value;
  512.     int        charnum, ele;
  513.     char    ch;
  514.     
  515.     charnum = 0;
  516.     value = 0;
  517.     ele = 0;
  518.     while ((ele < numele) && (value == 0))
  519.     {
  520.         if (charnum == STRINGSIZE) /* made it to the end without filling all element entries */
  521.             value = -1;
  522.         else
  523.         {    /*This routine does not care if digits are separated or not.
  524.               each instance of a 0 or 1 will be taken as an element entry in
  525.               the pattern.  */
  526.               
  527.             ch = string[charnum];
  528.             switch (ch)
  529.             {
  530.             case '0' :  /* each "0" will be treated as a grid entry */
  531.                         pattern[ele][ygrid] = 0;
  532.                         ele++;
  533.                         break;
  534.             case '1' :  /* each "1" will be treated as a grid entry */
  535.                         pattern[ele][ygrid] = 1;
  536.                         ele++;
  537.                         break;
  538.             default     :  /* all other characters are ignored. */
  539.                         break;
  540.             }
  541.             charnum++;
  542.         }
  543.     }
  544.     return value;
  545. }
  546.  
  547. /*******************************************************************
  548.     randomize_wts()
  549.         Intialize the weights in the grid neurodes to
  550.         random values between -0.25..+0.25
  551. ********************************************************************/
  552. randomize_wts()
  553. {
  554.     int            i,j;
  555.     double        value;
  556.     
  557.     printf("\n Please enter a random number seed (1..32767):  ");
  558.     scanf("%d", &i);
  559.     srand(i);  
  560.  
  561.     for(i=0; i<ROWSIZE; i++)
  562.     {
  563.         for (j = 0; j<COLSIZE; j++)
  564.         {
  565.             value = (rand() / 32767.0 ) - 0.5;
  566.             gridwts[i][j] = value/2;
  567.         }
  568.     }
  569.     return;
  570. }
  571. /*******************************************************************
  572.     randomize_activity()
  573.         Intialize the activity in the grid neurodes to
  574.         random values between 0.0..0.5
  575. ********************************************************************/
  576. randomize_activity()
  577. {
  578.     int            i,j;
  579.     double        value;
  580.     
  581.     for(i=0; i<ROWSIZE; i++)
  582.     {
  583.         for (j = 0; j<COLSIZE; j++)
  584.         {
  585.             value = ( rand() / 32767.0 );
  586.             activity[i][j] = value/2.0;
  587.         }
  588.     }
  589.     return;
  590. }
  591.  
  592. /*******************************************************************
  593.     set_constants()
  594.         displays current (default) values for learning/activation
  595.         constants and requests user changes.  
  596. ********************************************************************/
  597. set_constants()
  598. {
  599.     int        ans;
  600.     float    value;
  601.     
  602.     show_constants(ACTIVATION);
  603.     scanf("%d",&ans);
  604.     while (ans != 0)
  605.     {
  606.         printf("\n    New value for A?  ");
  607.         scanf("%f",&value);            
  608.         A = (double) value;
  609.         printf("\n    New value for T?  ");
  610.         scanf("%f",&value);
  611.         T = (double) value;
  612.         printf("\n    New value for t0?  ");
  613.         scanf("%d",&t0);
  614.         show_constants(ACTIVATION);
  615.         scanf("%d",&ans);
  616.     }
  617.     show_constants(LEARNING);
  618.     scanf("%d",&ans);
  619.     while (ans != 0)
  620.     {
  621.         printf("\n    New value for F?  ");
  622.         scanf("%f",&value);
  623.         F = (double) value;
  624.         printf("\n    New value for G?  ");
  625.         scanf("%f",&value);
  626.         G = (double) value;
  627.         show_constants(LEARNING);
  628.         scanf("%d",&ans);
  629.     }
  630.     return;
  631. }
  632. /*********************************************************************
  633.     show_constants (which)
  634.         displays either activation or learning constants for
  635.         user approval or modification
  636.         Paramter "which" determines which set will be displayed
  637. **********************************************************************/
  638. show_constants(which)
  639. int        which;
  640. {
  641.     if (which == ACTIVATION) 
  642.     {
  643.         printf("\n The current values for the Grossberg activation constants are:");
  644.         printf("\n   Activation Decay Time constant (A):  %6.3f",A);
  645.         printf("\n   Activity Threshold (T):              %6.3f",T);
  646.         printf("\n   Transmission time to grid (t0):      %d",t0);
  647.     }
  648.     if (which == LEARNING)
  649.     {
  650.         printf("\n The current values for the Grossberg learning constants are:");
  651.         printf("\n   Learning Decay 'Forgetting' constant (F):  %6.3f",F);
  652.         printf("\n   Learning Gain constant (G):                %6.3f",G);
  653.     }    
  654.     printf("\n\n Do you wish to change any of these constants? (0 = no) ");
  655.     return;
  656. }
  657.  
  658. /*******************************************************************
  659.     show_wts()
  660.         print out the weights for the grid neurodes on the screen
  661. ********************************************************************/
  662. show_wts()
  663. {
  664.     int        row,col;
  665.     
  666.     printf("\n  The current weights for the grid neurodes are:\n");
  667.     for (col = 0; col < COLSIZE; col++)
  668.     {
  669.         printf ("\n");
  670.         for (row = 0; row < ROWSIZE; row++)
  671.         {
  672.             printf(" %6.3f ",gridwts[row][col]);
  673.         }
  674.     }
  675.     printf("\n\n");
  676.     return;
  677. }
  678.  
  679. /**************************************************************
  680.     displaygrid()
  681.         prints (text-only for portability) the current activity
  682.         of the grid neurodes.  Also displays the current time,
  683.         and the desired pattern.
  684. ***************************************************************/
  685. displaygrid()
  686. {
  687.     int        i,j;
  688.     double    value;
  689.     
  690.     printf("\n  Current pattern and activity at time %d:",curtime);
  691.     printf("\n Scale (0.0 to 1.0):  '  .  _  o  O  Ñ' \n");
  692.     printf("\n Grid activity is:");
  693.     printf("                   ");
  694.     printf("  Desired pattern is:");
  695.     for (j=0; j<COLSIZE; j++)
  696.     {
  697.         printf("\n     ");
  698.         for (i=0; i<ROWSIZE; i++)
  699.         {
  700.             value = activity[i][j];
  701.             if (value < 0.17)
  702.                 printf("   ");
  703.             if ((value >= 0.17) && (value < 0.35))
  704.                 printf(" . ");
  705.             if ((value >= 0.35) && (value < 0.50))
  706.                 printf(" _ ");
  707.             if ((value >= 0.50) && (value < 0.67))
  708.                 printf(" o ");
  709.             if ((value >= 0.67) && (value < 0.83))
  710.                 printf(" O ");
  711.             if (value >= 0.83)
  712.                 printf(" Ñ ");
  713.         }
  714.         printf("                   ");
  715.         for (i=0; i<ROWSIZE; i++)
  716.         {
  717.             switch(pattern[i][j])
  718.             {
  719.             case 0:        printf("   ");
  720.                         break;
  721.             case 1:        printf(" Ñ ");
  722.                         break;
  723.             default:    break;
  724.             }
  725.         }
  726.     }
  727.     printf("\n");
  728.     return;
  729. }
  730.  
  731. /***************************************************************
  732.     print_menu()
  733.         prints out menu of operations for user choice
  734. ****************************************************************/
  735. print_menu()
  736. {
  737.     printf("\n\n\n     Please select an operation:");
  738.     printf("\n\n          1.  Train the network for a period of time.");
  739.     printf("\n              (Both external and outstar stimulate grid)");
  740.     printf("\n\n          2.  Allow the network to decay for a period of time.");
  741.     printf("\n              (Neither external or outstar stimulates grid)");
  742.     printf("\n\n          3.  Test the network for a period of time.");
  743.     printf("\n              (Only outstar stimulates grid)");
  744.     printf("\n\n         -1.  Train the network for a period of time.");
  745.     return;
  746. }
  747.  
  748. /***************************************************************
  749.     main()
  750.         main program
  751. ****************************************************************/
  752. main()
  753. {
  754.     int        yesno;
  755.     int        done, donetraining;
  756.     int        traintime;
  757.     int        choice;
  758.     
  759.     done = 0; donetraining = 0;
  760.     while (done == 0)
  761.     {
  762.         initialize();
  763.         choice = 0;
  764.         /* display the desired grid pattern on the screen */
  765.         print_menu();
  766.         printf("\n\n  Please enter your choice:  ");
  767.         scanf("%d",&choice);
  768.         printf("\n Your selection was %d",choice);
  769.         while (choice != QUIT)
  770.         {
  771.             switch (choice)
  772.             {
  773.             case 1:    
  774.                         train();
  775.                         break;
  776.             case 2:        
  777.                         decay();
  778.                         break;
  779.             case 3:        
  780.                         test();
  781.                         break;
  782.             default:
  783.                 {
  784.                 choice = QUIT;
  785.                 break;
  786.                 }
  787.             }    
  788.             print_menu();
  789.             printf("\n\n  Please enter your choice:  ");
  790.             scanf("%d",&choice);
  791.             printf("\n Your selection was %d",choice);
  792.         }
  793.         printf("\n\n Training session terminated at user request...");
  794.         
  795.         /* want to start over (allows modification of constants)? */
  796.         printf("\n\n Would you like to reset the network and begin again (no = 0)?  ");
  797.         scanf("%d",&yesno);
  798.         if (yesno < 1)
  799.             done = 2;
  800.     }
  801.     printf("\n\n Program complete.");
  802.     /* stop */
  803.     return;
  804. }