/// <summary> /// Create a new instance of <see cref="NeatEvolutionAlgorithm{T}"/> for the given neat experiment, and neat population. /// </summary> /// <param name="neatExperiment">A neat experiment instance; this conveys everything required to create a new evolution algorithm instance that is ready to be run.</param> /// <param name="neatPop">A pre constructed/loaded neat population; this must be compatible with the provided neat experiment, otherwise an exception will be thrown.</param> /// <returns>A new instance of <see cref="NeatEvolutionAlgorithm{T}"/>.</returns> public static NeatEvolutionAlgorithm <double> CreateNeatEvolutionAlgorithm( INeatExperiment <double> neatExperiment, NeatPopulation <double> neatPop) { // Validate MetaNeatGenome and NeatExperiment are compatible; normally the former should have been created based on the latter, but this is not enforced. MetaNeatGenome <double> metaNeatGenome = neatPop.MetaNeatGenome; ValidateCompatible(neatExperiment, metaNeatGenome); // Create a genomeList evaluator based on the experiment's configuration settings. var genomeListEvaluator = CreateGenomeListEvaluator(neatExperiment); // Create a speciation strategy based on the experiment's configuration settings. var speciationStrategy = CreateSpeciationStrategy(neatExperiment); // Create an instance of the default connection weight mutation scheme. var weightMutationScheme = WeightMutationSchemeFactory.CreateDefaultScheme(neatExperiment.ConnectionWeightScale); // Pull all of the parts together into an evolution algorithm instance. var ea = new NeatEvolutionAlgorithm <double>( neatExperiment.NeatEvolutionAlgorithmSettings, genomeListEvaluator, speciationStrategy, neatPop, neatExperiment.ComplexityRegulationStrategy, neatExperiment.ReproductionAsexualSettings, neatExperiment.ReproductionSexualSettings, weightMutationScheme); return(ea); }
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); } }
public void SaveGenome_FrenchLocale() { // Store the current/default culture info. Thread currentThread = Thread.CurrentThread; CultureInfo defaultCulture = currentThread.CurrentCulture; // Change the default culture to French (which uses e.g. a comma as a decimal separator). CultureInfo frenchCulture = new("fr-FR"); Thread.CurrentThread.CurrentCulture = frenchCulture; try { // Manually build a genome. var metaNeatGenome = new MetaNeatGenome <double>(3, 2, true, new ReLU()); NeatGenome <double> genomeBuilt = CreateGenome1(metaNeatGenome); // Save the genome into a MemoryStream. using MemoryStream ms = new(); NeatGenomeSaver <double> .Save(genomeBuilt, ms); // Load the saved genome. ms.Position = 0; NeatGenomeLoader <double> loader = NeatGenomeLoaderFactory.CreateLoaderDouble(metaNeatGenome); NeatGenome <double> genomeLoaded = loader.Load(ms); // Compare the original genome with the loaded one. IOTestUtils.CompareGenomes(genomeLoaded, genomeBuilt); } finally { // Restore the current thread's default culture; otherwise we may break other unit tests that use this thread. Thread.CurrentThread.CurrentCulture = defaultCulture; } }
private static NeatPopulation <double> CreateNeatPopulation( int count, double defaultFitness, IRandomSource rng) { MetaNeatGenome <double> metaNeatGenome = new MetaNeatGenome <double>( inputNodeCount: 3, outputNodeCount: 2, isAcyclic: true, activationFn: new NeuralNets.Double.ActivationFunctions.ReLU()); NeatPopulation <double> neatPop = NeatPopulationFactory <double> .CreatePopulation(metaNeatGenome, 1.0, count, rng); Assert.Equal(count, neatPop.GenomeList.Count); Assert.Equal(count, neatPop.GenomeIdSeq.Peek); // Assign the default fitness to all genomes. var genomeList = neatPop.GenomeList; for (int i = 0; i < count; i++) { var genome = genomeList[i]; genome.FitnessInfo = new FitnessInfo(defaultFitness); } // Init species. InitialiseSpecies(neatPop); return(neatPop); }
public void Simple() { var metaNeatGenome = new MetaNeatGenome <double>(3, 2, true, new ReLU()); var genomeBuilder = NeatGenomeBuilderFactory <double> .Create(metaNeatGenome); // Simple acyclic graph. var connGenes = new ConnectionGenes <double>(4); connGenes[0] = (0, 3, 0.0); connGenes[1] = (1, 3, 1.0); connGenes[2] = (2, 3, 2.0); connGenes[3] = (2, 4, 3.0); // Wrap in a genome. var genome = genomeBuilder.Create(0, 0, connGenes); // Note. The genome builder creates a digraph representation of the genome and attaches/caches it on the genome object. var acyclicDigraph = (DirectedGraphAcyclic)genome.DirectedGraph; Assert.NotNull(acyclicDigraph); // The graph should be unchanged from the input connections. CompareConnectionLists(connGenes, acyclicDigraph.ConnectionIds, genome.ConnectionIndexMap); // Check the node count. Assert.Equal(5, acyclicDigraph.TotalNodeCount); }
/// <summary> /// Construct with the given NEAT genome metadata. /// </summary> /// <param name="metaNeatGenome">NEAT genome metadata.</param> /// <param name="validateAcyclic">Enable acyclic graph validation.</param> /// <remarks> /// If the caller can guarantee that calls to Create() will provide acyclic graphs only, then /// <paramref name="validateAcyclic"/> can be set to false to avoid the cost of the cyclic graph check (which is relatively expensive to perform). /// </remarks> public NeatGenomeBuilderAcyclic(MetaNeatGenome <T> metaNeatGenome, bool validateAcyclic) { Debug.Assert(metaNeatGenome is not null && metaNeatGenome.IsAcyclic); _metaNeatGenome = metaNeatGenome; _graphDepthAnalysis = new AcyclicGraphDepthAnalysis(validateAcyclic); _workingIdSet = new HashSet <int>(); }
public void Simple_DefinedNodes() { var metaNeatGenome = new MetaNeatGenome <double>(0, 10, false, new ReLU()); var genomeBuilder = NeatGenomeBuilderFactory <double> .Create(metaNeatGenome); // Simple acyclic graph. var connGenes = new ConnectionGenes <double>(4); connGenes[0] = (10, 13, 0.0); connGenes[1] = (11, 13, 1.0); connGenes[2] = (12, 13, 2.0); connGenes[3] = (12, 14, 3.0); // Wrap in a genome. var genome = genomeBuilder.Create(0, 0, connGenes); // Note. The genome builder creates a digraph representation of the genome and attaches/caches it on the genome object. var digraph = genome.DirectedGraph; // The graph should be unchanged from the input connections. CompareConnectionLists(connGenes, digraph.ConnectionIdArrays); // Check the node count. Assert.AreEqual(15, digraph.TotalNodeCount); }
/// <summary> /// Create a new instance of <see cref="NeatPopulationLoader{Double}"/>. /// </summary> /// <param name="metaNeatGenome">Meta neat genome.</param> /// <returns>A new instance of <see cref="NeatPopulationLoader{Double}"/>.</returns> public static NeatPopulationLoader <double> CreateLoaderDouble( MetaNeatGenome <double> metaNeatGenome) { NeatGenomeLoader <double> genomeLoader = NeatGenomeLoaderFactory.CreateLoaderDouble(metaNeatGenome); return(new NeatPopulationLoader <double>(genomeLoader)); }
public void Simple_DefinedNodes_NodeIdGap() { var metaNeatGenome = new MetaNeatGenome <double>(0, 10, false, new ReLU()); var genomeBuilder = NeatGenomeBuilderFactory <double> .Create(metaNeatGenome); // Simple acyclic graph. var connGenes = new ConnectionGenes <double>(4); connGenes[0] = (100, 103, 0.0); connGenes[1] = (101, 103, 1.0); connGenes[2] = (102, 103, 2.0); connGenes[3] = (102, 104, 3.0); // Wrap in a genome. var genome = genomeBuilder.Create(0, 0, connGenes); // Note. The genome builder creates a digraph representation of the genome and attaches/caches it on the genome object. var digraph = genome.DirectedGraph; // The gaps in the node IDs should be removed such that node IDs form a contiguous span starting from zero. var connArrExpected = new DirectedConnection[4]; var weightArrExpected = new double[4]; connArrExpected[0] = new DirectedConnection(10, 13); weightArrExpected[0] = 0.0; connArrExpected[1] = new DirectedConnection(11, 13); weightArrExpected[1] = 1.0; connArrExpected[2] = new DirectedConnection(12, 13); weightArrExpected[2] = 2.0; connArrExpected[3] = new DirectedConnection(12, 14); weightArrExpected[3] = 3.0; // The graph should be unchanged from the input connections. CompareConnectionLists(connArrExpected, digraph.ConnectionIdArrays); // Check the node count. Assert.AreEqual(15, digraph.TotalNodeCount); }
public static NeatGenome <double> CreateNeatGenome( MetaNeatGenome <double> metaNeatGenome, INeatGenomeBuilder <double> genomeBuilder) { var connGenes = new ConnectionGenes <double>(12); connGenes[0] = (0, 3, 0.1); connGenes[1] = (0, 4, 0.2); connGenes[2] = (0, 5, 0.3); connGenes[3] = (3, 6, 0.4); connGenes[4] = (4, 7, 0.5); connGenes[5] = (5, 8, 0.6); connGenes[6] = (6, 9, 0.7); connGenes[7] = (7, 10, 0.8); connGenes[8] = (8, 11, 0.9); connGenes[9] = (9, 1, 1.0); connGenes[10] = (10, 1, 1.1); connGenes[11] = (11, 1, 1.2); var genome = genomeBuilder.Create(0, 0, connGenes); return(genome); }
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); }
/// <summary> /// Create a digraph from the a set of connection genes. /// </summary> /// <typeparam name="T">Neural net numeric data type.</typeparam> /// <param name="metaNeatGenome">Genome metadata.</param> /// <param name="connGenes">Connection genes.</param> /// <param name="nodeIndexByIdMap">A mapping from node IDs to node indexes.</param> /// <returns>A new instance of <see cref="DirectedGraph"/>.</returns> public static DirectedGraph CreateDirectedGraph <T>( MetaNeatGenome <T> metaNeatGenome, ConnectionGenes <T> connGenes, INodeIdMap nodeIndexByIdMap) where T : struct { // Extract/copy the neat genome connectivity graph into a ConnectionIds structure. // Notes. // The array contents will be manipulated, so copying this avoids modification of the genome's // connection gene list. // The IDs are substituted for node indexes here. CopyAndMapIds( connGenes._connArr, nodeIndexByIdMap, out ConnectionIds connIds); // Construct a new DirectedGraph. var digraph = new DirectedGraph( metaNeatGenome.InputNodeCount, metaNeatGenome.OutputNodeCount, nodeIndexByIdMap.Count, connIds); return(digraph); }
/// <summary> /// Construct a new instance. /// </summary> /// <param name="metaNeatGenome">NeatGenome metadata.</param> /// <param name="genomeBuilder">NeatGenome builder.</param> /// <param name="genomeIdSeq">Genome ID sequence; for obtaining new genome IDs.</param> /// <param name="innovationIdSeq">Innovation ID sequence; for obtaining new innovation IDs.</param> /// <param name="generationSeq">Generation sequence; for obtaining the current generation number.</param> /// <param name="addedNodeBuffer">A history buffer of added nodes.</param> /// <param name="settings">Asexual reproduction settings.</param> /// <param name="weightMutationScheme">Connection weight mutation scheme.</param> public NeatReproductionAsexual( MetaNeatGenome <T> metaNeatGenome, INeatGenomeBuilder <T> genomeBuilder, Int32Sequence genomeIdSeq, Int32Sequence innovationIdSeq, Int32Sequence generationSeq, AddedNodeBuffer addedNodeBuffer, NeatReproductionAsexualSettings settings, WeightMutationScheme <T> weightMutationScheme) { _settings = settings; // Instantiate reproduction strategies. _mutateWeightsStrategy = new MutateWeightsStrategy <T>(metaNeatGenome, genomeBuilder, genomeIdSeq, generationSeq, weightMutationScheme); _deleteConnectionStrategy = new DeleteConnectionStrategy <T>(metaNeatGenome, genomeBuilder, genomeIdSeq, generationSeq); // Add connection mutation; select acyclic/cyclic strategy as appropriate. if (metaNeatGenome.IsAcyclic) { _addConnectionStrategy = new AddAcyclicConnectionStrategy <T>( metaNeatGenome, genomeBuilder, genomeIdSeq, innovationIdSeq, generationSeq); } else { _addConnectionStrategy = new AddCyclicConnectionStrategy <T>( metaNeatGenome, genomeBuilder, genomeIdSeq, innovationIdSeq, generationSeq); } _addNodeStrategy = new AddNodeStrategy <T>(metaNeatGenome, genomeBuilder, genomeIdSeq, innovationIdSeq, generationSeq, addedNodeBuffer); }
public void CreatePopulation() { MetaNeatGenome <double> metaNeatGenome = new MetaNeatGenome <double>( inputNodeCount: 3, outputNodeCount: 2, isAcyclic: true, activationFn: new NeuralNets.Double.ActivationFunctions.ReLU()); int count = 10; NeatPopulation <double> neatPop = NeatPopulationFactory <double> .CreatePopulation(metaNeatGenome, 1.0, count, RandomDefaults.CreateRandomSource()); Assert.Equal(count, neatPop.GenomeList.Count); Assert.Equal(count, neatPop.GenomeIdSeq.Peek); // The population factory assigns the same innovation IDs to matching structures in the genomes it creates. // In this test there are 5 nodes and 6 connections in each genome, and they are each identifiably // the same structure in each of the genomes (e.g. input 0 or whatever) and so have the same innovation ID // across all of the genomes. // Thus in total although we created N genomes there are only 5 innovation IDs allocated (5 nodes). Assert.Equal(5, neatPop.InnovationIdSeq.Peek); // Loop the created genomes. for (int i = 0; i < count; i++) { var genome = neatPop.GenomeList[i]; Assert.Equal(i, genome.Id); Assert.Equal(0, genome.BirthGeneration); TestGenome(genome); } }
public NeatPopulation( MetaNeatGenome <T> metaNeatGenome, List <NeatGenome <T> > genomeList, Int32Sequence genomeIdSeq, Int32Sequence innovationIdSeq) : this(metaNeatGenome, genomeList, genomeIdSeq, innovationIdSeq, __defaultInnovationHistoryBufferSize, __defaultInnovationHistoryBufferSize) { }
/// <summary> /// Create a new NeatPopulation with randomly initialised genomes. /// Genomes are randomly initialised by giving each a random subset of all possible connections between the input and output layer. /// </summary> /// <param name="metaNeatGenome">Genome metadata, e.g. the number of input and output nodes that each genome should have.</param> /// <param name="connectionsProportion">The proportion of possible connections between the input and output layers, to create in each new genome.</param> /// <param name="popSize">Population size. The number of new genomes to create.</param> /// <returns>A new instance of <see cref="NeatPopulation{T}"/>.</returns> public static NeatPopulation <T> CreatePopulation( MetaNeatGenome <T> metaNeatGenome, double connectionsProportion, int popSize) { var factory = new NeatPopulationFactory <T>(metaNeatGenome, connectionsProportion, RandomDefaults.CreateRandomSource()); return(factory.CreatePopulation(popSize)); }
public void DepthNodeReorderTest() { var metaNeatGenome = new MetaNeatGenome <double>(2, 2, true, new ReLU()); var genomeBuilder = NeatGenomeBuilderFactory <double> .Create(metaNeatGenome); // Define graph connections. var connGenes = new ConnectionGenes <double>(5); connGenes[0] = (0, 4, 0.0); connGenes[1] = (4, 5, 1.0); connGenes[2] = (5, 2, 2.0); connGenes[3] = (1, 2, 3.0); connGenes[4] = (2, 3, 4.0); connGenes.Sort(); // Wrap in a genome. var genome = genomeBuilder.Create(0, 0, connGenes); // Note. The genome builder creates a digraph representation of the genome and attaches/caches it on the genome object. var acyclicDigraph = (DirectedGraphAcyclic)genome.DirectedGraph; Assert.NotNull(acyclicDigraph); // Simulate the actual weight array that would occur in e.g. a WeightedDirectedGraphAcyclic or NeuralNetAcyclic. double[] weightArrActual = new double[connGenes._weightArr.Length]; for (int i = 0; i < weightArrActual.Length; i++) { weightArrActual[i] = connGenes._weightArr[genome.ConnectionIndexMap[i]]; } // The nodes should have IDs allocated based on depth, i.e. the layer they are in. // And connections should be ordered by source node ID. var connArrExpected = new DirectedConnection[5]; var weightArrExpected = new double[5]; connArrExpected[0] = new DirectedConnection(0, 2); weightArrExpected[0] = 0.0; connArrExpected[1] = new DirectedConnection(1, 4); weightArrExpected[1] = 3.0; connArrExpected[2] = new DirectedConnection(2, 3); weightArrExpected[2] = 1.0; connArrExpected[3] = new DirectedConnection(3, 4); weightArrExpected[3] = 2.0; connArrExpected[4] = new DirectedConnection(4, 5); weightArrExpected[4] = 4.0; // Compare actual and expected connections. CompareConnectionLists(connArrExpected, weightArrExpected, acyclicDigraph.ConnectionIds, weightArrActual); // Test layer info. LayerInfo[] layerArrExpected = new LayerInfo[5]; layerArrExpected[0] = new LayerInfo(2, 2); layerArrExpected[1] = new LayerInfo(3, 3); layerArrExpected[2] = new LayerInfo(4, 4); layerArrExpected[3] = new LayerInfo(5, 5); layerArrExpected[4] = new LayerInfo(6, 5); Assert.Equal(5, acyclicDigraph.LayerArray.Length); // Check the node count. Assert.Equal(6, acyclicDigraph.TotalNodeCount); }
private static MetaNeatGenome <double> CreateMetaNeatGenome() { MetaNeatGenome <double> metaNeatGenome = new MetaNeatGenome <double>( inputNodeCount: 3, outputNodeCount: 1, isAcyclic: true, activationFn: new SharpNeat.NeuralNet.Double.ActivationFunctions.ReLU()); return(metaNeatGenome); }
/// <summary> /// Create a new instance of <see cref="INeatGenomeBuilder{T}"/>. /// </summary> /// <param name="metaNeatGenome">Neat genome metadata.</param> /// <returns>A new instance of <see cref="INeatGenomeBuilder{T}"/>.</returns> public static INeatGenomeBuilder <T> Create( MetaNeatGenome <T> metaNeatGenome) { if (metaNeatGenome.IsAcyclic) { return(new NeatGenomeAcyclicBuilder <T>(metaNeatGenome)); } // else return(new NeatGenomeBuilder <T>(metaNeatGenome)); }
/// <summary> /// Create a new instance of <see cref="INeatGenomeBuilder{T}"/>. /// </summary> /// <param name="metaNeatGenome">Neat genome metadata.</param> /// <param name="validateAcyclic">Enable acyclic graph validation.</param> /// <returns>A new instance of <see cref="INeatGenomeBuilder{T}"/>.</returns> /// <remarks> /// If the caller can guarantee that calls to Create() will provide acyclic graphs only when metaNeatGenome.IsAcyclic is true, then /// <paramref name="validateAcyclic"/> can be set to false to avoid the cost of the cyclic graph check (which is relatively expensive to perform). /// </remarks> public static INeatGenomeBuilder <T> Create( MetaNeatGenome <T> metaNeatGenome, bool validateAcyclic = false) { if (metaNeatGenome.IsAcyclic) { return(new NeatGenomeBuilderAcyclic <T>(metaNeatGenome, validateAcyclic)); } // else return(new NeatGenomeBuilderCyclic <T>(metaNeatGenome)); }
/// <summary> /// Construct a new instance. /// </summary> /// <param name="metaNeatGenome">NEAT genome metadata.</param> /// <param name="genomeBuilder">NeatGenome builder.</param> /// <param name="genomeIdSeq">Genome ID sequence; for obtaining new genome IDs.</param> /// <param name="generationSeq">Generation sequence; for obtaining the current generation number.</param> public DeleteConnectionStrategy( MetaNeatGenome <T> metaNeatGenome, INeatGenomeBuilder <T> genomeBuilder, Int32Sequence genomeIdSeq, Int32Sequence generationSeq) { _metaNeatGenome = metaNeatGenome; _genomeBuilder = genomeBuilder; _genomeIdSeq = genomeIdSeq; _generationSeq = generationSeq; }
//private IGenomeCollectionEvaluator<NeatGenome<double>> CreateGenomeListEvaluator() //{ // var genomeDecoder = new NeatGenomeAcyclicDecoder(false); // var phenomeEvaluator = new BinaryElevenMultiplexerEvaluator(); // var genomeCollectionEvaluator = new SerialGenomeListEvaluator<NeatGenome<double>, IPhenome<double>>(genomeDecoder, phenomeEvaluator); // return genomeListEvaluator; //} private static NeatPopulation <double> CreatePopulation( MetaNeatGenome <double> metaNeatGenome, int popSize) { NeatPopulation <double> pop = NeatPopulationFactory <double> .CreatePopulation( metaNeatGenome, connectionsProportion : 1.0, popSize : popSize, rng : RandomDefaults.CreateRandomSource()); return(pop); }
protected NeatGenomeLoader( MetaNeatGenome <T> metaNeatGenome, int connCountEstimate) { _metaNeatGenome = metaNeatGenome ?? throw new ArgumentNullException(nameof(metaNeatGenome)); _genomeBuilder = NeatGenomeBuilderFactory <T> .Create(metaNeatGenome); _activationFnName = metaNeatGenome.ActivationFn.GetType().Name; _connList = new List <DirectedConnection>(connCountEstimate); _weightList = new List <T>(connCountEstimate); _actFnList = new List <ActivationFunctionRow>(); }
public NeatPopulation( MetaNeatGenome <T> metaNeatGenome, List <NeatGenome <T> > genomeList) : base(genomeList) { GetMaxObservedIds(genomeList, out int maxGenomeId, out int maxInnovationId); this.MetaNeatGenome = metaNeatGenome; this.GenomeIdSeq = new Int32Sequence(maxGenomeId + 1); this.InnovationIdSeq = new Int32Sequence(maxInnovationId + 1); this.AddedNodeBuffer = new AddedNodeBuffer(__defaultInnovationHistoryBufferSize); }
private static MetaNeatGenome <double> CreateMetaNeatGenome(int inputCount, int outputCount) { var activationFnFactory = new DefaultActivationFunctionFactory <double>(); MetaNeatGenome <double> metaNeatGenome = new MetaNeatGenome <double>( inputNodeCount: inputCount, outputNodeCount: outputCount, isAcyclic: true, activationFn: activationFnFactory.GetActivationFunction("LeakyReLU")); return(metaNeatGenome); }
/// <summary> /// Construct a new instance. /// </summary> /// <param name="metaNeatGenome">NeatGenome metadata.</param> /// <param name="genomeBuilder">NeatGenome builder.</param> /// <param name="genomeIdSeq">Genome ID sequence; for obtaining new genome IDs.</param> /// <param name="generationSeq">Generation sequence; for obtaining the current generation number.</param> /// <param name="settings">Sexual reproduction settings.</param> public NeatReproductionSexual( MetaNeatGenome <T> metaNeatGenome, INeatGenomeBuilder <T> genomeBuilder, Int32Sequence genomeIdSeq, Int32Sequence generationSeq, NeatReproductionSexualSettings settings) { _strategy = new UniformCrossoverReproductionStrategy <T>( metaNeatGenome.IsAcyclic, settings.SecondaryParentGeneProbability, genomeBuilder, genomeIdSeq, generationSeq); }
/// <summary> /// Construct a new instance. /// </summary> /// <param name="metaNeatGenome">NEAT genome metadata.</param> /// <param name="genomeBuilder">NeatGenome builder.</param> /// <param name="genomeIdSeq">Genome ID sequence; for obtaining new genome IDs.</param> /// <param name="generationSeq">Generation sequence; for obtaining the current generation number.</param> /// <param name="weightMutationScheme">Connection weight mutation scheme.</param> public MutateWeightsStrategy( MetaNeatGenome <T> metaNeatGenome, INeatGenomeBuilder <T> genomeBuilder, Int32Sequence genomeIdSeq, Int32Sequence generationSeq, WeightMutationScheme <T> weightMutationScheme) { _metaNeatGenome = metaNeatGenome; _genomeBuilder = genomeBuilder; _genomeIdSeq = genomeIdSeq; _generationSeq = generationSeq; _weightMutationScheme = weightMutationScheme; }
private static void AssertNodeCounts( MetaNeatGenome <T> metaNeatGenome, int[] hiddenNodeIdArr, INodeIdMap nodeIndexByIdMap, DirectedGraph digraph) { int totalNodeCount = metaNeatGenome.InputNodeCount + metaNeatGenome.OutputNodeCount + hiddenNodeIdArr.Length; Debug.Assert(digraph.InputCount == metaNeatGenome.InputNodeCount); Debug.Assert(digraph.OutputCount == metaNeatGenome.OutputNodeCount); Debug.Assert(digraph.TotalNodeCount == totalNodeCount); Debug.Assert(nodeIndexByIdMap.Count == totalNodeCount); }
private void btnCreateRandomPop_Click(object sender, EventArgs e) { INeatExperiment <double> neatExperiment = GetNeatExperiment(); MetaNeatGenome <double> metaNeatGenome = NeatUtils.CreateMetaNeatGenome(neatExperiment); // Create an initial population of genomes. _neatPop = NeatPopulationFactory <double> .CreatePopulation( metaNeatGenome, connectionsProportion : neatExperiment.InitialInterconnectionsProportion, popSize : neatExperiment.PopulationSize); // Update UI. UpdateUIState(); }
/// <summary> /// Construct a new population with the provided genomes. /// </summary> /// <param name="metaNeatGenome">NeatGenome metadata.</param> /// <param name="genomeBuilder">NeatGenome builder.</param> /// <param name="genomeList">A list of genomes that will make up the population.</param> public NeatPopulation( MetaNeatGenome <T> metaNeatGenome, INeatGenomeBuilder <T> genomeBuilder, List <NeatGenome <T> > genomeList) : base(genomeList) { GetMaxObservedIds(genomeList, out int maxGenomeId, out int maxInnovationId); this.MetaNeatGenome = metaNeatGenome ?? throw new ArgumentNullException(nameof(metaNeatGenome)); this.GenomeBuilder = genomeBuilder ?? throw new ArgumentNullException(nameof(genomeBuilder)); this.GenomeIdSeq = new Int32Sequence(maxGenomeId + 1); this.InnovationIdSeq = new Int32Sequence(maxInnovationId + 1); this.AddedNodeBuffer = new AddedNodeBuffer(__defaultInnovationHistoryBufferSize); }