public override void UseStatusDumpReadsInformationFromFile()
{
var basePopulation = this.CreatePopulation();
var incumbent = this.CreateIncumbentGenomeWrapper();
this.Strategy.Initialize(basePopulation, incumbent, this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.DumpStatus();
var originalPoints = StatusBase.ReadFromFile <DifferentialEvolutionStrategyStatus <TestInstance> >(this._statusFilePath)
.MostRecentSorting;
// Create new strategy to read the status dump.
var newStrategy = new DifferentialEvolutionStrategy <TestInstance, IntegerResult>(
this.Configuration,
this.ParameterTree,
this.GenomeBuilder,
this.GenerationEvaluationActor,
this.ResultStorageActor);
newStrategy.UseStatusDump(null);
newStrategy.DumpStatus();
var status =
StatusBase.ReadFromFile <DifferentialEvolutionStrategyStatus <TestInstance> >(this._statusFilePath);
// Strategy should have read the last sorting from file.
// Use strings in comparisons to also compare age.
Assert.Equal(
originalPoints.Select(point => point.Genome.ToString()).ToList(),
status.MostRecentSorting.Select(point => point.Genome.ToString()).ToList());
// Strategy should have read the original incumbent from file.
Assert.Equal(
incumbent.IncumbentGenome.ToString(),
status.OriginalIncumbent.ToString());
// Strategy should have read the current evaluation instances from file.
Assert.Equal(
this.SingleTestInstance.Select(instance => instance.ToString()).ToArray(),
status.CurrentEvaluationInstances.Select(instance => instance.ToString()).ToArray());
// And its DE runner should have also used its status dump.
var deStatus =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <GenomeSearchPoint> >(this._deStatusFilePath);
Assert.True(
deStatus.SortedPopulation.Count > 0,
"New DE runner should have read initialized population from old file.");
}
public void InformationFlowDependsOnFocusOnIncumbentOption()
{
// Create two strategies: One with focus on incumbent, one without.
var noIncumbentFocusConfiguration = base.CreateTunerConfigurationBuilder()
.AddDetailedConfigurationBuilder(
DifferentialEvolutionStrategyArgumentParser.Identifier,
new DifferentialEvolutionStrategyConfiguration.DifferentialEvolutionStrategyConfigurationBuilder()
.SetFocusOnIncumbent(false)
.SetReplacementRate(0)
.SetDifferentialEvolutionConfigurationBuilder(
new DifferentialEvolutionConfiguration.DifferentialEvolutionConfigurationBuilder())).Build();
var globalStrategy = new DifferentialEvolutionStrategy <TestInstance, IntegerResult>(
noIncumbentFocusConfiguration,
this.ParameterTree,
this.GenomeBuilder,
this.GenerationEvaluationActor,
this.ResultStorageActor);
var incumbentFocusConfiguration = base.CreateTunerConfigurationBuilder()
.AddDetailedConfigurationBuilder(
DifferentialEvolutionStrategyArgumentParser.Identifier,
new DifferentialEvolutionStrategyConfiguration.DifferentialEvolutionStrategyConfigurationBuilder()
.SetFocusOnIncumbent(true)
.SetReplacementRate(0)
.SetDifferentialEvolutionConfigurationBuilder(
new DifferentialEvolutionConfiguration.DifferentialEvolutionConfigurationBuilder())).Build();
var localStrategy = new DifferentialEvolutionStrategy <TestInstance, IntegerResult>(
incumbentFocusConfiguration,
this.ParameterTree,
this.GenomeBuilder,
this.GenerationEvaluationActor,
this.ResultStorageActor);
// Create a population.
var basePopulation = this.CreatePopulation();
var incumbent = this.CreateIncumbentGenomeWrapper();
basePopulation.AddGenome(incumbent.IncumbentGenome, isCompetitive: true);
// Let both DE strategies run for an iteration.
globalStrategy.Initialize(basePopulation, incumbent, this.SingleTestInstance, 0, false);
localStrategy.Initialize(basePopulation, incumbent, this.SingleTestInstance, 0, false);
globalStrategy.PerformIteration(0, this.SingleTestInstance, false);
localStrategy.PerformIteration(0, this.SingleTestInstance, false);
// Count the number of competitive genomes which did not change for the local strategy.
var newCompetitives = localStrategy.FinishPhase(basePopulation).GetCompetitiveIndividuals();
int notChanged = 0;
foreach (var genome in basePopulation.GetCompetitiveIndividuals())
{
if (newCompetitives.Any(individual => individual.ToString().Equals(genome.ToString())))
{
notChanged++;
}
}
Assert.True(
newCompetitives.Count - 1 == notChanged,
"In the local strategy with replacement rate of 0, only one genome should have changed.");
// And then do the same for the global strategy.
var otherCompetitives = globalStrategy.FinishPhase(basePopulation).GetCompetitiveIndividuals();
notChanged = 0;
foreach (var genome in basePopulation.GetCompetitiveIndividuals())
{
if (otherCompetitives.Any(individual => individual.ToString().Equals(genome.ToString())))
{
notChanged++;
}
}
Assert.True(
otherCompetitives.Count - 1 > notChanged,
"In the global strategy with replacement rate of 0, more than one genome should have changed.");
}
