/// <summary>
/// Create a NeatGenome with the given meta data, connection genes and supplementary data.
/// </summary>
/// <param name="id">Genome ID.</param>
/// <param name="birthGeneration">Birth generation.</param>
/// <param name="connGenes">Connection genes.</param>
/// <param name="hiddenNodeIdArr">An array of the hidden node IDs in the genome, in ascending order.</param>
/// <returns>A new NeatGenome instance.</returns>
public NeatGenome <T> Create(
int id, int birthGeneration,
ConnectionGenes <T> connGenes,
int[] hiddenNodeIdArr)
{
int inputCount = _metaNeatGenome.InputNodeCount;
int outputCount = _metaNeatGenome.OutputNodeCount;
int inputOutputCount = _metaNeatGenome.InputOutputNodeCount;
// Create a mapping from node IDs to node indexes.
Dictionary <int, int> nodeIdxById = BuildNodeIndexById(hiddenNodeIdArr);
// Create a DictionaryNodeIdMap.
DictionaryNodeIdMap nodeIndexByIdMap = new DictionaryNodeIdMap(inputCount, nodeIdxById);
// Create a digraph from the genome.
DirectedGraph digraph = NeatGenomeBuilderUtils.CreateDirectedGraph(
_metaNeatGenome, connGenes, nodeIndexByIdMap);
// Calc the depth of each node in the digraph.
GraphDepthInfo depthInfo = _graphDepthAnalysis.CalculateNodeDepths(digraph);
// Create a weighted acyclic digraph.
// Note. This also outputs connectionIndexMap. For each connection in the acyclic graph this gives
// the index of the same connection in the genome; this is because connections are re-ordered based
// on node depth in the acyclic graph.
AcyclicDirectedGraph acyclicDigraph = AcyclicDirectedGraphBuilderUtils.CreateAcyclicDirectedGraph(
digraph,
depthInfo,
out int[] newIdByOldId,
out int[] connectionIndexMap,
ref _timesortWorkArr,
ref _timesortWorkVArr);
// TODO: Write unit tests to cover this!
// Update nodeIdxById with the new depth based node index allocations.
// Notes.
// The current nodeIndexByIdMap maps node IDs (also know as innovation IDs in NEAT) to a compact
// ID space in which any gaps have been removed, i.e. a compacted set of IDs that can be used as indexes,
// i.e. if there are N nodes in total then the highest node ID will be N-1.
//
// Here we map the new compact IDs to an alternative ID space that is also compact, but ensures that nodeIDs
// reflect the depth of a node in the acyclic graph.
UpdateNodeIndexById(nodeIdxById, hiddenNodeIdArr, newIdByOldId);
// Create the neat genome.
return(new NeatGenome <T>(
_metaNeatGenome, id, birthGeneration,
connGenes,
hiddenNodeIdArr,
nodeIndexByIdMap,
acyclicDigraph,
connectionIndexMap));
}
/// <summary>
/// Constructs a AcyclicNeuralNet with the provided neural net definition parameters.
/// </summary>
/// <param name="digraph">Network structure definition</param>
/// <param name="activationFn">Node activation function.</param>
/// <param name="boundedOutput">Indicates that the output values at the output nodes should be bounded to the interval [0,1]</param>
public AcyclicNeuralNet(
AcyclicDirectedGraph digraph,
double[] weightArr,
VecFnSegment <double> activationFn,
bool boundedOutput)
{
// Store refs to network structure data.
_srcIdArr = digraph.ConnectionIdArrays._sourceIdArr;
_tgtIdArr = digraph.ConnectionIdArrays._targetIdArr;
_weightArr = weightArr;
_layerInfoArr = digraph.LayerArray;
// Store network activation function.
_activationFn = activationFn;
// Store input/output node counts.
_inputCount = digraph.InputCount;
_outputCount = digraph.OutputCount;
// Create working array for node activation signals.
_activationArr = new double[digraph.TotalNodeCount];
// Wrap a sub-range of the _activationArr that holds the activation values for the input nodes.
_inputVector = new VectorSegment <double>(_activationArr, 0, _inputCount);
// 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 indirection described by outputNodeIdxArr.
var outputVec = new MappingVector <double>(_activationArr, digraph.OutputNodeIdxArr);
if (boundedOutput)
{
_outputVector = new BoundedVector(outputVec);
}
else
{
_outputVector = outputVec;
}
}
