Changeset 12764 for branches/PerformanceComparison/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityVsEvaluationsAnalyzer.cs

Timestamp:

07/16/15 11:48:59 (10 years ago)

Author:

abeham

Message:

#2431:

• branched relevant plugins
• added analyzer to calculate quality vs evaluation first-hit graph
• (also added results parameter)

Location:

branches/PerformanceComparison

Files:

• . (added)
• HeuristicLab.Analysis (copied) (copied from trunk/sources/HeuristicLab.Analysis)
• HeuristicLab.Analysis/3.3/QualityAnalysis/QualityVsEvaluationsAnalyzer.cs (copied) (copied from trunk/sources/HeuristicLab.Analysis/3.3/QualityAnalysis/ScaledQualityDifferenceAnalyzer.cs) (2 diffs)

branches/PerformanceComparison/HeuristicLab.Analysis/3.3/QualityAnalysis/QualityVsEvaluationsAnalyzer.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -28 +29 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Analysis.QualityAnalysis {
-  [Item("ScaledQualityDifferenceAnalyzer", @"Calculates the quality value relative to a certain range given with a minimum and a maximum value.
-The difference lies in the interval [0;1] if the range [min;max] is as large as the observed quality values, otherwise the difference will become < 0 or > 1.
-A value towards 0 always means that it's closer to the better fitness value, while a value towards 1 means that it's closer to the worse fitness value.")]
+namespace HeuristicLab.Analysis {
+  [Item("QualityVsEvaluationsAnalyzer", @"Creates a plot of the solution quality with respect to the number of evaluated solutions.")]
   [StorableClass]
-  public class ScaledQualityDifferenceAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator {
+  public class QualityVsEvaluationsAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator {
     public virtual bool EnabledByDefault {
-      get { return true; }
+      get { return false; }
     }
 
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    public ILookupParameter<DoubleValue> BestQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestQuality"]; }
     }
-    public ILookupParameter<BoolValue> MaximizationParameter {
-      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
     }
-    public ILookupParameter<DoubleValue> ScaledDifferenceParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["ScaledDifference"]; }
-    }
-    public ILookupParameter<ResultCollection> ResultsParameter {
-      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
-    }
-    public IValueLookupParameter<DoubleValue> MinimumQualityParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["MinimumQuality"]; }
-    }
-    public IValueLookupParameter<DoubleValue> MaximumQualityParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["MaximumQuality"]; }
+    public IResultParameter<IndexedDataTable<int>> QualityVsEvaluationsParameter {
+      get { return (IResultParameter<IndexedDataTable<int>>)Parameters["QualityVsEvaluations"]; }
     }
 
     [StorableConstructor]
-    protected ScaledQualityDifferenceAnalyzer(bool deserializing) : base(deserializing) { }
-    protected ScaledQualityDifferenceAnalyzer(ScaledQualityDifferenceAnalyzer original, Cloner cloner) : base(original, cloner) { }
-    public ScaledQualityDifferenceAnalyzer()
+    protected QualityVsEvaluationsAnalyzer(bool deserializing) : base(deserializing) { }
+    protected QualityVsEvaluationsAnalyzer(QualityVsEvaluationsAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public QualityVsEvaluationsAnalyzer()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value that should be compared."));
-      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, false otherwise."));
-      Parameters.Add(new LookupParameter<DoubleValue>("ScaledDifference", "The value that describes whether the quality value lies towards the better quality in the range (<=0.5) or more towards the worse quality (> 0.5)."));
-      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The result collection where the difference will be stored (in addition to the scope)."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("MinimumQuality", "The lower bound of the quality range to which the quality is compared."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumQuality", "The upper bound of the quality range to which the quality is compared."));
+      Parameters.Add(new LookupParameter<DoubleValue>("BestQuality", "The quality value that should be compared."));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The quality value that should be compared."));
+      Parameters.Add(new ResultParameter<IndexedDataTable<int>>("QualityVsEvaluations", "Data table containing the first hitting graph with evaluations as the x-axis."));
+      QualityVsEvaluationsParameter.DefaultValue = new IndexedDataTable<int>("Quality vs Evaluations") {
+        Rows = { new IndexedDataRow<int>("First-hit Graph") { VisualProperties = { ChartType = DataRowVisualProperties.DataRowChartType.StepLine } } }
+      };
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new ScaledQualityDifferenceAnalyzer(this, cloner);
+      return new QualityVsEvaluationsAnalyzer(this, cloner);
     }
 
     public override IOperation Apply() {
-      bool maximization = MaximizationParameter.ActualValue.Value;
-      double quality = QualityParameter.ActualValue.Value, max = MaximumQualityParameter.ActualValue.Value, min = MinimumQualityParameter.ActualValue.Value;
-      double difference;
+      var bestQuality = BestQualityParameter.ActualValue.Value;
+      var evaluations = EvaluatedSolutionsParameter.ActualValue.Value;
 
-      difference = ((quality - min) / (max - min));
-      if (maximization) difference = 1.0 - difference;
-
-      DoubleValue differenceValue = ScaledDifferenceParameter.ActualValue;
-      if (differenceValue == null) {
-        differenceValue = new DoubleValue(difference);
-        ScaledDifferenceParameter.ActualValue = differenceValue;
-      } else differenceValue.Value = difference;
-
-      ResultCollection results = ResultsParameter.ActualValue;
-      if (results != null) {
-        IResult r;
-        if (!results.TryGetValue(ScaledDifferenceParameter.TranslatedName, out r)) {
-          r = new Result(ScaledDifferenceParameter.TranslatedName, differenceValue);
-          results.Add(r);
-        }
-      }
+      var dataTable = QualityVsEvaluationsParameter.ResultValue;
+      dataTable.Rows["First-hit Graph"].Values.Add(Tuple.Create(evaluations, bestQuality));
 
       return base.Apply();