Changeset 12957 for branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem/3.3

Timestamp:

09/19/15 21:21:13 (9 years ago)

Author:

abeham

Message:

#2457: Worked on expert system

• using newly created ERT helper class

Location:

branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem/3.3

Files:

• ExpertSystem.cs (modified) (5 diffs)
• HeuristicLab.OptimizationExpertSystem-3.3.csproj (modified) (1 diff)

branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem/3.3/ExpertSystem.cs

@@ -67 +67 @@
     public ItemList<IAlgorithm> AlgorithmInstances {
       get { return algorithmInstances; }
+      set {
+        if (algorithmInstances == value) return;
+        algorithmInstances = value;
+        OnPropertyChanged("AlgorithmInstances");
+      }
     }
 
@@ -86 +91 @@
     public ReadOnlyItemList<IAlgorithm> SuggestedInstances {
       get { return readOnlySuggestedInstances; }
+    }
+
+    [Storable]
+    private RunCollection problemInstances;
+    public RunCollection ProblemInstances {
+      get { return problemInstances; }
+      set {
+        if (problemInstances == value) return;
+        problemInstances = value;
+        OnPropertyChanged("ProblemInstances");
+      }
     }
 
@@ -101 +117 @@
       suggestedInstances = cloner.Clone(original.suggestedInstances);
       readOnlySuggestedInstances = suggestedInstances.AsReadOnly();
+      problemInstances = cloner.Clone(original.problemInstances);
       RegisterEventHandlers();
     }
@@ -110 +127 @@
       suggestedInstances = new ItemList<IAlgorithm>();
       readOnlySuggestedInstances = suggestedInstances.AsReadOnly();
+      problemInstances = new RunCollection();
       RegisterEventHandlers();
     }
@@ -137 +155 @@
       var runCollection = sender as RunCollection;
       if (runCollection != null && runCollection.UpdateOfRunsInProgress) return;
+      UpdateInstanceMap();
       UpdateSuggestions();
+    }
+
+    private void UpdateInstanceMap() {
+      var flaValues = ProblemInstances.ResultNames
+                      .Where(x => x.StartsWith("Characteristic.")
+                        && ProblemInstances.All(y => y.Results.ContainsKey(x) && y.Results[x] is DoubleValue))
+                      .Select(x => x).ToList();
+      var ds = new double[ProblemInstances.Count, flaValues.Count];
+      var instanceCounter = 0;
+      foreach (var instance in ProblemInstances) {
+        for (var feature = 0; feature < flaValues.Count; feature++)
+          ds[instanceCounter, feature] = ((DoubleValue)instance.Results[flaValues[feature]]).Value;
+        instanceCounter++;
+      }
+
+      int info;
+      double[] s2;
+      double[,] v;
+      alglib.pcabuildbasis(ds, instanceCounter, flaValues.Count, out info, out s2, out v);
+
+      var algInstRunDict = AlgorithmInstances.SelectMany(x => x.Runs)
+                                             .Where(x => x.Parameters.ContainsKey("Problem Name") && x.Parameters["Problem Name"] is StringValue)
+                                             .GroupBy(x => ((StringValue)x.Parameters["Problem Name"]).Value)
+                                             .ToDictionary(x => x.Key, x => x.GroupBy(y => ((StringValue)y.Parameters["Algorithm Name"]).Value)
+                                                                             .ToDictionary(y => y.Key, y => y.ToList()));
+      ProblemInstances.UpdateOfRunsInProgress = true;
+      try {
+        instanceCounter = 0;
+        foreach (var instance in ProblemInstances) {
+          IItem probNameParam;
+          if (!instance.Parameters.TryGetValue("Problem Name", out probNameParam)) continue;
+          var probInstanceName = ((StringValue)probNameParam).Value;
+
+          double x = 0, y = 0;
+          for (var feature = 0; feature < flaValues.Count; feature++) {
+            x += ds[instanceCounter, feature] * v[feature, 0];
+            y += ds[instanceCounter, feature] * v[feature, 1];
+          }
+          IItem item;
+          if (instance.Results.TryGetValue("Projection.PCA1", out item)) {
+            ((DoubleValue)item).Value = x;
+          } else instance.Results.Add("Projection.PCA1", new DoubleValue(x));
+          if (instance.Results.TryGetValue("Projection.PCA2", out item)) {
+            ((DoubleValue)item).Value = y;
+          } else instance.Results.Add("Projection.PCA2", new DoubleValue(y));
+
+          var bkQuality = ((DoubleValue)instance.Parameters["BestKnownQuality"]).Value;
+          var maximization = ((BoolValue)instance.Parameters["Maximization"]).Value;
+          foreach (var kvp in algInstRunDict[probInstanceName]) {
+            var algInstanceName = kvp.Key;
+            foreach (var run in kvp.Value) {
+              // TODO: Things needs to be configurable here (table name, targets)
+              foreach (var target in new[] { 1, 1.01, 1.05, 1.1, 1.2, 1.5 }) {
+                var result = ExpectedRuntimeHelper.CalculateErt(kvp.Value, "QualityPerEvaluations", bkQuality * target, maximization);
+                var resultName = algInstanceName + "@" + ((target - 1) * 100) + "%";
+                if (run.Results.TryGetValue(resultName, out item))
+                  ((DoubleValue)item).Value = result.ExpectedRuntime;
+                else run.Results.Add(resultName, new DoubleValue(result.ExpectedRuntime));
+              }
+            }
+          }
+        }
+      } finally { ProblemInstances.UpdateOfRunsInProgress = false; }
     }
 

branches/PerformanceComparison/HeuristicLab.OptimizationExpertSystem/3.3/HeuristicLab.OptimizationExpertSystem-3.3.csproj

@@ -73 +73 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="ALGLIB-3.7.0, Version=3.7.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="HeuristicLab.Collections-3.3">
       <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>