home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1997 July / macformat52.iso / mac / Shareware Plus / Educational / LEE 2.1 / Source / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-07  |  13.1 KB  |  628 lines
  1. /* lee.c
  2.  *                         Copyright (1992)
  3.  *
  4.  *         Jeff Elman.  University of California, San Diego
  5.  *          Rik Belew.  University of California, San Diego
  6.  *      Stefano Nolfi.  Institute of Psychology, Rome.
  7.  *    Filippo Menczer.  University of California, San Diego
  8.  *        Greg Linden.  University of California, San Diego
  9.  *
  10.  *        This software may be redistributed without charge;
  11.  *                 this notice should be preserved.
  12.  */
  13.  
  14. #include "defs.h"
  15.  
  16.  
  17.  
  18. /*
  19.  * generate a file name using a root and a suffix
  20.  */
  21. genfilen(filename,root,suffix)
  22.  
  23.    char  *filename;
  24.    char  *root;
  25.    char  *suffix;
  26.  
  27. {
  28.   sprintf(filename,"%s.%s",root,suffix);
  29. }
  30.  
  31.  
  32.  
  33.  
  34. main(argc, argv)
  35.     int     argc;
  36.     char  **argv;
  37. {
  38.     int    n_weights=0;
  39.     int    n_biases=0;
  40.     boolean    w_mu_flag=0;
  41.     boolean    b_mu_flag=0;
  42.     float    p_w_mu;
  43.     float    p_b_mu;
  44.     int     i;
  45.     int     c;
  46.  
  47.  
  48.     InteractiveInit(&argc, &argv);
  49.  
  50.     seed = (unsigned long)time(NULL);
  51.  
  52.     carica_sigmoide();
  53.  
  54.     for (i=0;i<4;i++)
  55.         for (c=0;c<MAXRANGESIZE;c++)
  56.             off_vec[i][c] = (offset *)malloc(sizeof(offset));    
  57.     carica_offsets(MAXRANGE);
  58.  
  59.     /*
  60.      * we read the command-line options
  61.      */
  62.     while ((c = getopt(argc, argv, "R:E:L:Sf:s:p:r:G:P:g:h:n:o:bUv:d:e:u")) != EOF) {
  63.  
  64.         switch (c) {
  65.         case 'R':
  66.             seed = (unsigned long)atol(optarg);
  67.             break;
  68.         case 'E':
  69.             ecount = atoi(optarg);
  70.             errsig=TRUE;
  71.             break;
  72.         case 'L':
  73.             learn = atoi(optarg);
  74.             if ((learn != 1) && (learn != 2))
  75.             {
  76.                 printf("\nError in learning (-L) option\n\n");
  77.                 usage();
  78.                 exit(2);
  79.             }
  80.             break;
  81.         case 'S':
  82.             saturation=TRUE;
  83.             break;
  84.         case 'f':
  85.             strcpy(fileroot, optarg);
  86.             break;
  87.         case 's':
  88.             sweeps = atoi(optarg);
  89.             break;
  90.         case 'p':
  91.             if ( *optarg== 'o')
  92.               printout=TRUE;
  93.             break;
  94.         case 'r':
  95.             rate = (float) atof(optarg);
  96.             break;
  97.         case 'G':
  98.             generations = atoi(optarg);
  99.             break;
  100.         case 'P':
  101.             start_num_amoebas = atoi(optarg);
  102.             break;                        
  103.         case 'g':
  104.             startgeneration = atoi(optarg);
  105.             break;                    
  106.         case 'h':
  107.             mutations_range = atof(optarg);        
  108.             break;
  109.         case 'n':
  110.             w_mu_flag++;
  111.             p_w_mu = (float)atoi(optarg)/100.0;
  112.             break;
  113.         case 'o':
  114.             b_mu_flag++;
  115.             p_b_mu = (float)atoi(optarg)/100.0;
  116.             break;
  117.         case 'b':
  118.             mbiasestoo=FALSE;
  119.             break;          
  120.         case 'U':
  121.             unary_reactions=TRUE;
  122.             break;          
  123.         case 'v':
  124.             verbose = atoi(optarg);        
  125.             break;
  126.         case 'd':
  127.             save_best =  atoi(optarg);
  128.             break;
  129.         case 'e':
  130.             save_everyn = atoi(optarg);
  131.             break;
  132.         case 'u':
  133.         case '?':
  134.         default:
  135.             usage();
  136.             exit(2);
  137.             break;
  138.         }
  139.     }
  140.  
  141.     if (errsig && (learn !=2))
  142.     {
  143.         printf("\nWarning: cannot record prediction error in absence\n");
  144.         printf("         of prediction learning\n");
  145.         errsig = FALSE;
  146.         ecount = 0;
  147.     }
  148.  
  149.     /*
  150.      * we configure the network and figure out mutations;
  151.      */
  152.     config();
  153.  
  154.     for (i=1;i<nlayers;i++)
  155.     {
  156.         n_weights += (*(layer_descp+i-1) * *(layer_descp+i));    
  157.         n_biases += *(layer_descp + i);
  158.     }
  159.  
  160.     if (w_mu_flag) mutations = (int)(p_w_mu * n_weights);
  161.     else mutations = (int)(WMUPE * n_weights);
  162.  
  163.     if (b_mu_flag) bmutations = (int)(p_b_mu * n_biases);
  164.     else bmutations = (int)(BMUPE * n_biases);
  165.     
  166.  
  167.     /*
  168.      * print command information on the screen
  169.      */
  170.     if  (verbose > 0) {
  171.         printf("\n\n");        
  172.         printf("Configuration file              : %s\n", fileroot);
  173.         printf("Stop at generation              : %d\n",generations);
  174.         printf("Life sweeps per generation      : %d\n", sweeps);
  175.         
  176.         printf("Neural net's architecture       : ");
  177.         for (i=0; i < (nlayers -1); i++)
  178.             printf("%d -> ", *(layer_descp + i));
  179.         printf("%d\n", *(layer_descp + i));
  180.         
  181.         printf("Gutsize                         : %d\n",gutsize);
  182.  
  183.         if (learn)
  184.             printf("Learning rate                   : %.2f\n",rate);
  185.  
  186.         if (startgeneration > 0)
  187.                         printf("We start at generation          : %d\n",startgeneration);
  188.                 else
  189.         {
  190.             printf("Random seed                     : %lu\n", seed);
  191.             printf("Initial population              : %d\n",start_num_amoebas);
  192.         }
  193.  
  194.         printf("Number of weight mutations      : %d\n",mutations);
  195.  
  196.         if (mbiasestoo)
  197.             printf("Number of bias mutations        : %d\n",bmutations);
  198.         printf("Range of mutations              : %.2f\n",mutations_range);
  199.         if (save_best > 0)
  200.             printf("Saving only the %d best each generation\n",save_best);
  201.         if (save_everyn > 0)
  202.             printf("Saving individuals each %d generations\n",save_everyn);
  203.         if (errsig && (learn == 2))
  204.             printf("Saving global prediction error each %d sweeps\n", ecount);    
  205.                 printf("\n\n");
  206.     }
  207.  
  208.  
  209.  
  210.     /*
  211.      * load or initialize state, world, 
  212.      * and population (order is important!)
  213.      */
  214.     if (startgeneration > 0)
  215.     {
  216.         load_all_indiv(startgeneration);
  217.         load_world(startgeneration);
  218.     }
  219.     else
  220.     {
  221.         Srand((long)seed);
  222.             init_world();
  223.         pop_size = start_num_amoebas;
  224.             init_pop(pop_size);
  225.     }
  226.  
  227.  
  228.     InteractiveFinalSetUp();
  229.  
  230.     /*
  231.      * main generational loop
  232.      */
  233.     generati();
  234. }
  235.  
  236.  
  237.  
  238.  
  239. /*
  240.  * Read simulation parameters from file "lee-config"
  241.  * (or other name determined by -f option).
  242.  * Comments begin with '#' and are skipped.
  243.  * Lines should be less than 256 characters long.
  244.  * Order matters!!!!
  245.  */
  246. config()
  247. {
  248.     FILE    *cfp;
  249.     char line[256];
  250.     char c;
  251.     register int i;
  252.     register int    x,y,z;
  253.     int    *ldp;
  254.     int n, m;
  255.     
  256.     cfp = fopen(fileroot, "r");
  257.     if (cfp == NULL)
  258.     {
  259.         printf("ERROR: file %s not found", fileroot);
  260.         exit(1);
  261.     }
  262.  
  263.     /*
  264.      * read size of world
  265.      */
  266.     c = getc(cfp);
  267.     while (c == '#')
  268.     {
  269.         fgets(line,256,cfp);
  270.         c = getc(cfp);
  271.     }
  272.     ungetc(c,cfp);
  273.     m=fscanf(cfp,"%d ",&x_dim);
  274.     if (m!=1)
  275.     {
  276.         printf("ERROR: Reading from configuration file.\n");
  277.         exit(1);    
  278.     }
  279.  
  280.     c = getc(cfp);
  281.     while (c == '#')
  282.     {
  283.         fgets(line,256,cfp);
  284.         c = getc(cfp);
  285.     }
  286.     ungetc(c,cfp);
  287.     m=fscanf(cfp,"%d ",&y_dim);
  288.     if (m!=1)
  289.     {
  290.         printf("ERROR: Reading from configuration file.\n");
  291.         exit(1);    
  292.     }
  293.     
  294.     if ((x_dim > MAX_X) || (y_dim > MAX_Y))
  295.     {
  296.         printf("ERROR: World x or y dimension too large.\n");
  297.         printf("       Either decrease size from configuration file, or\n");
  298.         printf("       increase limits (file defs.h) and recompile code.\n");
  299.         exit(1);
  300.     }
  301.  
  302.     /*
  303.      * read atom types and distributions
  304.      */
  305.  
  306.     c = getc(cfp);
  307.     while (c == '#')
  308.     {
  309.         fgets(line,256,cfp);
  310.         c = getc(cfp);
  311.     }
  312.     ungetc(c,cfp);
  313.     m=fscanf(cfp,"%d ",&types);
  314.     if (m!=1)
  315.     {
  316.         printf("ERROR: Reading from configuration file.\n");
  317.         exit(1);    
  318.     }
  319.     
  320.     if (types > MAXTYPES)
  321.     {
  322.         printf("ERROR: Number of types too large.\n");
  323.         printf("       Either decrease types from configuration file, or\n");
  324.         printf("       increase limit (file defs.h) and recompile code.\n");
  325.         exit(1);
  326.     }
  327.  
  328.     c = getc(cfp);
  329.     while (c == '#')
  330.     {
  331.         fgets(line,256,cfp);
  332.         c = getc(cfp);
  333.     }
  334.     ungetc(c,cfp);
  335.     for (i=0; i<types; i++) 
  336.     {
  337.         m=fscanf(cfp,"(%d,%d,%d,%d,%d) ", 
  338.             &distrib[i][0], &distrib[i][1], &distrib[i][2], 
  339.             &distrib[i][3], &distrib[i][4]); 
  340.         if (m!=5)
  341.         {
  342.             printf("ERROR: Reading from configuration file.\n");
  343.             exit(1);    
  344.         }
  345.         if ((distrib[i][0]<0) || (distrib[i][0]>=x_dim) ||
  346.             (distrib[i][1]<0) || (distrib[i][1]>=y_dim) ||
  347.             (distrib[i][2]<1) || (distrib[i][2]>6) ||
  348.             (distrib[i][3]<1) || (distrib[i][3]>6) ||
  349.             (distrib[i][4]<0) || (distrib[i][4]>100))
  350.         {
  351.             printf("ERROR: Incorrect distribution parameters.\n");
  352.             printf("       Please follow directions in configuration\n");
  353.             printf("       file and adjust parameters accordingly.\n");
  354.             exit(1);
  355.         }
  356.     }
  357.  
  358.     /*
  359.      * next the numbers and types of sensors and motors
  360.      */
  361.     c = getc(cfp);
  362.     while (c == '#')
  363.     {
  364.         fgets(line,256,cfp);
  365.         c = getc(cfp);
  366.     }
  367.     ungetc(c,cfp);
  368.     m=fscanf(cfp,"%d ",&nsensors);
  369.     if (m!=1)
  370.     {
  371.         printf("ERROR: Reading from configuration file.\n");
  372.         exit(1);    
  373.     }
  374.  
  375.     if (nsensors > MAXSENSORS)
  376.     {
  377.         printf("ERROR: Number of sensors too large.\n");
  378.         printf("       Either decrease sensors from configuration file, or\n");
  379.         printf("       increase limit (file defs.h) and recompile code.\n");
  380.         exit(1);
  381.     }
  382.     
  383.     c = getc(cfp);
  384.     while (c == '#')
  385.     {
  386.         fgets(line,256,cfp);
  387.         c = getc(cfp);
  388.     }
  389.     ungetc(c,cfp);
  390.     for (i=0; i<nsensors; i++) 
  391.     {
  392.         m=fscanf(cfp,"(%d,%d,%d) ", &s_type[i], &s_orient[i], &s_range[i]);
  393.         if (m!=3)
  394.         {
  395.             printf("ERROR: Reading from configuration file.\n");
  396.             exit(1);    
  397.         }
  398.         
  399.         if ((s_orient[i]<-1) || (s_orient[i]>2) || 
  400.             (s_range[i]<1) || (s_range[i]>MAXRANGE))
  401.         {
  402.             printf("ERROR: Incorrect sensor specifications.\n");
  403.             printf("       Please follow directions in configuration\n");
  404.             printf("       file and adjust parameters accordingly.\n");
  405.             exit(1);
  406.         }
  407.     }
  408.  
  409.     c = getc(cfp);
  410.     while (c == '#')
  411.     {
  412.         fgets(line,256,cfp);
  413.         c = getc(cfp);
  414.     }
  415.     ungetc(c,cfp);
  416.     m=fscanf(cfp,"%d ",&nmotors);
  417.     if (m!=1)
  418.     {
  419.         printf("ERROR: Reading from configuration file.\n");
  420.         exit(1);    
  421.     }
  422.  
  423.     if (nmotors > MAXMOTORS)
  424.     {
  425.         printf("ERROR: Number of motors too large.\n");
  426.         printf("       Either decrease motors from configuration file, or\n");
  427.         printf("       increase limit (file defs.h) and recompile code.\n");
  428.         exit(1);
  429.     }
  430.     
  431.     c = getc(cfp);
  432.     while (c == '#')
  433.     {
  434.         fgets(line,256,cfp);
  435.         c = getc(cfp);
  436.     }
  437.     ungetc(c,cfp);
  438.     for (i=0; i<nmotors; i++) 
  439.     {
  440.         m=fscanf(cfp, "%d ", &m_type[i]);
  441.         if (m!=1)
  442.         {
  443.             printf("ERROR: Reading from configuration file.\n");
  444.             exit(1);    
  445.         }
  446.     }
  447.  
  448.     /*
  449.      * read # of hidden layers and add 2 for input and output
  450.      */
  451.     c = getc(cfp);
  452.     while (c == '#')
  453.     {
  454.         fgets(line,256,cfp);
  455.         c = getc(cfp);
  456.     }
  457.     ungetc(c,cfp);
  458.     m=fscanf(cfp, "%d ", &nlayers);
  459.     if (m!=1)
  460.     {
  461.         printf("ERROR: Reading from configuration file.\n");
  462.         exit(1);    
  463.     }
  464.  
  465.     if (nlayers < 0)
  466.     {
  467.             printf("ERROR: Negative number of hidden layers.\n");
  468.             exit(1);    
  469.     }
  470.     nlayers += 2;
  471.  
  472.     /*
  473.      * descriptions of # of units per layer
  474.      */
  475.     layer_descp = (int *)malloc(nlayers * sizeof(int));
  476.     
  477.     c = getc(cfp);
  478.     while (c == '#')
  479.     {
  480.         fgets(line,256,cfp);
  481.         c = getc(cfp);
  482.     }
  483.     ungetc(c,cfp);
  484.     
  485.     n = 0;
  486.     for (i=0; i<nsensors; i++) n += sensor_size(s_type[i]);
  487.     ldp = layer_descp;
  488.     *ldp = n;
  489.     x = n;
  490.     ldp++;
  491.     for (i=1; i < (nlayers-1); i++, ldp++) 
  492.     {
  493.         m=fscanf(cfp, "%d ", ldp);
  494.         if (m!=1)
  495.         {
  496.             printf("ERROR: Reading from configuration file.\n");
  497.             exit(1);    
  498.         }
  499.         if (*ldp <= 0)
  500.         {
  501.                 printf("ERROR: Zero or negative number of hidden units.\n");
  502.                 exit(1);    
  503.         }
  504.     }
  505.     n = 0;
  506.     for (i=0; i<nmotors; i++) n += motor_size(m_type[i]);
  507.     if (learn == 2) *ldp = n+x;
  508.     else *ldp = n;
  509.     
  510.     if ((*layer_descp > NINPUTS) || (*(layer_descp+nlayers-1) > NOUTPUTS))
  511.     {
  512.         printf("ERROR: number of input or output units too large.\n");
  513.         printf("       Use fewer sensors/motors, or increase neural net\n");
  514.         printf("       size limits (file defs.h) and recompile code.\n");
  515.         exit(1);
  516.     }
  517.     
  518.     /*
  519.      *  gut size
  520.      */
  521.     c = getc(cfp);
  522.     while (c == '#')
  523.     {
  524.         fgets(line,256,cfp);
  525.         c = getc(cfp);
  526.     }
  527.     ungetc(c,cfp);
  528.     m=fscanf(cfp, "%d ", &gutsize);
  529.     if (m!=1)
  530.     {
  531.         printf("ERROR: Reading from configuration file.\n");
  532.         exit(1);    
  533.     }
  534.     if (gutsize < 0)
  535.     {
  536.             printf("ERROR: Negative gutsize.\n");
  537.             exit(1);    
  538.     }
  539.     
  540.     /*
  541.      *  get the reaction matrix entries
  542.      */
  543.     c = getc(cfp);
  544.     while (c == '#')
  545.     {
  546.         fgets(line,256,cfp);
  547.         c = getc(cfp);
  548.     }
  549.     ungetc(c,cfp);
  550.     if (unary_reactions) 
  551.         for (x=0; x<types; x++)
  552.         {
  553.             m=fscanf(cfp, "(%*d,%f", &react_table[x][0].energy);
  554.             if (m!=1)
  555.             {
  556.                 printf("ERROR: Reading from configuration file.\n");
  557.                 exit(1);    
  558.             }
  559.             for (y=0; y<types; y++) fscanf(cfp, ",%*d");
  560.             fscanf(cfp, ") ");
  561.         }
  562.     else 
  563.         for (x=0; x<types; x++)
  564.             for (y=0; y<types; y++)
  565.             {
  566.                 m=fscanf(cfp, "(%d,%f", &react_table[x][y].possible, &react_table[x][y].energy);
  567.                 if (m!=2)
  568.                 {
  569.                     printf("ERROR: Reading from configuration file.\n");
  570.                     exit(1);    
  571.                 }
  572.                 if ((react_table[x][y].possible!=0) && (react_table[x][y].possible!=1))
  573.                 {
  574.                     printf("ERROR: Incorrect reaction parameter(s).\n");
  575.                     printf("       Please follow directions in configuration\n");
  576.                     printf("       file and adjust parameters accordingly.\n");
  577.                     exit(1);    
  578.                 }                
  579.                 for (z=0; z<types; z++)
  580.                 {
  581.                     m=fscanf(cfp, ",%d", &react_table[x][y].by_prod[z]);
  582.                     if (m!=1)
  583.                     {
  584.                         printf("ERROR: Reading from configuration file.\n");
  585.                         exit(1);    
  586.                     }
  587.                     if (react_table[x][y].by_prod[z] < 0)
  588.                     {
  589.                         printf("ERROR: Negative number of by-products.\n");
  590.                         printf("       Please follow directions in configuration\n");
  591.                         printf("       file and adjust parameters accordingly.\n");
  592.                         exit(1);    
  593.                     }
  594.                 }
  595.                 fscanf(cfp, ") ");
  596.             }    
  597.  
  598.     fclose(cfp);
  599. }
  600.  
  601.  
  602.  
  603. usage()
  604. {
  605.     printf("\nCOMMAND-LINE OPTIONS:\n\n");
  606.     printf("-R #\tuse # to seed random generator\n");
  607.     printf("-L #\tuse learning: 1 reinforcement, 2 prediction\n");
  608.     printf("-E #\trecord prediction error in .err file every # sweeps\n");
  609.     printf("-f #\tspecify <filename> for configuration file\n");
  610.     printf("-S  \tno world replenishment if saturated\n");
  611.     printf("-s #\trun for # sweeps\n");
  612.     printf("-po \tprint informations each cycle\n");
  613.     printf("-r #\tuse learning rate #\n");
  614.     printf("-G #\tnumber of generations\n");
  615.     printf("-P #\tsize of initial population\n");
  616.     printf("-g #\tstart generation\n");
  617.     printf("-h #\tmutations range\n");
  618.     printf("-n #\tpercent of weights mutated (0-100)\n");
  619.     printf("-o #\tpercent of biases mutated  (0-100)\n");
  620.     printf("-b  \tdo not mutate biases\n");
  621.     printf("-U  \tunary reactions\n");
  622.     printf("-v #\tverbose mode (0-4)\n");
  623.     printf("-d #\tsave only best # individuals of generation\n");
  624.     printf("-e #\tsave individuals each # generations\n");
  625.     printf("-u  \tusage\n");
  626. }
  627.  
  628.