Changeset 10721 for branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

04/03/14 16:21:07 (11 years ago)

Author:

bburlacu

Message:

#1837: Performance and usability improvements.

File:

• branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SlidingWindow/SlidingWindowBestSolutionsCollection.cs (modified) (15 diffs)

branches/Sliding Window GP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SlidingWindow/SlidingWindowBestSolutionsCollection.cs

@@ -35 +35 @@
     [Storable]
     private List<SlidingWindowRange> slidingWindowRanges;
+
     public List<SlidingWindowRange> SlidingWindowRanges {
       get { return slidingWindowRanges; }
@@ -55 +56 @@
     [Storable]
     private Dictionary<SlidingWindowRange, ISymbolicExpressionTree> slidingWindowBestSolutions;
+
     public Dictionary<SlidingWindowRange, ISymbolicExpressionTree> SlidingWindowBestSolutions {
       get { return slidingWindowBestSolutions; }
@@ -62 +64 @@
     [Storable]
     private IDataAnalysisProblemData problemData;
+
     public IDataAnalysisProblemData ProblemData {
       get { return problemData; }
@@ -69 +72 @@
     [Storable]
     private ISymbolicDataAnalysisExpressionTreeInterpreter interpreter;
+
     public ISymbolicDataAnalysisExpressionTreeInterpreter Interpreter {
       get { return interpreter; }
@@ -76 +80 @@
     [Storable]
     private bool applyLinearScaling;
+
     public bool ApplyLinearScaling {
       get { return applyLinearScaling; }
@@ -98 +103 @@
 
     private QualityMeasures qualityMeasure;
+
     public QualityMeasures QualityMeasure {
       get { return qualityMeasure; }
@@ -122 +128 @@
     }
 
+    public event EventHandler QualitiesCalculationStarted;
+
+    private void OnQualitiesCalculationStarted(object sender, EventArgs e) {
+      var started = QualitiesCalculationStarted;
+      if (started != null) {
+        started(sender, e);
+      }
+    }
+
     public event EventHandler QualitiesUpdated;
     private void OnQualitiesUpdated(object sender, EventArgs e) {
       var updated = QualitiesUpdated;
-      if (updated != null) { updated(sender, e); }
+      if (updated != null) {
+        updated(sender, e);
+      }
     }
 
     [StorableConstructor]
-    protected SlidingWindowBestSolutionsCollection(bool deserializing) : base(deserializing) { }
+    protected SlidingWindowBestSolutionsCollection(bool deserializing)
+      : base(deserializing) {
+    }
+
     protected SlidingWindowBestSolutionsCollection(SlidingWindowBestSolutionsCollection original, Cloner cloner)
       : base(original, cloner) {
@@ -137 +157 @@
       this.applyLinearScaling = original.ApplyLinearScaling;
     }
+
     protected SlidingWindowBestSolutionsCollection() {
       slidingWindowBestSolutions = new Dictionary<SlidingWindowRange, ISymbolicExpressionTree>();
@@ -154 +175 @@
 
     public ISymbolicExpressionTree this[SlidingWindowRange key] {
-      get {
-        return slidingWindowBestSolutions[key];
-      }
+      get { return slidingWindowBestSolutions[key]; }
       set {
         AddSolution(key, value); // this should be fast so there's no need for a background worker
@@ -177 +196 @@
     }
 
-    public abstract ISymbolicDataAnalysisModel CreateModel(ISymbolicExpressionTree tree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-     double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue);
-
-    public abstract ISymbolicDataAnalysisSolution CreateSolution(ISymbolicDataAnalysisModel model, IDataAnalysisProblemData problemData);
+    public abstract ISymbolicDataAnalysisModel CreateModel(ISymbolicExpressionTree tree,
+      ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+      double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue);
+
+    public abstract ISymbolicDataAnalysisSolution CreateSolution(ISymbolicDataAnalysisModel model,
+      IDataAnalysisProblemData problemData);
 
     private void AddSolution(SlidingWindowRange range, ISymbolicExpressionTree solution) {
-      // add a solution and update the qualities matrix
       Add(range, solution);
 
@@ -193 +213 @@
       var trainingIndices = problemData.TrainingIndices.ToList();
       var matrix = new double[nRows, nCols];
-      List<int> rows;
+
       // copy old qualities into the new matrix
       for (int i = 0; i < nRows - 1; ++i) {
@@ -201 +221 @@
       }
       // copy qualities of new solution into the new matrix
+      var rows = Enumerable.Range(slidingWindowRanges.First().Start, slidingWindowRanges.Last().End - slidingWindowRanges.First().Start).ToList();
+      var estimatedValues = Interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows).ToList();
+      var originalValues = ProblemData.Dataset.GetDoubleValues(GetTargetVariable(ProblemData), rows).ToList();
       for (int i = 0; i < nCols; ++i) {
-        rows = i == nCols - 1 ? trainingIndices : Enumerable.Range(slidingWindowRanges[i].Start, slidingWindowRanges[i].Size).ToList();
-        matrix[nRows - 1, i] = CalculateQuality(solution, rows);
+        if (i == nCols - 1) {
+          matrix[nRows - 1, i] = CalculateQuality(solution, trainingIndices);
+        } else {
+          var indices = Enumerable.Range(slidingWindowRanges[i].Start, slidingWindowRanges[i].Size).ToList();
+          var estimated = indices.Select(x => estimatedValues[x]);
+          var original = indices.Select(x => originalValues[x]);
+          matrix[nRows - 1, i] = CalculateQuality(estimated, original);
+        }
       }
       // shift old training qualities one column to the right
@@ -223 +252 @@
       }
 
+      OnQualitiesCalculationStarted(this, EventArgs.Empty);
+
       var ranges = SlidingWindowRanges;
       var solutions = ranges.Select(x => SlidingWindowBestSolutions[x]).ToList();
 
-      int rows = solutions.Count;
-      int columns = ranges.Count + 1;
-
-      SlidingWindowQualities = new double[rows, columns];
-
-      for (int i = 0; i < rows; ++i) {
+      int nRows = solutions.Count;
+      int nCols = ranges.Count + 1;
+
+      SlidingWindowQualities = new double[nRows, nCols];
+      var rows = Enumerable.Range(ranges.First().Start, ranges.Last().End - ranges.First().Start).ToList();
+      var originalValues = ProblemData.Dataset.GetDoubleValues(GetTargetVariable(ProblemData), rows).ToList();
+
+      for (int i = 0; i < nRows; ++i) {
         if (worker.CancellationPending) {
           e.Cancel = true;
@@ -238 +271 @@
 
         var solution = solutions[i];
-        for (int j = 0; j < columns; ++j) {
-          var range = (j == columns - 1) ? ProblemData.TrainingIndices : Enumerable.Range(ranges[j].Start, ranges[j].Size);
-          var q = CalculateQuality(solution, range);
+        var estimatedValues = Interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows).ToList();
+
+        for (int j = 0; j < nCols; ++j) {
+          double q;
+          if (j == nCols - 1) {
+            q = CalculateQuality(solution, problemData.TrainingIndices);
+          } else {
+            var range = ranges[j];
+            var indices = Enumerable.Range(range.Start, range.Size).ToList();
+            var estimated = indices.Select(x => estimatedValues[x]);
+            var original = indices.Select(x => originalValues[x]);
+
+            q = CalculateQuality(estimated, original);
+          }
 
           SlidingWindowQualities[i, j] = q;
         }
 
-        worker.ReportProgress((int)Math.Round(i * 100.0 / rows));
+        worker.ReportProgress((int)Math.Round(i * 100.0 / nRows));
       }
     }
@@ -259 +303 @@
       if (classificationProblemData != null) return classificationProblemData.TargetVariable;
       throw new NotSupportedException();
+    }
+
+    private double CalculateQuality(IEnumerable<double> estimatedValues, IEnumerable<double> originalValues) {
+      var errorState = OnlineCalculatorError.None;
+      double quality = 0.0;
+      switch (QualityMeasure) {
+        case QualityMeasures.PEARSON:
+          quality = OnlinePearsonsRSquaredCalculator.Calculate(estimatedValues, originalValues, out errorState);
+          break;
+        case QualityMeasures.MSE:
+          quality = OnlineMeanSquaredErrorCalculator.Calculate(estimatedValues, originalValues, out errorState);
+          break;
+      }
+      return errorState == OnlineCalculatorError.None ? quality : double.NaN;
     }