Changeset 13771 for branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/NormalizedHypervolumeAnalyzer.cs

Timestamp:

04/18/16 10:50:15 (8 years ago)

Author:

bwerth

Message:

#1087 bugfix + additional relative HV calculation added

File:

• branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/NormalizedHypervolumeAnalyzer.cs (copied) (copied from branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/HypervolumeAnalyzer.cs) (4 diffs)

branches/HeuristicLab.Problems.MultiObjectiveTestFunctions/HeuristicLab.Problems.MultiObjectiveTestFunctions/3.3/Analyzers/NormalizedHypervolumeAnalyzer.cs

@@ -32 +32 @@
   [StorableClass]
   [Item("GenerationalDistanceAnalyzer", "Computes the enclosed Hypervolume between the current front and a given reference Point")]
-  public class HypervolumeAnalyzer : MOTFAnalyzer {
+  public class NormalizedHypervolumeAnalyzer : MOTFAnalyzer {
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
     }
     [StorableConstructor]
-    protected HypervolumeAnalyzer(bool deserializing) : base(deserializing) { }
-    public HypervolumeAnalyzer(HypervolumeAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    protected NormalizedHypervolumeAnalyzer(bool deserializing) : base(deserializing) { }
+    public NormalizedHypervolumeAnalyzer(NormalizedHypervolumeAnalyzer original, Cloner cloner) : base(original, cloner) { }
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new HypervolumeAnalyzer(this, cloner);
+      return new NormalizedHypervolumeAnalyzer(this, cloner);
     }
 
-    public IValueParameter<DoubleArray> ReferencePointParameter {
+
+    #region Names
+    private const string bestKnownFront = "BestKnownFront_2";
+    private const string resultsHV = "NormalizedHypervolume";
+    private const string resultsDist = "Absolute Distance to Normalized BestKnownHypervolume";
+
+    private const string bestknownHV = "NormalizedBestKnownHyperVolume";
+    #endregion
+
+    #region parameters
+    public IValueParameter<DoubleMatrix> OptimalFrontParameter {
       get {
-        return (IValueParameter<DoubleArray>)Parameters["ReferencePoint"];
+        return (IValueParameter<DoubleMatrix>)Parameters[bestKnownFront];
       }
     }
@@ -51 +61 @@
     public IValueParameter<DoubleValue> BestKnownHyperVolumeParameter {
       get {
-        return (IValueParameter<DoubleValue>)Parameters["BestKnownHyperVolume"];
+        return (IValueParameter<DoubleValue>)Parameters[bestknownHV];
       }
       set {
-        Parameters["BestKnownHyperVolume"].ActualValue = value;
+        Parameters[bestknownHV].ActualValue = value;
       }
     }
+    #endregion
 
-    public HypervolumeAnalyzer() {
-      Parameters.Add(new ValueParameter<DoubleArray>("ReferencePoint", "The reference point for hypervolume calculation"));
-      Parameters.Add(new ValueParameter<DoubleValue>("BestKnownHyperVolume", "The currently best known hypervolume"));
+    public NormalizedHypervolumeAnalyzer() {
+      if (!Parameters.ContainsKey(bestKnownFront)) Parameters.Add(new ValueParameter<DoubleMatrix>(bestKnownFront, "The true / best known pareto front"));
+      if (!Parameters.ContainsKey(bestknownHV)) Parameters.Add(new ValueParameter<DoubleValue>(bestknownHV, "The currently best known hypervolume"));
     }
 
     private void RegisterEventHandlers() {
-      ReferencePointParameter.ValueChanged += ReferencePointParameterOnValueChanged;
+      OptimalFrontParameter.ValueChanged += OptimalFrontParameterOnValueChanged;
     }
 
-    private void ReferencePointParameterOnValueChanged(object sender, EventArgs e) {
+    private void OptimalFrontParameterOnValueChanged(object sender, EventArgs e) {
       BestKnownHyperVolumeParameter.Value = new DoubleValue(0);
     }
 
     public override void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results) {
-      if (qualities == null || qualities.Length < 2) return;
+      if (qualities == null || qualities.Length < 1) return;
       int objectives = qualities[0].Length;
       double best = BestKnownHyperVolumeParameter.Value.Value;
+      if (OptimalFrontParameter.Value == null || OptimalFrontParameter.Value.Rows < 1 || OptimalFrontParameter.Value.Columns != qualities[0].Length) {
+        return; // too pareto front nonexistant or with wrong number of dimensions
+      }
 
       double diff;
 
-      if (!results.ContainsKey("Hypervolume")) results.Add(new Result("Hypervolume", typeof(DoubleValue)));
+      if (!results.ContainsKey(resultsHV)) results.Add(new Result(resultsHV, typeof(DoubleValue)));
       IEnumerable<double[]> front = NonDominatedSelect.selectNonDominatedVectors(qualities, TestFunctionParameter.ActualValue.Maximization(objectives), true);
-      if (!results.ContainsKey("BestKnownHypervolume")) results.Add(new Result("BestKnownHypervolume", typeof(DoubleValue)));
+      if (!results.ContainsKey(bestknownHV)) results.Add(new Result(bestknownHV, typeof(DoubleValue)));
       else {
-        DoubleValue dv = (DoubleValue)(results["BestKnownHypervolume"].Value);
+        DoubleValue dv = (DoubleValue)(results[bestknownHV].Value);
         best = dv.Value;
       }
-      if (!results.ContainsKey("Absolute Distance to BestKnownHypervolume")) results.Add(new Result("Absolute Distance to BestKnownHypervolume", typeof(DoubleValue)));
+      if (!results.ContainsKey(resultsDist)) results.Add(new Result(resultsDist, typeof(DoubleValue)));
 
       double hv = Double.NaN;
+
+      bool[] maximization = TestFunctionParameter.ActualValue.Maximization(objectives);
+      double[] invPoint = GetBestPoint(OptimalFrontParameter.Value, maximization);
+      double[] refPoint = GetWorstPoint(OptimalFrontParameter.Value, maximization);
+      double normalization = GetHypervolume(refPoint, invPoint);
+
+
       try {
         if (objectives == 2) { //Hypervolume analysis only with 2 objectives for now
-          hv = Hypervolume.Calculate(front, ReferencePointParameter.Value, TestFunctionParameter.ActualValue.Maximization(objectives));
-        } else if (Array.TrueForAll(TestFunctionParameter.ActualValue.Maximization(objectives), x => !x)) {
-          hv = MultiDimensionalHypervolume.Calculate(front, ReferencePointParameter.Value);
+          hv = Hypervolume.Calculate(front, refPoint, maximization);
+        } else if (Array.TrueForAll(maximization, x => !x)) {
+          hv = MultiDimensionalHypervolume.Calculate(front, refPoint);
         }
       }
@@ -98 +119 @@
 
       }
+
+      hv /= normalization;
 
       if (best < 0) {
@@ -109 +132 @@
       }
 
-      results["Hypervolume"].Value = new DoubleValue(hv);
-      results["Absolute Distance to BestKnownHypervolume"].Value = new DoubleValue(diff);
-      results["BestKnownHypervolume"].Value = new DoubleValue(best);
+      results[resultsHV].Value = new DoubleValue(hv);
+      results[resultsDist].Value = new DoubleValue(diff);
+      results[bestknownHV].Value = new DoubleValue(best);
 
+    }
+
+    private double GetHypervolume(double[] refPoint, double[] invPoint) {
+      if (refPoint.Length == 0) return 0;
+      double hv = 1;
+      for (int i = 0; i < refPoint.Length; i++) {
+        hv *= Math.Abs(refPoint[i] - invPoint[i]);
+      }
+      return hv;
+    }
+
+    private double[] GetWorstPoint(DoubleMatrix value, bool[] maximization) {
+      bool[] invMax = new bool[maximization.Length];
+      int i = 0;
+      foreach (bool b in maximization) {
+        invMax[i++] = !b;
+      }
+      return GetBestPoint(value, invMax);
+    }
+
+    private double[] GetBestPoint(DoubleMatrix value, bool[] maximization) {
+      double[] res = new double[maximization.Length];
+      for (int i = 0; i < maximization.Length; i++) {
+        res[i] = maximization[i] ? Double.MinValue : Double.MaxValue;
+      }
+
+      for (int r = 0; r < value.Rows; r++) {
+        for (int c = 0; c < maximization.Length; c++) {
+          res[c] = maximization[c] ? Math.Max(res[c], value[r, c]) : Math.Min(res[c], value[r, c]);
+        }
+      }
+      return res;
     }
   }