Changeset 14526 for branches/HeuristicLab.GoalSeekingProblem/HeuristicLab.GoalSeekingProblem/3.4/GoalSeekingOptimizer.cs

Timestamp:

12/22/16 16:52:32 (4 years ago)

Author:

bburlacu

Message:

#2679: Add analyzer for SingleObjectiveGoalSeekingProblem. Add result aggregation in the GoalSeekingOptimizer. Remove unused dataset parameter from the problems.

File:

• branches/HeuristicLab.GoalSeekingProblem/HeuristicLab.GoalSeekingProblem/3.4/GoalSeekingOptimizer.cs (modified) (9 diffs)

branches/HeuristicLab.GoalSeekingProblem/HeuristicLab.GoalSeekingProblem/3.4/GoalSeekingOptimizer.cs

@@ -24 +24 @@
 using System.Drawing;
 using System.Linq;
+using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -69 +71 @@
 
         optimizer = value;
-        optimizer.Problem = problem;
+
+        if (problem != null)
+          optimizer.Problem = problem;
+
         RegisterOptimizerEvents();
         OnAlgorithmChanged();
@@ -92 +97 @@
     }
 
+    [Storable]
+    private ResultCollection results;
+    public ResultCollection Results {
+      get { return results; }
+      private set {
+        if (value != null)
+          results = value;
+        OnResultsChanged();
+      }
+    }
+
     private GoalSeekingOptimizerAction gsoAction;
 
@@ -112 +128 @@
       this.Problem = (IGoalSeekingProblem)original.Problem.Clone(cloner);
       this.ProblemData = (IRegressionProblemData)original.ProblemData.Clone(cloner);
+      this.Results = (ResultCollection)original.Results.Clone();
     }
 
@@ -139 +156 @@
     }
 
+    public EventHandler ResultsChanged;
+    private void OnResultsChanged() {
+      var changed = ResultsChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
     private int calculatedRows;
+    private int currentRow;
+
     public void Start() {
       if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
@@ -148 +174 @@
         Optimizer.Prepare(clearRuns: true);
         calculatedRows = 0;
-
-        var row = problemData.TrainingIndices.Skip(calculatedRows).First();
-        problem.Configure(problemData, row);
+        currentRow = problemData.TrainingIndices.Skip(calculatedRows).First();
+        problem.Configure(problemData, currentRow);
         optimizer.Prepare();
       }
@@ -188 +213 @@
       if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused) && (ExecutionState != ExecutionState.Stopped))
         throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
+
+      if (Results != null)
+        Results.Clear();
+
       if (optimizer != null) {
         ExecutionTime = TimeSpan.Zero;
@@ -223 +252 @@
     }
 
-    public IEnumerable<IOptimizer> NestedOptimizers { get; }
+    public IEnumerable<IOptimizer> NestedOptimizers { get; private set; }
 
     public string Filename { get; set; }
@@ -367 +396 @@
       var remainingRows = problemData.TrainingIndices.Skip(calculatedRows);
 
-      if (gsoAction == GoalSeekingOptimizerAction.Stop) OnStopped();
-      else if (!remainingRows.Any()) OnStopped();
-      else if (gsoAction == GoalSeekingOptimizerAction.Pause) OnPaused();
-      else if (gsoAction == GoalSeekingOptimizerAction.Start) {
-        var row = remainingRows.First();
-        problem.Configure(problemData, row);
-        optimizer.Prepare();
-        optimizer.Start();
-      } else if (ExecutionState == ExecutionState.Started) {
-        OnPaused();
-      } else OnStopped();
+      // extract results from the optimizer 
+      GetResults();
+
+      if (gsoAction == GoalSeekingOptimizerAction.Stop)
+        OnStopped();
+      else if (!remainingRows.Any()) {
+        OnStopped();
+      } else switch (gsoAction) {
+          case GoalSeekingOptimizerAction.Pause:
+            OnPaused();
+            break;
+          case GoalSeekingOptimizerAction.Start:
+            currentRow = remainingRows.First();
+            problem.Configure(problemData, currentRow);
+            optimizer.Prepare();
+            optimizer.Start();
+            break;
+          default:
+            if (ExecutionState == ExecutionState.Started) {
+              OnPaused();
+            } else OnStopped();
+            break;
+        }
     }
     #endregion
+    #endregion
+
+    #region aggregate results
+    private void GetResults() {
+      if (Problem is MultiObjectiveGoalSeekingProblem) {
+        var m = (DoubleMatrix)optimizer.Results["Pareto Front Solutions"].Value;
+        AggregateMultiObjectiveResults(m);
+      } else if (Problem is SingleObjectiveGoalSeekingProblem) {
+        var m = (DoubleMatrix)optimizer.Results["Best Solution"].Value;
+        AggregateSingleObjectiveResults(m);
+      }
+    }
+
+    private void AggregateSingleObjectiveResults(DoubleMatrix solutions) {
+      var indices = solutions.ColumnNames.Select((x, i) => Tuple.Create(x, i)).ToDictionary(x => x.Item1, x => x.Item2);
+
+      var goals = Problem.Goals.Where(x => x.Active).ToList();
+      var inputs = Problem.Inputs.Where(x => x.Active).ToList();
+
+      if (Results == null)
+        Results = new ResultCollection();
+      // goals
+      if (!Results.ContainsKey("Goals"))
+        Results.Add(new Result("Goals", new ResultCollection()));
+      var goalResults = (ResultCollection)Results["Goals"].Value;
+      foreach (var goal in goals) {
+        var estimatedGoalName = goal.Name + " (estimated)";
+        if (!goalResults.ContainsKey(goal.Name)) {
+          goalResults.Add(new Result(goal.Name, new ScatterPlot(goal.Name, "")));
+        }
+
+        var plot = (ScatterPlot)goalResults[goal.Name].Value;
+        if (!plot.Rows.ContainsKey(goal.Name)) {
+          plot.Rows.Add(new ScatterPlotDataRow { Name = goal.Name });
+          plot.Rows.Add(new ScatterPlotDataRow { Name = estimatedGoalName });
+        }
+
+        plot.Rows[goal.Name].Points.Add(new Point2D<double>(currentRow, solutions[0, indices[goal.Name]]));
+        plot.Rows[estimatedGoalName].Points.Add(new Point2D<double>(currentRow, solutions[0, indices[estimatedGoalName]]));
+      }
+
+      // inputs
+      if (!Results.ContainsKey("Inputs"))
+        Results.Add(new Result("Inputs", new ResultCollection()));
+      var inputResults = (ResultCollection)Results["Inputs"].Value;
+      foreach (var input in inputs) {
+        var estimatedInputName = input.Name + " (estimated)";
+        if (!inputResults.ContainsKey(input.Name)) {
+          inputResults.Add(new Result(input.Name, new ScatterPlot(input.Name, "")));
+        }
+
+        var plot = (ScatterPlot)inputResults[input.Name].Value;
+        if (!plot.Rows.ContainsKey(input.Name)) {
+          plot.Rows.Add(new ScatterPlotDataRow { Name = input.Name });
+          plot.Rows.Add(new ScatterPlotDataRow { Name = estimatedInputName });
+        }
+
+        plot.Rows[input.Name].Points.Add(new Point2D<double>(currentRow, solutions[0, indices[input.Name]]));
+        plot.Rows[estimatedInputName].Points.Add(new Point2D<double>(currentRow, solutions[0, indices[estimatedInputName]]));
+      }
+      // aggregate results as a matrix
+      UpdateResultsMatrix(solutions);
+    }
+
+    private void AggregateMultiObjectiveResults(DoubleMatrix solutions) {
+      int maxSolutionsCount = Math.Min(solutions.Rows, 10);
+
+      var indices = solutions.ColumnNames.Select((x, i) => Tuple.Create(x, i)).ToDictionary(x => x.Item1, x => x.Item2);
+
+      var goals = Problem.Goals.Where(x => x.Active).ToList();
+      var inputs = Problem.Inputs.Where(x => x.Active).ToList();
+
+      if (Results == null)
+        Results = new ResultCollection();
+      // goals
+      if (!Results.ContainsKey("Goals"))
+        Results.Add(new Result("Goals", new ResultCollection()));
+      var goalResults = (ResultCollection)Results["Goals"].Value;
+      foreach (var goal in goals) {
+        var estimatedGoalName = goal.Name + " (estimated)";
+        if (!goalResults.ContainsKey(goal.Name)) {
+          goalResults.Add(new Result(goal.Name, new ScatterPlot(goal.Name, "")));
+        }
+
+        var plot = (ScatterPlot)goalResults[goal.Name].Value;
+        if (!plot.Rows.ContainsKey(goal.Name)) {
+          plot.Rows.Add(new ScatterPlotDataRow { Name = goal.Name, VisualProperties = { PointSize = 5 } });
+        }
+
+        plot.Rows[goal.Name].Points.Add(new Point2D<double>(currentRow, solutions[0, indices[goal.Name]]));
+        for (int i = 0; i < maxSolutionsCount; ++i) {
+          if (!plot.Rows.ContainsKey(estimatedGoalName + i))
+            plot.Rows.Add(new ScatterPlotDataRow { Name = estimatedGoalName + i, VisualProperties = { PointSize = 5 } });
+          plot.Rows[estimatedGoalName + i].Points.Add(new Point2D<double>(currentRow, solutions[i, indices[estimatedGoalName]]));
+        }
+      }
+      // inputs
+      if (!Results.ContainsKey("Inputs"))
+        Results.Add(new Result("Inputs", new ResultCollection()));
+      var inputResults = (ResultCollection)Results["Inputs"].Value;
+      foreach (var input in inputs) {
+        var estimatedInputName = input.Name + " (estimated)";
+        if (!inputResults.ContainsKey(input.Name)) {
+          inputResults.Add(new Result(input.Name, new ScatterPlot(input.Name, "")));
+        }
+
+        var plot = (ScatterPlot)inputResults[input.Name].Value;
+        if (!plot.Rows.ContainsKey(input.Name)) {
+          plot.Rows.Add(new ScatterPlotDataRow { Name = input.Name, VisualProperties = { PointSize = 5 } });
+        }
+
+        plot.Rows[input.Name].Points.Add(new Point2D<double>(currentRow, solutions[0, indices[input.Name]])); // it stays the same for all the rows
+        for (int i = 0; i < maxSolutionsCount; ++i) {
+          if (!plot.Rows.ContainsKey(estimatedInputName + i))
+            plot.Rows.Add(new ScatterPlotDataRow { Name = estimatedInputName + i, VisualProperties = { PointSize = 5 } });
+          plot.Rows[estimatedInputName + i].Points.Add(new Point2D<double>(currentRow, solutions[i, indices[estimatedInputName]]));
+        }
+      }
+      // also add a matrix containing the whole solution data including the row
+      UpdateResultsMatrix(solutions);
+    }
+
+    private void UpdateResultsMatrix(DoubleMatrix solutions) {
+      // also add a matrix containing the whole solution data including the row
+      var rows = problemData.TrainingIndices.Take(calculatedRows).ToList();
+      var m = new DoubleMatrix(calculatedRows, solutions.Columns + 1) {
+        RowNames = rows.Select(x => x.ToString()),
+        ColumnNames = new[] { "Row" }.Concat(solutions.ColumnNames)
+      };
+      DoubleMatrix old = null;
+      if (Results.ContainsKey("Solutions"))
+        old = (DoubleMatrix)Results["Solutions"].Value;
+      else
+        Results.Add(new Result("Solutions", m));
+
+      if (old != null && calculatedRows > 0) {
+        for (int i = 0; i < old.Rows; ++i) {
+          for (int j = 0; j < old.Columns; ++j) {
+            m[i, j] = old[i, j];
+          }
+        }
+      }
+      m[rows.Count - 1, 0] = currentRow;
+      for (int i = 1; i < m.Columns; ++i) {
+        m[rows.Count - 1, i] = solutions[0, i - 1];
+      }
+      Results["Solutions"].Value = m;
+    }
     #endregion
   }