/// <summary> /// Create the next generation of programs. /// </summary> public void ComputeNextGeneration(int Generation) { if (m_PopulatonFactory == null) { m_PopulatonFactory = new GPPopulationFactory(this, this.Training.Columns); } // // Create the next generation of programs GPPopulation popNew = m_PopulatonFactory.ComputeNext(Generation, m_Population, m_Fitness, m_SeedPrograms); // // If the Population size changed, update the configuration if (popNew.Count != m_Population.Count) { this.Profile.PopulationSize = popNew.Count; Console.WriteLine("GPServer: Memory is low, Population size reduced to ({0})", popNew.Count); // // Reset the Fitness object m_Fitness.TerminateProcessingThreads(); m_Fitness = null; } m_Population = popNew; // // Clear out any seed programs we just used ResetSeedPrograms(); }
/// <summary> /// Compute the fitness of the entire Population and return the value of /// the best program in the Population. /// </summary> public void EvaluateFitness(int Generation) { // // First time through the fitness object doesn't exist, so have to create it if (m_Fitness == null) { m_Fitness = new GPFitness( this, this.Training, GPEnums.RESULTS_TOLERANCE, m_FunctionSet.UseInputHistory); } m_BestProgram = m_Fitness.Compute(Generation, m_Population); // // Always simplify a program before it is transmitted. m_BestProgram.ConvertToTree(this.FunctionSet, false); m_BestProgram.Edit(); m_BestProgram.ConvertToArray(this.FunctionSet); // // Obtain the Population stats m_Population.ComputeComplexity( out m_PopulationComplexityMin, out m_PopulationComplexityMax, out m_PopulationComplexityAve); }
/// <summary> /// Creates the next generation of programs. This method also keeps tabs on memory /// as it creates the new Population. If we run out of physical memory then the /// new Population size is changed to wherever we ran out of memory. /// </summary> /// <param name="nGeneration">Which generation is currently being processed</param> /// <param name="Population">Reference to the Population just computed for fitness</param> /// <param name="Fitness">Fitness object with the fitness computation results</param> /// <param name="AutoReproduce">List of programs to automatically reproduce into the next generation</param> /// <returns>Reference to the new Population to use</returns> public GPPopulation ComputeNext(int nGeneration, GPPopulation Population, GPFitness Fitness, List <GPProgram> AutoReproduce) { m_PopCurrent = Population; m_Fitness = Fitness; // // Setup the program selection delegate switch (m_ModelerConfig.Profile.Reproduction) { case GPEnums.Reproduction.Tournament: ExecProgramSelection = new DELProgramSelection(Fitness.FitnessSelection.SelectProgramTournament); break; case GPEnums.Reproduction.OverSelection: ExecProgramSelection = new DELProgramSelection(Fitness.FitnessSelection.SelectProgramOverSelection); break; } // // Create a Tree Factory object - It helps in support of the mutation and // crossover operations m_TreeFactory = new GPProgramTreeFactory(m_ModelerConfig, m_InputDimension); return(ComputeNext(Population, Fitness, AutoReproduce)); }
/// <summary> /// This method instructs the server object to clean up as much memory /// as possible. /// </summary> public void ForceCleanup() { m_Population = null; m_Fitness.TerminateProcessingThreads(); m_Fitness = null; m_Training = null; System.GC.Collect(); }
public GPPopulation ComputeNext(GPPopulation PopCurrent, GPFitness Fitness, List <GPProgram> AutoReproduce) { GPPopulation PopNew = new GPPopulation(m_ModelerConfig); // // Add the new programs into the next generation automatically foreach (GPProgram Seed in AutoReproduce) { PopNew.Programs.Add(Seed); } // // Automatically reproduce the best program into the next generation PopNew.Programs.Add((GPProgram)Fitness.BestProgramRef.Clone()); // // Now, go ahead and fill out the rest of the Population while (PopNew.Count < m_ModelerConfig.Profile.PopulationSize) { // // Make a probabilistic selection between... // Reproduction // Mutation // Crossover double Choice = GPUtilities.rngNextDouble(); double Cumulative = m_ModelerConfig.Profile.ProbabilityReproductionD; bool bSelected = false; if (Choice <= Cumulative) { Reproduce(PopNew, Fitness.FitnessSelection); bSelected = true; } Cumulative += m_ModelerConfig.Profile.ProbabilityMutationD; if (!bSelected && (Choice <= Cumulative)) { Mutate(PopNew, Fitness.FitnessSelection); bSelected = true; } Cumulative += m_ModelerConfig.Profile.ProbabilityCrossoverD; if (!bSelected && (Choice <= Cumulative)) { Crossover(PopNew, Fitness.FitnessSelection); bSelected = true; } // // Only check every 100 times to save a little time on doing this // check. if (PopNew.Count % 100 == 0) { if (!CheckMemory()) { // // Do a garbage collect just to be sure and check again System.GC.Collect(); if (!CheckMemory()) { break; } } } } return(PopNew); }