/// <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; } }