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

Timestamp:

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

Author:

mkommend

Message:

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

Location:

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

Files:

• IIndicator.cs (modified) (1 diff)
• Indicators/CrowdingIndicator.cs (modified) (2 diffs)
• Indicators/HypervolumeIndicator.cs (modified) (4 diffs)
• Indicators/MinimalDistanceIndicator.cs (modified) (2 diffs)
• MOCMAEvolutionStrategy.cs (modified) (13 diffs)

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

@@ -36 +36 @@
     /// <param name="problem">The problem on which the front is evaluated (!! The function itself will NOT be evluated only bounds referencePoints & other metadata will be used</param>
     /// <returns>the index of the least contributing point according to any type of quality criteria</returns>
-    int LeastContributer(IReadOnlyList<Individual> front, MultiObjectiveProblem<RealVectorEncoding, RealVector> problem);
+    int LeastContributer(IReadOnlyList<Individual> front, IMultiObjectiveProblemDefinition problem);
   }
 }

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

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -37 +36 @@
     protected CrowdingIndicator(StorableConstructorFlag _) : base(_) { }
     protected CrowdingIndicator(CrowdingIndicator original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) { return new CrowdingIndicator(this, cloner); }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CrowdingIndicator(this, cloner);
+    }
     public CrowdingIndicator() { }
     #endregion
 
-    public int LeastContributer(IReadOnlyList<Individual> front, MultiObjectiveProblem<RealVectorEncoding, RealVector> problem) {
-      var bounds = problem.Encoding.Bounds;
+    public int LeastContributer(IReadOnlyList<Individual> front, IMultiObjectiveProblemDefinition problem) {
       var extracted = front.Select(x => x.PenalizedFitness).ToArray();
       if (extracted.Length <= 2) return 0;
-      var pointsums = new double[extracted.Length];
-
-      for (var dim = 0; dim < problem.Maximization.Length; dim++) {
-        var arr = extracted.Select(x => x[dim]).ToArray();
-        Array.Sort(arr);
-        var fmax = problem.Encoding.Bounds[dim % bounds.Rows, 1];
-        var fmin = bounds[dim % bounds.Rows, 0];
-        var pointIdx = 0;
-        foreach (var point in extracted) {
-          var pos = Array.BinarySearch(arr, point[dim]);
-          var d = pos != 0 && pos != arr.Length - 1 ? (arr[pos + 1] - arr[pos - 1]) / (fmax - fmin) : double.PositiveInfinity;
-          pointsums[pointIdx] += d;
-          pointIdx++;
-        }
-      }
-      return pointsums.Select((value, index) => new { value, index }).OrderBy(x => x.value).First().index;
+      var pointsums = CrowdingCalculator.CalculateCrowdingDistances(extracted);
+      return pointsums.Select((value, index) => new {value, index}).OrderBy(x => x.value).First().index;
     }
   }

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

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -26 +25 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Problems.TestFunctions.MultiObjective;
+
 namespace HeuristicLab.Algorithms.MOCMAEvolutionStrategy {
-  [Item("HypervolumeIndicator", "Selection of Offspring based on contributing Hypervolume")]
+  [Item("HypervolumeIndicator", "Selection of offspring based on contributing Hypervolume")]
   [StorableType("ADF439D6-64E4-4C92-A4D3-E8C05B050406")]
   internal class HypervolumeIndicator : Item, IIndicator {
@@ -37 +36 @@
     protected HypervolumeIndicator(StorableConstructorFlag _) : base(_) { }
     protected HypervolumeIndicator(HypervolumeIndicator original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) { return new HypervolumeIndicator(this, cloner); }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new HypervolumeIndicator(this, cloner);
+    }
     public HypervolumeIndicator() { }
     #endregion
 
-    public int LeastContributer(IReadOnlyList<Individual> front, MultiObjectiveProblem<RealVectorEncoding, RealVector> problem) {
+    public int LeastContributer(IReadOnlyList<Individual> front, IMultiObjectiveProblemDefinition problem) {
       var frontCopy = front.Select(x => x.PenalizedFitness).ToList();
       if (frontCopy.Count <= 1) return 0;
       //TODO discuss with bwerth
-      var p = problem as MultiObjectiveTestFunctionProblem;
-      var refPoint = BuildReferencePoint(p != null ? frontCopy.Concat(new[] { p.ReferencePoint.CloneAsArray() }) : frontCopy, problem.Maximization);
+      var tep = problem != null ? frontCopy.Concat(new[] {problem.ReferencePoint}) : frontCopy;
+      var refPoint = HypervolumeCalculator.CalculateNadirPoint(tep, problem.Maximization);
       var contributions = Enumerable.Range(0, frontCopy.Count).Select(i => Contribution(frontCopy, i, problem.Maximization, refPoint));
-      return contributions.Select((value, index) => new { value, index }).OrderBy(x => x.value).First().index;
+      return contributions.Select((value, index) => new {value, index}).OrderBy(x => x.value).First().index;
     }
 
@@ -55 +56 @@
       var point = front[idx];
       front.RemoveAt(idx);
-      var contribution = -Hypervolume.Calculate(front.ToArray(), refPoint, maximization);
+      var contribution = -HypervolumeCalculator.CalculateHypervolume(front.ToArray(), refPoint, maximization);
       front.Insert(idx, point);
       return contribution;
-    }
-    private static double[] BuildReferencePoint(IEnumerable<double[]> front, IReadOnlyList<bool> maximization) {
-      var refPoint = new double[maximization.Count];
-      foreach (var point in front)
-        for (var i = 0; i < maximization.Count; i++)
-          refPoint[i] = maximization[i] ? Math.Min(refPoint[i], point[i]) : Math.Max(refPoint[i], point[i]);
-      return refPoint;
     }
     #endregion

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

@@ -33 +33 @@
   [StorableType("FBBD4517-164C-4DEE-B87D-49B99172EDF4")]
   internal class MinimalDistanceIndicator : Item, IIndicator {
-
     #region Constructor and Cloning
     [StorableConstructor]
     protected MinimalDistanceIndicator(StorableConstructorFlag _) : base(_) { }
     protected MinimalDistanceIndicator(MinimalDistanceIndicator original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) { return new MinimalDistanceIndicator(this, cloner); }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MinimalDistanceIndicator(this, cloner);
+    }
     public MinimalDistanceIndicator() { }
     #endregion
 
-    public int LeastContributer(IReadOnlyList<Individual> front, MultiObjectiveProblem<RealVectorEncoding, RealVector> problem) {
+    public int LeastContributer(IReadOnlyList<Individual> front, IMultiObjectiveProblemDefinition problem) {
       var extracted = front.Select(x => x.PenalizedFitness).ToArray();
       if (extracted.Length <= 2) return 0;
@@ -88 +89 @@
       var res = new double[extracted.Count, extracted.Count];
       for (var i = 0; i < extracted.Count; i++)
-        for (var j = 0; j < i; j++)
-          res[i, j] = res[j, i] = Dist(extracted[i], extracted[j]);
+      for (var j = 0; j < i; j++)
+        res[i, j] = res[j, i] = Dist(extracted[i], extracted[j]);
       return res;
     }

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;