private void GenerateInitailPopulation(double[] populationEvaluation)
{
initialPopulationSize = populationEvaluation.Length;
var initailPopulation = new IChromosome[initialPopulationSize];
for (int i = 0; i < initailPopulation.Length; i++)
{
initailPopulation[i] = A.Fake <IChromosome>();
A.CallTo(() => initailPopulation[i].ToString()).Returns("Initial Chromosome");
A.CallTo(() => initailPopulation[i].Evaluate()).Returns(populationEvaluation[i]);
}
A.CallTo(() => populationGenerator.GeneratePopulation(A <int> ._)).Returns(initailPopulation);
}
public void K_PointCrossoverTest(int k)
{
var crossoverManager = new K_PointCrossoverManager <int>(k, A.Fake <IMutationManager <int> >(), A.Fake <IEvaluator>());
for (int i = 0; i < TEST_RUNS; i++)
{
var chromosome1 = (VectorChromosome <int>)smallPopulationGenerator1.GeneratePopulation(1).First();
var chromosome2 = (VectorChromosome <int>)smallPopulationGenerator2.GeneratePopulation(1).First();
var newChromosome = (VectorChromosome <int>)crossoverManager.Crossover(chromosome1, chromosome2);
var crossoverPoints = Utils.K_CrossoverGetCrossoverPointsAndAssertThatGenomesAreRight(newChromosome, chromosome2, chromosome1);
Assert.AreEqual(k, crossoverPoints.Count,
$"Found wrong number of crossoverPoints. 1: {chromosome1}; 2 {chromosome2}; newChromosome {newChromosome}");
}
}
public void UniformCrossoverManagerTest()
{
var crossoverManager = new UniformCrossoverManager <int>(A.Fake <IMutationManager <int> >(), A.Fake <IEvaluator>());
for (int i = 0; i < TEST_RUNS; i++)
{
var chromosome1 = (VectorChromosome <int>)smallPopulationGenerator1.GeneratePopulation(1).First();
var chromosome2 = (VectorChromosome <int>)smallPopulationGenerator2.GeneratePopulation(1).First();
var newChromosome = (VectorChromosome <int>)crossoverManager.Crossover(chromosome1, chromosome2);
Utils.K_CrossoverGetCrossoverPointsAndAssertThatGenomesAreRight(newChromosome, chromosome2, chromosome1);
}
}
//public IList<Constraint> GetSynthesizedModel()
//{
// return SynthesizedModel;
//}
//public IList<Constraint> GetReferenceModel()
//{
// return Benchmark.Constraints;
//}
public virtual MathModel SynthesizeModel(Point[] trainingPoints)
{
var offspringPopulationSize = ExperimentParameters.OffspringPopulationSize;
var numberOfGenerations = ExperimentParameters.NumberOfGenerations;
Evaluator.PositivePoints = trainingPoints.Where(tp => tp.ClassificationType == ClassificationType.Positive).ToArray();
Evaluator.NegativePoints = trainingPoints.Where(tp => tp.ClassificationType == ClassificationType.Negative).ToArray();
BasePopulation = PopulationGenerator.GeneratePopulation(ExperimentParameters);
for (var i = 0; i < offspringPopulationSize; i++)
{
OffspringPopulation[i] = new Solution(ExperimentParameters);
}
InitialPopulation = BasePopulation.DeepCopyByExpressionTree();
Stoper.Restart();
for (var i = 0; i < numberOfGenerations; i++)
{
Evolve(offspringPopulationSize);
}
Stoper.Stop();
Statistics.TotalEvolutionTime = Stoper.Elapsed;
Statistics.MeanSingleGenerationEvolutionTime = TimeSpan.FromTicks(Statistics.TotalEvolutionTime.Ticks / numberOfGenerations);
Stoper.Restart();
SynthesizedModel = RedundantConstriantsRemover.ApplyProcessing(BasePopulation.First().GetConstraints(ExperimentParameters));
Stoper.Stop();
Statistics.RedundantConstraintsRemovingTime = Stoper.Elapsed;
Statistics.TotalSynthesisTime = Statistics.TotalEvolutionTime + Stoper.Elapsed;
Stoper.Reset();
MathModel = new MathModel(SynthesizedModel, Benchmark);
return(MathModel);
}
/// <summary>
/// Test that the genomes in the chromosome are within range, and that they are dispersed.
/// </summary>
public static void TestChromosomes <T>(this IPopulationGenerator populationGenerator, int minGenome, int maxGenome)
{
var chromosomes = populationGenerator.GeneratePopulation(20);
var recivedGenomes = new HashSet <int>();
foreach (var chromosome in chromosomes)
{
var vectorChromosome = (VectorChromosome <T>)chromosome;
foreach (var genome in vectorChromosome.GetVector())
{
var intGenome = genome.ToInt();
Assert.IsTrue(intGenome >= minGenome, $"Got a genome smaller than {minGenome} ({intGenome})");
Assert.IsTrue(intGenome <= maxGenome, $"Got a genome bigger than {maxGenome} ({intGenome})");
recivedGenomes.Add(intGenome);
}
}
for (int i = minGenome; i < maxGenome; i++)
{
Assert.IsTrue(recivedGenomes.Contains(i), $"Didn't get {i}");
}
}
/// <summary>
/// Starts the algorithm's number (<see cref="Generation"/> + 1) iteration.
/// </summary>
private void StartIteration()
{
++Generation;
if (Generation == 1)
{
if (initialChromosomeBrain != null)
{
CurrentPopulation = populationGenerator.GenerateFirstPopulation(PopulationSize, initialChromosomeBrain);
}
else
{
CurrentPopulation = populationGenerator.GenerateFirstPopulation(PopulationSize);
}
}
else
{
CurrentPopulation = populationGenerator.GeneratePopulation(CurrentPopulation, Generation);
}
fitnessEvaluator.StartEvaluation(CurrentPopulation);
}
private IEnumerable <Individual> InitializePopulation(int size)
{
return(_populationGenerator.GeneratePopulation(size, _simulationParameters));
}
private IChromosome[] CreateNewGeneration(Population population, int generation, IEnvironment environment)
{
return(generation == 0
? populationGenerator.GeneratePopulation(options.PopulationSize).ToArray()
: GenerateChildren(population, generation, environment));
}