private NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeListEvaluator <NeatGenome> evaluator, int populationSize) { var genomeFactory = new NeatGenomeFactory(_inputCount.Value, _outputCount.Value, _neatGenomeParams); var genomeList = genomeFactory.CreateGenomeList(populationSize, 0); return(CreateEvolutionAlgorithm(evaluator, genomeList)); }
/// <summary> /// 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 = GetGenomeListEvaluator(genomeDecoder); // 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); }
/// <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 override void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator, IGenomeFactory <TGenome> genomeFactory, List <TGenome> genomeList) { base.Initialize(genomeListEvaluator, genomeFactory, genomeList); Initialize(); }
public IEnumerator Start() { Debug.Assert(_populationSize > 5); Debug.Log($"Main thread is {Thread.CurrentThread.ManagedThreadId}"); Application.runInBackground = true; _activationScheme = NetworkActivationScheme.CreateCyclicFixedTimestepsScheme(2, true); _eaParams = new NeatEvolutionAlgorithmParameters(); _eaParams.ElitismProportion = _elitismProportion; _eaParams.SpecieCount = _specieCount; _neatGenomeParams = new NeatGenomeParameters(); _neatGenomeParams.AddConnectionMutationProbability = _AddConnectionMutationProbability; _neatGenomeParams.DeleteConnectionMutationProbability = _DeleteConnectionMutationProbability; _neatGenomeParams.AddNodeMutationProbability = _AddNodeMutationProbability; _neatGenomeParams.ConnectionWeightMutationProbability = _ConnectionWeightMutationProbability; _neatGenomeParams.InitialInterconnectionsProportion = _InitialInterconnectionsProportion; _neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork; Debug.Log("Creating evaluator"); yield return(new WaitForSeconds(0.1f)); _evaluator = CreateEvaluator(); Debug.Log("Creating algorithm"); yield return(new WaitForSeconds(0.1f)); _ea = CreateEvolutionAlgorithm(_evaluator, _populationSize); _ea.UpdateEvent += _ea_UpdateEvent; }
/// <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 override void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator, IGenomeFactory <TGenome> genomeFactory, int populationSize) { base.Initialize(genomeListEvaluator, genomeFactory, populationSize); Initialize(); }
/// <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 override void Initialize(IGenomeListEvaluator <TGenome> genomeListEvaluator, IGenomeFactory <TGenome> genomeFactory, List <TGenome> genomeList, bool addGenerationValue) { base.Initialize(genomeListEvaluator, genomeFactory, genomeList, addGenerationValue); Initialize(); }
/// <summary> /// Construct with the provided number of generations per champion, weight to the hall /// of fame fitness, and other parameters. /// The number of parallel threads defaults to Environment.ProcessorCount. /// </summary> public ParallelHallOfFameListEvaluator(uint generationsPerChampion, double hallOfFameWeight, AbstractGenerationalAlgorithm <TGenome> ea, IGenomeListEvaluator <TGenome> innerEvaluator, IGenomeDecoder <TGenome, TPhenome> genomeDecoder, ICoevolutionPhenomeEvaluator <TPhenome> phenomeEvaluator) : this(generationsPerChampion, hallOfFameWeight, ea, innerEvaluator, genomeDecoder, phenomeEvaluator, new ParallelOptions()) { }
/// <summary> /// Construct a new instance. /// </summary> /// <param name="eaSettings">NEAT evolution algorithm settings.</param> /// <param name="evaluator">An evaluator of lists of genomes.</param> /// <param name="speciationStrategy">Speciation strategy.</param> /// <param name="population">An initial population of genomes.</param> /// <param name="complexityRegulationStrategy">Complexity regulation strategy.</param> /// <param name="reproductionAsexualSettings">Asexual reproduction settings.</param> /// <param name="reproductionSexualSettings">Sexual reproduction settings.</param> /// <param name="weightMutationScheme">Connection weight mutation scheme.</param> /// <param name="rng">Random source.</param> public NeatEvolutionAlgorithm( NeatEvolutionAlgorithmSettings eaSettings, IGenomeListEvaluator <NeatGenome <T> > evaluator, ISpeciationStrategy <NeatGenome <T>, T> speciationStrategy, NeatPopulation <T> population, IComplexityRegulationStrategy complexityRegulationStrategy, NeatReproductionAsexualSettings reproductionAsexualSettings, NeatReproductionSexualSettings reproductionSexualSettings, WeightMutationScheme <T> weightMutationScheme, IRandomSource rng) { _eaSettingsCurrent = eaSettings ?? throw new ArgumentNullException(nameof(eaSettings)); _eaSettingsComplexifying = eaSettings; _eaSettingsSimplifying = eaSettings.CreateSimplifyingSettings(); _evaluator = evaluator ?? throw new ArgumentNullException(nameof(evaluator)); _speciationStrategy = speciationStrategy ?? throw new ArgumentNullException(nameof(speciationStrategy)); _pop = population ?? throw new ArgumentNullException(nameof(population)); _complexityRegulationStrategy = complexityRegulationStrategy ?? throw new ArgumentNullException(nameof(complexityRegulationStrategy)); if (reproductionAsexualSettings == null) { throw new ArgumentNullException(nameof(reproductionAsexualSettings)); } if (reproductionSexualSettings == null) { throw new ArgumentNullException(nameof(reproductionSexualSettings)); } _rng = rng; _genomeComparerDescending = new GenomeComparerDescending(evaluator.FitnessComparer); if (eaSettings.SpeciesCount > population.PopulationSize) { throw new ArgumentException("Species count is higher then the population size."); } _generationSeq = new Int32Sequence(); _reproductionAsexual = new NeatReproductionAsexual <T>( _pop.MetaNeatGenome, _pop.GenomeBuilder, _pop.GenomeIdSeq, population.InnovationIdSeq, _generationSeq, _pop.AddedNodeBuffer, reproductionAsexualSettings, weightMutationScheme); _reproductionSexual = new NeatReproductionSexual <T>( _pop.MetaNeatGenome, _pop.GenomeBuilder, _pop.GenomeIdSeq, _generationSeq, reproductionSexualSettings); _offspringBuilder = new OffspringBuilder <T>( _reproductionAsexual, _reproductionSexual, eaSettings.InterspeciesMatingProportion, evaluator.FitnessComparer); }
public DefaultEvolutionAlgorithm( EAParameters eaParams, IGenomeListEvaluator <TGenome> evaluator, ISelectionReproductionStrategy <TGenome> selectionReproStrategy, Population <TGenome> population) { _eaParams = eaParams; _evaluator = evaluator; _selectionReproStrategy = selectionReproStrategy; _pop = population; }
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, 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> /// 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)); }
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> /// Construct a new instance. /// </summary> /// <param name="eaSettings">NEAT evolution algorithm settings.</param> /// <param name="evaluator">An evaluator of lists of genomes.</param> /// <param name="speciationStrategy">Speciation strategy.</param> /// <param name="population">An initial population of genomes.</param> /// <param name="reproductionAsexualSettings">Asexual reproduction settings.</param> /// <param name="reproductionSexualSettings">Sexual reproduction settings.</param> /// <param name="weightMutationScheme">Connection weight mutation scheme.</param> public NeatEvolutionAlgorithm( NeatEvolutionAlgorithmSettings eaSettings, IGenomeListEvaluator <NeatGenome <T> > evaluator, ISpeciationStrategy <NeatGenome <T>, T> speciationStrategy, NeatPopulation <T> population, NeatReproductionAsexualSettings reproductionAsexualSettings, NeatReproductionSexualSettings reproductionSexualSettings, WeightMutationScheme <T> weightMutationScheme) : this(eaSettings, evaluator, speciationStrategy, population, reproductionAsexualSettings, reproductionSexualSettings, weightMutationScheme, RandomDefaults.CreateRandomSource()) { }
/// <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)); }
private NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeListEvaluator <NeatGenome> evaluator, List <NeatGenome> list) { IDistanceMetric distanceMetric = new ManhattanDistanceMetric(1.0, 0.0, 10.0); ISpeciationStrategy <NeatGenome> speciationStrategy = new KMeansClusteringStrategy <NeatGenome>(distanceMetric); IComplexityRegulationStrategy complexityRegulationStrategy = new DefaultComplexityRegulationStrategy(ComplexityCeilingType.Absolute, _complexityThreshold); NeatEvolutionAlgorithm <NeatGenome> neatEvolutionAlgorithm = new NeatEvolutionAlgorithm <NeatGenome>(_eaParams, speciationStrategy, complexityRegulationStrategy); var genomeFactory = new NeatGenomeFactory(_inputCount.Value, _outputCount.Value, _neatGenomeParams); neatEvolutionAlgorithm.Initialize(evaluator, genomeFactory, list); return(neatEvolutionAlgorithm); }
/// <summary> /// Constructs with the default NeatEvolutionAlgorithmParameters and speciation strategy /// (KMeansClusteringStrategy with ManhattanDistanceMetric). /// </summary> /* * public NeatEvolutionAlgorithm() * { * _eaParams = new NeatEvolutionAlgorithmParameters(); * _eaParamsComplexifying = _eaParams; * _eaParamsSimplifying = _eaParams.CreateSimplifyingParameters(); * _stats = new NeatAlgorithmStats(_eaParams); * _speciationStrategy = new KMeansClusteringStrategy<TGenome>(new ManhattanDistanceMetric()); * * _complexityRegulationMode = ComplexityRegulationMode.Complexifying; * _complexityRegulationStrategy = new NullComplexityRegulationStrategy(); * } */ /// <summary> /// Constructs with the provided NeatEvolutionAlgorithmParameters and ISpeciationStrategy. /// </summary> /* * public NeatEvolutionAlgorithm(NeatEvolutionAlgorithmParameters eaParams, * ISpeciationStrategy<TGenome> speciationStrategy, * IComplexityRegulationStrategy complexityRegulationStrategy) * { * _eaParams = eaParams; * _eaParamsComplexifying = _eaParams; * _eaParamsSimplifying = _eaParams.CreateSimplifyingParameters(); * _stats = new NeatAlgorithmStats(_eaParams); * _speciationStrategy = speciationStrategy; * * _complexityRegulationMode = ComplexityRegulationMode.Complexifying; * _complexityRegulationStrategy = complexityRegulationStrategy; * } */ public void Construct(NeatEvolutionAlgorithmParameters eaParams, ISpeciationStrategy <TGenome> speciationStrategy, IComplexityRegulationStrategy complexityRegulationStrategy, IGenomeListEvaluator <TGenome> initialGenomeListEvaluator) { _eaParams = eaParams; _eaParamsComplexifying = _eaParams; _eaParamsSimplifying = _eaParams.CreateSimplifyingParameters(); _stats = new NeatAlgorithmStats(_eaParams); _speciationStrategy = speciationStrategy; _complexityRegulationMode = ComplexityRegulationMode.Complexifying; _complexityRegulationStrategy = complexityRegulationStrategy; _initialGenomeListEvaluator = initialGenomeListEvaluator; }
/// <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); }
/// <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)); }
/// <summary> /// Construct with the provided number of generations per champion, weight to the hall /// of fame fitness, parallel options, and other parameters. /// </summary> public ParallelHallOfFameListEvaluator(uint generationsPerChampion, double hallOfFameWeight, AbstractGenerationalAlgorithm <TGenome> ea, IGenomeListEvaluator <TGenome> innerEvaluator, IGenomeDecoder <TGenome, TPhenome> genomeDecoder, ICoevolutionPhenomeEvaluator <TPhenome> phenomeEvaluator, ParallelOptions options) { Debug.Assert(hallOfFameWeight >= 0d); Debug.Assert(hallOfFameWeight <= 1d); _generationsPerChampion = generationsPerChampion; _hallOfFameWeight = hallOfFameWeight; _innerEvaluator = innerEvaluator; _genomeDecoder = genomeDecoder; _phenomeEvaluator = phenomeEvaluator; _parallelOptions = options; _hallOfFame = new List <TGenome>(); ea.UpdateEvent += new EventHandler(ea_UpdateEvent); }
/// <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. /// Uses the experiments default population size defined in the experiment's config XML. /// </summary> public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(IGenomeListEvaluator<NeatGenome> eval = null) { return CreateEvolutionAlgorithm(_populationSize, eval); }
/// <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) { //NOTE: Not calling the other public overload because it's virtual and that could mess with derived classes Initialize_private(genomeListEvaluator, genomeFactory, genomeFactory.CreateGenomeList(populationSize, _currentGeneration)); }
/// <summary> /// Construct with the provided IGenomeDecoder and IPhenomeEvaluator. /// </summary> public SelectiveGenomeListEvaluator(IGenomeListEvaluator <TGenome> innerEvaluator, Predicate <TGenome> selectionPredicate) { _innerEvaluator = innerEvaluator; _selectionPredicate = selectionPredicate; }
/// <summary> /// Log /// </summary> /// <param name="ea"></param> /// <param name="igle"></param> public void Log(NeatEvolutionAlgorithm <NeatGenome> ea) { Func <NeatGenome, double> costOfNeatGenome = neatGenome => neatGenome.EvaluationInfo.AuxFitnessArr[0]._value; // I made the evaluator public myself... IGenomeListEvaluator <NeatGenome> igle = ea._genomeListEvaluator; var champGenome = ea.GenomeList.Aggregate( (currentBest, candidate) => costOfNeatGenome(currentBest) <= costOfNeatGenome(candidate) ? currentBest : candidate); var currentTime = DateTime.Now; var currentGeneration = ea.CurrentGeneration; var minimumCost = costOfNeatGenome(champGenome); var meanCost = ea.GenomeList.Average(costOfNeatGenome); var highestCost = ea.GenomeList.Max(costOfNeatGenome); var meanSpecieChampCost = ea.SpecieList.Average( specieList => specieList.GenomeList.Min(costOfNeatGenome)); var champComplexity = champGenome.Complexity; var meanComplexity = ea.GenomeList.Average(neatGenome => neatGenome.Complexity); var maxComplexity = ea.GenomeList.Max(neatGenome => neatGenome.Complexity); //double totalEvaluationCount = ea.GenomeList.Sum(neatGenome => neatGenome.EvaluationInfo.EvaluationCount); var totalEvaluationCount = igle.EvaluationCount; var timeSinceLastCallToLog = currentTime - _oldCurrentTime; // To smooth out the evaluations per second statistic, we update only if at least one second has elapsed since it was last updated. // This was taken from NeatEvolutionAlgorithm.cs // Note that there, the documentation does not actually correspond to the implementation. // // I would actually write down the exact number I'm getting, calculating // sensible rolling averages during processing of results because I save // the result as a double instead of an integer. // For me, this does not really matter though: a generation takes far longer // than a second, and the Log function is called only at the end of a generation... //if (timeSinceLastCallToLog.Milliseconds > 999) //{ var evaluationsSinceLastUpdate = totalEvaluationCount - _oldTotalEvaluationCount; var evaluationsPerSecond = ((double)TimeSpan.TicksPerSecond * evaluationsSinceLastUpdate) / (timeSinceLastCallToLog.Ticks); // Reset working variables _oldCurrentTime = currentTime; _oldTotalEvaluationCount = totalEvaluationCount; _oldEvaluationCountPerSecond = evaluationsPerSecond; //} IEnumerable <int> specieSizes = ea.SpecieList.Select(specie => specie.GenomeList.Count).ToList(); String specieSizeString = String.Join(";", specieSizes); //ea.SpecieList.Aggregate("",(accumulatedString,specie) => specie.) _neatsim_logger.WriteLine( string.Format( CultureInfo.InvariantCulture, "{0:yyyy-MM-dd HH:mm:ss.fff},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12}", currentTime, //1 currentGeneration, //2 minimumCost, //3 meanCost, //4 highestCost, //5 meanSpecieChampCost, //6 champComplexity, //7 meanComplexity, //8 maxComplexity, //9 totalEvaluationCount, //10 _oldEvaluationCountPerSecond, //11 ea.ComplexityRegulationMode, //12 specieSizeString //13 ) ); _neatsim_logger.Flush(); var fitnessValues = ea.GenomeList.Select(individual => individual.EvaluationInfo.AuxFitnessArr[0]._value); String fitnessValueString = String.Join(";", fitnessValues); _fitness_logger.WriteLine(fitnessValueString); _fitness_logger.Flush(); }
/// <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) { Initialize_private(genomeListEvaluator, genomeFactory, genomeList); }
/// <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. /// Uses the experiments default population size defined in the experiment's config XML. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(IGenomeListEvaluator <NeatGenome> eval = null) { return(CreateEvolutionAlgorithm(_populationSize, eval)); }
/// <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 population size parameter that specifies how many genomes to create in an initial randomly /// generated population. /// </summary> public NeatEvolutionAlgorithm <NeatGenome> CreateEvolutionAlgorithm(int populationSize, IGenomeListEvaluator <NeatGenome> eval = null) { // Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes. IGenomeFactory <NeatGenome> genomeFactory = CreateGenomeFactory(); // Create an initial population of randomly generated genomes. List <NeatGenome> genomeList = genomeFactory.CreateGenomeList(populationSize, 0); // Create evolution algorithm. return(CreateEvolutionAlgorithm(genomeFactory, genomeList, eval)); }
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); }
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 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 population size parameter that specifies how many genomes to create in an initial randomly /// generated population. /// </summary> public NeatEvolutionAlgorithm<NeatGenome> CreateEvolutionAlgorithm(int populationSize, IGenomeListEvaluator<NeatGenome> eval = null) { // Create a genome factory with our neat genome parameters object and the appropriate number of input and output neuron genes. IGenomeFactory<NeatGenome> genomeFactory = CreateGenomeFactory(); // Create an initial population of randomly generated genomes. List<NeatGenome> genomeList = genomeFactory.CreateGenomeList(populationSize, 0); // Create evolution algorithm. return CreateEvolutionAlgorithm(genomeFactory, genomeList, eval); }