Changeset 14353 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs

Timestamp:

10/23/16 19:31:18 (8 years ago)

Author:

bburlacu

Message:

#2685: Add correction step for values miscalculated due to cyclical symbol dependencies in the grammar. Updated unit test.

File:

• trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs (modified) (5 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs

@@ -42 +42 @@
     private const string ProblemDataParameterName = "ProblemData";
     private const string EstimationLimitsParameterName = "EstimationLimits";
+    private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
     #endregion
 
@@ -60 +61 @@
       get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
     }
+    public ILookupParameter<BoolValue> ApplyLinearScalingParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
+    }
     #endregion
 
@@ -70 +74 @@
       Parameters.Add(new ValueLookupParameter<IRegressionProblemData>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
       Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The upper and lower limit that should be used as cut off value for the output values of symbolic data analysis trees."));
+      Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName, "Whether or not to apply linear scaling to the estimated values"));
       #endregion
 
@@ -79 +84 @@
     protected SymbolicRegressionPhenotypicDiversityAnalyzer(bool deserializing)
       : base(deserializing) {
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ApplyLinearScalingParameterName))
+        Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName, "Whether or not to apply linear scaling to the estimated values"));
     }
 
@@ -98 +109 @@
       }
 
-      if (updateCounter.Value == updateInterval) {
-        var trees = SymbolicExpressionTreeParameter.ActualValue;
+      if (updateCounter.Value != updateInterval) return base.Apply();
+
+      var scopes = ExecutionContext.Scope.SubScopes;
+      var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
+
+      foreach (var scope in scopes.Where(x => !x.Variables.ContainsKey("EstimatedValues"))) {
+        var tree = (ISymbolicExpressionTree)scope.Variables["SymbolicExpressionTree"].Value;
         var interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
         var ds = ProblemDataParameter.ActualValue.Dataset;
         var rows = ProblemDataParameter.ActualValue.TrainingIndices;
+        var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(tree, ds, rows).ToArray();
 
-        var evaluatedValues = new ItemArray<DoubleArray>(trees.Select(t => new DoubleArray(interpreter.GetSymbolicExpressionTreeValues(t, ds, rows).ToArray())));
-        EvaluatedValuesParameter.ActualValue = evaluatedValues;
+        var estimationLimits = EstimationLimitsParameter.ActualValue;
+
+        if (applyLinearScaling) {
+          var linearScalingCalculator = new OnlineLinearScalingParameterCalculator();
+          var targetValues = ds.GetDoubleValues(ProblemDataParameter.ActualValue.TargetVariable, rows);
+          int i = 0;
+          foreach (var target in targetValues) {
+            var estimated = estimatedValues[i];
+            if (!double.IsNaN(estimated) && !double.IsInfinity(estimated))
+              linearScalingCalculator.Add(estimated, target);
+            i++;
+          }
+          if (linearScalingCalculator.ErrorState == OnlineCalculatorError.None) {
+            var alpha = linearScalingCalculator.Alpha;
+            var beta = linearScalingCalculator.Beta;
+            for (i = 0; i < estimatedValues.Length; ++i) {
+              estimatedValues[i] = estimatedValues[i] * beta + alpha;
+            }
+          }
+        }
+        // add estimated values to escope
+        scope.Variables.Add(new Core.Variable("EstimatedValues", new DoubleArray(estimatedValues.LimitToRange(estimationLimits.Lower, estimationLimits.Upper).ToArray())));
       }
       return base.Apply();