/// <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>
/// 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);
}
