public override void ReadFromFileDeserializesCorrectly()
{
var status = this.CreateTestStatus();
status.WriteToFile(this.StatusFilePath);
var deserializedStatus =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <SearchPoint> >(this.StatusFilePath);
/* Check it's still the same. */
Assert.Equal(
this._sortedPopulation.Select(point => point.Values).ToArray(),
deserializedStatus.SortedPopulation.Select(point => point.Values).ToArray());
Assert.Equal(
this._generation,
deserializedStatus.CurrentGeneration);
Assert.Equal(
this._maxGenerations,
status.MaxGenerations);
Assert.Equal(
this._meanCrossoverRate,
deserializedStatus.MeanCrossoverRate);
Assert.Equal(
this._meanMutationFactor,
deserializedStatus.MeanMutationFactor);
}
public void FindIncumbentGenomeReturnsGenomeFoundByCmaEs()
{
// Update with different instances to check we return the correct results later on.
this.Strategy.Initialize(this.CreatePopulation(), this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(
0,
new List <TestInstance> {
new TestInstance("a"), new TestInstance("b"), new TestInstance("c")
},
false);
this.Strategy.PerformIteration(
12,
new List <TestInstance> {
new TestInstance("c"), new TestInstance("d")
},
false);
this.Strategy.DumpStatus();
var incumbent = this.Strategy.FindIncumbentGenome();
Assert.Equal(12, incumbent.IncumbentGeneration);
Assert.Equal(
2,
incumbent.IncumbentInstanceResults.Count);
var status =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <TSearchPoint, TestInstance> >(this.StatusFilePath);
Assert.Equal(
status.MostRecentSorting.First().Genome.ToString(),
this.Strategy.FindIncumbentGenome().IncumbentGenome.ToString());
}
public void InitializeUsesCompleteCompetitivesIfNoIncumbentExistis()
{
var population = new Population(this.Configuration);
for (int i = 0; i < 5; i++)
{
population.AddGenome(this.GenomeBuilder.CreateRandomGenome(age: i % 3), isCompetitive: true);
}
for (int i = 0; i < 2; i++)
{
population.AddGenome(this.GenomeBuilder.CreateRandomGenome(age: i % 3), isCompetitive: false);
}
var competitivesAsSearchPoints = population.GetCompetitiveIndividuals()
.Select(individual => ContinuizedGenomeSearchPoint.CreateFromGenome(individual, this.ParameterTree));
this.Strategy.Initialize(population, null, this.SingleTestInstance);
this.Strategy.DumpStatus();
var status = StatusBase.ReadFromFile <CmaEsStatus>(this.CmaEsStatusFilePath);
var expectedDistributionMean = Vector <double> .Build.Dense(
Enumerable.Range(0, this.ParameterTree.GetParameters().Count())
.Select(i => competitivesAsSearchPoints.Average(point => point.Values[i]))
.ToArray());
Assert.Equal(
expectedDistributionMean,
status.Data.DistributionMean);
}
public override void DumpedStatusHasNoEmptyProperties()
{
var incumbent = this.CreateIncumbentGenomeWrapper();
this.Strategy.Initialize(this.CreatePopulation(), incumbent, this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.DumpStatus();
// Check last status dump
var lastStatus =
StatusBase.ReadFromFile <DifferentialEvolutionStrategyStatus <TestInstance> >(this._statusFilePath);
var sorting = lastStatus.MostRecentSorting;
for (int i = 0; i + 1 < sorting.Count; i++)
{
Assert.True(sorting[i].Values[0] > sorting[i + 1].Values[0], "Points should be sorted.");
}
Assert.Equal(
this.SingleTestInstance.Select(instance => instance.ToString()).ToArray(),
lastStatus.CurrentEvaluationInstances.Select(instance => instance.ToString()).ToArray());
Assert.Equal(
incumbent.IncumbentGenome.ToString(),
lastStatus.OriginalIncumbent.ToString());
}
public void UseStatusDumpReinitializesBaseGenome()
{
var population = this.CreatePopulation();
this.Strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance);
this.Strategy.PerformIteration(0, this.SingleTestInstance);
this.Strategy.DumpStatus();
var originalStatus =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <PartialGenomeSearchPoint, TestInstance> >(this.StatusFilePath);
var originalIncumbent = originalStatus.OriginalIncumbent;
var newStrategy = this.CreateStrategy(this.Configuration);
newStrategy.UseStatusDump(null);
var newStatus =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <PartialGenomeSearchPoint, TestInstance> >(this.StatusFilePath);
var expectedDiscreteValue = originalIncumbent.GetGeneValue("categorical").GetValue().ToString();
foreach (var point in newStatus.MostRecentSorting)
{
Assert.Equal(
expectedDiscreteValue,
point.Genome.CreateMutableGenome().GetGeneValue("categorical").GetValue().ToString());
}
}
/// <summary>
/// Finds the continuous optimization method's current generation, e.g. by reading the latest status file.
/// </summary>
/// <returns>
/// The current generation.
/// </returns>
protected override int FindCurrentGeneration()
{
var status =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <GenomeSearchPoint> >(this._deStatusFilePath);
return(status.CurrentGeneration);
}
public override void DumpedStatusHasNoEmptyProperties()
{
var incumbent = this.CreateIncumbentGenomeWrapper();
this.Strategy.Initialize(this.CreatePopulation(), incumbent, this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.DumpStatus();
// Check last status dump
var lastStatus =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <TSearchPoint, TestInstance> >(this.StatusFilePath);
var sorting = lastStatus.MostRecentSorting;
for (int i = 0; i + 1 < sorting.Count; i++)
{
Assert.True(
Convert.ToInt32(sorting[i].Genome.CreateMutableGenome().GetGeneValue(ExtractIntegerValue.ParameterName).GetValue()) >
Convert.ToInt32(sorting[i + 1].Genome.CreateMutableGenome().GetGeneValue(ExtractIntegerValue.ParameterName).GetValue()),
"Points should be sorted.");
}
Assert.Equal(
this.SingleTestInstance.Select(instance => instance.ToString()).ToArray(),
lastStatus.CurrentEvaluationInstances.Select(instance => instance.ToString()).ToArray());
Assert.Equal(
incumbent.IncumbentGenome.ToString(),
lastStatus.OriginalIncumbent.ToString());
}
/// <summary>
/// Finds the continuous optimization method's current generation, e.g. by reading the latest status file.
/// </summary>
/// <returns>
/// The current generation.
/// </returns>
protected override int FindCurrentGeneration()
{
var status =
StatusBase.ReadFromFile <CmaEsStatus>(this.CmaEsStatusFilePath);
return(status.Data.Generation);
}
public void InitializeKeepsCurrentMeans()
{
var population = this.CreatePopulation();
this.Strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.DumpStatus();
var originalStatus =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <GenomeSearchPoint> >(this._deStatusFilePath);
var crossoverRate = originalStatus.MeanCrossoverRate;
var mutationFactor = originalStatus.MeanMutationFactor;
this.Strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.DumpStatus();
var newlyInitializedStatus =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <GenomeSearchPoint> >(this._deStatusFilePath);
Assert.Equal(
crossoverRate,
newlyInitializedStatus.MeanCrossoverRate);
Assert.Equal(
mutationFactor,
newlyInitializedStatus.MeanMutationFactor);
}
public void FindIncumbentGenomeReturnsBestInCurrentGeneration()
{
this.Strategy.Initialize(this.CreatePopulation(), this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(
0,
new List <TestInstance> {
new TestInstance("a"), new TestInstance("b"), new TestInstance("c")
},
false);
this.Strategy.PerformIteration(
12,
new List <TestInstance> {
new TestInstance("c"), new TestInstance("d")
},
false);
this.Strategy.DumpStatus();
var incumbent = this.Strategy.FindIncumbentGenome();
Assert.Equal(12, incumbent.IncumbentGeneration);
Assert.Equal(2, incumbent.IncumbentInstanceResults.Count);
var status =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <GenomeSearchPoint> >(this._deStatusFilePath);
var bestGenome = status.SortedPopulation
.OrderByDescending(point => point.Values[0])
.First().Genome.CreateMutableGenome();
Assert.True(
Genome.GenomeComparer.Equals(bestGenome, incumbent.IncumbentGenome),
$"Incumbent is {incumbent.IncumbentGenome} but should be {bestGenome}.");
}
public void ReadFromFileThrowsForWrongGenericType()
{
var status = this.CreateTestStatus();
status.WriteToFile(this.StatusFilePath);
Assert.Throws <InvalidCastException>(
() => StatusBase.ReadFromFile <WrongTypeStatus>(this.StatusFilePath));
}
/// <summary>
/// Reads all internal data from file.
/// </summary>
/// <param name="pathToStatusFile">Path to the file to read.</param>
public void UseStatusDump(string pathToStatusFile)
{
var status = StatusBase.ReadFromFile <DifferentialEvolutionStatus <TSearchPoint> >(pathToStatusFile);
this._sortedPopulation = status.SortedPopulation?.Select(point => point.Restore()).ToList();
this._currentJadeGeneration = status.CurrentGeneration;
this._maxJadeGenerations = status.MaxGenerations;
this.MeanMutationFactor = status.MeanMutationFactor;
this.MeanCrossoverRate = status.MeanCrossoverRate;
}
public void RunnerUsesCorrectConfiguration()
{
this._runner.Initialize(this._configuration, this._terminationCriteria);
this._runner.DumpStatus(this._statusFilePath);
var status = StatusBase.ReadFromFile <CmaEsStatus>(this._statusFilePath);
Assert.Equal(
this._configuration.PopulationSize,
status.Data.Configuration.PopulationSize);
}
public void InitializeUsesIncumbentForDistributionMean()
{
var incumbent = this.CreateIncumbentGenomeWrapper();
this.Strategy.Initialize(this.CreatePopulation(), incumbent, this.SingleTestInstance);
this.Strategy.DumpStatus();
var status = StatusBase.ReadFromFile <CmaEsStatus>(this.CmaEsStatusFilePath);
Assert.Equal(
ContinuizedGenomeSearchPoint.CreateFromGenome(incumbent.IncumbentGenome, this.ParameterTree).Values,
status.Data.DistributionMean);
}
public void UseStatusDump(string pathToStatusFile)
{
if (this._currGeneration > 0)
{
throw new InvalidOperationException("Status dump should only be read in at the very beginning of tuning.");
}
// Read status from file.
var status = StatusBase.ReadFromFile <Status <TInstance, TResult, TModelLearner, TPredictorModel, TSamplingStrategy> >(pathToStatusFile);
// Check if old tuner parameters match the new ones.
if (this._configuration.StrictCompatibilityCheck && !this._configuration.IsCompatible(status.Configuration))
{
throw new InvalidOperationException(
$"Current configuration is too different from the one used to create status file {pathToStatusFile}.");
}
if (!this._configuration.IsTechnicallyCompatible(status.Configuration))
{
throw new InvalidOperationException(
$"It is technically not possible to continue the tuning of {pathToStatusFile} with the current configuration.");
}
if (status.ElapsedTime > TimeSpan.Zero)
{
this._logWriter.SetElapsedTimeOffset(status.ElapsedTime);
}
// Update fields.
this._currGeneration = status.Generation;
this._incumbentGenomeWrapper = status.IncumbentGenomeWrapper;
this.IncumbentQuality = status.IncumbentQuality;
this.GeneticEngineering = status.GeneticEngineering;
this.GeneticEngineering?.RestoreInternalDictionariesWithCorrectComparers();
this._informationHistory = status.InformationHistory;
// Send all run results to storage.
foreach (var genomeResults in status.RunResults)
{
foreach (var result in genomeResults.Value)
{
this._targetRunResultStorage.Tell(new ResultMessage <TInstance, TResult>(genomeResults.Key, result.Key, result.Value));
}
}
// Restore status of all population update strategies.
this._populationUpdateStrategyManager.UseStatusDump(status.CurrentUpdateStrategyIndex, status.Population, this.GeneticEngineering);
Randomizer.Reset();
Randomizer.Configure(new Random().Next());
}
public void UseStatusDumpWorksCorrectly()
{
// Create a status dump.
this._runner.Initialize(this._configuration, this._terminationCriteria);
this._runner.NextGeneration();
this._runner.DumpStatus(this._statusFilePath);
var originalStatusDump = StatusBase.ReadFromFile <CmaEsStatus>(this._statusFilePath);
// Create a different runner, then use status dump.
var otherConfiguration = new CmaEsConfiguration(14, Vector <double> .Build.Dense(3), 0.2);
var otherTerminationCriteria = new List <ITerminationCriterion> {
new MaxIterations(89)
};
this._runner.Initialize(otherConfiguration, otherTerminationCriteria);
this._runner.UseStatusDump(this._statusFilePath);
// Check newly dumped status vs old one.
this._runner.DumpStatus(this._statusFilePath);
var newStatusDump = StatusBase.ReadFromFile <CmaEsStatus>(this._statusFilePath);
// Compare dumps
TestUtils.SetsAreEquivalent(
originalStatusDump.TerminationCriteria.Select(criterion => criterion.GetType()).ToArray(),
newStatusDump.TerminationCriteria.Select(criterion => criterion.GetType()).ToArray());
Assert.Equal(
originalStatusDump.Data.Configuration.CumulationLearningRate,
newStatusDump.Data.Configuration.CumulationLearningRate);
Assert.Equal(originalStatusDump.Data.Generation, newStatusDump.Data.Generation);
Assert.Equal(
originalStatusDump.Data.DistributionMean,
newStatusDump.Data.DistributionMean);
Assert.Equal(originalStatusDump.Data.StepSize, newStatusDump.Data.StepSize);
Assert.Equal(
originalStatusDump.Data.Covariances,
newStatusDump.Data.Covariances);
Assert.Equal(originalStatusDump.Data.CovariancesDiagonal, newStatusDump.Data.CovariancesDiagonal);
Assert.Equal(
originalStatusDump.Data.CovariancesEigenVectors,
newStatusDump.Data.CovariancesEigenVectors);
Assert.Equal(
originalStatusDump.Data.EvolutionPath,
newStatusDump.Data.EvolutionPath);
Assert.Equal(
originalStatusDump.Data.ConjugateEvolutionPath,
newStatusDump.Data.ConjugateEvolutionPath);
}
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 FinishPhaseReplacesCompetitiveGenomes()
{
var originalPopulation = this.CreatePopulation();
var incumbent = new IncumbentGenomeWrapper <IntegerResult>
{
IncumbentGeneration = 0,
IncumbentGenome = originalPopulation.GetCompetitiveIndividuals().First(),
IncumbentInstanceResults = new List <IntegerResult>().ToImmutableList(),
};
this.Strategy.Initialize(originalPopulation, incumbent, this.SingleTestInstance);
this.Strategy.PerformIteration(0, this.SingleTestInstance);
this.Strategy.DumpStatus();
var status =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <ContinuizedGenomeSearchPoint, TestInstance> >(this.StatusFilePath);
var searchPoints = status.MostRecentSorting;
var updatedPopulation = this.Strategy.FinishPhase(originalPopulation);
Assert.Equal(
originalPopulation.GetCompetitiveIndividuals().Count,
updatedPopulation.GetCompetitiveIndividuals().Count);
var valueComparer = new Genome.GeneValueComparator();
foreach (var point in searchPoints.Take(searchPoints.Count - 1))
{
var mappedGenome = point.Genome.CreateMutableGenome();
Assert.True(
updatedPopulation.GetCompetitiveIndividuals()
.Any(genome => valueComparer.Equals(genome, mappedGenome)),
$"{mappedGenome} is not worst search point, but was not found in new competitives.");
}
Assert.Contains(
incumbent.IncumbentGenome,
updatedPopulation.GetCompetitiveIndividuals().ToArray());
for (int age = 0; age < this.Configuration.MaxGenomeAge; age++)
{
Assert.True(
originalPopulation.GetCompetitiveIndividuals().Count(genome => genome.Age == age) ==
updatedPopulation.GetCompetitiveIndividuals().Count(genome => genome.Age == age),
$"Number of competitive genomes with age {age} changed.");
}
}
/// <summary>
/// Reads all internal data from file.
/// </summary>
/// <param name="pathToStatusFile">Path to the file to read.</param>
public void UseStatusDump(string pathToStatusFile)
{
var status = StatusBase.ReadFromFile <CmaEsStatus>(pathToStatusFile);
this._terminationCriteria.Clear();
foreach (var terminationCriterion in status.TerminationCriteria)
{
this._terminationCriteria.Add(terminationCriterion.Restore());
}
this._configuration = status.Data.Configuration;
this._currentCmaesGeneration = status.Data.Generation;
this._distributionMean = status.Data.DistributionMean;
this._covariances = status.Data.Covariances;
this._covariancesDecomposition = this._covariances?.Evd(Symmetricity.Symmetric);
this._stepSize = status.Data.StepSize;
this._evolutionPath = status.Data.EvolutionPath;
this._conjugateEvolutionPath = status.Data.ConjugateEvolutionPath;
}
public void DumpedStatusHasNoEmptyProperties()
{
this._runner.Initialize(this._configuration, this._terminationCriteria);
this._runner.DumpStatus(this._statusFilePath);
// Check status dump
var status = StatusBase.ReadFromFile <CmaEsStatus>(this._statusFilePath);
Assert.Equal(
this._terminationCriteria.Count,
status.TerminationCriteria.Count);
Assert.Equal(
this._configuration.PopulationSize,
status.Data.Configuration.PopulationSize);
Assert.Equal(0, status.Data.Generation);
Assert.Equal(
this._configuration.InitialDistributionMean,
status.Data.DistributionMean);
Assert.Equal(this._configuration.InitialStepSize, status.Data.StepSize);
var covariances = Matrix <double> .Build.DenseIdentity(3);
var eigendecomposition = covariances.Evd();
Assert.Equal(
covariances,
status.Data.Covariances);
Assert.Equal(eigendecomposition.D, status.Data.CovariancesDiagonal);
Assert.Equal(
eigendecomposition.EigenVectors,
status.Data.CovariancesEigenVectors);
var zeroVector = Vector <double> .Build.Dense(3);
Assert.Equal(
zeroVector,
status.Data.EvolutionPath);
Assert.Equal(
zeroVector,
status.Data.ConjugateEvolutionPath);
}
public void FinishPhaseWorksWithoutOriginalIncumbent()
{
var originalPopulation = this.CreatePopulation();
this.Strategy.Initialize(
originalPopulation,
null,
this.SingleTestInstance,
0,
false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.DumpStatus();
var status =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <ContinuizedGenomeSearchPoint, TestInstance> >(this.StatusFilePath);
var searchPoints = status.MostRecentSorting;
var updatedPopulation = this.Strategy.FinishPhase(originalPopulation);
Assert.Equal(
originalPopulation.GetCompetitiveIndividuals().Count,
updatedPopulation.GetCompetitiveIndividuals().Count);
var valueComparer = Genome.GenomeComparer;
foreach (var point in searchPoints)
{
var mappedGenome = point.Genome.CreateMutableGenome();
Assert.True(
updatedPopulation.GetCompetitiveIndividuals()
.Any(genome => valueComparer.Equals(genome, mappedGenome)),
$"{mappedGenome} was not found in new competitives.");
}
for (int age = 0; age < this.Configuration.MaxGenomeAge; age++)
{
Assert.True(
originalPopulation.GetCompetitiveIndividuals().Count(genome => genome.Age == age) ==
updatedPopulation.GetCompetitiveIndividuals().Count(genome => genome.Age == age),
$"Number of competitive genomes with age {age} changed.");
}
}
public void DumpedStatusHasNoEmptyProperties()
{
int maxGenerations = 12;
this._runner.Initialize(this._initialPositions, maxGenerations);
this._runner.DumpStatus(this._statusFilePath);
// Check status dump
var status = StatusBase.ReadFromFile <DifferentialEvolutionStatus <SearchPoint> >(this._statusFilePath);
Assert.Equal(
this._initialPositions.Select(point => point.Values).OrderBy(x => x.ToString()).ToArray(),
status.SortedPopulation.Select(point => point.Values).OrderBy(x => x.ToString()).ToArray());
Assert.Equal(0, status.CurrentGeneration);
Assert.Equal(
maxGenerations,
status.MaxGenerations);
Assert.Equal(0.5, status.MeanMutationFactor);
Assert.Equal(0.5, status.MeanCrossoverRate);
}
public void InstancesAreUpdatedOnEveryUpdateIfConfigurationIndicatesThat()
{
var severalInstances = new List <TestInstance> {
new TestInstance("c"), new TestInstance("d")
};
var population = this.CreatePopulation();
// Start first phase, but update with different instances.
this.Strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(0, severalInstances, false);
this.Strategy.DumpStatus();
// Instances should have been updated now.
var status =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <TSearchPoint, TestInstance> >(this.StatusFilePath);
Assert.Equal(
2,
status.CurrentEvaluationInstances.Count);
}
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 <CovarianceMatrixAdaptationStrategyStatus <TSearchPoint, TestInstance> >(this.StatusFilePath)
.MostRecentSorting;
var newStrategy = this.CreateStrategy(this.Configuration);
newStrategy.UseStatusDump(null);
newStrategy.DumpStatus();
var status =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <TSearchPoint, 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()).OrderBy(x => x).ToList(),
status.MostRecentSorting.Select(point => point.Genome.ToString()).OrderBy(x => x).ToList());
// 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());
// Strategy should have read the original incumbent from file.
Assert.Equal(
incumbent.IncumbentGenome.ToString(),
status.OriginalIncumbent.ToString());
// And its CMA-ES runner should have also used its status dump.
var cmaEsStatus = StatusBase.ReadFromFile <CmaEsStatus>(this.CmaEsStatusFilePath);
Assert.True(
cmaEsStatus.Data.IsCompletelySpecified(),
"New CMA-ES runner should have read internal data from old file.");
}
/// <summary>
/// Creates a <see cref="AlgorithmTunerConfiguration"/> object depending on what the provided
/// <see cref="MasterArgumentParser"/> has parsed.
/// </summary>
/// <param name="argsParser">
/// <see cref="MasterArgumentParser"/> which has already parsed arguments.
/// </param>
/// <returns>
/// The created <see cref="AlgorithmTunerConfiguration"/>.
/// </returns>
private static AlgorithmTunerConfiguration CreateAlgorithmTunerConfiguration(MasterArgumentParser argsParser)
{
var akkaConfiguration = CustomizeAkkaConfiguration(
argsParser.OwnHostName,
argsParser.Port,
argsParser.ConfigurationBuilder.Verbosity >= VerbosityLevel.Trace);
var builderForParsedConfiguration =
argsParser.ConfigurationBuilder.SetAkkaConfiguration(akkaConfiguration);
// If the tuning is not a continued one, just use the parsed arguments.
if (!argsParser.StartFromExistingStatus)
{
return(builderForParsedConfiguration.Build());
}
// Else base the configuration on the one stored in the status file.
var oldConfig = StatusBase.ReadFromFile <Status <TInstance, TResult, TLearnerModel, TPredictorModel, TSamplingStrategy> >(
Path.Combine(argsParser.StatusFileDirectory, AlgorithmTunerConfiguration.FileName))
.Configuration;
return(builderForParsedConfiguration.BuildWithFallback(oldConfig));
}
public void InitializeResetsAllData()
{
var population = this.CreatePopulation();
this.Strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.PerformIteration(0, this.SingleTestInstance, false);
this.Strategy.DumpStatus();
var originalStatus = StatusBase.ReadFromFile <CmaEsStatus>(this.CmaEsStatusFilePath);
this.Strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), this.SingleTestInstance, 0, false);
this.Strategy.DumpStatus();
var newlyInitializedStatus = StatusBase.ReadFromFile <CmaEsStatus>(this.CmaEsStatusFilePath);
var expectedStepSize = this.Configuration
.ExtractDetailedConfiguration <CovarianceMatrixAdaptationStrategyConfiguration>(
CovarianceMatrixAdaptationStrategyArgumentParser.Identifier)
.InitialStepSize;
Assert.NotEqual(
originalStatus.Data.DistributionMean,
newlyInitializedStatus.Data.DistributionMean);
Assert.NotEqual(
originalStatus.Data.Covariances,
newlyInitializedStatus.Data.Covariances);
Assert.Equal(
expectedStepSize,
newlyInitializedStatus.Data.StepSize);
Assert.NotEqual(
originalStatus.Data.EvolutionPath,
newlyInitializedStatus.Data.EvolutionPath);
Assert.NotEqual(
originalStatus.Data.ConjugateEvolutionPath,
newlyInitializedStatus.Data.ConjugateEvolutionPath);
Assert.Equal(
0,
newlyInitializedStatus.Data.Generation);
}
public override void ReadFromFileDeserializesCorrectly()
{
var status = new CovarianceMatrixAdaptationStrategyStatus <PartialGenomeSearchPoint, TestInstance>(
this._originalIncumbent,
this._currentEvaluationInstances,
this._mostRecentSorting);
status.WriteToFile(this.StatusFilePath);
var deserializedStatus =
StatusBase.ReadFromFile <CovarianceMatrixAdaptationStrategyStatus <PartialGenomeSearchPoint, TestInstance> >(this.StatusFilePath);
// Use to string to not compare references.
Assert.Equal(
status.OriginalIncumbent.ToString(),
deserializedStatus.OriginalIncumbent.ToString());
Assert.Equal(
status.MostRecentSorting.Select(point => point.Genome.ToString()).ToArray(),
deserializedStatus.MostRecentSorting.Select(point => point.Genome.ToString()).ToArray());
Assert.Equal(
status.CurrentEvaluationInstances.Select(instance => instance.ToString()).ToArray(),
deserializedStatus.CurrentEvaluationInstances.Select(instance => instance.ToString()).ToArray());
}
/// <summary>
/// Reads all internal data from file.
/// </summary>
/// <param name="evaluationModel">Reference to up-to-date evaluation model.</param>
public void UseStatusDump(IGeneticEngineering evaluationModel)
{
// Update evaluation model.
this._geneticEngineering = evaluationModel;
// Read status from file.
var status = StatusBase.ReadFromFile <GgaStatus>(this.StatusFilePath);
this._population = status.Population;
this._iterationCounter = status.IterationCounter;
this._incumbentKeptCounter = status.IncumbentKeptCounter;
this.AllKnownRanks = status.AllKnownRanks;
// somehow, the equality comparer is not restored properly.
// fix this.
var restoredRanks = this.AllKnownRanks.GroupBy(kr => kr.Key, Genome.GenomeComparer).ToDictionary(
grp => grp.Key,
grp => grp.SelectMany(ranks => ranks.Value).ToList(),
Genome.GenomeComparer);
this.AllKnownRanks = restoredRanks;
}
public void UseStatusDumpWorksCorrectly()
{
// Create a status dump.
int maxGenerations = 12;
this._runner.Initialize(this._initialPositions, maxGenerations);
this._runner.NextGeneration();
this._runner.DumpStatus(this._statusFilePath);
var originalStatusDump =
StatusBase.ReadFromFile <DifferentialEvolutionStatus <SearchPoint> >(this._statusFilePath);
// Create a different runner, then use status dump.
var randomPoints = Enumerable.Range(0, 50).Select(i => new SearchPoint(Vector <double> .Build.Random(3)));
this._runner.Initialize(randomPoints, maxGenerations * 2);
this._runner.UseStatusDump(this._statusFilePath);
// Check newly dumped status vs old one.
this._runner.DumpStatus(this._statusFilePath);
var newStatusDump = StatusBase.ReadFromFile <DifferentialEvolutionStatus <SearchPoint> >(this._statusFilePath);
// Compare dumps
Assert.Equal(
originalStatusDump.SortedPopulation.Select(point => point.Values).OrderBy(x => x.ToString()).ToArray(),
newStatusDump.SortedPopulation.Select(point => point.Values).OrderBy(x => x.ToString()).ToArray());
Assert.Equal(
originalStatusDump.CurrentGeneration,
newStatusDump.CurrentGeneration);
Assert.Equal(
originalStatusDump.MaxGenerations,
newStatusDump.MaxGenerations);
Assert.Equal(
originalStatusDump.MeanMutationFactor,
newStatusDump.MeanMutationFactor);
Assert.Equal(
originalStatusDump.MeanCrossoverRate,
newStatusDump.MeanCrossoverRate);
}
public void DumpedStatusHasNoEmptyProperties()
{
var population = new Population(this._configuration);
population.AddGenome(this._genomeBuilder.CreateRandomGenome(age: 1), true);
var strategy = this.CreateTestStrategy();
strategy.Initialize(population, this.CreateIncumbentGenomeWrapper(), null);
strategy.PerformIteration(0, this._singleTestInstance);
strategy.DumpStatus();
// Check last status dump
var lastStatus = StatusBase.ReadFromFile <GgaStatus>(this._statusFilePath);
Assert.Equal(
1,
lastStatus.Population.GetCompetitiveIndividuals().Count);
Assert.Equal(
1,
lastStatus.IterationCounter);
Assert.True(lastStatus.AllKnownRanks.Count > 0);
}
