Changeset 7154 for branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis

Timestamp:

12/07/11 22:47:12 (13 years ago)

Author:

gkronber

Message:

#1081: worked on multi-variate time series prognosis

Location:

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

Files:

• SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveMeanSquaredErrorEvaluator.cs (modified) (5 diffs)
• SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveProblem.cs (modified) (2 diffs)
• SymbolicTimeSeriesPrognosisModel.cs (modified) (5 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;
@@ -65 +66 @@
       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();
 
-      var allPredictedContinuations = interpreter.GetSymbolicExpressionTreeValues(scaledSolution, problemData.Dataset,
-                                                                                  problemData.TargetVariables.ToArray(),
-                                                                                  rows, horizon);
-      var allContinuationsEnumerator = allPredictedContinuations.GetEnumerator();
-      var rowsEnumerator = rows.GetEnumerator();
-      while (allContinuationsEnumerator.MoveNext() & rowsEnumerator.MoveNext()) {
-        var componentEnumerator = allContinuationsEnumerator.Current.GetEnumerator();
-        var mseCalculatorsEnumerator = meanSquaredErrorCalculators.AsEnumerable().GetEnumerator();
-        var targetVarEnumerator = problemData.TargetVariables.GetEnumerator();
-        while (componentEnumerator.MoveNext() & mseCalculatorsEnumerator.MoveNext() & targetVarEnumerator.MoveNext()) {
-          var stepEnumerator = componentEnumerator.Current.GetEnumerator();
-          var actualContinuationEnumerator = problemData.Dataset.GetDoubleValues(targetVarEnumerator.Current,
-                                                                       Enumerable.Range(rowsEnumerator.Current, horizon)).GetEnumerator();
-          while (stepEnumerator.MoveNext() & actualContinuationEnumerator.MoveNext()) {
-            double e = Math.Min(upperEstimationLimit, Math.Max(lowerEstimationLimit, stepEnumerator.Current));
-            mseCalculatorsEnumerator.Current.Add(actualContinuationEnumerator.Current, e);
-            if (mseCalculatorsEnumerator.Current.ErrorState == OnlineCalculatorError.InvalidValueAdded)
-              return double.NaN;
+      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();
           }
         }
@@ -92 +90 @@
       var meanCalculator = new OnlineMeanAndVarianceCalculator();
       foreach (var calc in meanSquaredErrorCalculators) {
-        if (calc.ErrorState != OnlineCalculatorError.None) return double.NaN;
+        if (calc.ErrorState != OnlineCalculatorError.None) return double.MaxValue;
         meanCalculator.Add(calc.MeanSquaredError);
       }
@@ -109 +107 @@
       //  }
       //}
-      return meanCalculator.MeanErrorState == OnlineCalculatorError.None ? meanCalculator.Mean : double.NaN;
+      return meanCalculator.MeanErrorState == OnlineCalculatorError.None ? meanCalculator.Mean : double.MaxValue;
     }
 
@@ -153 +151 @@
       alpha = new double[nComponents];
       beta = new double[nComponents];
-      var oneStepPredictions = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset,
-                                                                     targetVariables, rows,
-                                                                     1);
+      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++) {
-        var target = problemData.Dataset.GetDoubleValues(targetVariables[i], rows);
-        var prediction = oneStepPredictions.Select(v => v.ElementAt(i).First());
-        OnlineCalculatorError errorState;
-        OnlineLinearScalingParameterCalculator.Calculate(prediction, target, out alpha[i], out beta[i], out errorState);
-        if (errorState != OnlineCalculatorError.None) {
-          alpha[i] = 0;
-          beta[i] = 1;
+        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;
         }
       }

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

@@ -57 +57 @@
       EstimationLimitsParameter.Hidden = true;
 
-      Maximization.Value = true;
+      Maximization.Value = false;
       MaximumSymbolicExpressionTreeDepth.Value = InitialMaximumTreeDepth;
       MaximumSymbolicExpressionTreeLength.Value = InitialMaximumTreeLength;
@@ -106 +106 @@
           op.EstimationLimitsParameter.ActualName = EstimationLimitsParameter.Name;
         }
+        foreach (var op in operators.OfType<SymbolicTimeSeriesPrognosisSingleObjectiveTrainingBestSolutionAnalyzer>())
+        {
+          op.MaximizationParameter.ActualName = MaximizationParameter.Name;
+          op.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
+          op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+          op.SymbolicDataAnalysisTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameter.Name;
+          op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+        }
       }
     }

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

@@ -20 +20 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Drawing;
@@ -69 +70 @@
       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);
     }
     public SymbolicTimeSeriesPrognosisModel(ISymbolicExpressionTree tree, ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter interpreter, IEnumerable<string> targetVariables)
@@ -83 +86 @@
 
     public IEnumerable<IEnumerable<IEnumerable<double>>> GetPrognosedValues(Dataset dataset, IEnumerable<int> rows, int horizon) {
-      return Interpreter.GetSymbolicExpressionTreeValues(SymbolicExpressionTree, dataset, targetVariables, rows, 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] = enumerator.Current;
+          }
+          l.Add(components);
+        }
+        yield return l;
+      }
     }
 
@@ -95 +112 @@
     public static void Scale(SymbolicTimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData) {
       var dataset = problemData.Dataset;
-      var targetVariables = problemData.TargetVariables;
+      var targetVariables = problemData.TargetVariables.ToArray();
       var rows = problemData.TrainingIndizes;
-      int i = 0;
-      int horizon = 1;
-      var estimatedValues = model.Interpreter.GetSymbolicExpressionTreeValues(model.SymbolicExpressionTree, dataset, problemData.TargetVariables.ToArray(), rows, horizon)
-        .ToArray();
-      foreach (var targetVariable in targetVariables) {
-        var targetValues = dataset.GetDoubleValues(targetVariable, rows);
-        double alpha;
-        double beta;
-        OnlineCalculatorError errorState;
-        OnlineLinearScalingParameterCalculator.Calculate(estimatedValues.Select(x => x.ElementAt(i).First()), targetValues,
-          out alpha, out beta, out errorState);
-        if (errorState != OnlineCalculatorError.None) continue;
+      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 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();
+        }
+      }
+
+      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;
@@ -136 +161 @@
           startNode.InsertSubtree(i, scaledMainBranch);
         }
-        i++;
       } // foreach
     }