Class Network

Known Subclasses:

GovernorNetwork, SRN

Class which contains all of the parameters and methods needed to
run a neural network.

Constructor for the Network class. Takes optional name and
verbosity arguments.

Returns the layer specified by name.

Returns the number of layers in the network.

Returns string representation of network.

Determine the activation of a node based on that nodes net input.

Used in compute_error.

Adds a layer. Layer verbosity is optional (default 0).

Adds a pattern with key word.

Example: net.addPattern("tom", [0, 0, 0, 1])

Creates a three layer network with 'input', 'hidden', and
'output' layers.

Returns an array of node bias values and connection weights
for use in a GA.

inName layer and outName layer will be auto-associating.

Computes error and wed for back propagation of error.

Initializes error computation. Calculates error for output
layers and initializes hidden layer error to zero.

Changes the weights according to the error values calculated
during backprop(). Learning must be set.

Changes layer size. Newsize must be greater than zero.

Close the layerName's log file.

Compares two values. Returns 1 if all values are withing
self.tolerance of each other.

Computes error for all non-output layers backwards through all
projections.

Computes weight error derivative for all connections in
self.connections starting with the last connection.

Connects two layers by instantiating an instance of Connection
class.

Copies activations in vec to the specified layer, replacing
patterns if necessary.

Copies targets in vec to specified layer, replacing patterns
if necessary.

Copies vec2 into vector1 being sure to replace patterns if
necessary. Use self.copyActivations() or self.copyTargets()
instead.

Alternate to sweep().

Delete a pattern with key word.

Example: net.delPattern("tom")

Returns value to within 0.001. Then returns 0.0.

Displays the network to the screen.

Returns a dictionary of layer names that map to a list of activations.

Returns the value of the active flag for the layer specified
by layerName.

Returns the connection instance connecting the specified (string)
layer names.

Returns the number of correct activation within tolerance of a
layer.

Returns dictionary with input and target given pos.

Returns the epsilon for the Network instance.

Returns the layer with the argument (string) name.

Given a reference to a layer, returns the index of that layer in
self.layers.

Returns the pattern with key word.

Example: net.getPattern("tom") => [0, 0, 0, 1]

Gets the weights of the connection between two layers (argument strings).

Returns the word associated with pattern.

Example: net.getWord([0, 0, 0, 1]) => "tom"

This method uses the net.compare() method to compute if the patterns
are the same. Tolerance is adjusted using net.setTolerance().

Initializes network by calling Connection.initialize() and
Layer.initialize(). self.count is set to zero.

Loads data (targets/inputs) from file.

Loads inputs as patterns from file.

Loads inputs from file. Patterning is lost.

Loads targets as patterns from file.

Loads targets from file.

Load a set of vectors from a file. Takes a filename, list of cols
you want (or None for all), get every everyNrows (or 1 for no
skipping), and a delimeter.

Loads weights from a file in pickle, plain, or tlearn mode.

Sets the layerName's log feature.

Logs a message with layerName log.

Adds layerName and offset to inputMap.

Adds layerName and offset to targetMap.

Used in error checking with verifyArchitecture() and in prop_from().

Replaces vector with patterns. Used for loading inputs or
targets from a file and still preserving patterns.

Start propagation from the layers in the list
startLayers. Make sure startLayers are initialized with the
desired activations. NO ERROR CHECKING.

Propagates activation through the network. Optionally, takes input layer names
as keywords, and their associated activations. If input layer(s) are given, then
propagate() will return the output layer's activation. If there is more than
one output layer, then a dictionary is returned.

Examples:

>>> net.propagate()
>>> net.propagate(input = [0, .5, 0], context = [.5, .5, .5])
{"output": [0.345]}

Propagates activation through the network. Optionally, takes input layer names
as keywords, and their associated activations. If input layer(s) are given, then
propagate() will return the output layer's activation. If there is more than
one output layer, then a dictionary is returned.

Examples:

>>> net.propagate()
>>> net.propagate(input = [0, .5, 0], context = [.5, .5, .5])
{"output": [0.345]}

Puts a dict of name: activations into their respective layers.

Randomizes self.loadOrder, the order in which inputs set with
self.setInputs() are presented.

Replaces patterned inputs or targets with activation vectors.

Resets seed values.

Resets layer flags for activation and target.

Returns Root Mean Squared Error for all output layers in this network.

Saves data (targets/inputs) to file.

Saves inputs to file.

Saves network to file using pickle.

Saves targets to file.

Saves weights to file in pickle, plain, or tlearn mode.

Sets a layer to active. Affects ce_init(), compute_error(),
propagate(), change_weights(), display().

Sets self.batch to value. Accumulates error over the entire
training set and only changes weights after each training
batch is complete.

Sets epsilon value for the network.

Sets self.input to inputs. Load order is by default random. Use setOrderedInputs() to order inputs.

Network.setInputsAndTargets()
Sets the corpus of data for training. Can be in one of two formats:

Format 1: setInputsAndTargets([[input0, target0], [input1, target1]...])
Network.setInputsAndTargets([[[i00, i01, ...], [t00, t01, ...]],
                             [[i10, i11, ...], [t10, t11, ...]],
                             ...])
Format 2: setInputsAndTargets([input0, input1, ...], [target0, target1, ...])
Network.setInputsAndTargets([[i00, i01, ...], [i10, i11, ...],...],
                            [[t00, t01, ...], [t10, t11, ...],...] )

Sets interactive to value. Specifies if an interactive prompt
should accompany sweep() or step().

Sets learning to value. Determines if the network learns,
ie. changes connection weights.

Sets the maxRandom Layer attribute for each layer to value.Specifies
the global range for randomly initialized values, [-max, max].

Sets self.momentum to value. Used in change_weights().

Sets self.orderedInputs to value. Specifies if inputs
should be ordered and if so orders the inputs.

For compatiblity.

Sets a pattern with key word. Better to use addPattern() and
delPattern().

Example: net.setPattern("tom", [1, 0, 0, 0])

Sets the network to use patterns for inputs and targets.

Sets patterns to the dictionary argument.

Example: net.setPatterns( {"tom": [0, 0, 0, 1], "mary": [1, 0, 0, 0]} )

Sets net.patterned to 1 as a side-effect.

Sets self.reportRate to value.  train() will report when
epoch % reportRate == 0. Cross validation will only report if
there is a cross validation data set.

Sets self.resetEpoch to value. When the number of epochs
reaches self.resetEpoch the network restarts.

Sets self.resetLimit to value. When the number of resets
reaches the reset limit the network quits.

Sets the seed to value.

Sets self.sigmoid_prime_offset to value.

Sets self.stopPercent to value. train() will stop if the percent
correct surpasses the stop percent.

Sets self.sweepReportRate to value.  sweep() will report
when epoch % sweepReportRate == 0.  there is a cross
validation data set.

Sets the targets.

Sets tolerance to value. This specifies how close acceptable
outputs must be to targets.

Sets flag so that self.stopPercent is compared to cross validation
percent rather than the regular training data percentage correct.

Sets self.verbosity and each layer verbosity to value.

Sets the weight of the connection between two layers (argument strings).

Share weights with another network. Connection
is broken after a randomize or change of size. Layers must have the same
names and sizes for shared connections in both networks.

Example: net.shareWeights(otherNet, [["hidden", "output"]])

This example will take the weights between the hidden and output layers
of otherNet and share them with net. Also, the bias values of
otherNet["output"] will be shared with net["output"].

If no list is given, will share all weights.

Network.step()
Does a single step. Calls propagate(), backprop(), and
change_weights() if learning is set.
Format for parameters: <layer name> = <activation/target list>

Runs through entire dataset. 
Returns TSS error, total correct, and total count.

sweepCrossValidation() will go through each of the crossvalidation input/targets.
The crossValidationCorpus is a list of dictionaries of input/targets
referenced by layername.
Example: ({"input": [0.0, 0.1], "output": [1.0]}, {"input": [0.5, 0.9], "output": [0.0]})

Returns the network layers as a string.

Trains the network on the dataset till a stopping condition is
met. This stopping condition can be a limiting epoch or a percentage correct requirement.

Returns Total Sum Squared error for the specified layer's pattern.

Copies gene bias values and weights to network bias values and
weights.

Check for orphaned layers or connections. Assure that network
architecture is feed-forward (no-cycles). Check connectivity. Check naming.

Verifies that arguments to setInputs and setTargets are appropriately formatted.

Used in propagate() to verify that the network input
activations have been set.

Used in backprop() to verify that the network targets have
been set.