/// <summary> /// Calculates the output error for each node in the target layer and all hidden layers. Note that this is a wrapper /// method which takes a signal array, converts it to a double array, and passes that on to the method below. /// </summary> /// <param name="layers">The discrete layers in the ANN.</param> /// <param name="connections">Array of all connections in the ANN.</param> /// <param name="nodeActivationValues">The neuron activation values resulting from the last forward pass.</param> /// <param name="targetValues">The target values against which the network is being trained.</param> /// <param name="nodeActivationFunctions">The activation function for each neuron (this will only differ with HyperNEAT).</param> /// <returns>The errors for each output and hidden neuron.</returns> public static double[] CalculateErrorSignals(LayerInfo[] layers, FastConnection[] connections, double[] nodeActivationValues, ISignalArray outputValues, ISignalArray targetValues, IActivationFunction[] nodeActivationFunctions) { double[] targets = new double[targetValues.Length]; // Load the target double array from the input signal array targetValues.CopyTo(targets, 0); // Return the error signals return CalculateErrorSignals(layers, connections, nodeActivationValues, (MappingSignalArray) outputValues, targets, nodeActivationFunctions); }
/// <summary> /// Updates weights based on node error calculations using a given learning rate (momentum isn't taken into /// consideration here). /// </summary> /// <param name="layers">The discrete layers in the ANN.</param> /// <param name="connections">Array of all connections in the ANN.</param> /// <param name="learningRate">The learning rate for all connections.</param> /// <param name="signalErrors">The errors for each output and hidden neuron.</param> /// <param name="nodeActivationValues">The activation function for each neuron (this will only differ with HyperNEAT).</param> public static void BackpropagateError(LayerInfo[] layers, FastConnection[] connections, double learningRate, double[] signalErrors, double[] nodeActivationValues, MappingSignalArray outputArray) { int conIdx = 0; // Iterate through every layer in a forward pass, calculating the new weights on each connection for (int layerIdx = 1; layerIdx < layers.Length; layerIdx++) { // Start at one layer below the current layer so we can access the source nodes LayerInfo layerInfo = layers[layerIdx - 1]; // Handle the output layer as a special case, calculating the error against the given target if (layerIdx == layers.Length - 1) { // Calculate the new weight for every connection in the current layer up to the last (i.e. "end") // connection by adding its current weight to the product of the learning rate, target neuron error, // and source neuron output for (; conIdx < layerInfo._endConnectionIdx; conIdx++) { //double sigError = signalErrors[outputArray._map[connections[conIdx]._tgtNeuronIdx]]; double sigError = signalErrors[connections[conIdx]._tgtNeuronIdx]; connections[conIdx]._weight = connections[conIdx]._weight + learningRate * sigError * nodeActivationValues[connections[conIdx]._srcNeuronIdx]; } } else { // Calculate the new weight for every connection in the current layer up to the last (i.e. "end") // connection by adding its current weight to the product of the learning rate, target neuron error, // and source neuron output for (; conIdx < layerInfo._endConnectionIdx; conIdx++) { connections[conIdx]._weight = connections[conIdx]._weight + learningRate * signalErrors[connections[conIdx]._tgtNeuronIdx] * nodeActivationValues[connections[conIdx]._srcNeuronIdx]; } } } }
/// <summary> /// Calculates the output error for each node in the target layer and all hidden layers. /// </summary> /// <param name="layers">The discrete layers in the ANN.</param> /// <param name="connections">Array of all connections in the ANN.</param> /// <param name="nodeActivationValues">The neuron activation values resulting from the last forward pass.</param> /// <param name="targetValues">The target values against which the network is being trained.</param> /// <param name="nodeActivationFunctions">The activation function for each neuron (this will only differ with HyperNEAT).</param> /// <returns>The errors for each output and hidden neuron.</returns> public static double[] CalculateErrorSignals(LayerInfo[] layers, FastConnection[] connections, double[] nodeActivationValues, MappingSignalArray outputValues, double[] targetValues, IActivationFunction[] nodeActivationFunctions) { double[] signalErrors = new double[nodeActivationValues.Length]; // Get the last connection int conIdx = connections.Length - 1; // Get the last of the output nodes int nodeIdx = nodeActivationValues.Length - 1; // Iterate through the layers in reverse, calculating the signal errors for (int layerIdx = layers.Length - 1; layerIdx > 0; layerIdx--) { // Handle the output layer as a special case, calculating the error against the given target if (layerIdx == layers.Length - 1) { // Calculate the error for every output node with respect to its corresponding target value for (; nodeIdx >= layers[layerIdx - 1]._endNodeIdx; nodeIdx--) { //int targetValuesID = outputValues._map[nodeIdx - outputValues.Length - 1] - outputValues.Length - 1; int targetValuesID = 0; for (int i = 0; i < targetValues.Length; i++) { if (outputValues._map[i] == nodeIdx) { targetValuesID = i; break; } } signalErrors[nodeIdx] = (targetValues[targetValuesID] - nodeActivationValues[nodeIdx])* nodeActivationFunctions[nodeIdx].CalculateDerivative( nodeActivationValues[nodeIdx]); /* int targetValuesID = (targetValues.Length - 1) - ((nodeActivationValues.Length - 1) - nodeIdx); signalErrors[nodeIdx] = (targetValues[targetValuesID] - outputValues[nodeIdx - layers[layerIdx - 1]._endNodeIdx])* nodeActivationFunctions[nodeIdx].CalculateDerivative( outputValues[nodeIdx - layers[layerIdx - 1]._endNodeIdx]); */ } } // Otherwise, we're on a hidden layer, so just compute the error with respect to the target // node's error in the layer above else { // Calculate the error for each hidden node with respect to the error of the // target node(s) of the next layer for (; nodeIdx >= layers[layerIdx - 1]._endNodeIdx; nodeIdx--) { double deltas = 0; // Calculate the sum of the products of the target node error and connection weight while (connections[conIdx]._srcNeuronIdx == nodeIdx) { deltas += connections[conIdx]._weight* signalErrors[connections[conIdx]._tgtNeuronIdx]; conIdx--; } // The output error for the hidden node is the then the sum of the errors // plus the derivative of the activation function with respect to the output signalErrors[nodeIdx] = deltas* nodeActivationFunctions[nodeIdx].CalculateDerivative( nodeActivationValues[nodeIdx]); } } } return signalErrors; }
/// <summary> /// Construct a FastAcyclicNetwork with provided network definition data structures. /// </summary> /// <param name="nodeActivationFnArr">Array of neuron activation functions.</param> /// <param name="nodeAuxArgsArr">Array of neuron activation function arguments.</param> /// <param name="connectionArr">Array of connections.</param> /// <param name="layerInfoArr">Array of layer information.</param> /// <param name="outputNodeIdxArr">An array that specifies the index of each output neuron within _activationArr. /// This is necessary because the neurons have been sorted by their depth in the network structure and are therefore /// no longer in their original positions. Note however that the bias and input neurons *are* in their original /// positions as they are defined as being at depth zero.</param> /// <param name="nodeCount">Number of nodes in the network.</param> /// <param name="inputNodeCount">Number of input nodes in the network.</param> /// <param name="outputNodeCount">Number of output nodes in the network.</param> public FastAcyclicNetwork(IActivationFunction[] nodeActivationFnArr, double[][] nodeAuxArgsArr, FastConnection[] connectionArr, LayerInfo[] layerInfoArr, int[] outputNodeIdxArr, int nodeCount, int inputNodeCount, int outputNodeCount) { // Store refs to network structrue data. _nodeActivationFnArr = nodeActivationFnArr; _nodeAuxArgsArr = nodeAuxArgsArr; _connectionArr = connectionArr; _layerInfoArr = layerInfoArr; // Create working array for node activation signals. _activationArr = new double[nodeCount]; // Wrap a sub-range of the _activationArr that holds the activation values for the input nodes. // Offset is 1 to skip bias neuron (The value at index 1 is the first black box input). _inputSignalArrayWrapper = new SignalArray(_activationArr, 1, inputNodeCount); // Wrap the output nodes. Nodes have been sorted by depth within the network therefore the output // nodes can no longer be guaranteed to be in a contiguous segment at a fixed location. As such their // positions are indicated by outputNodeIdxArr, and so we package up this array with the node signal // array to abstract away the level of indirection described by outputNodeIdxArr. _outputSignalArrayWrapper = new MappingSignalArray(_activationArr, outputNodeIdxArr); // Store counts for use during activation. _inputNodeCount = inputNodeCount; _inputAndBiasNodeCount = inputNodeCount+1; _outputNodeCount = outputNodeCount; // Initialise the bias neuron's fixed output value. _activationArr[0] = 1.0; }