public void RunBest() { Time.timeScale = 1; NeatGenome genome = null; // Try to load the genome from the XML document. try { using (XmlReader xr = XmlReader.Create(champFileSavePath)) genome = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, (NeatGenomeFactory)experiment.CreateGenomeFactory())[0]; } catch (Exception e1) { Debug.Log(" Error loading genome from file! Loading aborted.\n" + e1.Message); return; } // Genomedecoders convert genomes to pheonomes var genomeDecoder = experiment.CreateGenomeDecoder(); // Decode into a network var phenome = genomeDecoder.Decode(genome); GameObject obj = Instantiate(Unit, transform.position, Unit.transform.rotation) as GameObject; obj.AddComponent <Creature>(); UnitController controller = obj.GetComponent <UnitController>(); ControllerMap.Add(phenome, controller); controller.Activate(phenome); }
public void RunBest() { Time.timeScale = 1; NeatGenome genome = null; // Try to load the genome from the XML document. try { using (XmlReader xr = XmlReader.Create(champFileSavePath)) genome = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, (NeatGenomeFactory)experiment.CreateGenomeFactory())[0]; } catch (Exception e1) { // print(champFileLoadPath + " Error loading genome from file!\nLoading aborted.\n" // + e1.Message + "\nJoe: " + champFileLoadPath); return; } // Get a genome decoder that can convert genomes to phenomes. var genomeDecoder = experiment.CreateGenomeDecoder(); // Decode the genome into a phenome (neural network). var phenome = genomeDecoder.Decode(genome); GameObject obj = Instantiate(Unit, Unit.transform.position, Unit.transform.rotation) as GameObject; UnitController controller = obj.GetComponent <UnitController>(); ControllerMap.Add(phenome, controller); controller.Activate(phenome); }
/// <summary> /// Refresh/update the view with the provided genome. /// </summary> public override void RefreshView(object genome) { NeatGenome neatGenome = genome as NeatGenome; if (null == neatGenome) { return; } // Decode genome. IBlackBox box = _genomeDecoder.Decode(neatGenome); // Update plot points. double x = _xMin; for (int i = 0; i < _sampleCount; i++, x += _xIncr) { box.ResetState(); box.InputSignalArray[0] = x; box.Activate(); _plotPointListResponse[i].Y = box.OutputSignalArray[0]; } // Trigger graph to redraw. zed.AxisChange(); Refresh(); }
private bool TryGetConnectionInner(NeatGenome <T> parent, out DirectedConnection conn, out int insertIdx) { int inputCount = _metaNeatGenome.InputNodeCount; int outputCount = _metaNeatGenome.OutputNodeCount; int hiddenCount = parent.HiddenNodeIdArray.Length; // Select a source node at random. // Note. this can be any node (input, output or hidden). int totalNodeCount = parent.MetaNeatGenome.InputOutputNodeCount + hiddenCount; int srcId = GetNodeIdFromIndex(parent, _rng.Next(totalNodeCount)); // Select a target node at random. // Note. This cannot be an input node (so must be a hidden or output node). int outputHiddenCount = outputCount + hiddenCount; int tgtId = GetNodeIdFromIndex(parent, inputCount + _rng.Next(outputHiddenCount)); // Test if the chosen connection already exists. // Note. Connection genes are always sorted by sourceId then targetId, so we can use a binary search to // find an existing connection in O(log(n)) time. conn = new DirectedConnection(srcId, tgtId); if ((insertIdx = Array.BinarySearch(parent.ConnectionGenes._connArr, conn)) < 0) { // The proposed new connection does not already exist, therefore we can use it. // Get the position in parent.ConnectionGeneArray that the new connection should be inserted at (to maintain sort order). insertIdx = ~insertIdx; return(true); } conn = default(DirectedConnection); insertIdx = default(int); return(false); }
public static GenomeList CreateGenomeListAddedInputs(NeatGenome seedGenome, int length, NeatParameters neatParameters, IdGenerator idGenerator) { //Build the list. GenomeList genomeList = new GenomeList(); // Use the seed directly just once. NeatGenome newGenome = new NeatGenome(seedGenome, idGenerator.NextGenomeId); //genomeList.Add(newGenome); // For the remainder we alter the weights. for (int i = 0; i < length; i++) { newGenome = new NeatGenome(seedGenome, idGenerator.NextGenomeId); // Reset the connection weights foreach (ConnectionGene connectionGene in newGenome.ConnectionGeneList) { connectionGene.Weight = (Utilities.NextDouble() * neatParameters.connectionWeightRange) - neatParameters.connectionWeightRange / 2.0; } newGenome.ConnectionGeneList.Add(new ConnectionGene(idGenerator.NextInnovationId, 5, newGenome.NeuronGeneList[Utilities.Next(newGenome.NeuronGeneList.Count - 7) + 7].InnovationId, (Utilities.NextDouble() * neatParameters.connectionWeightRange) - neatParameters.connectionWeightRange / 2.0)); newGenome.ConnectionGeneList.Add(new ConnectionGene(idGenerator.NextInnovationId, 6, newGenome.NeuronGeneList[Utilities.Next(newGenome.NeuronGeneList.Count - 7) + 7].InnovationId, (Utilities.NextDouble() * neatParameters.connectionWeightRange) - neatParameters.connectionWeightRange / 2.0)); genomeList.Add(newGenome); } // return(genomeList); }
/// <summary> /// Gets the species with a centroid closest to the given genome. /// If multiple species are equally close then we return all of the those species. /// </summary> public static List <Species <T> > GetNearestSpeciesList <T>( NeatGenome <T> genome, Species <T>[] speciesArr, IDistanceMetric <T> distanceMetric) where T : struct { var nearestSpeciesList = new List <Species <T> >(4); nearestSpeciesList.Add(speciesArr[0]); double nearestDistance = distanceMetric.CalcDistance(genome.ConnectionGenes, speciesArr[0].Centroid); for (int i = 1; i < speciesArr.Length; i++) { double distance = distanceMetric.CalcDistance(genome.ConnectionGenes, speciesArr[i].Centroid); if (distance < nearestDistance) { nearestSpeciesList.Clear(); nearestSpeciesList.Add(speciesArr[i]); nearestDistance = distance; } else if (distance == nearestDistance) { nearestSpeciesList.Add(speciesArr[i]); } } return(nearestSpeciesList); }
private static void TestGenome(IGenomeDecoder<NeatGenome, IBlackBox> decoder, NeatGenome genome) { // Decode the genome into a phenome (neural network). IBlackBox phenome = decoder.Decode(genome); List<string> lines = new List<string>(); double v = 0f; while (v < Math.PI * 2f) { phenome.ResetState(); phenome.InputSignalArray[0] = v; phenome.Activate(); double result = phenome.OutputSignalArray[0]; lines.Add(string.Format("{0}\t{1}", v, result)); v += 0.1d; } System.IO.File.WriteAllLines(@"output.csv", lines); }
/// <summary> /// /// </summary> /// <param name="doc"></param> /// <param name="genome"></param> /// <param name="activationFn">Not strictly part of a genome. But it is useful to document which function /// the genome is supposed to run against when decoded into a network.</param> public static void Write(XmlNode parentNode, NeatGenome genome, IActivationFunction activationFn) { //----- Start writing. Create document root node. XmlElement xmlGenome = XmlUtilities.AddElement(parentNode, "genome"); XmlUtilities.AddAttribute(xmlGenome, "id", genome.GenomeId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "species-id", genome.SpeciesId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "age", genome.GenomeAge.ToString()); XmlUtilities.AddAttribute(xmlGenome, "fitness", genome.Fitness.ToString("0.00")); XmlUtilities.AddAttribute(xmlGenome, "objective-fitness", genome.ObjectiveFitness.ToString("0.00")); XmlUtilities.AddAttribute(xmlGenome, "activation-fn-id", activationFn.FunctionId); //----- Write neurons. XmlElement xmlNeurons = XmlUtilities.AddElement(xmlGenome, "neurons"); foreach (NeuronGene neuronGene in genome.NeuronGeneList) { WriteNeuron(xmlNeurons, neuronGene); } //----- Write Connections. XmlElement xmlConnections = XmlUtilities.AddElement(xmlGenome, "connections"); foreach (ConnectionGene connectionGene in genome.ConnectionGeneList) { WriteConnectionGene(xmlConnections, connectionGene); } }
public static GenomeList CreateGenomeList(Population seedPopulation, int length, NeatParameters neatParameters, IdGenerator idGenerator) { //Build the list. GenomeList genomeList = new GenomeList(); int seedIdx = 0; for (int i = 0; i < length; i++) { NeatGenome newGenome = new NeatGenome((NeatGenome)seedPopulation.GenomeList[seedIdx], idGenerator.NextGenomeId); // Reset the connection weights foreach (ConnectionGene connectionGene in newGenome.ConnectionGeneList) { connectionGene.Weight = (Utilities.NextDouble() * neatParameters.connectionWeightRange) - neatParameters.connectionWeightRange / 2.0; } genomeList.Add(newGenome); if (++seedIdx >= seedPopulation.GenomeList.Count) { // Back to first genome. seedIdx = 0; } } return(genomeList); }
public void GenerateMesh(NeatGenome genome) { // Perform analysis AcyclicNetworkDepthAnalysis depthAnalysis = new AcyclicNetworkDepthAnalysis(); NetworkDepthInfo depthInfo = depthAnalysis.CalculateNodeDepths(genome); int maxDepth = depthInfo._networkDepth; int[] nodesPerDepthLevel = new int[maxDepth]; Dictionary <int, List <int> > nodesByDepth = new Dictionary <int, List <int> >(); Dictionary <uint, int> nodeIdxById = new Dictionary <uint, int>(); int mostNodesPerLayer = 0; for (int i = 0; i < genome.NodeList.Count; i++) { int depth = depthInfo._nodeDepthArr[i]; List <int> nodes; if (!nodesByDepth.TryGetValue(depth, out nodes)) { nodes = new List <int>(); nodesByDepth.Add(depth, nodes); } nodes.Add(i); mostNodesPerLayer = Mathf.Max(++nodesPerDepthLevel[depth], mostNodesPerLayer); } List <Vector3> vertices; var neuronsMesh = GenerateNeuronsMesh(genome, nodeIdxById, maxDepth, mostNodesPerLayer, nodesByDepth, out vertices); neuronObject.GetComponent <MeshFilter>().mesh = neuronsMesh; var connectionMesh = GenerateConnectionsMesh(genome, nodeIdxById, vertices); connectionObject.GetComponent <MeshFilter>().mesh = connectionMesh; }
private Mesh GenerateConnectionsMesh(NeatGenome genome, Dictionary <uint, int> nodeIdxById, List <Vector3> nodeVertices) { Mesh mesh = new Mesh(); List <Vector3> vertices = new List <Vector3>(); List <Color> colors = new List <Color>(); List <int> pointIndices = new List <int>(); // Connections int idx = 0; foreach (var connection in genome.ConnectionList) { int sourceIdx = nodeIdxById[connection.SourceNodeId]; int targetIdx = nodeIdxById[connection.TargetNodeId]; var sourcePos = nodeVertices[sourceIdx]; var targetPos = nodeVertices[targetIdx]; vertices.Add(new Vector3((float)connection.Weight, 0, 0)); colors.Add(new Color(sourcePos.x, sourcePos.y, targetPos.x, targetPos.y)); pointIndices.Add(idx++); //Debug.Log($"[{genome.Id}] {connection.SourceNodeId} - {connection.TargetNodeId}: {connection.Weight}"); } mesh.subMeshCount = 1; mesh.SetVertices(vertices); mesh.SetColors(colors); mesh.SetIndices(pointIndices.ToArray(), MeshTopology.Points, 0); return(mesh); }
public static IBlackBox LoadBrain(string filePath, INeatExperiment experiment) { NeatGenome genome = null; // Try to load the genome from the XML document. try { using (XmlReader xr = XmlReader.Create(filePath)) genome = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, (NeatGenomeFactory)experiment.CreateGenomeFactory())[0]; } catch (Exception e1) { print(filePath + " Error loading genome from file!\nLoading aborted.\n" + e1.Message + "\nJoe: " + filePath); return(null); } // Get a genome decoder that can convert genomes to phenomes. var genomeDecoder = experiment.CreateGenomeDecoder(); // Decode the genome into a phenome (neural network). var phenome = genomeDecoder.Decode(genome); return(phenome); }
private NeatGenome loadGenome(string filename) { NeatGenome genome = null; DirectoryInfo dir = new DirectoryInfo(Application.persistentDataPath + string.Format("/{0}", folder_prefix)); if (dir.Exists) { FileInfo[] info = dir.GetFiles(filename + ".xml"); print(info.Length); foreach (FileInfo f in info) { try { using (XmlReader xr = XmlReader.Create(Application.persistentDataPath + string.Format("/{0}/{1}", folder_prefix, f.Name))) genome = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, (NeatGenomeFactory)experiment.CreateGenomeFactory()) [0]; } catch (Exception e1) { print(" Error loading genome from file!\nLoading aborted.\n" + e1.Message); continue; } } // Debug.Log ("Filled map with " + map + " elites."); // } } return(genome); }
private static void Backprop(NeatGenome genome, IGenomeDecoder<NeatGenome, IBlackBox> decoder, double learningRate) { var phenome = decoder.Decode(genome); var network = (FastCyclicNetwork)phenome; network.Momentum = 0; network.BackpropLearningRate = learningRate; //Console.WriteLine("Weights Before:"); //PrintWeights(network); //Console.WriteLine(); network.Train(new double[] { 0.3, 0.3 }, new double[] { 0.9 }); Console.WriteLine("Weights:"); PrintWeights(network); Console.WriteLine(); network.Train(new double[] { 0.3, 0.3 }, new double[] { 0.9 }); Console.WriteLine("Weights:"); PrintWeights(network); Console.WriteLine(); }
private NeatGenome <double> CreateGenome1(MetaNeatGenome <double> metaNeatGenome) { var genomeBuilder = NeatGenomeBuilderFactory <double> .Create(metaNeatGenome); // Define a genome that matches the one defined in example1.genome. var connGenes = new ConnectionGenes <double>(12); connGenes[0] = (0, 5, 0.5); connGenes[1] = (0, 7, 0.7); connGenes[2] = (0, 3, 0.3); connGenes[3] = (1, 5, 1.5); connGenes[4] = (1, 7, 1.7); connGenes[5] = (1, 3, 1.3); connGenes[6] = (1, 6, 1.6); connGenes[7] = (1, 8, 1.8); connGenes[8] = (1, 4, 1.4); connGenes[9] = (2, 6, 2.6); connGenes[10] = (2, 8, 2.8); connGenes[11] = (2, 4, 2.4); // Ensure the connections are sorted correctly. connGenes.Sort(); // Wrap in a genome. NeatGenome <double> genome = genomeBuilder.Create(0, 0, connGenes); return(genome); }
public void SaveAndLoadGenome() { var metaNeatGenome = new MetaNeatGenome <double>(3, 2, true, new ReLU()); var genomeBuilder = NeatGenomeBuilderFactory <double> .Create(metaNeatGenome); // Simple acyclic graph. var connGenes = new ConnectionGenes <double>(6); connGenes[0] = (0, 3, 0.123); connGenes[1] = (1, 3, 1.234); connGenes[2] = (2, 3, -0.5835); connGenes[3] = (2, 4, 5.123456789); connGenes[4] = (2, 5, 2.5); connGenes[5] = (5, 4, 5.4); // Wrap in a genome. NeatGenome <double> genome = genomeBuilder.Create(0, 0, connGenes); // Create a memory stream to save the genome into. using (MemoryStream ms = new(1024)) { // Save the genome. NeatGenomeSaver <double> .Save(genome, ms); // Load the genome. ms.Position = 0; NeatGenomeLoader <double> loader = NeatGenomeLoaderFactory.CreateLoaderDouble(metaNeatGenome); NeatGenome <double> genomeLoaded = loader.Load(ms); // Compare the original genome with the loaded genome. IOTestUtils.CompareGenomes(genome, genomeLoaded); } }
/// <param name="activationFn">Not strictly part of a genome. But it is useful to document which function /// the genome is supposed to run against when decoded into a network.</param> public static void Write(XmlNode parentNode, NeatGenome genome, IActivationFunction activationFn) { //----- Start writing. Create document root node. XmlElement xmlGenome = XmlUtilities.AddElement(parentNode, "genome"); XmlUtilities.AddAttribute(xmlGenome, "id", genome.GenomeId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "species-id", genome.SpeciesId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "age", genome.GenomeAge.ToString()); XmlUtilities.AddAttribute(xmlGenome, "fitness", genome.Fitness.ToString("0.00")); XmlUtilities.AddAttribute(xmlGenome, "activation-fn-id", activationFn.FunctionId); //----- Write neurons. XmlElement xmlNeurons = XmlUtilities.AddElement(xmlGenome, "neurons"); foreach(NeuronGene neuronGene in genome.NeuronGeneList) WriteNeuron(xmlNeurons, neuronGene); //----- Write modules. XmlElement xmlModules = XmlUtilities.AddElement(xmlGenome, "modules"); foreach (ModuleGene moduleGene in genome.ModuleGeneList) WriteModule(xmlModules, moduleGene); //----- Write Connections. XmlElement xmlConnections = XmlUtilities.AddElement(xmlGenome, "connections"); foreach(ConnectionGene connectionGene in genome.ConnectionGeneList) WriteConnectionGene(xmlConnections, connectionGene); //----- Write beahavior if(genome.Behavior!=null) { if(genome.Behavior.behaviorList!=null) { XmlElement xmlBehavior = XmlUtilities.AddElement(xmlGenome, "behavior"); WriteBehavior(xmlBehavior,genome.Behavior); } } }
private bool TryGetConnectionInner(NeatGenome <T> parent, out DirectedConnection conn, out int insertIdx) { int inputCount = _metaNeatGenome.InputNodeCount; int outputCount = _metaNeatGenome.OutputNodeCount; int hiddenCount = parent.HiddenNodeIdArray.Length; // Select a source node at random. // Note. Valid source nodes are input and hidden nodes. Output nodes are not source node candidates // for acyclic nets, because that can prevent future connections from targeting the output if it would // create a cycle. int inputHiddenCount = inputCount + hiddenCount; int srcIdx = _rng.Next(inputHiddenCount); if (srcIdx >= inputCount) { srcIdx += outputCount; } int srcId = GetNodeIdFromIndex(parent, srcIdx); // Select a target node at random. // Note. Valid target nodes are all hidden and output nodes (cannot be an input node). int outputHiddenCount = outputCount + hiddenCount; int tgtId = GetNodeIdFromIndex(parent, inputCount + _rng.Next(outputHiddenCount));; // Test for simplest cyclic connectivity - node connects to itself. if (srcId == tgtId) { conn = default(DirectedConnection); insertIdx = default(int); return(false); } // Test if the chosen connection already exists. // Note. Connection genes are always sorted by sourceId then targetId, so we can use a binary search to // find an existing connection in O(log(n)) time. conn = new DirectedConnection(srcId, tgtId); if ((insertIdx = Array.BinarySearch(parent.ConnectionGenes._connArr, conn)) >= 0) { // The proposed new connection already exists. conn = default(DirectedConnection); insertIdx = default(int); return(false); } // Test if the connection will form a cycle in the wider network. int totalNodeCount = _metaNeatGenome.InputOutputNodeCount + hiddenCount; if (_cyclicTest.IsConnectionCyclic(parent.ConnectionGenes._connArr, parent.NodeIndexByIdMap, totalNodeCount, conn)) { conn = default(DirectedConnection); insertIdx = default(int); return(false); } // Get the position in parent.ConnectionGeneArray that the new connection should be inserted at (to maintain sort order). insertIdx = ~insertIdx; return(true); }
public void TestAddNode3() { var pop = CreateNeatPopulation(); var genomeBuilder = NeatGenomeBuilderFactory <double> .Create(pop.MetaNeatGenome); var genome = pop.GenomeList[0]; var strategy = new AddNodeStrategy <double>( pop.MetaNeatGenome, genomeBuilder, pop.GenomeIdSeq, pop.InnovationIdSeq, pop.GenerationSeq, pop.AddedNodeBuffer); IRandomSource rng = RandomDefaults.CreateRandomSource(); CircularBuffer <NeatGenome <double> > genomeRing = new CircularBuffer <NeatGenome <double> >(10); genomeRing.Enqueue(genome); for (int i = 0; i < 5000; i++) { NeatGenome <double> childGenome = CreateAndTestChildGenome(genome, strategy, rng); // Add the new child genome to the ring. genomeRing.Enqueue(childGenome); // Take the genome at the tail of the ring for the next parent. genome = genomeRing[0]; } }
public void calcFitness(string genomeFile, int type) { XmlDocument doc = new XmlDocument(); doc.Load(genomeFile); NeatGenome genome = XmlNeatGenomeReaderStatic.Read(doc); INetworkEvaluator eval; if (type == 0) { eval = new CTRNNNetworkEvaluator(4, 12, 12); } else if (type == 1) { eval = new SUPGNetworkEvaluator(4, 12, 12); } else { doClune = true; eval = new CluneNetworkEvaluator(20, 20, 20); } var tempNet = genome.Decode(null); MessageBox.Show(eval.threadSafeEvaluateNetwork(tempNet)[0].ToString()); }
private void RedrawGraph(NeatGenome genome) { IBlackBox box = _experiment.GetBlackBox(genome); Color trueColor = panPlot.TrueColor; Color falseColor = panPlot.FalseColor; var samples = Enumerable.Range(0, 1000). Select(o => { Vector3D pos = Math3D.GetRandomVector(new Vector3D(0, 0, 0), new Vector3D(1, 1, 1)); box.ResetState(); //box.InputSignalArray.CopyFrom() box.InputSignalArray[0] = pos.X; box.InputSignalArray[1] = pos.Y; box.InputSignalArray[2] = pos.Z; box.Activate(); double percent = box.OutputSignalArray[0]; Color color = UtilityWPF.AlphaBlend(trueColor, falseColor, percent); return(Tuple.Create(pos.ToPoint(), color)); }); panPlot.ClearFrame(); panPlot.AddDots(samples, .01, false); }
/// <summary> /// Determine the set of hidden node IDs that have been deleted as a result of a connection deletion. /// I.e. a node only exists if a connection connects to it, therefore if there are no other connections /// referring to a node then it has been deleted, with the exception of input and output nodes that /// always exist. /// </summary> private static (int?, int?) GetDeletedNodeIds( NeatGenome <T> parent, int deleteIdx, DirectedConnection[] childConnArr) { // Get the two node IDs referred to by the deleted connection. int?nodeId1 = parent.ConnectionGenes._connArr[deleteIdx].SourceId; int?nodeId2 = parent.ConnectionGenes._connArr[deleteIdx].TargetId; // Set IDs to null for input/output nodes (these nodes are fixed and therefore cannot be deleted). // Also, for cyclic networks nodeId1 and 2 could refer to the same node (a cyclic connection on the same node), if // so then we don't need to set nodeId2. if (nodeId1.Value < parent.MetaNeatGenome.InputOutputNodeCount) { nodeId1 = null; } if (nodeId2.Value < parent.MetaNeatGenome.InputOutputNodeCount || nodeId1 == nodeId2) { nodeId2 = null; } if (!nodeId1.HasValue && !nodeId2.HasValue) { return(null, null); } if (!nodeId1.HasValue) { // 'Shuffle up' nodeId2 into nodeId1. nodeId1 = nodeId2; nodeId2 = null; } if (!nodeId2.HasValue) { if (!IsNodeConnectedTo(childConnArr, nodeId1 !.Value)) { return(nodeId1.Value, null); } return(null, null); } (bool, bool)isConnectedTuple = AreNodesConnectedTo(childConnArr, nodeId1 !.Value, nodeId2.Value); if (!isConnectedTuple.Item1 && !isConnectedTuple.Item2) { return(nodeId1.Value, nodeId2.Value); } if (!isConnectedTuple.Item1) { return(nodeId1.Value, null); } if (!isConnectedTuple.Item2) { return(nodeId2.Value, null); } return(null, null); }
public void SetBrain(INetwork network, bool useSUPG = false, NeatGenome genome = null, INetwork cppn = null, int[] triggerMap = null) { if (useSUPG) { supgOutputs = new float[network.TotalNeuronCount /*- (network.InputNeuronCount + network.OutputNeuronCount)*/, wavelength]; // need at least as many rows as the number of hidden neurons // set all supgOutputs to min value to signal they have not been cached yet for (int i = 0; i < network.TotalNeuronCount /*- (network.InputNeuronCount + network.OutputNeuronCount)*/; i++) { for (int j = 0; j < wavelength; j++) { supgOutputs[i, j] = float.MinValue; } } } this.network = network; this.useSUPG = useSUPG; this.genome = genome; this.cppn = cppn; this.triggerMap = triggerMap; bool[] useSUPGArray = new bool[genome.NeuronGeneList.Count]; useSUPGArray[7] = true; useSUPGArray[8] = true; if (useSUPG) { ((FloatFastConcurrentNetwork)network).UseSUPG = false; ((FloatFastConcurrentNetwork)network).useSUPGArray = useSUPGArray; } brain = network; }
public RobotIndividual(Robot robot, Individual[] parents) { Robot = robot; Genome = robot.Genome; Parents = parents; _distanceMetric = new EuclideanDistanceMetric(); }
private NeatGenome <T> CreateGenomeInner( NeatGenome <T> parent1, NeatGenome <T> parent2, IRandomSource rng) { // Resolve a flag that determines if *all* disjoint genes from the secondary parent will be included in the child genome, or not. // This approach is from SharpNEAT v2.x and is preserved to act as baseline in v4.x, but better strategies may exist. bool includeSecondaryParentGene = DiscreteDistribution.SampleBernoulli(rng, _secondaryParentGeneProbability); // Enumerate over the connection genes in both parents. foreach (var geneIndexPair in EnumerateParentGenes(parent1.ConnectionGenes, parent2.ConnectionGenes)) { // Create a connection gene based on the current position in both parents. ConnectionGene <T>?connGene = CreateConnectionGene( parent1.ConnectionGenes, parent2.ConnectionGenes, geneIndexPair.Item1, geneIndexPair.Item2, includeSecondaryParentGene, rng); if (connGene.HasValue) { // Attempt to add the gene to the child genome we are building. _connGeneListBuilder.TryAddGene(connGene.Value); } } // Convert the genes to the structure required by NeatGenome. ConnectionGenes <T> connGenes = _connGeneListBuilder.ToConnectionGenes(); // Create and return a new genome. return(_genomeBuilder.Create( _genomeIdSeq.Next(), _generationSeq.Peek, connGenes)); }
/// <summary> /// Create a new child genome from a given parent genome. /// </summary> /// <param name="parent">The parent genome.</param> /// <param name="rng">Random source.</param> /// <returns>A new child genome.</returns> public NeatGenome <T> CreateChildGenome(NeatGenome <T> parent, IRandomSource rng) { // Clone the parent's connection weight array. var weightArr = (T[])parent.ConnectionGenes._weightArr.Clone(); // Apply mutation to the connection weights. _weightMutationScheme.MutateWeights(weightArr, rng); // Create the child genome's ConnectionGenes object. // Note. The parent genome's connection arrays are re-used; these remain unchanged because we are mutating // connection *weights* only, so we can avoid the cost of cloning these arrays. var connGenes = new ConnectionGenes <T>( parent.ConnectionGenes._connArr, weightArr); // Create and return a new genome. // Note. The parent's ConnectionIndexArray and HiddenNodeIdArray can be re-used here because the new genome // has the same set of connections (same neural net structure). return(_genomeBuilder.Create( _genomeIdSeq.Next(), _generationSeq.Peek, connGenes, parent.HiddenNodeIdArray, parent.NodeIndexByIdMap, parent.DirectedGraph, parent.ConnectionIndexMap)); }
/// <summary> /// Create and return a NeatEvolutionAlgorithm with a single seed genome. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(NeatGenome seed) { // Create evolution algorithm. return(CreateEvolutionAlgorithm(_populationSize, seed.BirthGeneration, new List <NeatGenome> { seed })); }
/// <summary> /// Creates an instance of the current champion /// </summary> public void RunBest() { champRunning = true; NeatGenome genome = LoadChampion(); // Get a genome decoder that can convert genomes to phenomes. var genomeDecoder = experiment.CreateGenomeDecoder(); // Decode the genome into a phenome (neural network). var phenome = genomeDecoder.Decode(genome); InstantiateCandidate(phenome); GameObject bestInstance = ControllerMap[phenome].gameObject; // Special tag so we can selectively actuate on these units. bestInstance.tag = "BestUnit"; // Also removes the tag from child components (but no granchildren. This // is currently ok since these elements have no coliders and champions // are destroyed before entering evolution). // These cannot use "BestUnit" or we will be in trouble when we destroy // the unit! foreach (Transform child in bestInstance.transform) { child.gameObject.tag = "Untagged"; } // This is called if we want the champions to be evaluated, mostly for // research reasons. if (false) { Coroutiner.StartCoroutine(EvaluateChamp(phenome)); } }
private void saveBestGenomeToolStripMenuItem_Click(object sender, EventArgs e) { // Get the current best genome. NeatGenome <double> bestGenome = _neatPop?.BestGenome; if (bestGenome is null) { return; } // Ask the user to select a file path and name to save to. string filepath = SelectFileToSave("Save best genome", "genome", "(*.genome)|*.genome"); if (string.IsNullOrEmpty(filepath)) { return; } // Save the genome. try { NeatGenomeSaver <double> .Save(bestGenome, filepath); } catch (Exception ex) { __log.ErrorFormat("Error saving genome; [{0}]", ex.Message); } }
/// <summary> /// Load a population from a zip archive file containing one or more genome file entries (with a .genome file extension). /// </summary> /// <param name="path">Path to the zip file to load.</param> /// <returns>A list of the loaded genomes.</returns> public List <NeatGenome <T> > LoadFromZipArchive(string path) { if (!File.Exists(path)) { throw new IOException($"File does not exist [{path}]"); } using (ZipArchive zipArchive = ZipFile.OpenRead(path)) { // Alloc genome list with an appropriate capacity. List <NeatGenome <T> > genomeList = new List <NeatGenome <T> >(zipArchive.Entries.Count); // Loop the genome file entries, loading each in turn. foreach (ZipArchiveEntry zipEntry in zipArchive.Entries) { // Skip non-genome files. if (Path.GetExtension(zipEntry.Name) != ".genome") { continue; } using (Stream zipEntryStream = zipEntry.Open()) { NeatGenome <T> genome = _genomeLoader.Load(zipEntryStream); genomeList.Add(genome); } } return(genomeList); } }
void Update () { if (Input.GetKey(KeyCode.Space) || Input.GetKeyDown(KeyCode.UpArrow)) { currentGenome = evolutionHelper.MutateGenome(currentGenome); //Debug.Log("Current generation: " + currentGenome.BirthGeneration); //var byteCount = System.Text.ASCIIEncoding.ASCII.GetByteCount(NeatGenomeXmlIO.Save(currentGenome, true).OuterXml); //Debug.LogWarning("Byte count: " + byteCount); var phenome = genomeDecoder.Decode(currentGenome); Mesh mesh = ArtefactEvaluator.Evaluate(phenome, m_voxelVolume, out evaluationInfo); mesh.RecalculateNormals(); //The diffuse shader wants uvs so just fill with a empty array, they're not actually used mesh.uv = new Vector2[mesh.vertices.Length]; // destroy mesh object to free up memory GameObject.DestroyImmediate(m_meshGameObject.GetComponent<MeshFilter>().mesh); m_meshGameObject.GetComponent<MeshFilter>().mesh = mesh; //m_meshGameObject.GetComponent<Renderer>().material.color = ArtefactEvaluator.artefactColor; SaveGenome(); } }
/// <summary> /// Refresh/update the view with the provided genome. /// </summary> public override void RefreshView(object genome) { NeatGenome neatGenome = genome as NeatGenome; if (null == neatGenome) { return; } // Decode genome. IBlackBox box = _genomeDecoder.Decode(neatGenome); // Probe the black box. _blackBoxProbe.Probe(box, _yArrTarget); // Update plot points. double[] xArr = _paramSamplingInfo._xArr; for (int i = 0; i < xArr.Length; i++) { if (!_generativeMode) { box.ResetState(); box.InputSignalArray[0] = xArr[i]; } box.Activate(); _plotPointListResponse[i].Y = _yArrTarget[i]; } // Trigger graph to redraw. zed.AxisChange(); Refresh(); }
private NeatGenome <T> CreateGenomeInner(NeatGenome <T> parent1, NeatGenome <T> parent2) { // Randomly select one parent as being the primary parent. if (_rng.NextBool()) { VariableUtils.Swap(ref parent1, ref parent2); } // Enumerate over the connection genes in both parents. foreach (var geneIndexPair in EnumerateParentGenes(parent1.ConnectionGenes, parent2.ConnectionGenes)) { // Create a connection gene based on the current position in both parents. ConnectionGene <T>?connGene = CreateConnectionGene( parent1.ConnectionGenes, parent2.ConnectionGenes, geneIndexPair.Item1, geneIndexPair.Item2, out bool isSecondaryGene); if (connGene.HasValue) { // Attempt to add the gene to the child genome we are building. _builder.TryAddGene(connGene.Value, isSecondaryGene); } } // Convert the genes to the structure required by NeatGenome. var connGenes = _builder.ToConnectionGenes(); // Create and return a new genome. return(_genomeBuilder.Create( _genomeIdSeq.Next(), _generationSeq.Peek, connGenes)); }
/** * Assigns an AI brain to this player. This is used when * loading a brain from an existing neural network xml champion file. */ public AIFighter getFighterBrain() { //try to load a champion file. If any issues, use default AI. try { // Initialise log4net (log to console). XmlConfigurator.Configure(new FileInfo("log4net.properties")); // Experiment classes encapsulate much of the nuts and bolts of setting up a NEAT search. AIExperiment experiment = new AIExperiment(new AIFighterEvaluatorFactory()); // Load config XML. XmlDocument xmlConfig = new XmlDocument(); xmlConfig.Load("ai.config.xml"); experiment.Initialize("AI", xmlConfig.DocumentElement); // assign genome decoder for reading champion files IGenomeDecoder <NeatGenome, IBlackBox> decoder = experiment.CreateGenomeDecoder(); //load existing champion file into a genome string championFileLocation = "coevolution_champion.xml"; XmlReader xr = XmlReader.Create(championFileLocation); NeatGenome genome = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false)[0]; //decode genome into a usable AIFighter brain. return(new AIFighter(decoder.Decode(genome))); } catch (System.Exception e) { Debug.Log("Unable to load CHAMPION xml file. It may not exist.\n" + e); return(null); } }
public void CacheChampion(NeatGenome championGenome) { _championGenomeMemoryStream.SetLength(0); using (var xmlWriter = XmlWriter.Create(_championGenomeMemoryStream, _xmlWriterSettings)) { _neatExperiment.SavePopulation(xmlWriter, new List<NeatGenome> { championGenome }); } }
/// <summary> /// Writes a single NeatGenome to XML within a containing 'Root' element and the activation function /// library that the genome is associated with. /// The XML is returned as a newly created XmlDocument. /// </summary> /// <param name="genome">The genome to save.</param> /// <param name="nodeFnIds">Indicates if node activation function IDs should be emitted. They are required /// for HyperNEAT genomes but not for NEAT.</param> public static XmlDocument SaveComplete(NeatGenome genome, bool nodeFnIds) { XmlDocument doc = new XmlDocument(); using(XmlWriter xw = doc.CreateNavigator().AppendChild()) { WriteComplete(xw, genome, nodeFnIds); } return doc; }
public static NeatGenome Read(XmlElement xmlGenome) { int inputNeuronCount=0; int outputNeuronCount=0; uint id = uint.Parse(XmlUtilities.GetAttributeValue(xmlGenome, "id")); //--- Read neuron genes into a list. NeuronGeneList neuronGeneList = new NeuronGeneList(); XmlNodeList listNeuronGenes = xmlGenome.SelectNodes("neurons/neuron"); foreach(XmlElement xmlNeuronGene in listNeuronGenes) { NeuronGene neuronGene = ReadNeuronGene(xmlNeuronGene); // Count the input and output neurons as we go. switch(neuronGene.NeuronType) { case NeuronType.Input: inputNeuronCount++; break; case NeuronType.Output: outputNeuronCount++; break; } neuronGeneList.Add(neuronGene); } //--- Read module genes into a list. List<ModuleGene> moduleGeneList = new List<ModuleGene>(); XmlNodeList listModuleGenes = xmlGenome.SelectNodes("modules/module"); foreach (XmlElement xmlModuleGene in listModuleGenes) { moduleGeneList.Add(ReadModuleGene(xmlModuleGene)); } //--- Read connection genes into a list. ConnectionGeneList connectionGeneList = new ConnectionGeneList(); XmlNodeList listConnectionGenes = xmlGenome.SelectNodes("connections/connection"); foreach(XmlElement xmlConnectionGene in listConnectionGenes) connectionGeneList.Add(ReadConnectionGene(xmlConnectionGene)); //return new NeatGenome(id, neuronGeneList, connectionGeneList, inputNeuronCount, outputNeuronCount); NeatGenome g = new NeatGenome(id, neuronGeneList, moduleGeneList, connectionGeneList, inputNeuronCount, outputNeuronCount); g.Behavior = ReadBehavior(xmlGenome.SelectSingleNode("behavior")); g.Behavior.objectives = new double[6]; g.objectives = new double[6]; // JUSTIN: Read grid/trajectory info g.GridCoords = ReadGrid(xmlGenome.SelectSingleNode("grid")); g.Behavior.trajectory = ReadTrajectory(xmlGenome.SelectSingleNode("trajectory")); return g; }
/// <summary> /// For saving and vizualization, we somtimes need to change the genome /// BackProp for instance, happens on the phenotype and so if we want to see/save those changes /// we need to send the data back to NeatGenome /// </summary> /// <param name="genomeToWrite">The genome whose weights are being changed</param> /// <param name="connections">we set the genome's weights to the weights of these connections</param> /// <returns></returns> public static NeatGenome ChangeGenomeWeights(NeatGenome genomeToWrite, FastConnection[] connections) { IConnectionList connectionList = genomeToWrite.ConnectionList; int connectionCount = connectionList.Count; for (int i = 0; i < connectionCount; i++) { genomeToWrite.ConnectionGeneList[i].Weight = connections[i]._weight; } return genomeToWrite; }
public static void Write(XmlNode parentNode, NeatGenome genome) { //----- Start writing. Create document root node. XmlElement xmlGenome = XmlUtilities.AddElement(parentNode, "genome"); XmlUtilities.AddAttribute(xmlGenome, "id", genome.GenomeId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "species-id", genome.SpeciesId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "age", genome.GenomeAge.ToString()); XmlUtilities.AddAttribute(xmlGenome, "fitness", genome.Fitness.ToString("0.00")); XmlUtilities.AddAttribute(xmlGenome, "realfitness", genome.RealFitness.ToString("0.00")); XmlUtilities.AddAttribute(xmlGenome, "adaptable", genome.networkAdaptable.ToString()); XmlUtilities.AddAttribute(xmlGenome, "modulated", genome.networkModulatory.ToString()); //----- Write neurons. XmlElement xmlNeurons = XmlUtilities.AddElement(xmlGenome, "neurons"); foreach (NeuronGene neuronGene in genome.NeuronGeneList) WriteNeuron(xmlNeurons, neuronGene); //----- Write modules. XmlElement xmlModules = XmlUtilities.AddElement(xmlGenome, "modules"); foreach (ModuleGene moduleGene in genome.ModuleGeneList) WriteModule(xmlModules, moduleGene); //----- Write connections. XmlElement xmlConnections = XmlUtilities.AddElement(xmlGenome, "connections"); foreach(ConnectionGene connectionGene in genome.ConnectionGeneList) WriteConnectionGene(xmlConnections, connectionGene); //----- Write beahavior if(genome.Behavior!=null) { if(genome.Behavior.behaviorList!=null) { XmlElement xmlBehavior = XmlUtilities.AddElement(xmlGenome, "behavior"); WriteBehavior(xmlBehavior,genome.objectives,genome.Behavior); } } //----- JUSTIN: Write grid coords if (genome.GridCoords != null) { XmlElement xmlGridCoords = XmlUtilities.AddElement(xmlGenome, "grid"); WriteGridCoords(xmlGridCoords, genome.GridCoords); } //----- JUSTIN: Write trajectory if (genome.Behavior.trajectory != null && genome.Behavior.trajectory.Count > 0) { XmlElement xmlTrajectory = XmlUtilities.AddElement(xmlGenome, "trajectory"); WriteTrajectory(xmlTrajectory, genome.Behavior.trajectory); } }
/// <summary> /// Serializes a NEAT genome into a string. /// </summary> /// <param name="neatGenome">The NEAT genome object to serialize.</param> /// <returns>The serialized NEAT genome string.</returns> public static string GetGenomeXml(NeatGenome neatGenome) { // Create a new string writer into which to write the genome XML StringWriter genomeStringWriter = new StringWriter(); // Serialize the genome to XML, but write it into a string writer instead of outputting to a file if (neatGenome != null) { using (XmlTextWriter genomeTextWriter = new XmlTextWriter(genomeStringWriter)) { WriteComplete(genomeTextWriter, neatGenome, false); } } // Convert to a string representation and return return genomeStringWriter.ToString(); }
void Start () { evolutionHelper = new EvolutionHelper(k_numberOfInputs, k_numberOfOutputs); currentGenome = evolutionHelper.CreateInitialGenome(); genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateAcyclicScheme()); ArtefactEvaluator.DefaultInputType = InputType; SaveGenome(); Sine.__DefaultInstance.Curve = sineCurve; m_meshGameObject = new GameObject("Mesh"); m_meshGameObject.AddComponent<MeshFilter>(); m_meshGameObject.AddComponent<MeshRenderer>(); m_meshGameObject.AddComponent<ProceduralMesh>(); m_meshGameObject.GetComponent<Renderer>().material = standardMaterial; Camera.main.GetComponent<CameraMouseOrbit>().target = m_meshGameObject.transform; }
void CreateMesh(NeatGenome genome, GameObject attachedGameObject) { var phenome = genomeDecoder.Decode(genome); Mesh mesh = ArtefactEvaluator.Evaluate(phenome, m_voxelVolume, out evaluationInfo); mesh.RecalculateNormals(); //The diffuse shader wants uvs so just fill with a empty array, they're not actually used mesh.uv = new Vector2[mesh.vertices.Length]; // destroy mesh object to free up memory GameObject.DestroyImmediate(attachedGameObject.GetComponent<MeshFilter>().mesh); attachedGameObject.GetComponent<MeshFilter>().mesh = mesh; var meshCollider = attachedGameObject.GetComponent<MeshCollider>(); if (meshCollider != null) Destroy(meshCollider); attachedGameObject.AddComponent<MeshCollider>(); }
public static void Write(XmlNode parentNode, NeatGenome genome) { //----- Start writing. Create document root node. XmlElement xmlGenome = XmlUtilities.AddElement(parentNode, "genome"); XmlUtilities.AddAttribute(xmlGenome, "id", genome.GenomeId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "species-id", genome.SpeciesId.ToString()); XmlUtilities.AddAttribute(xmlGenome, "age", genome.GenomeAge.ToString()); XmlUtilities.AddAttribute(xmlGenome, "fitness", genome.Fitness.ToString("0.00")); XmlUtilities.AddAttribute(xmlGenome, "realfitness", genome.RealFitness.ToString("0.00")); XmlUtilities.AddAttribute(xmlGenome, "adaptable", genome.networkAdaptable.ToString()); XmlUtilities.AddAttribute(xmlGenome, "modulated", genome.networkModulatory.ToString()); // Schrum: Extra properties necessary for multimodal networks to make sense XmlUtilities.AddAttribute(xmlGenome, "outputsperpolicy", genome.OutputsPerPolicy.ToString()); //----- Write neurons. XmlElement xmlNeurons = XmlUtilities.AddElement(xmlGenome, "neurons"); foreach (NeuronGene neuronGene in genome.NeuronGeneList) WriteNeuron(xmlNeurons, neuronGene); //----- Write modules. XmlElement xmlModules = XmlUtilities.AddElement(xmlGenome, "modules"); foreach (ModuleGene moduleGene in genome.ModuleGeneList) WriteModule(xmlModules, moduleGene); //----- Write connections. XmlElement xmlConnections = XmlUtilities.AddElement(xmlGenome, "connections"); foreach(ConnectionGene connectionGene in genome.ConnectionGeneList) WriteConnectionGene(xmlConnections, connectionGene); //----- Write beahavior if(genome.Behavior!=null) { if(genome.Behavior.behaviorList!=null) { XmlElement xmlBehavior = XmlUtilities.AddElement(xmlGenome, "behavior"); WriteBehavior(xmlBehavior,genome.Behavior); } } }
private static void BackpropEpochs(NeatGenome genome, IGenomeDecoder<NeatGenome, IBlackBox> decoder, double learningRate, int epochs) { var phenome = decoder.Decode(genome); var network = (FastCyclicNetwork)phenome; network.Momentum = 0; network.BackpropLearningRate = learningRate; //Console.WriteLine("Weights Before:"); //PrintWeights(network); //Console.WriteLine(); //double[][] inputs = TrainXOR(epochs, network); for(int i = 0; i < epochs; i++) network.Train(new double[] { 0.3, 0.3 }, new double[] { 0.9 }); Console.WriteLine("Weights After:"); PrintWeights(network); Console.WriteLine(); //RunXor(network, inputs); }
/// <summary> /// Add a ConnectionGene to the builder, but only if the connection is not already present (as determined by it's neuron ID endpoints). /// </summary> /// <param name="connectionGene">The connection to add.</param> /// <param name="parentGenome">The conenction's parent genome. This is used to obtain NeuronGene(s) for the connection endpoints.</param> /// <param name="overwriteExisting">A flag that indicates if this connection should take precedence oevr an existing connection with /// the same endpoints.</param> public void TryAddGene(ConnectionGene connectionGene, NeatGenome parentGenome, bool overwriteExisting) { // Check if a matching gene has already been added. ConnectionEndpointsStruct connectionKey = new ConnectionEndpointsStruct(connectionGene.SourceNodeId, connectionGene.TargetNodeId); ConnectionGene existingConnectionGene; if(!_connectionGeneDictionary.TryGetValue(connectionKey, out existingConnectionGene)) { // Add new connection gene. ConnectionGene connectionGeneCopy = new ConnectionGene(connectionGene); _connectionGeneDictionary.Add(connectionKey, connectionGeneCopy); // Insert connection gene into a list. Use more efficient approach (append to end) if we know the gene belongs at the end. if(connectionGeneCopy.InnovationId > _highestConnectionGeneId) { _connectionGeneList.Add(connectionGeneCopy); _highestConnectionGeneId = connectionGeneCopy.InnovationId; } else { _connectionGeneList.InsertIntoPosition(connectionGeneCopy); } // Add neuron genes (if not already added). // Source neuron. NeuronGene srcNeuronGene; if(!_neuronDictionary.TryGetValue(connectionGene.SourceNodeId, out srcNeuronGene)) { srcNeuronGene = parentGenome.NeuronGeneList.GetNeuronById(connectionGene.SourceNodeId); srcNeuronGene = new NeuronGene(srcNeuronGene, false); // Make a copy. _neuronDictionary.Add(srcNeuronGene.Id, srcNeuronGene); } // Target neuron. NeuronGene tgtNeuronGene; if(!_neuronDictionary.TryGetValue(connectionGene.TargetNodeId, out tgtNeuronGene)) { tgtNeuronGene = parentGenome.NeuronGeneList.GetNeuronById(connectionGene.TargetNodeId); tgtNeuronGene = new NeuronGene(tgtNeuronGene, false); // Make a copy. _neuronDictionary.Add(tgtNeuronGene.Id, tgtNeuronGene); } // Register connectivity with each neuron. srcNeuronGene.TargetNeurons.Add(tgtNeuronGene.Id); tgtNeuronGene.SourceNeurons.Add(srcNeuronGene.Id); } else if(overwriteExisting) { // The genome we are building already has a connection with the same neuron endpoints as the one we are // trying to add. It didn't match up during correlation because it has a different innovation number, this // is possible because the innovation history buffers throw away old innovations in a FIFO manner in order // to prevent them from bloating. // Here the 'overwriteExisting' flag is set so the gene we are currently trying to add is probably from the // fitter parent, and therefore we want to use its connection weight in place of the existing gene's weight. existingConnectionGene.Weight = connectionGene.Weight; } }
void SpawnParentAndSeeds(NeatGenome parent) { CreateMesh(parent, parentGameObject); seeds.Clear(); for (int i = 0; i < numberOfChildren; i++) { var child = evolutionHelper.MutateGenome(parent); seeds.Add(child); CreateMesh(child, seedsGameObjects[i]); } }
/// <summary> /// Writes a NeatGenome to XML. /// </summary> /// <param name="xw">XmlWriter to write XML to.</param> /// <param name="genome">Genome to write as XML.</param> /// <param name="nodeFnIds">Indicates if node activation function IDs should be emitted. They are required /// for HyperNEAT genomes but not for NEAT.</param> public static void Write(XmlWriter xw, NeatGenome genome, bool nodeFnIds) { xw.WriteStartElement(__ElemNetwork); xw.WriteAttributeString(__AttrId, genome.Id.ToString(NumberFormatInfo.InvariantInfo)); xw.WriteAttributeString(__AttrBirthGeneration, genome.BirthGeneration.ToString(NumberFormatInfo.InvariantInfo)); xw.WriteAttributeString(__AttrFitness, genome.EvaluationInfo.Fitness.ToString("R", NumberFormatInfo.InvariantInfo)); // Emit nodes. StringBuilder sb = new StringBuilder(); xw.WriteStartElement(__ElemNodes); foreach(NeuronGene nGene in genome.NeuronGeneList) { xw.WriteStartElement(__ElemNode); xw.WriteAttributeString(__AttrType, NetworkXmlIO.GetNodeTypeString(nGene.NodeType)); xw.WriteAttributeString(__AttrId, nGene.Id.ToString(NumberFormatInfo.InvariantInfo)); if(nodeFnIds) { // Write activation fn ID. xw.WriteAttributeString(__AttrActivationFunctionId, nGene.ActivationFnId.ToString(NumberFormatInfo.InvariantInfo)); // Write aux state as comma separated list of real values. XmlIoUtils.WriteAttributeString(xw, __AttrAuxState, nGene.AuxState); } xw.WriteEndElement(); } xw.WriteEndElement(); // Emit connections. xw.WriteStartElement(__ElemConnections); foreach(ConnectionGene cGene in genome.ConnectionList) { xw.WriteStartElement(__ElemConnection); xw.WriteAttributeString(__AttrId, cGene.InnovationId.ToString(NumberFormatInfo.InvariantInfo)); xw.WriteAttributeString(__AttrSourceId, cGene.SourceNodeId.ToString(NumberFormatInfo.InvariantInfo)); xw.WriteAttributeString(__AttrTargetId, cGene.TargetNodeId.ToString(NumberFormatInfo.InvariantInfo)); xw.WriteAttributeString(__AttrWeight, cGene.Weight.ToString("R", NumberFormatInfo.InvariantInfo)); xw.WriteEndElement(); } xw.WriteEndElement(); // </Network> xw.WriteEndElement(); }
/// <summary> /// Refresh/update the view with the provided genome. /// </summary> public override void RefreshView(object genome) { _box = null; _neatGenome = genome as NeatGenome; if(null == _neatGenome) { return; } // Decode genome. _box = _genomeDecoder.Decode(_neatGenome); // Generate new test case. _testCaseField.InitTestCase(_largeBoxTestCase++ % 3); // Paint test case and network response. PaintView(_box); }
/// <summary> /// Writes a single NeatGenome to XML within a containing 'Root' element and the activation /// function library that the genome is associated with. /// </summary> /// <param name="xw">XmlWriter to write XML to.</param> /// <param name="genome">Genome to write as XML.</param> /// <param name="nodeFnIds">Indicates if node activation function IDs should be emitted. They are required /// for HyperNEAT genomes but not for NEAT.</param> public static void WriteComplete(XmlWriter xw, NeatGenome genome, bool nodeFnIds) { // <Root> xw.WriteStartElement(__ElemRoot); // Write activation function library. NetworkXmlIO.Write(xw, genome.ActivationFnLibrary); // <Networks> xw.WriteStartElement(__ElemNetworks); // Write single genome. Write(xw, genome, nodeFnIds); // </Networks> xw.WriteEndElement(); // </Root> xw.WriteEndElement(); }
public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(NeatGenome seed, IGenomeListEvaluator<NeatGenome> eval = null) { // Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes. IGenomeFactory<NeatGenome> genomeFactory = CreateGenomeFactory(); // Create an initial population of randomly generated genomes. List<NeatGenome> genomeList = genomeFactory.CreateGenomeList(_populationSize, 0, seed); return CreateEvolutionAlgorithm(genomeFactory, genomeList, eval); }
public static void WriteNeatGenome(string serializedGenomePath, NeatGenome genomeToWrite) { // Create a reader for the serialized genome XmlWriter writer = XmlWriter.Create(serializedGenomePath); NeatGenomeXmlIO.WriteComplete(writer, genomeToWrite, true); writer.Close(); }
public NeatGenome MutateGenome(NeatGenome genome) { return genome.CreateOffspring(genome.BirthGeneration + 1); }