home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume28 / backprop / part03 / io.c < prev    next >
C/C++ Source or Header  |  1992-02-23  |  25KB  |  973 lines
  1. /* ************************************************ */
  2. /* file io.c:  contains most input/output functions */
  3. /*                                                  */
  4. /* Copyright (c) 1991 by Donald R. Tveter           */
  5. /*                                                  */
  6. /* ************************************************ */
  7.  
  8. #include <stdio.h>
  9. #ifdef INTEGER
  10. #include "ibp.h"
  11. #else
  12. #include "rbp.h"
  13. #endif
  14.  
  15. #ifdef UNIX
  16. #include <malloc.h>
  17. #define WRITEBIN "w"
  18. #define READBIN "r"
  19. #else
  20. #include <stdlib.h>
  21. #define WRITEBIN "wb"
  22. #define READBIN "rb"
  23. #endif
  24.  
  25. extern char buffer[buffsize], copyflag, *datafilename, echo, outformat;
  26. extern char outstr[OUTSTRSIZE], *wtfile, wtformat;
  27. extern int bufferend, bufferptr, filestackptr, format[maxformat];
  28. extern FILE *data, *filestack[];
  29. extern LAYER *start;
  30. extern int lastsave, pagesize, readerror, readingpattern, totaliter;
  31. extern INT32 lineno;
  32. extern short nlayers;
  33. extern WTTYPE qmark, toler;
  34. extern FILE *copy;
  35.  
  36. WTTYPE error;
  37. int bad;
  38.  
  39. #ifdef INTEGER
  40.  
  41. short scale(x)     /* returns x as a scaled 16-bit value */
  42. REAL x;
  43. {
  44.  short s;
  45.  
  46. if (x > 31.999 || x < -32.0)
  47.  {
  48.   sprintf(outstr,"magnitude of %f is too large for the integer",x);
  49.   pg(outstr);
  50.   pg(" representation\n");
  51.   readerror = 1;
  52.   if (x > 31.999) return(MAXSHORT); else return(MINSHORT);
  53.  };
  54. if (x > 0.0) s = x * 1024 + 0.5;
  55. else s = x * 1024 - 0.5;
  56. if (x != 0.0 && s == 0)
  57.  {
  58.   sprintf(outstr,"warning:  magnitude of %f is too small for",x);
  59.   pg(outstr);
  60.   pg(" the integer representation\n");
  61.   return(0);
  62.  };
  63. return(s);
  64. }
  65.  
  66. REAL unscale(x)  /* returns the REAL value of short x */
  67. short x;
  68. { return((REAL) x / 1024.0); }
  69.  
  70. REAL unscaleint(x)  /* returns the REAL value of INT32 x */
  71. INT32 x;
  72. { return((REAL) x / 1024.0); }
  73.  
  74. #endif
  75.  
  76. int pushfile(filename)
  77. char *filename;
  78. {
  79. FILE *file;
  80.  
  81. bufferptr = 0;
  82. bufferend = 0;
  83. buffer[0] = '\n';
  84. file = fopen(filename,"r");
  85. if (file == NULL)
  86.  {
  87.   sprintf(outstr,"cannot open:, %s\n",filename); pg(outstr);
  88.   return(0);
  89.  };
  90. filestackptr = filestackptr + 1;
  91. if (filestackptr > 3)
  92.  {
  93.   pg("can't stack up any more files\n");
  94.   filestackptr = filestackptr - 1;
  95.   return(0);
  96.  };
  97. filestack[filestackptr] = file;
  98. data = file;
  99. return(1);
  100. } 
  101.  
  102. void popfile()
  103. {
  104. bufferptr = 0;
  105. bufferend = 0;
  106. buffer[0] = '\n';
  107. if (filestackptr > 0)
  108.  {
  109.   fclose(data);
  110.   filestackptr = filestackptr - 1;
  111.  }
  112. else pg("\nunexpected EOF:  to quit the program, type q\n");
  113. data = filestack[filestackptr];
  114. }
  115.  
  116. int readch() /* returns the next character in the input buffer */
  117. { 
  118.  int i, ch2;
  119.  
  120. if (bufferptr > bufferend) /* then read next line into buffer */
  121.  {
  122.   ch2 = getc(data);
  123.   if (ch2 == EOF) return(ch2);
  124.   i = 0;
  125.   while(ch2 != '\n' && i < buffsize)
  126.    {
  127.     if (ch2 == 13) ch2 = ' '; /* turn a ctrl-M into a blank */
  128.     buffer[i] = ch2;
  129.     i = i + 1;
  130.     ch2 = getc(data);
  131.    };
  132.   if (i == buffsize) pg("line too long\n");
  133.   buffer[i] = '\n';
  134.   bufferend = i;
  135.   bufferptr = 0;
  136.   if (echo == '+') for(i = 0; i <= bufferend; i++) putchar(buffer[i]);
  137.   if (copy && ((data == stdin) || (echo == '+')))
  138.    for (i=0;i<=bufferend;i++) putc(buffer[i],copy);
  139.  }
  140. ch2 = buffer[bufferptr];
  141. bufferptr = bufferptr + 1;
  142. return(ch2);
  143. }
  144.  
  145. void texterror()
  146. {
  147. int ch2;
  148. pg("unexpected text:  ");
  149. bufferptr = bufferptr - 1;
  150. do {ch2 = readch(); putchar(ch2);} while (ch2 != '\n');
  151. putchar('\n');
  152. bufferptr = bufferptr - 1;
  153. }
  154.  
  155. char *readstr()
  156. {
  157. short i,start,end;
  158. char *addr, *addr2;
  159. i = bufferptr;
  160. while (buffer[i] == ' ') i = i + 1;
  161. start = i;
  162. while (buffer[i] != ' ' && buffer[i] != '\n') i = i + 1;
  163. end = i-1;
  164. addr = (char *) malloc((int) end-start+2);
  165. addr2 = addr;
  166. for (i=start;i<=end;i++) *addr++ = buffer[i];
  167. bufferptr = end + 1;
  168. *addr = '\0';
  169. return(addr2);
  170. }
  171.  
  172. int scanfordigit()
  173. {
  174. int sign, ch2;
  175.  
  176. sign = 1;
  177.  
  178. restart:
  179. do ch2 = readch(); while (ch2 == ' ' || ch2 == '\n');
  180. if (ch2 >= '0' && ch2 <= '9')
  181.  {
  182.   bufferptr = bufferptr - 1;
  183.   return(sign);
  184.  };
  185. if (ch2 >= 'h' && ch2 <= 'k')
  186.  {
  187.   bufferptr = bufferptr - 1;
  188.   return(0);
  189.  };
  190.           switch (ch2) {
  191. case EOF: readerror = 2;
  192.           return(0);
  193. case '*': while (ch2 != '\n') ch2 = readch();
  194.           goto restart;
  195. case '-': sign = -sign;
  196.           goto restart;
  197. case '?': bufferptr = bufferptr - 1;
  198.           return(0);
  199. default:  readerror = 1;
  200.           return(0);
  201.           };
  202. }
  203.  
  204. int readint(min,max,command)
  205. int min, max;
  206. char command;
  207. {
  208. int sign, number, ch2;
  209.  
  210. readerror = 0;
  211. sign = scanfordigit();
  212. if (readerror)
  213.  {
  214.   if (readerror == 1) texterror();
  215.   return(0);
  216.  };
  217. number = 0;
  218. do ch2 = readch(); while (ch2 == ' ');
  219. while (ch2 >= '0' && ch2 <= '9')
  220.  {
  221.   number = number * 10 + (ch2 - '0');
  222.   ch2 = readch();
  223.  };
  224. bufferptr = bufferptr - 1;
  225. number = sign * number;
  226. if (number < min || number > max)
  227.  {
  228.   sprintf(outstr,"out of range value: %d",number); pg(outstr);
  229.   if (data == stdin) pg("\n");
  230.   else {sprintf(outstr," in %c command\n",command); pg(outstr);};
  231.   readerror = 1;
  232.  };
  233. return(number);
  234. }
  235.  
  236. REAL readreal(op,min,command)
  237. int op;
  238. REAL min;
  239. int command;
  240. {
  241. REAL number, fractpart, divisor, intpart, sign;
  242. int ch2;
  243.  
  244. readerror = 0;
  245. sign = (REAL) scanfordigit();
  246. if (readerror || (sign == 0 && !readingpattern))
  247.  {
  248.   if (readerror == 1) texterror();
  249.   return(0);
  250.  };
  251. ch2 = readch();
  252. if (ch2 == 'h' && readingpattern) return(unscale(HCODE));
  253. else if (ch2 == 'i' && readingpattern && nlayers >= 3)
  254.   return(unscale(ICODE));
  255. else if (ch2 == 'j' && readingpattern && nlayers >= 4)
  256.   return(unscale(JCODE));
  257. else if (ch2 == 'k' && readingpattern && nlayers >= 5)
  258.   return(unscale(KCODE));
  259. else if (ch2 == '?' && readingpattern)
  260.   return(unscale(qmark));
  261. intpart = 0.0;
  262. while (ch2 >= '0' && ch2 <= '9')
  263.  {
  264.   intpart = 10.0 * intpart + (ch2 - '0');
  265.   ch2 = readch();
  266.  };
  267. fractpart = 0.0;
  268. divisor = 1.0;
  269. if (ch2 == '.')
  270.  {
  271.   ch2 = readch();
  272.   while (ch2 >= '0' && ch2 <= '9')
  273.    {
  274.     fractpart = fractpart * 10.0 + (ch2 - '0');
  275.     divisor = divisor * 10.0;
  276.     ch2 = readch();
  277.    };
  278.  };
  279. bufferptr = bufferptr - 1;
  280. number = sign * (((REAL) intpart) +
  281.                 ((REAL) fractpart) / ((REAL) divisor));
  282. if (op == GT && number > min) return(number);
  283. else if (op == GE && number >= min) return(number);
  284. else
  285.  {
  286.   sprintf(outstr,"erroneous value: %f",number); pg(outstr);
  287.   if (data == stdin) pg("\n");
  288.   else {sprintf(outstr," in %c command\n",command); pg(outstr);};
  289.   readerror = 1;
  290.   return(0.0);
  291.  };
  292. }
  293.  
  294. WTTYPE rdr(op,min,command) /* reads REAL real numbers and converts */
  295. int op;                    /* them to 16-bit integers if necessary */
  296. REAL min;
  297. int command;
  298. {
  299. REAL x;
  300. WTTYPE ix;
  301.  
  302. x = readreal(op,min,command);
  303. if (readerror) return(0);
  304. ix = scale(x);
  305. if (readerror) return(0);
  306. return(ix);
  307. }
  308.  
  309. REAL readchar()   /* reads data in compressed format */
  310. {
  311. int ch2;
  312. readerror = 0;
  313. ch2 = readch();
  314. do {
  315.           switch (ch2) {
  316. case '\n':
  317. case ' ': ch2 = readch();
  318.           break;
  319. case '1': return(1.0);
  320. case '0': return(0.0);
  321. case '?': return(unscale(qmark));
  322. case '*': do ch2 = readch(); while(ch2 != '\n');
  323.           break;
  324. case 'h': return(unscale(HCODE));
  325. case 'i': if (nlayers >= 3) return(unscale(ICODE));
  326. case 'j': if (nlayers >= 4) return(unscale(JCODE));
  327. case 'k': if (nlayers >= 5) return(unscale(KCODE));
  328. case EOF: readerror = 2;
  329.           return(0.0);
  330. default:  texterror();
  331.           readerror = 1;
  332.           return(0.0);};
  333. } while (0 == 0);
  334. }
  335.  
  336. int pg(str) /* paging and making a copy function */
  337. char *str;
  338. {
  339. char *ch3,action,cr;
  340. int copying;
  341.  
  342. copying = copyflag == '+';
  343. ch3 = str;
  344. while (*ch3 != '\0')
  345.    {
  346.      if (*ch3 == '\n')
  347.         {
  348.           putchar('\n');
  349.           if (copying) putc('\n',copy);
  350. #ifndef UNIX
  351.           putchar('\r');
  352.           if (copying) putc('\r',copy);
  353.           if (*ch3++ != '\r') ch3--;
  354. #endif
  355.           lineno = lineno + 1;
  356.           if (pagesize && lineno % pagesize == 0)
  357.              {
  358.                putchar(':');
  359.                action = getchar();
  360.                if (action == 'q')
  361.                   {
  362.                     cr = getchar();
  363.                     return(action);
  364.                   };
  365.              }
  366.         }
  367.      else {putchar(*ch3); if (copying) putc(*ch3,copy); };
  368.      ch3++;
  369.    };
  370. return(0);
  371. }
  372.  
  373. int printoutunits(printing,layer,printerr)  /* prints values of units */
  374. int printing;                               /* and computes errors */
  375. LAYER *layer;
  376. int printerr;
  377. {
  378. short unitno, fmtbreaknum, maxval, maxunit;
  379. UNIT *u;
  380. WTTYPE upper, middle, diff;
  381.  
  382. if (printing)
  383.  {
  384.   upper = scale(1.0) - toler;
  385.   middle = scale(0.5);
  386.   unitno = 0;
  387.   fmtbreaknum = 1;
  388.  };
  389. bad = 0;
  390. maxval = -scale(2.0);
  391. maxunit = 0;
  392. error = 0;
  393. u = (UNIT *) layer->units;
  394. while (u != NULL)
  395.  {
  396.   diff = u->tj - u->oj;
  397.   if (diff < 0) diff = -diff;
  398.   if (diff >= toler) bad = 1;
  399.   error = error +  diff;
  400.   if (printing)
  401.    {
  402.     unitno = unitno + 1;
  403.     if (outformat == 'r')
  404.      {
  405.       sprintf(outstr,"%5.2f ",unscale(u->oj)); pg(outstr);
  406.       if (format[fmtbreaknum] == unitno)
  407.        {
  408.         if (pg("\n    ")) return(1);
  409.         if (fmtbreaknum < maxformat - 1) fmtbreaknum = fmtbreaknum + 1;
  410.        }
  411.      }
  412.     else if (outformat == 'a' && printerr)
  413.      {
  414.       if (diff < toler) pg("c");
  415.       else if (u->oj > upper) pg("1");
  416.       else if (u->oj < toler) pg("0");
  417.       else if (u->oj > u->tj) pg("^");
  418.       else pg("v");
  419.       if (format[fmtbreaknum] == unitno)
  420.        {
  421.         pg(" ");
  422.         if (fmtbreaknum < maxformat - 1) fmtbreaknum = fmtbreaknum + 1;
  423.        }
  424.      }
  425.     else 
  426.      {
  427.       if (u->oj > upper) pg("1");
  428.       else if (u->oj > middle) pg("^");
  429.       else if (u->oj < toler) pg("0");
  430.       else pg("v");
  431.       if (format[fmtbreaknum] == unitno)
  432.        {
  433.         pg(" ");
  434.         if (fmtbreaknum < maxformat - 1) fmtbreaknum = fmtbreaknum + 1;
  435.        }
  436.      }
  437.    };
  438.   u = u->next;
  439.  };
  440. if (!printing) return(0);
  441. if (printerr) {sprintf(outstr," (%5.3f)",unscale(error)); pg(outstr);};
  442. if (printerr && !bad) pg(" ok");
  443. if (pg("\n")) return(1); else return(0);
  444. }
  445.  
  446. void saveweights()    /* saves weights on the file weights */
  447. {
  448. UNIT *u;
  449. LAYER *layer;
  450. WTNODE *w;
  451. WTTYPE wvalue, evalue, dvalue, svalue;
  452. int wtsize;
  453. FILE *weights;
  454.  
  455. wtsize = WTSIZE;
  456. weights = fopen(wtfile,WRITEBIN);
  457. if (weights == NULL)
  458.  {
  459.   sprintf(outstr,"cannot open: %s\n",wtfile); pg(outstr);
  460.   return;
  461.  };
  462. fprintf(weights,"%d%c",totaliter,wtformat);
  463. if (wtformat == 'b' || wtformat == 'B') fprintf(weights,"%1d",WTSIZE);
  464. fprintf(weights,"   file = %s\r\n",datafilename);
  465. layer = start->next;
  466. while (layer != NULL)
  467.  {
  468.   u = (UNIT *) layer->units;
  469.   while (u != NULL)
  470.    {
  471.     w = (WTNODE *) u->wtlist;
  472.     while (w != NULL)
  473.      {
  474. #ifdef SYMMETRIC
  475.       wvalue = *(w->weight);
  476.       evalue = *(w->eta);
  477.       dvalue = *(w->olddw);
  478.       svalue = 0; /* not worth having in the symmetric version */
  479. #else
  480.       wvalue = w->weight;
  481.       evalue = w->eta;
  482.       dvalue = w->olddw;
  483.       svalue = w->slope;
  484. #endif
  485.       if (wtformat == 'r' || wtformat == 'R')
  486.        {
  487.         fprintf(weights,"%16.10f",unscale(wvalue));
  488.         if (wtformat == 'R')
  489.          {
  490.           fprintf(weights," %16.10f",unscale(evalue));
  491.           fprintf(weights," %16.10f",unscale(dvalue));
  492. #ifdef NEXTVERSION
  493.           fprintf(weights," %16.10f",unscale(svalue));
  494. #endif
  495.          };
  496.         fprintf(weights,"\r\n");
  497.        }
  498.       else  /* binary format; uses the least space */
  499.        {
  500.         fwrite((char *) &wvalue,wtsize,1,weights);
  501.         if (wtformat == 'B')
  502.          {
  503.           fwrite((char *) &evalue,wtsize,1,weights);
  504.           fwrite((char *) &dvalue,wtsize,1,weights);
  505. #ifdef NEXTVERSION
  506.           fwrite((char *) &svalue,wtsize,1,weights);
  507. #endif
  508.          };
  509.        };
  510.       w = w->next;
  511.      };
  512.     u = u->next;
  513.    };
  514.   layer = layer->next;
  515.  };
  516. fflush(weights);
  517. fclose(weights);
  518. lastsave = totaliter;
  519. }
  520.  
  521. WTTYPE rdb(wtfile,wtsize) /* read binary and convert between sizes */
  522. FILE *wtfile;
  523. int wtsize;
  524. {
  525. int i, ch2;
  526. double dvalue;
  527. float fvalue;
  528. short ivalue;
  529. unsigned char *charptr;
  530.  
  531. if (wtsize == 2) charptr = (unsigned char *) &ivalue;
  532. else if (wtsize == 4) charptr = (unsigned char *) &fvalue;
  533. else if (wtsize == 8) charptr = (unsigned char *) &dvalue;
  534. else pg("bad weight size\n");
  535. for (i=1;i<=wtsize;i++)
  536.  {
  537.   ch2 = fgetc(wtfile);
  538.   *charptr = (unsigned char) ch2;
  539.   charptr++;
  540.  };
  541. if (WTSIZE == 2 && wtsize == 2) return(ivalue);
  542. else if (WTSIZE == 2 && wtsize == 4) return(scale(fvalue));
  543. else if (WTSIZE == 2 && wtsize == 8) return(scale(dvalue));
  544. else if (WTSIZE == 4 && wtsize == 2) return(ivalue / 1024.0);
  545. else if (WTSIZE == 4 && wtsize == 4) return(fvalue);
  546. else if (WTSIZE == 4 && wtsize == 8) return((float) dvalue);
  547. else if (WTSIZE == 8 && wtsize == 2) return(ivalue / 1024.0);
  548. else if (WTSIZE == 8 && wtsize == 4) return((double) fvalue);
  549. else if (WTSIZE == 8 && wtsize == 8) return(dvalue);
  550. }
  551.  
  552. void restoreweights()    /* restore weights from the file weights */
  553. {
  554. FILE *weights;
  555. UNIT *u;
  556. LAYER *layer;
  557. WTNODE *w;
  558. int ch2, fileformat, wtsize;
  559. WTTYPE wvalue, evalue, dvalue, svalue;
  560. double temp;
  561.  
  562. weights = fopen(wtfile,READBIN);
  563. if (weights == NULL)
  564.  {
  565.   pg("cannot open file weights\n");
  566.   return;
  567.  };
  568. fscanf(weights,"%d",&totaliter);
  569. fileformat = getc(weights);
  570. if (fileformat != wtformat) pg("note: weight format mismatch\n");
  571. if (fileformat == 'b' || fileformat == 'B')
  572.  {
  573.   wtsize = getc(weights) - '0';
  574.   if (WTSIZE != wtsize) pg("note: weight sizes mismatched\n");
  575.  }
  576. else wtsize = WTSIZE;
  577. do ch2 = getc(weights); while (ch2 != '\n'); /* skip rest of line */
  578. layer = start->next;
  579. while (layer != NULL)
  580.  {
  581.   u = (UNIT *) layer->units;
  582.   while (u != NULL)
  583.    {
  584.     w = (WTNODE *) u->wtlist;
  585.     while (w != NULL)
  586.      {
  587.       if (fileformat == 'r' || fileformat == 'R')
  588.        {
  589.         fscanf(weights,"%lf",&temp);
  590.         wvalue = scale((REAL) temp);
  591.         if (fileformat == 'R')
  592.          {
  593.           fscanf(weights,"%lf",&temp);
  594.           evalue = scale((REAL) temp);
  595.           fscanf(weights,"%lf",&temp);
  596.           dvalue = scale((REAL) temp);
  597. #ifdef NEXTVERSION
  598.           fscanf(weights,"%lf",&temp);
  599.           svalue = scale((REAL) temp);
  600. #endif
  601.          };
  602.        }
  603.       else
  604.        {
  605.         wvalue = rdb(weights,wtsize);
  606.         if (fileformat == 'B')
  607.          {
  608.           evalue = rdb(weights,wtsize);
  609.           dvalue = rdb(weights,wtsize);
  610. #ifdef NEXTVERSION
  611.           svalue = rdb(weights,wtsize);
  612. #endif
  613.          };
  614.        };
  615. #ifdef SYMMETRIC
  616.       *(w->weight) = wvalue;
  617.       if (fileformat == 'R' || fileformat == 'B')
  618.        {
  619.         *(w->olddw) = dvalue;
  620.         *(w->eta) = evalue;
  621.        }
  622.       else *(w->olddw) = 0;
  623. #else
  624.       w->weight = wvalue;
  625.       if (fileformat == 'R' || fileformat == 'B')
  626.        {
  627.         w->olddw = dvalue;
  628.         w->eta = evalue;
  629.         w->slope = svalue;
  630.        }
  631.       else w->olddw = 0;
  632. #endif
  633.       w = w->next;
  634.      };
  635.     u = u->next;
  636.    };
  637.   layer = layer->next;
  638.  };
  639. fclose(weights);
  640. }
  641.  
  642. void printweights(u)   /* print the weights leading into unit u */
  643. UNIT *u;
  644.  
  645. {
  646. WTNODE *w;
  647. UNIT *bunit;
  648. WTTYPE value;
  649. #ifdef INTEGER
  650. INT32 sum, input;
  651. #else
  652. REAL sum, input;
  653. #endif
  654.  
  655. w = (WTNODE *) u->wtlist;
  656. sum = 0;
  657. pg("layer unit  unit value     weight         input from unit\n");
  658. while (w != NULL)
  659.  {
  660.   bunit = (UNIT *) w->backunit;
  661. #ifdef SYMMETRIC
  662.   value = *(w->weight);
  663. #else
  664.   value = w->weight;
  665. #endif
  666.  
  667. #ifdef INTEGER
  668.   input = (INT32) value * bunit->oj;
  669.   input = input / 1024;
  670. #else
  671.   input = value * bunit->oj;
  672. #endif
  673.   sum = sum + input;
  674.   sprintf(outstr,"%3d   ",bunit->layernumber); pg(outstr);
  675.   if (bunit->unitnumber == 32767) pg("   t ");
  676.   else {sprintf(outstr,"%4d ",bunit->unitnumber); pg(outstr);};
  677.   sprintf(outstr,"%10.5f  %10.5f  ",unscale(bunit->oj),unscale(value));
  678.   pg(outstr);
  679.   sprintf(outstr,"%18.5f\n",unscaleint(input));
  680.   if (pg(outstr)) return;
  681.   w = w->next;
  682.  };
  683. pg("                                      ");
  684. sprintf(outstr,"sum = %9.5f\n\n",unscaleint(sum)); pg(outstr);
  685. }
  686.  
  687. void help()
  688. {
  689. int ch2;
  690. pg("\n");
  691. do ch2 = readch(); while (ch2 == ' ' && ch2 != '\n');
  692.         switch(ch2) {
  693.  
  694. default:
  695. pg("for help type h followed by the letter of the command\n");
  696. if (ch2 == '\n') bufferptr = bufferptr - 1;
  697. break;
  698.  
  699. case '?':
  700. pg("? prints program status and parameters.\n");
  701. break;
  702.  
  703. case '*':
  704. pg("* at the beginning of a line makes the line a comment.\n");
  705. break;
  706.  
  707. case '!':
  708. pg("Enter system commands after the !.\n");
  709. break;
  710.  
  711. case 'A':
  712. pg("A is used to set details of the algorithm.  One or more of \n");
  713. pg("the following commands can go on the same line as the 'A':\n\n");
  714. pg("a l sets the linear activation function.\n");
  715. pg("a p sets the piecewise linear activation function.\n");
  716. pg("a t sets the piecewise near tanh activation function.\n");
  717. #ifndef INTEGER
  718. pg("a s sets the smooth activation function.\n");
  719. pg("a T sets the smooth near tanh activation function.\n");
  720. #endif
  721. pg("\n");
  722. pg("b + will backpropagate errors even when a unit is close to ");
  723. pg("its target.\n");
  724. pg("b - will not backpropagate errors when a unit is close to its");
  725. pg(" target.\n\n");
  726. pg("D <real> will set the sharpness of the sigmoid to <real>.\n\n");
  727. pg("d d will use the derivatives from the differential step size");
  728. pg(" algorithm.\n");
  729. pg("d F uses Fahlman's derivative in the output layer.\n");
  730. pg("d f uses Fahlman's derivative in all layers.\n");
  731. pg("d o uses the original derivative.\n\n");
  732. pg("g <int> updates weights after every group of <int> patterns if <int> != 0.\n\n");
  733. pg("s <int> will skip for <int> iterations patterns that have been ");
  734. pg("learned.\n\n");
  735. pg("t <int> will take pattern <int> out of the training process.\n");
  736. pg("   To bring it back in, use t 0.\n\n");
  737. pg("u c gives the continuous update method.\n");
  738. #ifndef SYMMETRIC
  739. pg("u d gives the delta-bar-delta update method.\n");
  740. #endif
  741. pg("u p gives the periodic update method.\n");
  742. break;
  743.  
  744. case 'a':
  745. pg("a <real> sets the momentum parameter, alpha, to <real>.\n");
  746. break;
  747.  
  748. case 'B':
  749. pg("B <options> sets the following benchmarking options:\n\n");
  750. pg("g <int> sets <int> to be the goal for the number of");
  751. pg(" networks to converge.\n\n");
  752. pg("k <real> sets the range of the initial random");
  753. pg(" weights for each network.\n\n");
  754. pg("m <int> sets the maximum number of networks to try.\n\n");
  755. pg("r <int1> <int2> sets <int1> to be the maximum ");
  756. pg("number of iterations to run.\n  <int2>, if present,");
  757. pg(" sets the rate at which to sample the network.\n  ");
  758. pg("Using r in a B command will initiate benchmarking.\n\n");
  759. pg("t <int> will benchmark with pattern <int> removed");
  760. pg(" from the training set\n  and test it at the");
  761. pg(" sample rate given in the r command.\n");
  762. pg("t f <testfile> will test patterns on <testfile> at ");
  763. pg("the interval given for\n   the sample rate.\n");
  764. pg("t 0 turns off either type of testing.\n");
  765. break;
  766.  
  767. case 'b':
  768. pg("b <int1> <int2> ... <int20> puts a carriage break");
  769. pg(" after each <inti>\nvalues when the output format");
  770. pg(" is real and inserts a blank after each <inti>\n");
  771. pg("value if the format is condensed.\n");
  772. break;
  773.  
  774. case 'C':
  775. pg("C clears the network and other relevant parameters");
  776. pg(" so the problem can be re-run\nwith different");
  777. pg(" initial weights.  Added hidden units are not removed.\n");
  778. break;
  779.  
  780. #ifndef SYMMETRIC
  781. case 'c':
  782. pg("c <int1> <int2> <int3> <int4>  ");
  783. pg("Adds a connection from layer <int1> unit <int2>\n");
  784. pg("   to layer <int3> unit <int4>.\n");
  785. break;
  786. #endif
  787.  
  788. case 'd':
  789. pg("d is used to set parameters for the delta-bar-delta method.\n");
  790. pg("One or more of the following commands can go on the line:\n\n");
  791. pg("d <real> sets the decay factor to <real>.\n");
  792. pg("e <real> sets the initial eta value to <real>.\n");
  793. pg("k <real> sets kappa to <real>.\n");
  794. pg("m <real> limits the maximum value of each eta to <real>.\n");
  795. #ifdef INTEGER
  796. pg("n <real> sets some noise (integer versions only).");
  797. pg("   Try <real> around 0.005.\n");
  798. #endif
  799. pg("t <real> sets the theta parameter to <real>.\n");
  800. break;
  801.  
  802. case 'e':
  803. pg("e <real1> <real2> sets eta, the learning rate for the top layer");
  804. pg(" to <real1>\n   and eta2 for the lower layers to <real2>.  If ");
  805. pg("<real2> is not present,\n   eta2 is set to <real1>.\n");
  806. break;
  807.  
  808. case 'f':
  809. pg("f is used to set the input and output formats for data.\nOne ");
  810. pg("or more of the following commands can go on the line:\n\n");
  811. pg("b + will ring the bell when learning is complete.\n");
  812. pg("b - will not ring the bell when learning is complete.\n\n");
  813. pg("c + will copy i/o to the file, copy.\n");
  814. pg("c - will stop writing to the file, copy.\n\n");
  815. pg("e + echos the input.\ne - does not echo.\n\n");
  816. pg("i c will read pattern values using compressed format.\n");
  817. pg("i r will read pattern values as reals.\n\n");
  818. pg("o a will write node values as analog compressed.\n");
  819. pg("o c will write node values as compressed.\n");
  820. pg("o r will write node values as real.\n\n");
  821. pg("P <int> sets the page size to <int>; 0 means no paging.\n\n");
  822. pg("p c will read patterns in the classification format and ");
  823. pg("summarize the results\n    when testing.\n");
  824. pg("p C will read patterns in the classification format and ");
  825. pg("print every result\n    when testing.\n");
  826. pg("p g will accept general patterns and summarize results when ");
  827. pg("testing.\n");
  828. pg("p G will accept general patterns and print every result when ");
  829. pg("testing.\n\n");
  830. pg("s + will summarize learning status.\n");
  831. pg("s - will not summarize learning status and will");
  832. pg(" list each pattern.\n\n");
  833. pg("u + will give up-to-date statistics on learning.\n");
  834. pg("u - will give statistics one iteration out of date.\n\n");
  835. pg("w b will write the weights as binary.\n");
  836. pg("w B will write the weights, weight changes and etas as binary.\n");
  837. pg("w r will write the weights as real values.\n");
  838. pg("w R will write the weights, weight changes and etas as real");
  839. pg(" values.\n");
  840. break;
  841.  
  842. #ifndef SYMMETRIC
  843. case 'H':
  844. pg("H <int> <real> adds a hidden unit to layer <int>\n");
  845. pg("Weights are initialized to between -<real> and +<real>.\n");
  846. break;
  847. #endif
  848.  
  849. case 'h':
  850. pg("h <letter> gives help for command <letter>.\n");
  851. break;
  852.  
  853. case 'i':
  854. pg("i <inputfile> takes commands from the file.\n");
  855. pg("i takes commands from the current input file.\n");
  856. break;
  857.  
  858. case 'k':
  859. pg("k <real1> <real2> decreases all the weights in the ");
  860. pg("network whose values\nare greater than <real1> by a");
  861. pg(" random amount between 0 and <real2>.\nWeights ");
  862. pg("less than -<real1> are increased by an amount ");
  863. pg("between 0 and <real2>.\nIf <real1> = 0.0, and a ");
  864. pg("weight = 0.0 then the weight is changed to\na ");
  865. pg("random value between -<real2> and +<real2>.\n");
  866. break;
  867.  
  868. case 'l':
  869. pg("l <int> prints values of nodes on layer <int>.\n");
  870. break;
  871.  
  872. case 'm':
  873. pg("m <int1> <int2> ... <intn> makes a network with\n");
  874. pg("<int1> units in the first layer, <int2> units in\n");
  875. pg("the second layer, ... , <intn> units in the nth layer.\n");
  876. break;
  877.  
  878. case 'n':
  879. pg("n <int> <in1> <out1> ... <ini> <outi> ... <inN> <outN>");
  880. pg(" replaces all\n   training patterns with <int> new ones.\n");
  881. pg("n f <trainfile> reads however many patterns there are on");
  882. pg(" the file.\n");
  883. break;
  884.  
  885. case 'O':
  886. pg("O <int> will give the output targets for pattern, <int>.\n");
  887. break;
  888.  
  889. case 'o':
  890. pg("o a outputs node values in analog compressed form.");
  891. pg("\no c outputs node values in compressed form.\n");
  892. pg("o r outputs node values as real.\n");
  893. break;
  894.  
  895. case 'P':
  896. pg("P lists the outputs for all patterns.\n");
  897. pg("P <int> gives the output for pattern <int>.\n");
  898. pg("P0 gives an up-to-date summary of learning.\n");
  899. break;
  900.  
  901. case 'p':
  902. pg("p <pat> submits the pattern, <pat>, to the input units.\n");
  903. break;
  904.  
  905. case 'Q':
  906. pg("Q <real> sets the value of ? in input patterns to <real>.\n");
  907. break;
  908.  
  909. case 'q':
  910. pg("q ends the program.\n");
  911. break;
  912.  
  913. case 'R':
  914. pg("R restores weights from the current weights file\n");
  915. break;
  916.  
  917. case 'r':
  918. pg("r <int1> <int2> runs <int1> iterations thru the ");
  919. pg("patterns.  If <int2> is\npresent, the patterns are ");
  920. pg("printed (or summarized) every <int2> iterations.\n\n");
  921. pg("rw <filename> reads weights from the file, <filename> and sets ");
  922. pg("<filename>\n             to be the current weights file.\n");
  923. pg("rw reads weights from the current weights file.\n");
  924. break;
  925.  
  926. case 'S':
  927. pg("S <int> saves the weights on the current weights file every <int>");
  928. pg(" iterations.\nS or S 0 saves the weights immediately.\n");
  929. break;
  930.  
  931. case 's':
  932. pg("s <int1> <int2> ... <intn> sets the random number seeds.\n\n");
  933. pg("sw <filename> saves weights to the file, <filename> and sets ");
  934. pg("<filename>\n              to be the current weights file.\n");
  935. pg("sw saves weights to the current weights file.\n");
  936. break;
  937.  
  938. #ifdef SYMMETRIC
  939. case 'T':
  940. pg("T <real> freezes all threshold weights at <real>.\n");
  941. break;
  942. #endif
  943.  
  944. case 't':
  945. pg("t <real> sets <real> as the tolerance used in checking for");
  946. pg(" complete learning.\n");
  947. pg("t f <testfile> tests the patterns on the file.\n");
  948. pg("t f tests the patterns on the current test file.\n");
  949. pg("t tests the patterns on the current test file.\n");
  950. break;
  951.  
  952. #ifndef SYMMETRIC
  953. case 'W':
  954. pg("W <real> removes links whose weights are less than ");
  955. pg("the absolute value\nof <real>, except links to ");
  956. pg("threshold units are not removed.\n");
  957. break;
  958. #endif
  959.  
  960. case 'w':
  961. pg("w <int1> <int2>  ");
  962. pg("prints weights into unit <int2> in layer <int1>.\n");
  963. break;
  964.  
  965. case 'x':
  966. pg("x <int1> <in1> <out1> ... <ini> <outi> ... <inN> <outN>  adds");
  967. pg(" the extra\n   <int1> patterns.\n");
  968. pg("x f <trainfile> adds the extra patterns found on the file.\n");
  969. break;
  970.      }; /* end switch */
  971. pg("\n");
  972. }
  973.