/// <summary> /// Evaluates target function given by <see cref="TestDataUtils"/> on every genome provided. /// </summary> /// <param name="encoder">Encoder to convert genomes to double arrays.</param> /// <param name="genomes">Genomes to evaluate.</param> /// <returns>Results for every genome.</returns> public static List <double> EvaluateTargetFunction(IGenomeTransformation encoder, List <Genome> genomes) { var encodedGenomes = genomes.Select(g => encoder.ConvertGenomeToArray(g)); var result = encodedGenomes.Select(eg => TestDataUtils.EvaluateTargetFunction(eg)).ToList(); return(result); }
public void EngineerValidGenomes() { this.InitializeAndPopulateProperties(this.GetDefaultParameterTree(), this.GetDefaultAlgorithmTunerConfiguration()); this.EngineeringInstance.TrainForest(this.TrainingData); var engineeredGenomes = this.EngineeringInstance.EngineerGenomes( this.PopulationCompetitive, this.PopulationNonCompetitive.AsReadOnly(), this.PopulationCurrentComplete).ToList(); Assert.NotNull(engineeredGenomes); Assert.Equal(this.PopulationCompetitive.Count, engineeredGenomes.Count); foreach (var genome in engineeredGenomes) { Assert.NotNull(genome); Assert.True(genome.IsEngineered); this.ValidateGenomeValues(genome); } var populationPerformance = TestDataUtils.EvaluateTargetFunction( this.EngineeringInstance.GenomeTransformator, this.PopulationCurrentComplete); var engineeredPerformance = TestDataUtils.EvaluateTargetFunction( this.EngineeringInstance.GenomeTransformator, engineeredGenomes); var popAverage = populationPerformance.Average(); var engAverage = engineeredPerformance.Average(); Assert.True(engAverage <= popAverage); }
/// <summary> /// Generates training data. /// </summary> /// <param name="tree"><see cref="ParameterTree"/> to base genomes on.</param> /// <returns>The generated <see cref="TrainingDataWrapper"/>.</returns> private TrainingDataWrapper GetDefaultTrainingData(ParameterTree tree) { return(TestDataUtils.GenerateTrainingData( tree, this.EngineeringInstance.GenomeTransformator, GeneticEngineeringTest.PopsizeHalf, 1, this.CurrentConfig)); }
/// <summary> /// Initializes <see cref="TrainingData"/> and <see cref="PopulationNonCompetitive"/>, <see cref="PopulationCompetitive"/> as well as <see cref="PopulationCurrentComplete"/>. /// </summary> private void InitializeTrainingDataAndCurrentPopulation() { this.TrainingData = this.GetDefaultTrainingData(this.CurrentTree); this.PopulationNonCompetitive = TestDataUtils.GenerateGenomes( this.CurrentTree, this.CurrentConfig, GeneticEngineeringTest.PopsizeHalf); this.PopulationCompetitive = this.TrainingData.Genomes.ToList().InflateAndShuffle(GeneticEngineeringTest.PopsizeHalf); this.PopulationCurrentComplete = this.PopulationCompetitive.Union(this.PopulationNonCompetitive).ToList(); }
/// <summary> /// Simulates a tuner run for the specified number of generations and stores results in a new <see cref="TrainingDataWrapper"/>. /// </summary> /// <param name="tree"><see cref="ParameterTree"/> to base genomes on.</param> /// <param name="encoder">Strategy to convert genomes to double arrays.</param> /// <param name="genomeCount">Number of genomes to add to result per generation.</param> /// <param name="generations">Number of generations to simulate.</param> /// <param name="config"><see cref="AlgorithmTunerConfiguration"/>, required to generate new genomes.</param> /// <returns>The created <see cref="TrainingDataWrapper"/>.</returns> public static TrainingDataWrapper GenerateTrainingData( ParameterTree tree, IBulkGenomeTransformation encoder, int genomeCount, int generations, AlgorithmTunerConfiguration config) { var result = new TrainingDataWrapper( new Dictionary <Genome, List <GenomeTournamentRank> >(Genome.GenomeComparer), generations - 1); // Start with correct number of random genomes. var randomGenomes = TestDataUtils.GenerateGenomes(tree, config, genomeCount); // Then simulate the correct number of generations. for (var currentGen = 0; currentGen < generations; currentGen++) { var fitness = TestDataUtils.EvaluateTargetFunction(encoder, randomGenomes); // add result for every genome for (var genomeIndex = 0; genomeIndex < genomeCount; genomeIndex++) { var currentGenome = randomGenomes[genomeIndex]; if (!result.TournamentResults.ContainsKey(currentGenome)) { result.TournamentResults[currentGenome] = new List <GenomeTournamentRank>(); } var tournamentResult = new GenomeTournamentRank() { GenerationId = currentGen, TournamentId = currentGen, TournamentRank = fitness[genomeIndex], }; result.TournamentResults[currentGenome].Add(tournamentResult); } // swap out some genomes var replaceCount = (int)Math.Ceiling(0.3 * genomeCount); var indiciesToReplace = Randomizer.Instance.ChooseRandomSubset( Enumerable.Range(0, genomeCount), replaceCount); var newGenomes = TestDataUtils.GenerateGenomes(tree, config, replaceCount); var replacementIndex = 0; foreach (var indexToReplace in indiciesToReplace) { randomGenomes[indexToReplace] = newGenomes[replacementIndex++]; } } return(result); }
/// <summary> /// Evaluates x[0] ^ 3 - 3 * x[0] + x[1] ^ 2 + \sum_{i=2}{(-1) ^ i * x[i]} on the provided variables. /// </summary> /// <param name="genomeEncoding">The variables to evaluate the function on.</param> /// <returns>The value obtained by evaluation.</returns> public static double EvaluateTargetFunction(double[] genomeEncoding) { var rank = 0d; for (var i = 0; i < genomeEncoding.Length; i++) { rank += TestDataUtils.EvaluateSingleIndex(genomeEncoding[i], i); } return(rank); }