/// <summary> /// Create and return a GenerationalNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for running the /// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are /// also constructed and connected up. /// </summary> /// <param name="genomeFactory">The genome factory from which to generate new genomes</param> /// <param name="genomeList">The current genome population</param> /// <returns>Constructed evolutionary algorithm</returns> public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm( IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, ParallelOptions); // Create complexity regulation strategy. var complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold); // Create the evolution algorithm. var ea = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy); // Create IBlackBox evaluator. var mazeNavigationEvaluator = new MazeNavigationFitnessEvaluator(MaxDistanceToTarget, MaxTimesteps, MazeVariant, MinSuccessDistance); // Create genome decoder. var genomeDecoder = CreateGenomeDecoder(); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeEvaluator<NeatGenome> fitnessEvaluator = new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, ParallelOptions); // Initialize the evolution algorithm. ea.Initialize(fitnessEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return ea; }
public NeatTrainer(ExperimentSettings experimentSettings, NeatEvolutionAlgorithmParameters evolutionAlgorithmParameters, TrainingGameSettings gameSettings) { var neuromonPhenomeEvaluator = new NeuromonEvaluator(gameSettings, experimentSettings); var neatGenomeParameters = new NeatGenomeParameters(); _neuromonExperiment = new NeuromonExperiment(experimentSettings, evolutionAlgorithmParameters, neuromonPhenomeEvaluator, neatGenomeParameters); _genomeIo = new GenomeIo(_neuromonExperiment); _genomeFactory = _neuromonExperiment.CreateGenomeFactory(); if (experimentSettings.LoadExistingPopulation) { _genomePopulation = _genomeIo.Read(experimentSettings.ExistingPopulationFilePath); } else { // Randomly generate a new population _genomePopulation = _genomeFactory.CreateGenomeList(experimentSettings.PopulationSize, 0); } _genomeIo.CacheChampion(_genomePopulation.OrderByDescending(g => g.EvaluationInfo.Fitness).First()); _fitnessStagnationDetector = new FitnessStagnationDetector(experimentSettings.StagnationDetectionTriggerValue); _desiredFitness = experimentSettings.DesiredFitness; _previousGeneration = 0; _overallBestFitness = 0.0; }
static void Main(string[] args) { // 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. XorExperiment experiment = new XorExperiment(); // Load config XML. XmlDocument xmlConfig = new XmlDocument(); xmlConfig.Load("xor.config.xml"); experiment.Initialize("XOR", xmlConfig.DocumentElement); // Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes. _genomeFactory = experiment.CreateGenomeFactory(); // Create an initial population of randomly generated genomes. _genomeList = _genomeFactory.CreateGenomeList(150, 0); // Create evolution algorithm and attach update event. _ea = experiment.CreateEvolutionAlgorithm(_genomeFactory, _genomeList); _ea.UpdateEvent += new EventHandler(ea_UpdateEvent); // Start algorithm (it will run on a background thread). _ea.StartContinue(); // Hit return to quit. Console.ReadLine(); }
/// <summary> /// Create and return a SteadyStateNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for /// running the /// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are /// also constructed and connected up. /// </summary> /// <param name="genomeFactory">The genome factory from which to generate new genomes</param> /// <param name="genomeList">The current genome population</param> /// <param name="startingEvaluations">The number of evaluations that have been executed prior to the current run.</param> /// <returns>Constructed evolutionary algorithm</returns> public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm( IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList, ulong startingEvaluations) { FileDataLogger logger = null; // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, ParallelOptions); // Create complexity regulation strategy. var complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold); // Initialize the logger if (_generationalLogFile != null) { logger = new FileDataLogger(_generationalLogFile); } // Create the evolution algorithm. var ea = new SteadyStateNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy, _batchSize, _populationEvaluationFrequency, RunPhase.Primary, logger); // Create IBlackBox evaluator. var mazeNavigationEvaluator = new MazeNavigationMCNSEvaluator(MaxDistanceToTarget, MaxTimesteps, MazeVariant, MinSuccessDistance, _behaviorCharacterizationFactory); // Create genome decoder. var genomeDecoder = CreateGenomeDecoder(); // Create a novelty archive. AbstractNoveltyArchive<NeatGenome> archive = new BehavioralNoveltyArchive<NeatGenome>(_archiveAdditionThreshold, _archiveThresholdDecreaseMultiplier, _archiveThresholdIncreaseMultiplier, _maxGenerationArchiveAddition, _maxGenerationsWithoutArchiveAddition); // IGenomeEvaluator<NeatGenome> fitnessEvaluator = // new SerialGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, // _nearestNeighbors, archive); IGenomeEvaluator<NeatGenome> fitnessEvaluator = new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, SelectionType.SteadyState, SearchType.MinimalCriteriaNoveltySearch, _nearestNeighbors, archive); // Initialize the evolution algorithm. ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, 0, MaxEvaluations, archive); // Finished. Return the evolution algorithm return ea; }
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(int populationSize) { // 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); // Create evolution algorithm. return(CreateEvolutionAlgorithm(genomeFactory, genomeList)); }
public void Initialize(IGenomeFactory <NeatGenome> genomeFactory1, IGenomeFactory <NeatGenome> genomeFactory2, int populationSize) { // Make sure a parasite module has been attached. Debug.Assert(OtherModules != null); RhythmEvolutionAlgorithm.Initialize(_genomeRhythmModulesEvaluator, genomeFactory1, genomeFactory1.CreateGenomeList(populationSize, GENERATION_ZERO)); PitchEvolutionAlgorithm.Initialize(_genomePitchModulesEvaluator, genomeFactory2, genomeFactory2.CreateGenomeList(populationSize, GENERATION_ZERO)); RhythmEvolutionAlgorithm.UpdateScheme = new UpdateScheme(1); PitchEvolutionAlgorithm.UpdateScheme = new UpdateScheme(1); }
private NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm_private(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList, HyperNEAT_Args args = null) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1, 0, 10); ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> retVal = new NeatEvolutionAlgorithm <NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy); // Genome Decoder IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = null; if (args == null) { genomeDecoder = CreateGenomeDecoder(); } else { genomeDecoder = CreateGenomeDecoder(args); } // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeListEvaluator <NeatGenome> genomeEvaluator = null; if (_phenomeEvaluator != null) { IGenomeListEvaluator <NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, _phenomeEvaluator, _parallelOptions); // Wrap the list evaluator in a 'selective' evaluator 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 determined by examining each genome's evaluation info object. genomeEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly()); } else if (_phenomeEvaluators != null) { // Use the multi tick evaluator genomeEvaluator = new TickGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, _phenomeEvaluators, _phenometickeval_roundRobinManager, _phenometickeval_worldTick); } else { throw new ApplicationException("One of the phenome evaluators needs to be populated"); } // Initialize the evolution algorithm. retVal.Initialize(genomeEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return(retVal); }
/// <summary> /// Initializes the evolution algorithm with the provided IGenomeListEvaluator /// and an IGenomeFactory that can be used to create an initial population of genomes. /// </summary> /// <param name="genomeListEvaluator">The genome evaluation scheme for the evolution algorithm.</param> /// <param name="genomeFactory">The factory that was used to create the genomeList and which is therefore referenced by the genomes.</param> /// <param name="populationSize">The number of genomes to create for the initial population.</param> public virtual void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator, IGenomeFactory <TGenome> genomeFactory, int populationSize) { _currentGeneration = 0; _genomeListEvaluator = genomeListEvaluator; _genomeFactory = genomeFactory; _genomeList = genomeFactory.CreateGenomeList(populationSize, _currentGeneration); _populationSize = populationSize; _runState = RunState.Ready; _updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1)); }
/// <summary> /// Creates and returns a NeatEvolutionAlgorithm object ready for running /// the NEAT algorithm/search. An initial genome population is read from /// the file provided. If this file does not exist, it is created and /// the genomeFactory builds an initial population. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(string fileName) { List <NeatGenome> genomeList = null; IGenomeFactory <NeatGenome> genomeFactory = CreateGenomeFactory(); genomeList = LoadPopulationFromFile(fileName); if (genomeList == null) { genomeList = CreateNewGenome(genomeFactory); } return(CreateEvolutionAlgorithm(genomeFactory, genomeList)); }
/// <summary> /// Initializes the evolution algorithm with the provided IGenomeListEvaluator, IGenomeFactory /// and an initial population of genomes. /// </summary> /// <param name="genomeListEvaluator">The genome evaluation scheme for the evolution algorithm.</param> /// <param name="genomeFactory">The factory that was used to create the genomeList and which is therefore referenced by the genomes.</param> /// <param name="genomeList">An initial genome population.</param> public virtual void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator, IGenomeFactory <TGenome> genomeFactory, List <TGenome> genomeList) { _currentGeneration = 0; _genomeListEvaluator = genomeListEvaluator; _genomeFactory = genomeFactory; _genomeList = genomeList; _populationSize = _genomeList.Count; _runState = RunState.Ready; _updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1)); }
/// <summary> /// Create and return a SteadyStateNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for /// running the /// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are /// also constructed and connected up. /// </summary> /// <param name="genomeFactory">The genome factory from which to generate new genomes</param> /// <param name="genomeList">The current genome population</param> /// <param name="startingEvaluations">The number of evaluations that have been executed prior to the current run.</param> /// <returns>Constructed evolutionary algorithm</returns> public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm( IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList, ulong startingEvaluations) { ulong initializationEvaluations; // Instantiate the internal initialization algorithm _mazeNavigationInitializer.InitializeAlgorithm(ParallelOptions, genomeList, CreateGenomeDecoder(), startingEvaluations); // Run the initialization algorithm until the requested number of viable seed genomes are found List<NeatGenome> seedPopulation = _mazeNavigationInitializer.EvolveViableGenomes(SeedGenomeCount, true, out initializationEvaluations); // Create complexity regulation strategy. var complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold); // Create the evolution algorithm. AbstractNeatEvolutionAlgorithm<NeatGenome> ea = new QueueingNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, new ParallelKMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0), ParallelOptions), complexityRegulationStrategy, _batchSize, RunPhase.Primary, (_bridgingMagnitude > 0), false, _evolutionDataLogger, _experimentLogFieldEnableMap); // Create IBlackBox evaluator. IPhenomeEvaluator<IBlackBox, BehaviorInfo> mazeNavigationEvaluator = new MazeNavigationMCSEvaluator(MaxDistanceToTarget, MaxTimesteps, MazeVariant, MinSuccessDistance, _behaviorCharacterizationFactory, _bridgingMagnitude, _bridgingApplications, initializationEvaluations); // Create genome decoder. IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // IGenomeEvaluator<NeatGenome> fitnessEvaluator = // new SerialGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, // SelectionType.Queueing, SearchType.MinimalCriteriaSearch, _evaluationDataLogger, // SerializeGenomeToXml); IGenomeEvaluator<NeatGenome> fitnessEvaluator = new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, SelectionType.Queueing, SearchType.MinimalCriteriaSearch, _evaluationDataLogger, SerializeGenomeToXml); // Initialize the evolution algorithm. ea.Initialize(fitnessEvaluator, genomeFactory, seedPopulation, DefaultPopulationSize, null, MaxEvaluations + startingEvaluations); // Finished. Return the evolution algorithm return ea; }
public Solver(IGenomeFactory <T> genomeFactory, IGenomeEvaluator <T, TScore> evaluator, ISolverLogger <T, TScore> logger, ISolverParameters solverParameters, IEnumerable <IEarlyStoppingCondition <T, TScore> > earlyStoppingConditions, IEnumerable <IGenomeReproductionStrategy <T> > genomeReproductionStrategies) { _genomeFactory = genomeFactory; _evaluator = evaluator; _logger = logger; _solverParameters = solverParameters; _earlyStoppingConditions = earlyStoppingConditions; _genomeReproductionStrategies = genomeReproductionStrategies; }
private void Initialize_private(IGenomeListEvaluator <TGenome> genomeListEvaluator, IGenomeFactory <TGenome> genomeFactory, List <TGenome> genomeList) { _prevUpdateGeneration = 0; _prevUpdateTimeTick = DateTime.UtcNow.Ticks; _currentGeneration = 0; _genomeListEvaluator = genomeListEvaluator; _genomeFactory = genomeFactory; _genomeList = genomeList; _populationSize = _genomeList.Count; _runState = RunState.Ready; _updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1)); }
/// <summary> /// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome population and their associated/parent genome factory. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create IBlackBox evaluator. DoublePoleBalancingEvaluator evaluator; switch (_variantStr) { case "DoublePole": evaluator = new DoublePoleBalancingEvaluator(); break; case "DoublePoleNv": evaluator = new DoublePoleBalancingEvaluatorNv(); break; case "DoublePoleNvAntiWiggle": evaluator = new DoublePoleBalancingEvaluatorNvAntiWiggle(); break; default: throw new SharpNeatException(string.Format("DoublePoleBalancing experiment config XML specifies unknown variant [{0}]", _variantStr)); } // Create genome decoder. IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeListEvaluator <NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions); // 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 genome's evaluation info object. IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly()); // Initialize the evolution algorithm. ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return(ea); }
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList, IGenomeListEvaluator <NeatGenome> eval = null) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = new NullComplexityRegulationStrategy();// ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create the MC evaluator PasswordCrackingEvaluator.Passwords = _passwords; // Create genome decoder. IGenomeDecoder <NeatGenome, MarkovChain> genomeDecoder = CreateGenomeDecoder(); // If we're running specially on Condor, skip this if (eval == null) { _evaluator = new PasswordCrackingEvaluator(_guesses, Hashed); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. // IGenomeListEvaluator<NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator<NeatGenome, MarkovChain>(genomeDecoder, _evaluator, _parallelOptions); IGenomeListEvaluator <NeatGenome> innerEvaluator = new ParallelNEATGenomeListEvaluator <NeatGenome, MarkovChain>(genomeDecoder, _evaluator, this); /* * // 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 genome's evaluation info object. * IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>( * innerEvaluator, * SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); */ // Initialize the evolution algorithm. ea.Initialize(innerEvaluator, genomeFactory, genomeList); } else { // Initialize the evolution algorithm. ea.Initialize(eval, genomeFactory, genomeList); } // Finished. Return the evolution algorithm return(ea); }
/// <summary> /// Initializes the evolution algorithm with the provided IGenomeListEvaluator /// and an IGenomeFactory that can be used to create an initial population of genomes. /// </summary> /// <param name="genomeListEvaluator">The genome evaluation scheme for /// the evolution algorithm.</param> /// <param name="genomeFactory">The factory that was used to create the /// genomeList and which is therefore referenced by the genomes.</param> /// <param name="populationSize">The number of genomes to create for the /// initial population.</param> public virtual void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator, IGenomeFactory <TGenome> genomeFactory, int populationSize) { _currentGeneration = 0; _genomeListEvaluator = genomeListEvaluator; _genomeFactory = genomeFactory; _genomeList = genomeFactory.CreateGenomeList(populationSize, _currentGeneration); // We set an arbitrary genome as champion to avoid possible null exceptions. _currentBestGenome = _genomeList[0]; _populationSize = populationSize; _runState = RunState.Ready; _updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1)); }
/// <summary> /// Tries to load a genome population using a given file path. If this is /// unsuccessful then calls to the default method. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(string fileName) { IGenomeFactory <NeatGenome> genomeFactory = CreateGenomeFactory(); List <NeatGenome> genomeList = null; genomeList = LoadPopulationFromFile(fileName); if (genomeList == null) { return(CreateEvolutionAlgorithm()); } NeatEvolutionAlgorithm <NeatGenome> evolutionAlgorithm = CreateEvolutionAlgorithm(genomeFactory, genomeList); evolutionAlgorithm.FindLastGeneration(); return(evolutionAlgorithm); }
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric); IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); BraidNeatEvolutionAlgorithm <NeatGenome> ea = new BraidNeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create black box evaluator BraidEvaluator evaluator = new BraidEvaluator(m_optimizer); IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); IGenomeListEvaluator <NeatGenome> innerEvaluator = new BraidListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, m_optimizer); ea.Initialize(innerEvaluator, genomeFactory, genomeList); return(ea); }
static void RunTrial(int offset) { RESULTS_FILE = EXPERIMENTS_DIR + RESULTS_FILE_BASE + offset + ".csv"; _random = new FastRandom(); _experiment = new SocialExperiment(); XmlDocument xmlConfig = new XmlDocument(); xmlConfig.Load(CONFIG_FILE); _experiment.Initialize("SimpleEvolution", xmlConfig.DocumentElement); _experiment.NeatGenomeParameters.AddConnectionMutationProbability = 0; _experiment.NeatGenomeParameters.AddNodeMutationProbability = 0; _experiment.NeatGenomeParameters.DeleteConnectionMutationProbability = 0; SocialExperiment.CreateNetwork(FEED_FORWARD_NETWORK_FILE, _experiment.InputCount, _experiment.OutputCount); // Record the changes at each step _experiment.World.Stepped += new social_learning.World.StepEventHandler(World_Stepped); // Read in the seed genome from file. This is the prototype for our other population of networks. var seed = _experiment.LoadPopulation(XmlReader.Create(FEED_FORWARD_NETWORK_FILE))[0]; // Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes. IGenomeFactory <NeatGenome> genomeFactory = _experiment.CreateGenomeFactory(); // Create an initial population of randomly generated genomes. List <NeatGenome> genomeList = genomeFactory.CreateGenomeList(_experiment.DefaultPopulationSize, 0, seed); // Randomize the genomes RandomizeGenomes(genomeList); // Create genome decoder. IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = _experiment.CreateGenomeDecoder(); // Create the evaluator that will handle the simulation _evaluator = new ForagingEvaluator <NeatGenome>(genomeDecoder, _experiment.World, AgentTypes.Social) { MaxTimeSteps = 200000UL, BackpropEpochsPerExample = 1 }; using (TextWriter writer = new StreamWriter(RESULTS_FILE)) writer.WriteLine("Step,Best,Average"); // Start the simulation _evaluator.Evaluate(genomeList); }
public SexualGenomeReproductionStrategy( IMutator <T> mutator, IPairingStrategy pairingStrategy, IGenomeFactory <T> genomeFactory, IGenomeDescription <T> genomeDescription, IGenomeEvaluator <T, TScore> genomeEvaluator, int childrenToCreate, int childrenToKeepPerPair) { _mutator = mutator; _pairingStrategy = pairingStrategy; _genomeFactory = genomeFactory; _genomeDescription = genomeDescription; _genomeEvaluator = genomeEvaluator; _childrenToCreate = childrenToCreate; _childrenToKeepPerPair = childrenToKeepPerPair; }
/// <summary> /// Create and return a GenerationalNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for /// running the /// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are /// also constructed and connected up. /// </summary> /// <param name="genomeFactory">The genome factory from which to generate new genomes</param> /// <param name="genomeList">The current genome population</param> /// <param name="startingEvaluations">The number of evaluations that have been executed prior to the current run.</param> /// <returns>Constructed evolutionary algorithm</returns> public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm( IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList, ulong startingEvaluations) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, ParallelOptions); // Create complexity regulation strategy. var complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold); // Create the evolution algorithm. var ea = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy); // Create IBlackBox evaluator. var mazeNavigationEvaluator = new MazeNavigationNoveltyEvaluator(MaxDistanceToTarget, MaxTimesteps, MazeVariant, MinSuccessDistance, _behaviorCharacterizationFactory); // Create genome decoder. var genomeDecoder = CreateGenomeDecoder(); // Create a novelty archive. AbstractNoveltyArchive<NeatGenome> archive = new BehavioralNoveltyArchive<NeatGenome>(_archiveAdditionThreshold, _archiveThresholdDecreaseMultiplier, _archiveThresholdIncreaseMultiplier, _maxGenerationArchiveAddition, _maxGenerationsWithoutArchiveAddition); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. // IGenomeFitnessEvaluator<NeatGenome> fitnessEvaluator = // new SerialGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, _nearestNeighbors, archive); IGenomeEvaluator<NeatGenome> fitnessEvaluator = new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, SelectionType.Generational, SearchType.NoveltySearch, ParallelOptions, _nearestNeighbors, archive); // Initialize the evolution algorithm. ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, MaxGenerations, null, archive); // Finished. Return the evolution algorithm return ea; }
public override NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { var ea = DefaultNeatEvolutionAlgorithm; var evaluator = new LocalXorEvaluator(); // Create genome decoder. IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeListEvaluator<NeatGenome> innerEvaluator = new SerialGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator); // 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 determined by examining each genome's evaluation info object. IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); // Initialize the evolution algorithm. ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return ea; }
/// <summary> /// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome2 population and their associated/parent genome2 factory. /// </summary> public NeatEvolutionAlgorithm <NeatGenome>[] CreateEvolutionAlgorithms(IGenomeFactory <NeatGenome> genomeFactory1, List <NeatGenome> genomeList1, IGenomeFactory <NeatGenome> genomeFactory2, List <NeatGenome> genomeList2) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric1 = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy1 = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric1, _parallelOptions); // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric2 = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy2 = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric2, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy1 = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy2 = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> ea1 = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy1, complexityRegulationStrategy1); NeatEvolutionAlgorithm <NeatGenome> ea2 = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy2, complexityRegulationStrategy2); // Create genome decoder. IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder1 = CreateGenomeDecoder(); IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder2 = CreateGenomeDecoder(); // Create phenome evaluators. Note we are evolving one population of X players and one of O players. ICoevolutionPhenomeEvaluator <IBlackBox> phenomeEvaluator1 = new TicTacToeHostParasiteEvaluator(SquareTypes.X); ICoevolutionPhenomeEvaluator <IBlackBox> phenomeEvaluator2 = new TicTacToeHostParasiteEvaluator(SquareTypes.O); // Create a genome list evaluator. This packages up the genome decoder with the phenome evaluator. HostParasiteCoevolutionListEvaluator <NeatGenome, IBlackBox> genomeListEvaluator1 = new HostParasiteCoevolutionListEvaluator <NeatGenome, IBlackBox>(_parasiteCount, _championCount, ea2, genomeDecoder1, phenomeEvaluator1); HostParasiteCoevolutionListEvaluator <NeatGenome, IBlackBox> genomeListEvaluator2 = new HostParasiteCoevolutionListEvaluator <NeatGenome, IBlackBox>(_parasiteCount, _championCount, ea1, genomeDecoder2, phenomeEvaluator2); // Initialize the evolution algorithms. ea1.Initialize(genomeListEvaluator1, genomeFactory1, genomeList1); ea2.Initialize(genomeListEvaluator2, genomeFactory2, genomeList2); // Set the evolution algorithms to update every generation. ea1.UpdateScheme = new UpdateScheme(1); ea2.UpdateScheme = new UpdateScheme(1); // Finished. Return the evolution algorithms return(new [] { ea1, ea2 }); }
/// <summary> /// Create and return a SteadyStateNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for /// running the /// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are /// also constructed and connected up. /// </summary> /// <param name="genomeFactory">The genome factory from which to generate new genomes</param> /// <param name="genomeList">The current genome population</param> /// <param name="startingEvaluations">The number of evaluations that have been executed prior to the current run.</param> /// <returns>Constructed evolutionary algorithm</returns> public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm( IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList, ulong startingEvaluations) { FileDataLogger logger = null; // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, ParallelOptions); // Create complexity regulation strategy. var complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold); // Initialize the logger if (_generationalLogFile != null) { logger = new FileDataLogger(_generationalLogFile); } // Create the evolution algorithm. var ea = new SteadyStateNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy, _batchSize, _populationEvaluationFrequency, RunPhase.Primary, logger); // Create IBlackBox evaluator. var mazeNavigationEvaluator = new MazeNavigationRandomEvaluator(MaxDistanceToTarget, MaxTimesteps, MazeVariant, MinSuccessDistance); // Create genome decoder. var genomeDecoder = CreateGenomeDecoder(); IGenomeEvaluator<NeatGenome> fitnessEvaluator = new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, ParallelOptions); // Initialize the evolution algorithm. ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, null, MaxEvaluations); // Finished. Return the evolution algorithm return ea; }
public override NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { var ea = DefaultNeatEvolutionAlgorithm; var evaluator = new LocalXorEvaluator(); // Create genome decoder. IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeListEvaluator <NeatGenome> innerEvaluator = new SerialGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator); // 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 determined by examining each genome's evaluation info object. IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly()); // Initialize the evolution algorithm. ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return(ea); }
private IGenome <G, V> ApplyOperator(IGenomeFactory <G, V> gf, IPopulation <G, V> population) { if (gf is IGenomeCreator <G, V> ) { return(((IGenomeCreator <G, V>)gf).Create()); } if (gf is IGenomeMutator <G, V> ) { return(((IGenomeMutator <G, V>)gf).Mutate(this.ChooseGenome(population))); } if (gf is IGenomeCrossover <G, V> ) { return(((IGenomeCrossover <G, V>)gf).Crossover(this.ChooseGenome(population), this.ChooseGenome(population))); } throw new ArgumentException(); }
public override NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { // Create the evolution algorithm. var ea = DefaultNeatEvolutionAlgorithm; var evaluator = new RemoteBatchSixMultiplexerEvaluator(ea); IGenomeDecoder<NeatGenome, FastCyclicNetwork> genomeDecoder = _decoder; // Evaluates list of phenotypes IGenomeListEvaluator<NeatGenome> innerEvaluator = new BatchGenomeListEvaluator<NeatGenome, FastCyclicNetwork>( genomeDecoder, evaluator); // Weeds down the list to be evaluated IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); return ea; }
/// <summary> /// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome2 population and their associated/parent genome2 factory. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, new ParallelOptions()); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create genome decoder. IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // Finished. Return the evolution algorithm return(ea); }
/// <summary> /// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome population and their associated/parent genome factory. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create IBlackBox evaluator. DeepBeliefNetworkBiasEvaluator evaluator = new DeepBeliefNetworkBiasEvaluator(); // Create genome decoder. Decodes to a neural network packaged with an activation scheme that defines a fixed number of activations per evaluation. IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(_lengthCppnInput); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeListEvaluator <NeatGenome> innerEvaluator = null; if (Constants.IS_MULTI_THREADING) { innerEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions); } else { innerEvaluator = new SerialGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator); } // 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 genome's evaluation info object. IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly()); // Initialize the evolution algorithm. ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return(ea); }
private static void Main(string[] args) { Debug.Assert(args != null && args.Length == 2, "Experiment configuration file and number of runs are required!"); // Read in experiment configuration file string experimentName = args[0]; int numRuns = Int32.Parse(args[1]); // 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. SteadyStateMazeNavigationNoveltyExperiment experiment = new SteadyStateMazeNavigationNoveltyExperiment(); // Load config XML. XmlDocument xmlConfig = new XmlDocument(); xmlConfig.Load("./ExperimentConfigurations/" + experimentName); experiment.Initialize("Novelty", xmlConfig.DocumentElement, null, null); // Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes. _genomeFactory = experiment.CreateGenomeFactory(); // Create an initial population of randomly generated genomes. _genomeList = _genomeFactory.CreateGenomeList(experiment.DefaultPopulationSize, 0); // Create evolution algorithm and attach update event. _ea = experiment.CreateEvolutionAlgorithm(_genomeFactory, _genomeList); _ea.UpdateEvent += ea_UpdateEvent; // Start algorithm (it will run on a background thread). _ea.StartContinue(); /*while (RunState.Terminated != _ea.RunState && RunState.Paused != _ea.RunState && _ea.CurrentGeneration < maxGenerations) { Thread.Sleep(2000); }*/ // Hit return to quit. //Console.ReadLine(); }
/* * List<NeatGenome> CreateNewGenome(IGenomeFactory<NeatGenome> genomeFactory) * { * Console.WriteLine("Saved genome not found, creating new files."); * return genomeFactory.CreateGenomeList(_populationSize, 0); * } */ /// <summary> /// Creates and returns a NeatEvolutionAlgorithm object ready for running /// the NEAT algorithm/search. Various sub-parts of the algorithm are also /// constructed and connected up. This overload accepts a pre-built genome2 /// population and their associated/parent genome2 factory. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm( IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { // Creates distance metric. Mismatched genes have a fixed distance of 10; // for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); //ISpeciationStrategy<NeatGenome> speciationStrategy = new KMeansClusteringStrategy<NeatGenome>(distanceMetric); ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, _parallelOptions); IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Creates the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> evolAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>( _eaParams, speciationStrategy, complexityRegulationStrategy, userName); IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(_activationScheme); // Creates a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator. IGenomeListEvaluator <NeatGenome> genomeListEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, _parallelOptions); //To use single-thread evaluator: //IGenomeListEvaluator<NeatGenome> genomeListEvaluator = // new SerialGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, false); // Wraps 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 genome's evaluation info object. /* * int reevaluationPeriod = 1; * genomeListEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>( * genomeListEvaluator, * SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_PeriodicReevaluation(reevaluationPeriod)); */ genomeListEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>( genomeListEvaluator, SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly()); // Initializes the evolution algorithm. evolAlgorithm.Initialize(genomeListEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return(evolAlgorithm); }
/// <summary> /// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome population and their associated/parent genome factory. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { Debug.Log("........CreateEvolutionAlgorithm: Setting parameters"); // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); Debug.Log("........CreateEvolutionAlgorithm: Creating ea"); // Create the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); Debug.Log("........CreateEvolutionAlgorithm: Creating evaluator"); // Create IBlackBox evaluator. CPPNRepairEvaluator2 evaluator = new CPPNRepairEvaluator2(this); evaluator.SetOriginalFeatures(_originalFeatures); Debug.Log("........CreateEvolutionAlgorithm: Creating genome decoder and serial evaluator"); // Create genome decoder. IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeListEvaluator <NeatGenome> innerEvaluator = new SerialGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator); // 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 genome's evaluation info object. /*IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>( * innerEvaluator, * SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); */ // Initialize the evolution algorithm. Debug.Log("........CreateEvolutionAlgorithm: Initializing ea"); ea.Initialize(innerEvaluator, genomeFactory, genomeList); Debug.Log("........CreateEvolutionAlgorithm: Returning"); // Finished. Return the evolution algorithm return(ea); }
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm( IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; // for matched genes the distance is their weight difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = new NullComplexityRegulationStrategy(); // Create the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(this.eaParams, speciationStrategy, complexityRegulationStrategy); // Create genome decoder. IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = this.CreateGenomeDecoder(); var evaluator = new Evaluator(); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. //IGenomeListEvaluator<NeatGenome> innerEvaluator = // new SerialGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator); IGenomeListEvaluator <NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator <NeatGenome, IBlackBox>(genomeDecoder, evaluator); // Wrap the list evaluator in a 'selective' evaluator 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 determined by examining each genome's evaluation info object. IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly()); // Initialize the evolution algorithm. ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); ea.UpdateScheme = new UpdateScheme(1); // Finished. Return the evolution algorithm return(ea); }
/// <summary> /// Initializes the evolution algorithm with the provided IGenomeListEvaluator, IGenomeFactory /// an initial population of genomes and a boolean to update the currentGeneration value. /// </summary> /// <param name="genomeListEvaluator">The genome evaluation scheme for the evolution algorithm.</param> /// <param name="genomeFactory">The factory that was used to create the genomeList and which is therefore referenced by the genomes.</param> /// <param name="genomeList">An initial genome population.</param> /// <param name="addGenerationValue">boolean to trigger currentGeneration value from last genome in list</param> public virtual void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator, IGenomeFactory <TGenome> genomeFactory, List <TGenome> genomeList, bool addGenerationValue) { _currentGeneration = 0; if (genomeList.Count > 0) { int LastIndex = genomeList.Count - 1; _currentGeneration = genomeList.Min <TGenome, uint>(genome => genome.BirthGeneration); } _genomeListEvaluator = genomeListEvaluator; _genomeFactory = genomeFactory; _genomeList = genomeList; _populationSize = _genomeList.Count; _runState = RunState.Ready; _updateScheme = new UpdateScheme(new TimeSpan(0, 0, 1)); }
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric); IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Creates black box evaluator SimpleEvaluator evaluator = new SimpleEvaluator(_optimizer); IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); IGenomeListEvaluator <NeatGenome> innerEvaluator = new UnityParallelListEvaluator <NeatGenome, IBlackBox>( genomeDecoder, evaluator, _optimizer); IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly()); ea.Initialize(innerEvaluator, genomeFactory, genomeList); return(ea); }
public override NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { // Create the evolution algorithm. var ea = DefaultNeatEvolutionAlgorithm; var evaluator = new RemoteBatchSixMultiplexerEvaluator(ea); IGenomeDecoder <NeatGenome, FastCyclicNetwork> genomeDecoder = _decoder; // Evaluates list of phenotypes IGenomeListEvaluator <NeatGenome> innerEvaluator = new BatchGenomeListEvaluator <NeatGenome, FastCyclicNetwork>( genomeDecoder, evaluator); // Weeds down the list to be evaluated IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly()); ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); return(ea); }
public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy("absolute", 10); // Create the evolution algorithm. var ea = new NeatEvolutionAlgorithm <NeatGenome>( NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy); // Create IBlackBox evaluator. // var evaluator = new RemoteXorEvaluator(); var evaluator = new RemoteBatchXorEvaluator(); //LocalXorEvaluator evaluator = new LocalXorEvaluator(); // Create genome decoder. IGenomeDecoder <NeatGenome, FastCyclicNetwork> genomeDecoder = _decoder; // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeListEvaluator <NeatGenome> innerEvaluator = new BatchGenomeListEvaluator <NeatGenome, FastCyclicNetwork>(genomeDecoder, evaluator); // 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 determined by examining each genome's evaluation info object. IGenomeListEvaluator <NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator <NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator <NeatGenome> .CreatePredicate_OnceOnly()); // Initialize the evolution algorithm. ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return(ea); }
/// <summary> /// Configures and instantiates the initialization evolutionary algorithm. /// </summary> /// <param name="parallelOptions">Synchronous/Asynchronous execution settings.</param> /// <param name="genomeList">The initial population of genomes.</param> /// <param name="genomeFactory">The genome factory initialized by the main evolution thread.</param> /// <param name="mazeEnvironment">The maze on which to evaluate the navigators.</param> /// <param name="genomeDecoder">The decoder to translate genomes into phenotypes.</param> /// <param name="startingEvaluations"> /// The number of evaluations that preceeded this from which this process will pick up /// (this is used in the case where we're restarting a run because it failed to find a solution in the allotted time). /// </param> public override void InitializeAlgorithm(ParallelOptions parallelOptions, List <NeatGenome> genomeList, IGenomeFactory <NeatGenome> genomeFactory, MazeStructure mazeEnvironment, IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder, ulong startingEvaluations) { // Set the boiler plate algorithm parameters base.InitializeAlgorithm(parallelOptions, genomeList, genomeDecoder, startingEvaluations); // Create the initialization evolution algorithm. InitializationEa = new SteadyStateComplexifyingEvolutionAlgorithm <NeatGenome>(EvolutionAlgorithmParameters, SpeciationStrategy, ComplexityRegulationStrategy, _batchSize, _populationEvaluationFrequency, RunPhase.Initialization, NavigatorEvolutionDataLogger, NavigatorEvolutionLogFieldEnableMap, NavigatorPopulationDataLogger, PopulationLoggingBatchInterval); // Create IBlackBox evaluator. MazeNavigatorNoveltySearchInitializationEvaluator mazeNavigatorEvaluator = new MazeNavigatorNoveltySearchInitializationEvaluator(MinSuccessDistance, MaxDistanceToTarget, mazeEnvironment, _behaviorCharacterizationFactory, startingEvaluations); // Create a novelty archive AbstractNoveltyArchive <NeatGenome> archive = new BehavioralNoveltyArchive <NeatGenome>(_archiveAdditionThreshold, _archiveThresholdDecreaseMultiplier, _archiveThresholdIncreaseMultiplier, _maxGenerationArchiveAddition, _maxGenerationsWithoutArchiveAddition); // Create the genome evaluator IGenomeEvaluator <NeatGenome> fitnessEvaluator = new ParallelGenomeBehaviorEvaluator <NeatGenome, IBlackBox>(genomeDecoder, mazeNavigatorEvaluator, SearchType.NoveltySearch, _nearestNeighbors); // Only pull the number of genomes from the list equivalent to the initialization algorithm population size // (this is to handle the case where the list was created in accordance with the primary algorithm // population size, which is quite likely larger) genomeList = genomeList.Take(PopulationSize).ToList(); // Replace genome factory primary NEAT parameters with initialization parameters ((NeatGenomeFactory)genomeFactory).ResetNeatGenomeParameters(NeatGenomeParameters); // Initialize the evolution algorithm InitializationEa.Initialize(fitnessEvaluator, genomeFactory, genomeList, null, null, archive); }
/// <summary> /// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome2 population and their associated/parent genome2 factory. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory <NeatGenome> genomeFactory, List <NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy <NeatGenome>(distanceMetric, new ParallelOptions()); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = new NullComplexityRegulationStrategy();// ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm <NeatGenome> ea = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create genome decoder. IGenomeDecoder <NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // Create a genome list evaluator. This packages up the genome decoder with the phenome evaluator. _evaluator = new ForagingEvaluator <NeatGenome>(genomeDecoder, _world, _agentType, _navigationEnabled, _hidingEnabled) { MaxTimeSteps = _timeStepsPerGeneration, EvoParadigm = _paradigm, MemParadigm = _memory, GenerationsPerMemorySize = _memGens, MaxMemorySize = _maxMemorySize, TeachParadigm = _teaching, TrialId = TrialId, PredatorCount = _predCount, PredatorDistribution = PredatorDistribution, PredatorTypes = _predTypes, PredatorGenerations = _predGens, DistinguishPredators = _distinguishPreds, LogDiversity = _logDiversity }; // Initialize the evolution algorithm. ea.Initialize(_evaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return(ea); }
public NeatExperiment(Simulation simulation) { _simulation = simulation; _name = "Trader"; _populationSize = 100; _specieCount = 1; _activationScheme = NetworkActivationScheme.CreateAcyclicScheme(); _complexityRegulationStr = "Relative"; _complexityThreshold = 10; _description = "Generate trader neural network"; _parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = 2 }; UnityThread.SetUnityValue(() => _inputCount = 6 + UnityEngine.Object.FindObjectsOfType <Coin>().Length * 5); _outputCount = 8; _eaParams = new NeatEvolutionAlgorithmParameters(); _eaParams.SpecieCount = _specieCount; _neatGenomeParams = new NeatGenomeParameters(); _neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork; //_neatGenomeParams.ActivationFn = LeakyReLU.__DefaultInstance; _neatGenomeParams.ActivationFn = SharpNeat.Network.SReLU.__DefaultInstance; // Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes. _genomeFactory = CreateGenomeFactory(); // Create an initial population of randomly generated genomes. _genomeList = _genomeFactory.CreateGenomeList(_populationSize, 0); // Create evolution algorithm and attach update event. _ea = CreateEvolutionAlgorithm(_genomeFactory, _genomeList); // _ea.UpdateEvent += new EventHandler(ea_UpdateEvent); // Start algorithm (it will run on a background thread). _ea.StartContinue(); }
/// <summary> /// Create and return a SteadyStateNeatEvolutionAlgorithm object (specific to fitness-based evaluations) ready for /// running the /// NEAT algorithm/search based on the given genome factory and genome list. Various sub-parts of the algorithm are /// also constructed and connected up. /// </summary> /// <param name="genomeFactory">The genome factory from which to generate new genomes</param> /// <param name="genomeList">The current genome population</param> /// <param name="startingEvaluations">The number of evaluations that have been executed prior to the current run.</param> /// <returns>Constructed evolutionary algorithm</returns> public override INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm( IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList, ulong startingEvaluations) { // Create complexity regulation strategy. var complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(ComplexityRegulationStrategy, Complexitythreshold); // Create the evolution algorithm. AbstractNeatEvolutionAlgorithm<NeatGenome> ea = new QueueingNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, new ParallelKMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0), ParallelOptions), complexityRegulationStrategy, _batchSize, RunPhase.Primary); // Create IBlackBox evaluator. IPhenomeEvaluator<IBlackBox, FitnessInfo> mazeNavigationEvaluator = new MazeNavigationRandomEvaluator(MaxDistanceToTarget, MaxTimesteps, MazeVariant, MinSuccessDistance); // Create genome decoder. IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); IGenomeEvaluator<NeatGenome> fitnessEvaluator = new SerialGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, _evaluationDataLogger); // IGenomeEvaluator<NeatGenome> fitnessEvaluator = // new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, mazeNavigationEvaluator, // _evaluationDataLogger, SerializeGenomeToXml); // Initialize the evolution algorithm. ea.Initialize(fitnessEvaluator, genomeFactory, genomeList, DefaultPopulationSize, null, MaxEvaluations); // Finished. Return the evolution algorithm return ea; }
public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new KMeansClusteringStrategy<NeatGenome>(distanceMetric); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy("absolute", 10); // Create the evolution algorithm. var ea = new NeatEvolutionAlgorithm<NeatGenome>( NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy); // Create IBlackBox evaluator. var evaluator = new RemoteXorEvaluator(); // Create genome decoder. IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeListEvaluator<NeatGenome> innerEvaluator = new SerialGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator); // 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 determined by examining each genome's evaluation info object. IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); // Initialize the evolution algorithm. ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return ea; }
public abstract NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm( IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList);
public NeatInteractiveEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { _genomeDecoder = CreateGenomeDecoder(); var ea = new NeatInteractiveEvolutionAlgorithm< NeatGenome>(_eaParams); ea.Initialize(genomeList); return ea; }
public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList, IGenomeListEvaluator<NeatGenome> eval = null) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = new NullComplexityRegulationStrategy();// ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm<NeatGenome> ea = new NeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create the MC evaluator PasswordCrackingEvaluator.Passwords = _passwords; // Create genome decoder. IGenomeDecoder<NeatGenome, MarkovChain> genomeDecoder = CreateGenomeDecoder(); // If we're running specially on Condor, skip this if (eval == null) { _evaluator = new PasswordCrackingEvaluator(_guesses, Hashed); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. // IGenomeListEvaluator<NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator<NeatGenome, MarkovChain>(genomeDecoder, _evaluator, _parallelOptions); IGenomeListEvaluator<NeatGenome> innerEvaluator = new ParallelNEATGenomeListEvaluator<NeatGenome, MarkovChain>(genomeDecoder, _evaluator, this); /* // 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 genome's evaluation info object. IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); */ // Initialize the evolution algorithm. ea.Initialize(innerEvaluator, genomeFactory, genomeList); } else // Initialize the evolution algorithm. ea.Initialize(eval, genomeFactory, genomeList); // Finished. Return the evolution algorithm return ea; }
/// <summary> /// Create and return a GenerationalNeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome population and their associated/parent genome factory. /// </summary> public INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. GenerationalNeatEvolutionAlgorithm<NeatGenome> ea = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create IBlackBox evaluator. EvolvedAutoencoderEvaluator evaluator = new EvolvedAutoencoderEvaluator(_trainingImagesFilename, _visualFieldPixelCount, _numImageSamples, _learningRate, _numBackpropIterations, _trainingSampleProportion, _resolutionReductionPerSide); // Create genome decoder. Decodes to a neural network packaged with an activation scheme that defines a fixed number of activations per evaluation. IGenomeDecoder<NeatGenome,IBlackBox> genomeDecoder = CreateGenomeDecoder(_visualFieldResolution/ _resolutionReductionPerSide, _lengthCppnInput); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeEvaluator<NeatGenome> innerFitnessEvaluator = new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions); // 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 genome's evaluation info object. IGenomeEvaluator<NeatGenome> selectiveFitnessEvaluator = new SelectiveGenomeFitnessEvaluator<NeatGenome>( innerFitnessEvaluator, SelectiveGenomeFitnessEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); // Initialize the evolution algorithm. ea.Initialize(selectiveFitnessEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return ea; }
/// <summary> /// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome population and their associated/parent genome factory. /// </summary> public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm<NeatGenome> ea = new NeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create IBlackBox evaluator. DoublePoleBalancingEvaluator evaluator; switch(_variantStr) { case "DoublePole": evaluator = new DoublePoleBalancingEvaluator(); break; case "DoublePoleNv": evaluator = new DoublePoleBalancingEvaluatorNv(); break; case "DoublePoleNvAntiWiggle": evaluator = new DoublePoleBalancingEvaluatorNvAntiWiggle(); break; default: throw new SharpNeatException(string.Format("DoublePoleBalancing experiment config XML specifies unknown variant [{0}]", _variantStr)); } // Create genome decoder. IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeListEvaluator<NeatGenome> innerEvaluator = new ParallelGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions); // 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 genome's evaluation info object. IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>( innerEvaluator, SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); // Initialize the evolution algorithm. ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return ea; }
/// <summary> /// Construct a population. /// </summary> /// <param name="thePopulationSize"></param> /// <param name="theGenomeFactory"></param> public BasicPopulation(int thePopulationSize, IGenomeFactory theGenomeFactory) { PopulationSize = thePopulationSize; GenomeFactory = theGenomeFactory; }
/// <summary> /// Create and return a GenerationalNeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome population and their associated/parent genome factory. /// </summary> public INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. GenerationalNeatEvolutionAlgorithm<NeatGenome> ea = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create IBlackBox evaluator. PreyCaptureEvaluator evaluator = new PreyCaptureEvaluator(_trialsPerEvaluation, _gridSize, _preyInitMoves, _preySpeed, _sensorRange, _maxTimesteps); // Create genome decoder. IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // TODO: evaulation scheme that re-evaulates existing genomes and takes average over time. // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator. IGenomeEvaluator<NeatGenome> genomeFitnessEvaluator = new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions); // Initialize the evolution algorithm. ea.Initialize(genomeFitnessEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return ea; }
/// <summary> /// Evolves the requisite number of agents who satisfy the MC of the given maze. /// </summary> /// <param name="genomeFactory">The agent genome factory.</param> /// <param name="seedAgentList">The seed population of agents.</param> /// <param name="mazeStructure">The maze structure on which agents are to be evaluated.</param> /// <returns></returns> private List<NeatGenome> EvolveViableAgents(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> seedAgentList, MazeStructure mazeStructure) { List<NeatGenome> viableMazeAgents; uint restartCount = 0; ulong initializationEvaluations; do { // Instantiate the internal initialization algorithm _mazeNavigationInitializer.InitializeAlgorithm(ParallelOptions, seedAgentList.ToList(), genomeFactory, mazeStructure, new NeatGenomeDecoder(ActivationScheme), 0); // Run the initialization algorithm until the requested number of viable seed genomes are found viableMazeAgents = _mazeNavigationInitializer.EvolveViableGenomes(out initializationEvaluations, _maxInitializationEvaluations, restartCount); restartCount++; // Repeat if maximum allotted evaluations is exceeded } while (_maxInitializationEvaluations != null && viableMazeAgents == null && initializationEvaluations > _maxInitializationEvaluations); return viableMazeAgents; }
/// <summary> /// Creates the evolution algorithm container using the given factories and genome lists. /// </summary> /// <param name="genomeFactory1">The agent genome factory.</param> /// <param name="genomeFactory2">The maze genome factory.</param> /// <param name="genomeList1">The agent genome list.</param> /// <param name="genomeList2">The maze genome list.</param> /// <returns>The instantiated coevolution algorithm container.</returns> public override ICoevolutionAlgorithmContainer<NeatGenome, MazeGenome> CreateCoevolutionAlgorithmContainer( IGenomeFactory<NeatGenome> genomeFactory1, IGenomeFactory<MazeGenome> genomeFactory2, List<NeatGenome> genomeList1, List<MazeGenome> genomeList2) { List<NeatGenome> seedAgentPopulation = new List<NeatGenome>(); // Compute the maze max complexity ((MazeGenomeFactory) genomeFactory2).MaxComplexity = MazeUtils.DetermineMaxPartitions(_mazeHeight, _mazeWidth, 200); // Create maze decoder to decode initialization mazes MazeDecoder mazeDecoder = new MazeDecoder(_mazeHeight, _mazeWidth, _mazeScaleMultiplier); // Loop through every maze and evolve the requisite number of viable genomes that solve it for (int idx = 0; idx < genomeList2.Count; idx++) { Console.WriteLine(@"Evolving viable agents for maze population index {0} and maze ID {1}", idx, genomeList2[idx].Id); // Evolve the number of agents required to meet the success MC for the current maze List<NeatGenome> viableMazeAgents = EvolveViableAgents(genomeFactory1, genomeList1.ToList(), mazeDecoder.Decode(genomeList2[idx])); // Add the viable agent genomes who solve the current maze (but avoid adding duplicates, as identified by the genome ID) // Note that it's fine to have multiple mazes solved by the same agent, so in this case, we'll leave the agent // in the pool of seed agent genomes foreach ( NeatGenome viableMazeAgent in viableMazeAgents.Where( viableMazeAgent => seedAgentPopulation.Select(sap => sap.Id).Contains(viableMazeAgent.Id) == false)) { seedAgentPopulation.Add(viableMazeAgent); } } // If we still lack the genomes to fill out agent specie count while still satisfying the maze MC, // iteratively pick a random maze and evolve agents on that maze until we reach the requisite number while (seedAgentPopulation.ToList().Count < _numAgentSuccessCriteria*AgentNumSpecies) { FastRandom rndMazePicker = new FastRandom(); // Pick a random maze on which to evolve agent(s) MazeGenome mazeGenome = genomeList2[rndMazePicker.Next(genomeList2.Count - 1)]; Console.WriteLine( @"Continuing viable agent evolution on maze {0}, with {1} of {2} required agents in place", mazeGenome.Id, seedAgentPopulation.Count, (_numAgentSuccessCriteria*AgentNumSpecies)); // Evolve the number of agents required to meet the success MC for the maze List<NeatGenome> viableMazeAgents = EvolveViableAgents(genomeFactory1, genomeList1.ToList(), mazeDecoder.Decode(mazeGenome)); // Iterate through each viable agent and remove them if they've already solved a maze or add them to the list // of viable agents if they have not foreach (NeatGenome viableMazeAgent in viableMazeAgents) { // If they agent has already solved maze and is in the list of viable agents, remove that agent // from the pool of seed genomes (this is done because here, we're interested in getting unique // agents and want to avoid an endless loop wherein the same viable agents are returned) if (seedAgentPopulation.Select(sap => sap.Id).Contains(viableMazeAgent.Id)) { genomeList1.Remove(viableMazeAgent); } // Otherwise, add that agent to the list of viable agents else { seedAgentPopulation.Add(viableMazeAgent); } } } // Set dummy fitness so that seed maze(s) will be marked as evaluated foreach (MazeGenome mazeGenome in genomeList2) { mazeGenome.EvaluationInfo.SetFitness(0); } // Reset primary NEAT genome parameters on agent genome factory ((NeatGenomeFactory) genomeFactory1).ResetNeatGenomeParameters(NeatGenomeParameters); // Create the NEAT (i.e. navigator) queueing evolution algorithm AbstractEvolutionAlgorithm<NeatGenome> neatEvolutionAlgorithm = new MultiQueueNeatEvolutionAlgorithm<NeatGenome>( new NeatEvolutionAlgorithmParameters { SpecieCount = AgentNumSpecies, MaxSpecieSize = AgentDefaultPopulationSize/AgentNumSpecies }, new ParallelKMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0), ParallelOptions), null, NavigatorBatchSize, RunPhase.Primary, _navigatorEvolutionDataLogger, _navigatorLogFieldEnableMap, _navigatorPopulationGenomesDataLogger, _populationLoggingBatchInterval); // Create the maze queueing evolution algorithm AbstractEvolutionAlgorithm<MazeGenome> mazeEvolutionAlgorithm = new MultiQueueNeatEvolutionAlgorithm<MazeGenome>( new NeatEvolutionAlgorithmParameters { SpecieCount = MazeNumSpecies, MaxSpecieSize = MazeDefaultPopulationSize/MazeNumSpecies }, new ParallelKMeansClusteringStrategy<MazeGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0), ParallelOptions), null, MazeBatchSize, RunPhase.Primary, _mazeEvolutionDataLogger, _mazeLogFieldEnableMap, _mazePopulationGenomesDataLogger, _populationLoggingBatchInterval); // Create the maze phenome evaluator IPhenomeEvaluator<MazeStructure, BehaviorInfo> mazeEvaluator = new MazeEnvironmentMCSEvaluator( _maxTimesteps, _minSuccessDistance, BehaviorCharacterizationFactory, _numAgentSuccessCriteria, 0); // Create navigator phenome evaluator IPhenomeEvaluator<IBlackBox, BehaviorInfo> navigatorEvaluator = new MazeNavigatorMCSEvaluator( _maxTimesteps, _minSuccessDistance, BehaviorCharacterizationFactory, _numMazeSuccessCriteria); // Create maze genome decoder IGenomeDecoder<MazeGenome, MazeStructure> mazeGenomeDecoder = new MazeDecoder(_mazeHeight, _mazeWidth, _mazeScaleMultiplier); // Create navigator genome decoder IGenomeDecoder<NeatGenome, IBlackBox> navigatorGenomeDecoder = new NeatGenomeDecoder(ActivationScheme); // Create the maze genome evaluator IGenomeEvaluator<MazeGenome> mazeFitnessEvaluator = new ParallelGenomeBehaviorEvaluator<MazeGenome, MazeStructure>(mazeGenomeDecoder, mazeEvaluator, SelectionType.Queueing, SearchType.MinimalCriteriaSearch, ParallelOptions); // Create navigator genome evaluator IGenomeEvaluator<NeatGenome> navigatorFitnessEvaluator = new ParallelGenomeBehaviorEvaluator<NeatGenome, IBlackBox>(navigatorGenomeDecoder, navigatorEvaluator, SelectionType.Queueing, SearchType.MinimalCriteriaSearch, ParallelOptions); // Create the coevolution container ICoevolutionAlgorithmContainer<NeatGenome, MazeGenome> coevolutionAlgorithmContainer = new CoevolutionAlgorithmContainer<NeatGenome, MazeGenome>(neatEvolutionAlgorithm, mazeEvolutionAlgorithm); // Initialize the container and component algorithms coevolutionAlgorithmContainer.Initialize(navigatorFitnessEvaluator, genomeFactory1, seedAgentPopulation, AgentDefaultPopulationSize, mazeFitnessEvaluator, genomeFactory2, genomeList2, MazeDefaultPopulationSize, MaxGenerations, MaxEvaluations); return coevolutionAlgorithmContainer; }
private void loadSeedGenomesToolStripMenuItem_Click(object sender, EventArgs e) { string popFilePath = SelectFileToOpen("Load seed genomes", "pop.xml", "(*.pop.xml)|*.pop.xml"); if(string.IsNullOrEmpty(popFilePath)) { return; } // Parse population size from GUI field. int? popSize = ParseInt(txtParamPopulationSize); if(null == popSize) { return; } try { // Get the currently selected experiment. INeatExperiment experiment = GetSelectedExperiment(); // Load genome from file. List<NeatGenome> genomeList; using(XmlReader xr = XmlReader.Create(popFilePath)) { genomeList = experiment.LoadPopulation(xr); } if(genomeList.Count == 0) { __log.WarnFormat("No seed genomes loaded from file [{0}]", popFilePath); return; } // Create genome list from seed genomes, assign to local variables and update GUI. _genomeFactory = genomeList[0].GenomeFactory; _genomeList = _genomeFactory.CreateGenomeList(popSize.Value, 0u, genomeList); UpdateGuiState(); } catch(Exception ex) { __log.ErrorFormat("Error loading seed genomes. Error message [{0}]", ex.Message); } }
private void btnSearchReset_Click(object sender, EventArgs e) { _genomeFactory = null; _genomeList = null; // TODO: Proper cleanup of EA - e.g. main worker thread termination. _ea = null; _champGenomeFitness = 0.0; Logger.Clear(); UpdateGuiState_ResetStats(); UpdateGuiState(); }
private void btnCreateRandomPop_Click(object sender, EventArgs e) { // Parse population size and interconnection proportion from GUI fields. int? popSize = ParseInt(txtParamPopulationSize); if(null == popSize) { return; } double? initConnProportion = ParseDouble(txtParamInitialConnectionProportion); if(null == initConnProportion) { return; } INeatExperiment experiment = GetSelectedExperiment(); experiment.NeatGenomeParameters.InitialInterconnectionsProportion = initConnProportion.Value; // Create a genome factory appropriate for the experiment. IGenomeFactory<NeatGenome> genomeFactory = experiment.CreateGenomeFactory(); // Create an initial population of randomly generated genomes. List<NeatGenome> genomeList = genomeFactory.CreateGenomeList(popSize.Value, 0u); // Assign population to form variables & update GUI appropriately. _genomeFactory = genomeFactory; _genomeList = genomeList; UpdateGuiState(); }
/// <summary> /// Configures and instantiates the initialization evolutionary algorithm. /// </summary> /// <param name="parallelOptions">Synchronous/Asynchronous execution settings.</param> /// <param name="genomeList">The initial population of genomes.</param> /// <param name="genomeFactory">The genome factory initialized by the main evolution thread.</param> /// <param name="mazeEnvironment">The maze on which to evaluate the navigators.</param> /// <param name="genomeDecoder">The decoder to translate genomes into phenotypes.</param> /// <param name="startingEvaluations"> /// The number of evaluations that preceeded this from which this process will pick up /// (this is used in the case where we're restarting a run because it failed to find a solution in the allotted time). /// </param> public override void InitializeAlgorithm(ParallelOptions parallelOptions, List<NeatGenome> genomeList, IGenomeFactory<NeatGenome> genomeFactory, MazeStructure mazeEnvironment, IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder, ulong startingEvaluations) { // Set the boiler plate algorithm parameters base.InitializeAlgorithm(parallelOptions, genomeList, genomeDecoder, startingEvaluations); // Create the initialization evolution algorithm. InitializationEa = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(SpeciationStrategy, ComplexityRegulationStrategy, RunPhase.Initialization); // Create IBlackBox evaluator. MazeNavigatorFitnessInitializationEvaluator mazeNavigatorEvaluator = new MazeNavigatorFitnessInitializationEvaluator(MaxTimesteps, MinSuccessDistance, MaxDistanceToTarget, mazeEnvironment, startingEvaluations); // Create the genome evaluator IGenomeEvaluator<NeatGenome> fitnessEvaluator = new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>( genomeDecoder, mazeNavigatorEvaluator, parallelOptions); // Only pull the number of genomes from the list equivalent to the initialization algorithm population size // (this is to handle the case where the list was created in accordance with the primary algorithm // population size, which is quite likely larger) genomeList = genomeList.Take(PopulationSize).ToList(); // Replace genome factory primary NEAT parameters with initialization parameters ((NeatGenomeFactory) genomeFactory).ResetNeatGenomeParameters(NeatGenomeParameters); // Initialize the evolution algorithm InitializationEa.Initialize(fitnessEvaluator, genomeFactory, genomeList, null, null); }
/// <summary> /// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome2 population and their associated/parent genome2 factory. /// </summary> public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, new ParallelOptions()); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = new NullComplexityRegulationStrategy();// ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm<NeatGenome> ea = new NeatEvolutionAlgorithm<NeatGenome>(EvoParameters, speciationStrategy, complexityRegulationStrategy); // Create a genome list evaluator. This packages up the genome decoder with the phenome evaluator. if(Evaluator == null) Evaluator = CreateEvaluator(); // Initialize the evolution algorithm. ea.Initialize(Evaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return ea; }
/// <summary> /// Creates and returns a GenerationalNeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. /// Various sub-parts of the algorithm are also constructed and connected up. This overload accepts a pre-built genome /// population and their associated/parent genome factory. /// </summary> /// <param name="genomeFactory">The NEAT genome factory.</param> /// <param name="genomeList">The initial list of genomes.</param> /// <returns>The NEAT evolution algorithm.</returns> public INeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { FileDataLogger logger = null; // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Initialize the logger if (_generationalLogFile != null) { logger = new FileDataLogger(_generationalLogFile); } // Create the evolution algorithm GenerationalNeatEvolutionAlgorithm<NeatGenome> ea = new GenerationalNeatEvolutionAlgorithm<NeatGenome>(NeatEvolutionAlgorithmParameters, speciationStrategy, complexityRegulationStrategy, logger); // Create evalutor BinaryEvolvedAutoencoderEvaluator evaluator = new BinaryEvolvedAutoencoderEvaluator(_trainingImagesFilename, InputCount, _numImageSamples, _learningRate, _numBackpropIterations, _trainingSampleProportion); // Create genome decoder IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); // Create a genome list evaluator. This packages up the genome decoder with the genome evaluator IGenomeEvaluator<NeatGenome> innerFitnessEvaluator = new ParallelGenomeFitnessEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator, _parallelOptions); // 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 determined by examining each genome's evaluation info object. IGenomeEvaluator<NeatGenome> selectiveFitnessEvaluator = new SelectiveGenomeFitnessEvaluator<NeatGenome>( innerFitnessEvaluator, SelectiveGenomeFitnessEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); // Initialize the evolution algorithm ea.Initialize(selectiveFitnessEvaluator, genomeFactory, genomeList, null); // Finished. Return the evolution algorithm return ea; }
public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new KMeansClusteringStrategy<NeatGenome>(distanceMetric); IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); NeatEvolutionAlgorithm<NeatGenome> ea = new NeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create black box evaluator SimpleEvaluator evaluator = new SimpleEvaluator(_optimizer); IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = CreateGenomeDecoder(); IGenomeListEvaluator<NeatGenome> innerEvaluator = new UnityParallelListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, evaluator, _optimizer); IGenomeListEvaluator<NeatGenome> selectiveEvaluator = new SelectiveGenomeListEvaluator<NeatGenome>(innerEvaluator, SelectiveGenomeListEvaluator<NeatGenome>.CreatePredicate_OnceOnly()); //ea.Initialize(selectiveEvaluator, genomeFactory, genomeList); ea.Initialize(innerEvaluator, genomeFactory, genomeList); return ea; }
private void loadPopulationToolStripMenuItem_Click(object sender, EventArgs e) { string popFilePath = SelectFileToOpen("Load population", "pop.xml", "(*.pop.xml)|*.pop.xml"); if(string.IsNullOrEmpty(popFilePath)) { return; } try { // Get the currently selected experiment. INeatExperiment experiment = GetSelectedExperiment(); // Load population of genomes from file. List<NeatGenome> genomeList; using(XmlReader xr = XmlReader.Create(popFilePath)) { genomeList = experiment.LoadPopulation(xr); } if(genomeList.Count == 0) { __log.WarnFormat("No genomes loaded from population file [{0}]", popFilePath); return; } // Assign genome list and factory to class variables and update GUI. _genomeFactory = genomeList[0].GenomeFactory; _genomeList = genomeList; UpdateGuiState(); } catch(Exception ex) { __log.ErrorFormat("Error loading population. Error message [{0}]", ex.Message); } }
/// <summary> /// Create and return a NeatEvolutionAlgorithm object ready for running the NEAT algorithm/search. Various sub-parts /// of the algorithm are also constructed and connected up. /// This overload accepts a pre-built genome2 population and their associated/parent genome2 factory. /// </summary> public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeFactory<NeatGenome> genomeFactory, List<NeatGenome> genomeList) { // Create distance metric. Mismatched genes have a fixed distance of 10; for matched genes the distance is their weigth difference. IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy<NeatGenome> speciationStrategy = new ParallelKMeansClusteringStrategy<NeatGenome>(distanceMetric, _parallelOptions); // Create complexity regulation strategy. IComplexityRegulationStrategy complexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy(_complexityRegulationStr, _complexityThreshold); // Create the evolution algorithm. NeatEvolutionAlgorithm<NeatGenome> ea = new NeatEvolutionAlgorithm<NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); // Create genome2 decoder. IGenomeDecoder<NeatGenome, IBlackBox> genomeDecoder = new NeatGenomeDecoder(_activationScheme); // Create a genome2 list evaluator. This packages up the genome2 decoder with the genome2 evaluator. IGenomeListEvaluator<NeatGenome> genomeListEvaluator = new ParallelGenomeListEvaluator<NeatGenome, IBlackBox>(genomeDecoder, PhenomeEvaluator, _parallelOptions); // 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()); // Initialize the evolution algorithm. ea.Initialize(genomeListEvaluator, genomeFactory, genomeList); // Finished. Return the evolution algorithm return ea; }