Changeset 8113 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression

Timestamp:

06/26/12 08:27:57 (13 years ago)

Author:

gkronber

Message:

#1788 changed symbolic regression evaluators to bound estimated values after scaling instead of before.

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators

Files:

• SymbolicRegressionSingleObjectiveEvaluator.cs (modified) (3 diffs)
• SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs (modified) (2 diffs)
• SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs (modified) (2 diffs)
• SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveEvaluator.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -59 +60 @@
     private static double[] cache;
 
-    protected static void CalculateWithScaling(IEnumerable<double> targetValues, IEnumerable<double> estimatedValues, IOnlineCalculator calculator, int maxRows) {
+    protected static void CalculateWithScaling(IEnumerable<double> targetValues, IEnumerable<double> estimatedValues,
+      double lowerEstimationLimit, double upperEstimationLimit,
+      IOnlineCalculator calculator, int maxRows) {
       if (cache == null || cache.GetLength(0) < maxRows) {
         cache = new double[maxRows];
@@ -83 +86 @@
       //calculate the quality by using the passed online calculator
       targetValuesEnumerator = targetValues.GetEnumerator();
-      i = 0;
-      while (targetValuesEnumerator.MoveNext()) {
-        double target = targetValuesEnumerator.Current;
-        double estimated = cache[i] * beta + alpha;
-        calculator.Add(target, estimated);
-        i++;
+      var scaledBoundedEstimatedValuesEnumerator = (from r in Enumerable.Range(0, i)
+                                                    select cache[r] * beta + alpha)
+        .LimitToRange(lowerEstimationLimit, upperEstimationLimit)
+        .GetEnumerator();
+      while (targetValuesEnumerator.MoveNext() & scaledBoundedEstimatedValuesEnumerator.MoveNext()) {
+        calculator.Add(targetValuesEnumerator.Current, scaledBoundedEstimatedValuesEnumerator.Current);
       }
     }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs

@@ -56 +56 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       OnlineCalculatorError errorState;
 
@@ -62 +61 @@
       if (applyLinearScaling) {
         var maeCalculator = new OnlineMaxAbsoluteErrorCalculator();
-        CalculateWithScaling(targetValues, boundedEstimatedValues, maeCalculator, problemData.Dataset.Rows);
+        CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, maeCalculator, problemData.Dataset.Rows);
         errorState = maeCalculator.ErrorState;
         mse = maeCalculator.MaxAbsoluteError;
-      } else
+      } else {
+        IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
         mse = OnlineMaxAbsoluteErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
-
+      }
       if (errorState != OnlineCalculatorError.None) return Double.NaN;
       else return mse;

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs

@@ -56 +56 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       OnlineCalculatorError errorState;
 
@@ -62 +61 @@
       if (applyLinearScaling) {
         var maeCalculator = new OnlineMeanAbsoluteErrorCalculator();
-        CalculateWithScaling(targetValues, boundedEstimatedValues, maeCalculator, problemData.Dataset.Rows);
+        CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, maeCalculator, problemData.Dataset.Rows);
         errorState = maeCalculator.ErrorState;
         mse = maeCalculator.MeanAbsoluteError;
-      } else
+      } else {
+        IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit,
+                                                                                  upperEstimationLimit);
         mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
-
+      }
       if (errorState != OnlineCalculatorError.None) return Double.NaN;
       else return mse;

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs

@@ -56 +56 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
-      IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       OnlineCalculatorError errorState;
 
@@ -62 +61 @@
       if (applyLinearScaling) {
         var mseCalculator = new OnlineMeanSquaredErrorCalculator();
-        CalculateWithScaling(targetValues, boundedEstimatedValues, mseCalculator, problemData.Dataset.Rows);
+        CalculateWithScaling(targetValues, estimatedValues, lowerEstimationLimit, upperEstimationLimit, mseCalculator, problemData.Dataset.Rows);
         errorState = mseCalculator.ErrorState;
         mse = mseCalculator.MeanSquaredError;
-      } else
+      } else {
+        IEnumerable<double> boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
         mse = OnlineMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
-
+      }
       if (errorState != OnlineCalculatorError.None) return Double.NaN;
       else return mse;