Changeset 7989 for branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SymbolicTimeSeriesPrognosisModel.cs

Timestamp:

06/12/12 10:31:56 (12 years ago)

Author:

mkommend

Message:

#1081: Improved performance of time series prognosis.

File:

• branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SymbolicTimeSeriesPrognosisModel.cs (modified) (5 diffs)

branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SymbolicTimeSeriesPrognosisModel.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Drawing;
@@ -64 +63 @@
     #endregion
 
-    [Storable]
-    private string[] targetVariables;
-
-
     [StorableConstructor]
     protected SymbolicTimeSeriesPrognosisModel(bool deserializing) : base(deserializing) { }
@@ -74 +69 @@
       this.symbolicExpressionTree = cloner.Clone(original.symbolicExpressionTree);
       this.interpreter = cloner.Clone(original.interpreter);
-      this.targetVariables = new string[original.targetVariables.Length];
-      Array.Copy(original.targetVariables, this.targetVariables, this.targetVariables.Length);
       this.lowerEstimationLimit = original.lowerEstimationLimit;
       this.upperEstimationLimit = original.upperEstimationLimit;
     }
-    public SymbolicTimeSeriesPrognosisModel(ISymbolicExpressionTree tree, ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, IEnumerable<string> targetVariables, double lowerLimit = double.MinValue, double upperLimit = double.MaxValue)
+    public SymbolicTimeSeriesPrognosisModel(ISymbolicExpressionTree tree, ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, double lowerLimit = double.MinValue, double upperLimit = double.MaxValue)
       : base() {
       this.name = ItemName;
       this.description = ItemDescription;
       this.symbolicExpressionTree = tree;
-      this.interpreter = interpreter; this.targetVariables = targetVariables.ToArray();
+      this.interpreter = interpreter;
       this.lowerEstimationLimit = lowerLimit;
       this.upperEstimationLimit = upperLimit;
@@ -93 +86 @@
     }
 
-    public IEnumerable<IEnumerable<IEnumerable<double>>> GetPrognosedValues(Dataset dataset, IEnumerable<int> rows, int horizon) {
-      var enumerator =
-        Interpreter.GetSymbolicExpressionTreeValues(SymbolicExpressionTree, dataset, targetVariables, rows, horizon).
-          GetEnumerator();
-      foreach (var r in rows) {
-        var l = new List<double[]>();
-        for (int h = 0; h < horizon; h++) {
-          double[] components = new double[targetVariables.Length];
-          for (int c = 0; c < components.Length; c++) {
-            enumerator.MoveNext();
-            components[c] = Math.Min(upperEstimationLimit, Math.Max(lowerEstimationLimit, enumerator.Current));
-          }
-          l.Add(components);
-        }
-        yield return l;
-      }
+    public IEnumerable<IEnumerable<double>> GetPrognosedValues(Dataset dataset, IEnumerable<int> rows, int horizon) {
+      var estimatedValues = Interpreter.GetSymbolicExpressionTreeValues(SymbolicExpressionTree, dataset, rows, horizon);
+      return estimatedValues.Select(predictionPerRow => predictionPerRow.LimitToRange(lowerEstimationLimit, upperEstimationLimit));
     }
 
@@ -120 +100 @@
     public static void Scale(SymbolicTimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData) {
       var dataset = problemData.Dataset;
-      var targetVariables = problemData.TargetVariables.ToArray();
+      var targetVariable = problemData.TargetVariable;
       var rows = problemData.TrainingIndizes;
-      var estimatedValuesEnumerator = model.Interpreter.GetSymbolicExpressionTreeValues(model.SymbolicExpressionTree, dataset,
-                                                                              targetVariables,
-                                                                              rows).GetEnumerator();
-      var scalingParameterCalculators =
-        problemData.TargetVariables.Select(v => new OnlineLinearScalingParameterCalculator()).ToArray();
-      var targetValuesEnumerator = problemData.Dataset.GetVectorEnumerable(targetVariables, rows).GetEnumerator();
+      var estimatedValuesEnumerator = model.Interpreter.GetSymbolicExpressionTreeValues(model.SymbolicExpressionTree, dataset, rows);
+      var targetValuesEnumerator = problemData.Dataset.GetDoubleValues(targetVariable, rows);
 
-      var more = targetValuesEnumerator.MoveNext() & estimatedValuesEnumerator.MoveNext();
-      // foreach row
-      while (more) {
-        // foreach component
-        for (int i = 0; i < targetVariables.Length; i++) {
-          scalingParameterCalculators[i].Add(estimatedValuesEnumerator.Current, targetValuesEnumerator.Current);
-          more = estimatedValuesEnumerator.MoveNext() & targetValuesEnumerator.MoveNext();
+      double alpha, beta;
+      OnlineCalculatorError error;
+      OnlineLinearScalingParameterCalculator.Calculate(estimatedValuesEnumerator, targetValuesEnumerator, out alpha, out beta, out error);
+      if (error != OnlineCalculatorError.None) return;
+
+      ConstantTreeNode alphaTreeNode = null;
+      ConstantTreeNode betaTreeNode = null;
+      // check if model has been scaled previously by analyzing the structure of the tree
+      var startNode = model.SymbolicExpressionTree.Root.GetSubtree(0);
+      if (startNode.GetSubtree(0).Symbol is Addition) {
+        var addNode = startNode.GetSubtree(0);
+        if (addNode.SubtreeCount == 2 && addNode.GetSubtree(0).Symbol is Multiplication && addNode.GetSubtree(1).Symbol is Constant) {
+          alphaTreeNode = addNode.GetSubtree(1) as ConstantTreeNode;
+          var mulNode = addNode.GetSubtree(0);
+          if (mulNode.SubtreeCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {
+            betaTreeNode = mulNode.GetSubtree(1) as ConstantTreeNode;
+          }
         }
       }
-
-      for (int i = 0; i < targetVariables.Count(); i++) {
-        if (scalingParameterCalculators[i].ErrorState != OnlineCalculatorError.None) continue;
-        double alpha = scalingParameterCalculators[i].Alpha;
-        double beta = scalingParameterCalculators[i].Beta;
-        ConstantTreeNode alphaTreeNode = null;
-        ConstantTreeNode betaTreeNode = null;
-        // check if model has been scaled previously by analyzing the structure of the tree
-        var startNode = model.SymbolicExpressionTree.Root.GetSubtree(0);
-        if (startNode.GetSubtree(i).Symbol is Addition) {
-          var addNode = startNode.GetSubtree(i);
-          if (addNode.SubtreeCount == 2 && addNode.GetSubtree(0).Symbol is Multiplication &&
-              addNode.GetSubtree(1).Symbol is Constant) {
-            alphaTreeNode = addNode.GetSubtree(1) as ConstantTreeNode;
-            var mulNode = addNode.GetSubtree(0);
-            if (mulNode.SubtreeCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {
-              betaTreeNode = mulNode.GetSubtree(1) as ConstantTreeNode;
-            }
-          }
-        }
-        // if tree structure matches the structure necessary for linear scaling then reuse the existing tree nodes
-        if (alphaTreeNode != null && betaTreeNode != null) {
-          betaTreeNode.Value *= beta;
-          alphaTreeNode.Value *= beta;
-          alphaTreeNode.Value += alpha;
-        } else {
-          var mainBranch = startNode.GetSubtree(i);
-          startNode.RemoveSubtree(i);
-          var scaledMainBranch = MakeSum(MakeProduct(mainBranch, beta), alpha);
-          startNode.InsertSubtree(i, scaledMainBranch);
-        }
-      } // foreach
+      // if tree structure matches the structure necessary for linear scaling then reuse the existing tree nodes
+      if (alphaTreeNode != null && betaTreeNode != null) {
+        betaTreeNode.Value *= beta;
+        alphaTreeNode.Value *= beta;
+        alphaTreeNode.Value += alpha;
+      } else {
+        var mainBranch = startNode.GetSubtree(0);
+        startNode.RemoveSubtree(0);
+        var scaledMainBranch = MakeSum(MakeProduct(mainBranch, beta), alpha);
+        startNode.AddSubtree(scaledMainBranch);
+      }
     }