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