Changeset 7989 for branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveMeanSquaredErrorEvaluator.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/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveMeanSquaredErrorEvaluator.cs (modified) (4 diffs)

branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveMeanSquaredErrorEvaluator.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
-using System.Drawing.Printing;
 using System.Linq;
 using HeuristicLab.Common;
@@ -51 +50 @@
       IEnumerable<int> rows = GenerateRowsToEvaluate();
 
-      double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue,
-        solution,
+      var interpreter = (ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter)SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
+
+      double quality = Calculate(interpreter, solution,
         EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper,
         ProblemDataParameter.ActualValue,
-        rows, HorizonParameter.ActualValue.Value);
+        rows, HorizonParameter.ActualValue.Value, ApplyLinearScaling);
       QualityParameter.ActualValue = new DoubleValue(quality);
 
@@ -61 +61 @@
     }
 
-    public static double Calculate(ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, ITimeSeriesPrognosisProblemData problemData, IEnumerable<int> rows, int horizon) {
-      double[] alpha;
-      double[] beta;
-      DetermineScalingFactors(solution, problemData, interpreter, rows, out alpha, out beta);
-      var scaledSolution = Scale(solution, alpha, beta);
-      string[] targetVariables = problemData.TargetVariables.ToArray();
-      var meanSquaredErrorCalculators = Enumerable.Range(0, problemData.TargetVariables.Count())
-        .Select(i => new OnlineMeanSquaredErrorCalculator()).ToArray();
+    public static double Calculate(ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, ITimeSeriesPrognosisProblemData problemData, IEnumerable<int> rows, int horizon, bool applyLinearScaling) {
+      IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows.SelectMany(r => Enumerable.Range(r, horizon)));
+      IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows, horizon).SelectMany(x => x);
+      IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
+      OnlineCalculatorError errorState;
 
-      var allContinuationsEnumerator = interpreter.GetSymbolicExpressionTreeValues(scaledSolution, problemData.Dataset,
-                                                                                  targetVariables,
-                                                                                  rows, horizon).GetEnumerator();
-      allContinuationsEnumerator.MoveNext();
-      // foreach row
-      foreach (var row in rows) {
-        // foreach horizon
-        for (int h = 0; h < horizon; h++) {
-          // foreach component
-          for (int i = 0; i < meanSquaredErrorCalculators.Length; i++) {
-            double e = Math.Min(upperEstimationLimit, Math.Max(lowerEstimationLimit, allContinuationsEnumerator.Current));
-            meanSquaredErrorCalculators[i].Add(problemData.Dataset.GetDoubleValue(targetVariables[i], row + h), e);
-            if (meanSquaredErrorCalculators[i].ErrorState == OnlineCalculatorError.InvalidValueAdded)
-              return double.MaxValue;
-            allContinuationsEnumerator.MoveNext();
-          }
-        }
-      }
-      var meanCalculator = new OnlineMeanAndVarianceCalculator();
-      foreach (var calc in meanSquaredErrorCalculators) {
-        if (calc.ErrorState != OnlineCalculatorError.None) return double.MaxValue;
-        meanCalculator.Add(calc.MeanSquaredError);
-      }
+      double mse;
+      if (applyLinearScaling) {
+        var mseCalculator = new OnlineMeanSquaredErrorCalculator();
+        CalculateWithScaling(targetValues, boundedEstimatedValues, mseCalculator, problemData.Dataset.Rows);
+        errorState = mseCalculator.ErrorState;
+        mse = mseCalculator.MeanSquaredError;
+      } else
+        mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
 
-      return meanCalculator.MeanErrorState == OnlineCalculatorError.None ? meanCalculator.Mean : double.MaxValue;
+      if (errorState != OnlineCalculatorError.None) return Double.NaN;
+      else return mse;
     }
 
-    private static ISymbolicExpressionTree Scale(ISymbolicExpressionTree solution, double[] alpha, double[] beta) {
-      var clone = (ISymbolicExpressionTree)solution.Clone();
-      int n = alpha.Length;
-      for (int i = 0; i < n; i++) {
-        var parent = clone.Root.GetSubtree(0);
-        var rpb = clone.Root.GetSubtree(0).GetSubtree(i);
-        var scaledRpb = MakeSum(
-          MakeProduct(rpb,
-            MakeConstant(beta[i], clone.Root.Grammar), clone.Root.Grammar),
-            MakeConstant(alpha[i], clone.Root.Grammar), clone.Root.Grammar);
-        parent.RemoveSubtree(i);
-        parent.InsertSubtree(i, scaledRpb);
-      }
-      return clone;
-    }
-
-    private static ISymbolicExpressionTreeNode MakeSum(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b, ISymbolicExpressionTreeGrammar grammar) {
-      var sum = grammar.Symbols.Where(s => s is Addition).First().CreateTreeNode();
-      sum.AddSubtree(a);
-      sum.AddSubtree(b);
-      return sum;
-    }
-
-    private static ISymbolicExpressionTreeNode MakeProduct(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b, ISymbolicExpressionTreeGrammar grammar) {
-      var prod = grammar.Symbols.Where(s => s is Multiplication).First().CreateTreeNode();
-      prod.AddSubtree(a);
-      prod.AddSubtree(b);
-      return prod;
-    }
-
-    private static ISymbolicExpressionTreeNode MakeConstant(double c, ISymbolicExpressionTreeGrammar grammar) {
-      var node = (ConstantTreeNode)grammar.Symbols.Where(s => s is Constant).First().CreateTreeNode();
-      node.Value = c;
-      return node;
-    }
-
-    private static void DetermineScalingFactors(ISymbolicExpressionTree solution, ITimeSeriesPrognosisProblemData problemData, ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, IEnumerable<int> rows, out double[] alpha, out double[] beta) {
-      string[] targetVariables = problemData.TargetVariables.ToArray();
-      int nComponents = targetVariables.Length;
-      alpha = new double[nComponents];
-      beta = new double[nComponents];
-      var oneStepPredictionsEnumerator = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, targetVariables, rows).GetEnumerator();
-      var scalingParameterCalculators =
-        Enumerable.Repeat(0, nComponents).Select(x => new OnlineLinearScalingParameterCalculator()).ToArray();
-      var targetValues = problemData.Dataset.GetVectorEnumerable(targetVariables, rows);
-      var targetValueEnumerator = targetValues.GetEnumerator();
-
-      var more = oneStepPredictionsEnumerator.MoveNext() & targetValueEnumerator.MoveNext();
-      while (more) {
-        for (int i = 0; i < nComponents; i++) {
-          scalingParameterCalculators[i].Add(oneStepPredictionsEnumerator.Current, targetValueEnumerator.Current);
-          more = oneStepPredictionsEnumerator.MoveNext() & targetValueEnumerator.MoveNext();
-        }
-      }
-
-      for (int i = 0; i < nComponents; i++) {
-        if (scalingParameterCalculators[i].ErrorState == OnlineCalculatorError.None) {
-          alpha[i] = scalingParameterCalculators[i].Alpha;
-          beta[i] = scalingParameterCalculators[i].Beta;
-        } else {
-          alpha[i] = 0.0;
-          beta[i] = 1.0;
-        }
-      }
-    }
 
     public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, ITimeSeriesPrognosisProblemData problemData, IEnumerable<int> rows) {
@@ -168 +86 @@
       HorizonParameter.ExecutionContext = context;
 
-      double mse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, HorizonParameter.ActualValue.Value);
+      double mse = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue as ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, HorizonParameter.ActualValue.Value, ApplyLinearScaling);
 
       HorizonParameter.ExecutionContext = null;