private NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeListEvaluator <NeatGenome> evaluator, int populationSize) { var genomeFactory = new NeatGenomeFactory(_inputCount.Value, _outputCount.Value, _neatGenomeParams); var genomeList = genomeFactory.CreateGenomeList(populationSize, 0); return(CreateEvolutionAlgorithm(evaluator, genomeList)); }
/// <summary> /// Loads a list of genomes from the save file fitting the experiment name and the ExperimentFileType. /// </summary> private static List <NeatGenome> ReadGenomes(INeatExperiment experiment, ExperimentFileType fileType, bool createNewGenesIfNotLoadable = true) { List <NeatGenome> genomeList = null; NeatGenomeFactory genomeFactory = (NeatGenomeFactory)experiment.CreateGenomeFactory(); string filePath = GetSaveFilePath(experiment.Name, fileType); try { using (XmlReader xr = XmlReader.Create(filePath)) { genomeList = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, genomeFactory); if (genomeList != null && genomeList.Count > 0) { Utility.Log("Successfully loaded the genomes of the '" + fileType.ToString() + "' for the experiment '" + experiment.Name + "' from the location:\n" + filePath); } } } catch (Exception e1) { Utility.Log("Error loading genome from file, could not find the file at: " + filePath + "\n" + e1.Message); if (createNewGenesIfNotLoadable) { genomeList = genomeFactory.CreateGenomeList(experiment.DefaultPopulationSize, 0); } } return(genomeList); }
NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(bool load) { // Create a genome2 factory with our neat genome2 parameters object and the appropriate number of input and output neuron genes. var genomeFactory = new NeatGenomeFactory(TetrisEvaluator.NumInputs, TetrisEvaluator.NumOutputs); // Create an initial population of randomly generated genomes. List <NeatGenome> genomeList = null; if (load) { try { using (var reader = XmlReader.Create("SavedProgress.xml")) genomeList = NeatGenomeXmlIO.ReadCompleteGenomeList(reader, true, genomeFactory); Console.WriteLine("Loaded network!"); } catch { load = false; } } if (!load) { genomeList = genomeFactory.CreateGenomeList(150, 0); } var parallelOpts = new ParallelOptions() { MaxDegreeOfParallelism = -1 }; // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); var speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOpts); // Create the evolution algorithm. var ea = new NeatEvolutionAlgorithm <NeatGenome>(new NeatEvolutionAlgorithmParameters { SpecieCount = 10 }, speciationStrategy, new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, 50)); // Create genome2 decoder. var genomeDecoder = new NeatGenomeDecoder(NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(2)); // Create a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator. IGenomeListEvaluator <NeatGenome> genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, tetrisEvaluator, parallelOpts); // Wrap the list evaluator in a 'selective' evaulator that will only evaluate new genomes. That is, we skip re-evaluating any genomes // that were in the population in previous generations (elite genomes). This is determiend by examining each genome2's evaluation info object. //if (!EvaluateParents) //genomeListEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(genomeListEvaluator, SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); ea.UpdateEvent += Ea_UpdateEvent; // Initialize the evolution algorithm. ea.Initialize(genomeListEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return(ea); }
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(BattleEvaluator <NeatGenome> evaluator, int populationSize) { Debug.Assert(populationSize > 5); _eaParams.SpecieCount = populationSize / 5; var genomeFactory = new NeatGenomeFactory(InputCount, OutputCount, _neatGenomeParams); var genomeList = genomeFactory.CreateGenomeList(populationSize, 0); return(CreateEvolutionAlgorithm(evaluator, genomeList)); }
private void Start() { int populationSize = 100; NetworkActivationScheme activationScheme = NetworkActivationScheme.CreateAcyclicScheme(); NeatGenomeParameters neatParams = new NeatGenomeParameters(); neatParams.ActivationFn = TanH.__DefaultInstance; neatParams.FeedforwardOnly = activationScheme.AcyclicNetwork; IGenomeDecoder <NeatGenome, IBlackBox> neatDecoder = new NeatGenomeDecoder(activationScheme); IGenomeFactory <NeatGenome> neatFactory = new NeatGenomeFactory(3, 3, neatParams); List <NeatGenome> genomeList = neatFactory.CreateGenomeList(populationSize, 0); ArenaEvaluator evaluator = GetComponent <ArenaEvaluator>(); evaluator.Initialize(neatDecoder); IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); // Evolution parameters NeatEvolutionAlgorithmParameters neatEvolutionParams = new NeatEvolutionAlgorithmParameters(); neatEvolutionParams.SpecieCount = 10; ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric); IComplexityRegulationStrategy complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, 10); NeatEvolutionAlgorithm <NeatGenome> ea = GetComponent <UnityEvolutionAlgorithm>(); ea.Construct(neatEvolutionParams, speciationStrategy, complexityRegulationStrategy, new NullGenomeListEvaluator <NeatGenome, IBlackBox>()); ea.Initialize(evaluator, neatFactory, genomeList); ea.UpdateScheme = new UpdateScheme(1); // This needs to be set AFTER Initialize is called ea.PausedEvent += (sender, e) => { //ea.StartContinue(); }; ea.GenerationEvent += (sender, gen) => { Debug.Log($"Generation {gen}"); Debug.Log($"Highest fitness: {ea.CurrentChampGenome.EvaluationInfo.Fitness}"); nnMesh.GenerateMesh(ea.CurrentChampGenome); ea.RequestPause(); StartCoroutine(PauseRoutine(ea)); }; ea.StartContinue(); }
public void LoadPopulation() { Debug.Assert(_GenomeFactory != null); var fi = new FileInfo(_GenomeFile); if (fi.Exists) { using (XmlReader xr = XmlReader.Create(_GenomeFile)) { _GenomeList = NeatGenomeXmlIO.ReadCompleteGenomeList(xr, false, _GenomeFactory); } } else { _GenomeList = _GenomeFactory.CreateGenomeList(_PopulationSize, 0); } }
/// <inheritdoc /> /// <summary> /// Creates the MCC algorithm container using the given agent and maze population sizes. /// </summary> /// <param name="populationSize1">The agent population size.</param> /// <param name="populationSize2">The maze population size.</param> /// <returns>The instantiated MCC algorithm container.</returns> public override IMCCAlgorithmContainer <NeatGenome, MazeGenome> CreateMCCAlgorithmContainer( int populationSize1, int populationSize2) { // Create a genome factory for the NEAT genomes IGenomeFactory <NeatGenome> neatGenomeFactory = new NeatGenomeFactory(AnnInputCount, AnnOutputCount, NeatGenomeParameters); // Create a genome factory for the maze genomes IGenomeFactory <MazeGenome> mazeGenomeFactory = new MazeGenomeFactory(MazeGenomeParameters, MazeHeight, MazeWidth, MazeQuadrantHeight, MazeQuadrantWidth); // Create an initial population of maze navigators var neatGenomeList = neatGenomeFactory.CreateGenomeList(populationSize1, 0); // Create an initial population of mazes // NOTE: the population is set to 1 here because we're just starting with a single, completely open maze space var mazeGenomeList = mazeGenomeFactory.CreateGenomeList(populationSize2, 0); // Create the evolution algorithm container return(CreateMCCAlgorithmContainer(neatGenomeFactory, mazeGenomeFactory, neatGenomeList, mazeGenomeList, false)); }
private static void Train() { File.WriteAllText($"{NeatConsts.experimentName}/fitness.csv", "generation,firness\n"); var neatGenomeFactory = new NeatGenomeFactory(NeatConsts.ViewX * NeatConsts.ViewY * NeatConsts.typeIds.Count, 1); var genomeList = neatGenomeFactory.CreateGenomeList(NeatConsts.SpecCount, 0); var eaParams = new NeatEvolutionAlgorithmParameters { SpecieCount = NeatConsts.SpecCount }; //var distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); var distanceMetric = new ManhattanDistanceMetric(); var parallelOptions = new ParallelOptions(); var speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, parallelOptions); //var speciationStrategy = new KMeansClusteringStrategy<NeatGenome>(distanceMetric); //var speciationStrategy = new RandomClusteringStrategy<NeatGenome>(); var complexityRegulationStrategy = new NullComplexityRegulationStrategy(); //var complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Relative, 0.50); var ea = new NeatEvolutionAlgorithm <NeatGenome>(eaParams, speciationStrategy, complexityRegulationStrategy); var activationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(1); var genomeDecoder = new NeatGenomeDecoder(activationScheme); var phenomeEvaluator = new GameEvaluator(); var genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, phenomeEvaluator, parallelOptions); ea.Initialize(genomeListEvaluator, neatGenomeFactory, genomeList); ea.UpdateScheme = new UpdateScheme(NeatConsts.LogRate); ea.StartContinue(); ea.UpdateEvent += Ea_UpdateEvent; while (ea.RunState != RunState.Paused) { } ea.Stop(); }
/// <summary> /// Creates the coevolution algorithm container using the given agent and maze population sizes. /// </summary> /// <param name="populationSize1">The agent population size.</param> /// <param name="populationSize2">The maze population size.</param> /// <returns>The instantiated coevolution algorithm container.</returns> public override ICoevolutionAlgorithmContainer<NeatGenome, MazeGenome> CreateCoevolutionAlgorithmContainer( int populationSize1, int populationSize2) { // Create a genome factory for the NEAT genomes IGenomeFactory<NeatGenome> neatGenomeFactory = new NeatGenomeFactory(AnnInputCount, AnnOutputCount, NeatGenomeParameters); // Create a genome factory for the maze genomes IGenomeFactory<MazeGenome> mazeGenomeFactory = new MazeGenomeFactory(MazeGenomeParameters, _mazeHeight, _mazeWidth); // Create an initial population of maze navigators List<NeatGenome> neatGenomeList = neatGenomeFactory.CreateGenomeList(populationSize1, 0); // Create an initial population of mazes // NOTE: the population is set to 1 here because we're just starting with a single, completely open maze space List<MazeGenome> mazeGenomeList = mazeGenomeFactory.CreateGenomeList(populationSize2, 0); // Create the evolution algorithm container return CreateCoevolutionAlgorithmContainer(neatGenomeFactory, mazeGenomeFactory, neatGenomeList, mazeGenomeList); }