Changeset 17225 for branches/2521_ProblemRefactoring/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs

Timestamp:

08/29/19 13:53:26 (5 years ago)

Author:

mkommend

Message:

#2521: Integrated changes of #2943 into problem refactoring branch.

File:

• branches/2521_ProblemRefactoring/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs (modified) (13 diffs)

branches/2521_ProblemRefactoring/HeuristicLab.Algorithms.MOCMAEvolutionStrategy/3.3/MOCMAEvolutionStrategy.cs

@@ -52 +52 @@
     }
 
+    public RealVectorEncoding Encoding {
+      get { return Problem.Encoding; }
+    }
+
     #region Storable fields
     [Storable]
@@ -64 +68 @@
     private double stepSizeDampeningFactor; //d
     [Storable]
-    private double targetSuccessProbability;// p^target_succ
-    [Storable]
-    private double evolutionPathLearningRate;//cc
-    [Storable]
-    private double covarianceMatrixLearningRate;//ccov
+    private double targetSuccessProbability; // p^target_succ
+    [Storable]
+    private double evolutionPathLearningRate; //cc
+    [Storable]
+    private double covarianceMatrixLearningRate; //ccov
     [Storable]
     private double covarianceMatrixUnlearningRate;
     [Storable]
     private double successThreshold; //ptresh
-
     #endregion
 
@@ -162 +165 @@
     }
 
-    public double StepSizeLearningRate { get { return stepSizeLearningRate; } }
-    public double StepSizeDampeningFactor { get { return stepSizeDampeningFactor; } }
-    public double TargetSuccessProbability { get { return targetSuccessProbability; } }
-    public double EvolutionPathLearningRate { get { return evolutionPathLearningRate; } }
-    public double CovarianceMatrixLearningRate { get { return covarianceMatrixLearningRate; } }
-    public double CovarianceMatrixUnlearningRate { get { return covarianceMatrixUnlearningRate; } }
-    public double SuccessThreshold { get { return successThreshold; } }
+    public double StepSizeLearningRate {
+      get { return stepSizeLearningRate; }
+    }
+    public double StepSizeDampeningFactor {
+      get { return stepSizeDampeningFactor; }
+    }
+    public double TargetSuccessProbability {
+      get { return targetSuccessProbability; }
+    }
+    public double EvolutionPathLearningRate {
+      get { return evolutionPathLearningRate; }
+    }
+    public double CovarianceMatrixLearningRate {
+      get { return covarianceMatrixLearningRate; }
+    }
+    public double CovarianceMatrixUnlearningRate {
+      get { return covarianceMatrixUnlearningRate; }
+    }
+    public double SuccessThreshold {
+      get { return successThreshold; }
+    }
     #endregion
 
@@ -238 +255 @@
       get { return ((DoubleValue)Results[DifferenceToBestKnownHypervolumeResultName].Value).Value; }
       set { ((DoubleValue)Results[DifferenceToBestKnownHypervolumeResultName].Value).Value = value; }
-
     }
     //Solutions
@@ -257 +273 @@
       Parameters.Add(new FixedValueParameter<BoolValue>(SetSeedRandomlyName, "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
       Parameters.Add(new FixedValueParameter<IntValue>(PopulationSizeName, "λ (lambda) - the size of the offspring population.", new IntValue(20)));
-      Parameters.Add(new ValueParameter<DoubleArray>(InitialSigmaName, "The initial sigma can be a single value or a value for each dimension. All values need to be > 0.", new DoubleArray(new[] { 0.5 })));
+      Parameters.Add(new ValueParameter<DoubleArray>(InitialSigmaName, "The initial sigma can be a single value or a value for each dimension. All values need to be > 0.", new DoubleArray(new[] {0.5})));
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumGenerationsName, "The maximum number of generations which should be processed.", new IntValue(1000)));
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumEvaluatedSolutionsName, "The maximum number of evaluated solutions that should be computed.", new IntValue(int.MaxValue)));
-      var set = new ItemSet<IIndicator> { new HypervolumeIndicator(), new CrowdingIndicator(), new MinimalDistanceIndicator() };
+      var set = new ItemSet<IIndicator> {new HypervolumeIndicator(), new CrowdingIndicator(), new MinimalDistanceIndicator()};
       Parameters.Add(new ConstrainedValueParameter<IIndicator>(IndicatorName, "The selection mechanism on non-dominated solutions", set, set.First()));
     }
@@ -280 +296 @@
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) { return new MOCMAEvolutionStrategy(this, cloner); }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MOCMAEvolutionStrategy(this, cloner);
+    }
     #endregion
 
@@ -309 +327 @@
       solutions = new Individual[PopulationSize];
       for (var i = 0; i < PopulationSize; i++) {
-        var x = new RealVector(Problem.Encoding.Length); // Uniform distibution in all dimensions assumed.
-        var bounds = Problem.Encoding.Bounds;
-        for (var j = 0; j < Problem.Encoding.Length; j++) {
+        var x = new RealVector(Encoding.Length); // Uniform distibution in all dimensions assumed.
+        var bounds = Encoding.Bounds;
+        for (var j = 0; j < Encoding.Length; j++) {
           var dim = j % bounds.Rows;
           x[j] = random.NextDouble() * (bounds[dim, 1] - bounds[dim, 0]) + bounds[dim, 0];
@@ -322 +340 @@
     private void InitStrategy() {
       const int lambda = 1;
-      double n = Problem.Encoding.Length;
+      double n = Encoding.Length;
       targetSuccessProbability = 1.0 / (5.0 + Math.Sqrt(lambda) / 2.0);
       stepSizeDampeningFactor = 1.0 + n / (2.0 * lambda);
@@ -355 +373 @@
       Results.Add(new Result(ScatterPlotResultName, "A scatterplot displaying the evaluated solutions and (if available) the analytically optimal front", new ParetoFrontScatterPlot()));
 
-      var problem = Problem as MultiObjectiveTestFunctionProblem;
+      var problem = Problem;
       if (problem == null) return;
-      if (problem.BestKnownFront != null) {
-        ResultsBestKnownHypervolume = Hypervolume.Calculate(problem.BestKnownFront.ToJaggedArray(), problem.TestFunction.ReferencePoint(problem.Objectives), Problem.Maximization);
+      var bkf = problem.BestKnownFront == null ? null : problem.BestKnownFront.ToArray();
+      if (bkf != null && problem.ReferencePoint != null) {
+        ResultsBestKnownHypervolume = HypervolumeCalculator.CalculateHypervolume(bkf, problem.ReferencePoint, Problem.Maximization);
         ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume;
       }
-      ResultsScatterPlot = new ParetoFrontScatterPlot(new double[0][], new double[0][], problem.BestKnownFront.ToJaggedArray(), Problem.Objectives, Problem.Encoding.Length);
+      ResultsScatterPlot = new ParetoFrontScatterPlot(new double[0][], new double[0][], bkf, Problem.Objectives, Problem.Encoding.Length);
     }
     #endregion
@@ -417 +436 @@
     }
     private RealVector ClosestFeasible(RealVector x) {
-      var bounds = Problem.Encoding.Bounds;
+      var bounds = Encoding.Bounds;
       var r = new RealVector(x.Length);
       for (var i = 0; i < x.Length; i++) {
@@ -426 +445 @@
     }
     private bool IsFeasable(RealVector offspring) {
-      var bounds = Problem.Encoding.Bounds;
+      var bounds = Encoding.Bounds;
       for (var i = 0; i < offspring.Length; i++) {
         var dim = i % bounds.Rows;
@@ -438 +457 @@
       //perform a nondominated sort to assign the rank to every element
       int[] ranks;
-      var fronts = DominationCalculator<Individual>.CalculateAllParetoFronts(parents.ToArray(), parents.Select(i => i.PenalizedFitness).ToArray(), Problem.Maximization, out ranks);
+      var fronts = DominationCalculator.CalculateAllParetoFronts(parents.ToArray(), parents.Select(i => i.PenalizedFitness).ToArray(), Problem.Maximization, out ranks);
 
       //deselect the highest rank fronts until we would end up with less or equal mu elements
@@ -470 +489 @@
 
     private void Analyze() {
-      ResultsScatterPlot = new ParetoFrontScatterPlot(solutions.Select(x => x.Fitness).ToArray(), solutions.Select(x => x.Mean.ToArray()).ToArray(), ResultsScatterPlot.ParetoFront, ResultsScatterPlot.Objectives, ResultsScatterPlot.ProblemSize);
+      var qualities = solutions.Select(x => x.Fitness).ToArray();
+
+      //to do check for side effects
+      ResultsScatterPlot = new ParetoFrontScatterPlot(qualities, solutions.Select(x => x.Mean.ToArray()).ToArray(), ResultsScatterPlot.ParetoFront, ResultsScatterPlot.Objectives, ResultsScatterPlot.ProblemSize);
       ResultsSolutions = solutions.Select(x => x.Mean.ToArray()).ToMatrix();
 
-      var problem = Problem as MultiObjectiveTestFunctionProblem;
+      var problem = Problem as MultiObjectiveProblem<RealVectorEncoding, RealVector>;
       if (problem == null) return;
 
-      var front = NonDominatedSelect.GetDominatingVectors(solutions.Select(x => x.Fitness), problem.ReferencePoint.CloneAsArray(), Problem.Maximization, true).ToArray();
-      if (front.Length == 0) return;
-      var bounds = problem.Bounds.CloneAsMatrix();
-      ResultsCrowding = Crowding.Calculate(front, bounds);
-      ResultsSpacing = Spacing.Calculate(front);
-      ResultsGenerationalDistance = problem.BestKnownFront != null ? GenerationalDistance.Calculate(front, problem.BestKnownFront.ToJaggedArray(), 1) : double.NaN;
-      ResultsInvertedGenerationalDistance = problem.BestKnownFront != null ? InvertedGenerationalDistance.Calculate(front, problem.BestKnownFront.ToJaggedArray(), 1) : double.NaN;
-      ResultsHypervolume = Hypervolume.Calculate(front, problem.ReferencePoint.CloneAsArray(), Problem.Maximization);
+
+      if (qualities.Length == 0) return;
+      ResultsCrowding = CrowdingCalculator.CalculateCrowding(qualities);
+      ResultsSpacing = Spacing.Calculate(qualities);
+
+
+      ResultsGenerationalDistance = problem.BestKnownFront != null ? GenerationalDistance.Calculate(qualities, problem.BestKnownFront, 1) : double.NaN;
+      ResultsInvertedGenerationalDistance = problem.BestKnownFront != null ? InvertedGenerationalDistance.Calculate(qualities, problem.BestKnownFront, 1) : double.NaN;
+      ResultsHypervolume = problem.ReferencePoint != null ? HypervolumeCalculator.CalculateHypervolume(qualities, problem.ReferencePoint, Problem.Maximization) : double.NaN;
       ResultsBestHypervolume = Math.Max(ResultsHypervolume, ResultsBestHypervolume);
       ResultsDifferenceBestKnownHypervolume = ResultsBestKnownHypervolume - ResultsBestHypervolume;