home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / COMPUSCI / NNUTL101.ZIP / NNUTILS.DOC < prev    next >
Text File  |  1993-08-02  |  6KB  |  140 lines
  1.                                NEURAL NET UTILITIES
  2.                                    version 1.01
  3.               by Gregory Stevens (stevens@prodigal.psych.rochester.edu)
  4.  
  5.                           (implementation documentation)
  6.                      (These utilities are all ANSI compliant)
  7.  
  8. To make a neural net utility, the following files are necessary:
  9.  
  10. NNPARAMS.C      (parameter definitions for the size of the net)
  11. NNINPUTS.C      (definitions for defining and loading input patterns)
  12. NNSTRUCT.C      (definition for the net data type and init function)
  13. NNDISPLY.C      (functions for displaying information on the screen)
  14. NNLOADIN.C      (functions for loading inputs into the net and processing)
  15.  
  16. One of the following must be included as the head of the nnutils list, and
  17. will chain to the rest.  Which to use depends on whether Back Propagation,
  18. Hebbian learning, or Competative learning with the Hebb rule is used.
  19.  
  20. NNBKPROP.C      (functions for error and backpropagation algorithm)
  21. NNHEBBLN.C      (functions for error and Hebbian learning)
  22. NNCOMPET.C      (stuff for all-or-none clusters [also uses nnhebbln])
  23. NNRECURN.C      (stuff for a recurrent net [also uses nnbkprop.c])
  24.  
  25. You will also need to have or make the files:
  26.  
  27. NNINPUTS.DAT    (text file with values for the input patterns)
  28. NNOUTPUT.DAT    (this will be needed IF the routine is supervised learning)
  29. NNINTEST.DAT    (this will be needed IF you are testing unlearned patterns)
  30.  
  31. NNINPUTS.DAT needs a set of input patterns where there are a number of patterns
  32. equal to NUM_PATTERNS as defined in nninputs.c, and the number of elements
  33. per pattern is equal to INPUT_LAYER_SIZE as defined in nnparams.c.
  34.  
  35. NNOUTPUT.DAT needs a set of output patterns where there are a number of
  36. patterns equal to NUM_PATTERNS and elements per pattern equal to 
  37. OUTPUT_LAYER_SIZE.
  38.  
  39. NNINTEST.DAT needs to be equal in size and format to NNINPUTS.DAT.
  40.  
  41. In your main file you will only need to include the file, NNBKPROP.C,
  42. because all the others are linked with includes, if it is supervised learning,
  43. or the NNHEBBLN.C if unsupervised, or NNCOMPET.C if competative unsupervised.
  44.  
  45. Map of the data type:  Each node has: a real activation state value
  46.                                       a list of real-valued weights
  47.                                       to nodes in the previous layer
  48.                                       a real-valued threshhold weight
  49.                                       an integer flag for the output
  50.                                       function: 0=linear, 1=logistic
  51.  
  52.                        The network is: a structure which has a single
  53.                                        field, which is an array of
  54.                                        layers by nodes of type unit.
  55.  
  56.  
  57. User-Accessable Variables and Functions defined in each file:
  58.  
  59. NNPARAMS.C : INPUT_LAYER_SIZE      (size of input layer)
  60.              OUTPUT_LAYER_SIZE     (size of output layer)
  61.              NUM_HIDDEN_LAYERS     (number hidden layers)
  62.              HL_SIZE_#             (size of each hidden layer)
  63.  
  64.              NUMLAYERS             (number of layers total)
  65.              MAXNODES              (number of nodes in largest layer)
  66.  
  67. NNINPUTS.C : NUM_PATTERNS          (number of input patterns in file)
  68.              InitInPatterns()      (loads patterns from file        )
  69.  
  70. NNSTRUCT.C : NUMNODES[]            (number of nodes in each layer   )
  71.              InitNet()             (initializes network             )
  72.  
  73. NNDISPLY.C : DisplayLayer()
  74.  
  75. NNLOADIN.C : UpDateInputAct()      (loads pattern into the input layer)
  76.              UpDateLayerAct()      (updates act'tions for a [non-input] layer)
  77.  
  78. NNBKPROP.C : EPSILON               (increment for weight changes)
  79.              InitOutPatterns()     (loads in the appropriate output patterns)
  80.              GetDerivs()           (finds dE/ds for each unit; NOT FOR MAIN)
  81.              UpDateWeightandThresh() (does what it says)
  82.  
  83. NNHEBBLN.C : UpDateWeightandThresh() (does what it says with Hebb rule)
  84.  
  85. NNCOMPET.C : AllOrNoneLayerActs()    (sets only one node to winner)
  86.              NUM_CLUSTERS_#          (number of clusters in a given node)
  87.  
  88. User-Modifiable Values in each file:
  89.  
  90. NNPARAMS.C : INPUT_LAYER_SIZE      (size of input layer)
  91.              OUTPUT_LAYER_SIZE     (size of output layer)
  92.              NUM_HIDDEN_LAYERS     (number hidden layers)
  93.              HL_SIZE_#             (size of each hidden layer)
  94.  
  95. NNINPUTS.C : NUM_PATTERNS          (number of input patterns in file)
  96.  
  97. NNSTRUCT.C : InitNet()             (change how the net is initialized)
  98.  
  99. NNBKPROP.C : EPSILON               (increment for weight changes)
  100.  
  101. NNCOMPET.C : NUM_CLUSTERS_#        (number of clusters in a given layer)
  102.  
  103. In the main code, the following variables should be used (not necessarily
  104. with these variable names):
  105.  
  106. NNETtype net;                 /* variable for holding the network   */
  107. PATTERNtype InPatterns,       /* holding input training patterns    */
  108.             OutPattern;       /* holding output "correct" responses */
  109.  
  110. The following kinds of initialization assignments should appear:
  111.  
  112. net = InitNet( NUMNODES );
  113. InPatterns = InitInPatterns();
  114. OutPattern = InitOutPatterns();
  115.  
  116. If the backpropagation algorithm will be used, somewhere in the code the
  117. following line should appear:
  118.  
  119. net = UpDateWeightandThresh( net, OutPattern, pattern );
  120.  
  121. where pattern is a looping integer index marking which input pattern is
  122. the current one.
  123.  
  124. If Hebbian learning is used (means either using HEBBLN or COMPET):
  125.  
  126. net = UpDatWeightandThresh( net );
  127.  
  128. If competative learning is to be implemented, in the loop where you 
  129. UpDateLayerActs, follow that function call with 
  130.  
  131. net = AllOrNoneLayerActs( net, Layer)
  132.  
  133. All these are hints for writing your own from scratch, but I recommend copying
  134. the demo application code that is most similar to your paradigm and modifying
  135. a copy.  The basic loops will most likely be the same.
  136.  
  137. greg
  138.  
  139. stevens@prodigal.psych.rochester.edu
  140.