Changeset 8935 for branches/HeuristicLab.TreeSimplifier/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression

Timestamp:

11/22/12 15:03:32 (12 years ago)

Author:

bburlacu

Message:

#1763: Bugfixes and refactoring as suggested in the comments above.

File:

• branches/HeuristicLab.TreeSimplifier/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolutionImpactValuesCalculator.cs (modified) (2 diffs)

branches/HeuristicLab.TreeSimplifier/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolutionImpactValuesCalculator.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
   public class SymbolicRegressionSolutionImpactValuesCalculator : SymbolicDataAnalysisSolutionImpactValuesCalculator {
-    public override Dictionary<ISymbolicExpressionTreeNode, double> CalculateReplacementValues(ISymbolicExpressionTree tree,
-                                                                                               ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-                                                                                               IDataAnalysisProblemData problemData) {
-      var replacementValues = new Dictionary<ISymbolicExpressionTreeNode, double>();
-      foreach (ISymbolicExpressionTreeNode node in tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix()) {
-        replacementValues[node] = CalculateReplacementValue(node, tree, interpreter, problemData);
-      }
-      return replacementValues;
+    public override IEnumerable<Tuple<ISymbolicExpressionTreeNode, double>> CalculateReplacementValues(ISymbolicExpressionTree tree,
+                                                                                                       ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+                                                                                                       IDataAnalysisProblemData problemData) {
+      return from node in tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix()
+             select new Tuple<ISymbolicExpressionTreeNode, double>(node, CalculateReplacementValue(node, tree, interpreter, problemData));
     }
 
-    public override Dictionary<ISymbolicExpressionTreeNode, double> CalculateImpactValues(ISymbolicExpressionTree tree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IDataAnalysisProblemData regressionProblemData, double lowerEstimationLimit, double upperEstimationLimit) {
+    public override IEnumerable<Tuple<ISymbolicExpressionTreeNode, double>> CalculateImpactValues(ISymbolicExpressionTree tree,
+                                                                                                  ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+                                                                                                  IDataAnalysisProblemData regressionProblemData,
+                                                                                                  double lowerEstimationLimit, double upperEstimationLimit) {
       var problemData = (IRegressionProblemData)regressionProblemData;
       var dataset = problemData.Dataset;
       var rows = problemData.TrainingIndices.ToList();
       string targetVariable = problemData.TargetVariable;
-      var impactValues = new Dictionary<ISymbolicExpressionTreeNode, double>();
       List<ISymbolicExpressionTreeNode> nodes = tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPostfix().ToList();
-      var originalOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows).ToArray();
+      var originalOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows).LimitToRange(lowerEstimationLimit, upperEstimationLimit).ToArray();
       var targetValues = dataset.GetDoubleValues(targetVariable, rows).ToList();
       OnlineCalculatorError errorState;
@@ -49 +50 @@
       if (errorState != OnlineCalculatorError.None) originalR2 = 0.0;
 
-      foreach (ISymbolicExpressionTreeNode node in nodes) {
-        var parent = node.Parent;
-        var constantNode = ((ConstantTreeNode)new Constant().CreateTreeNode());
-        constantNode.Value = CalculateReplacementValue(node, tree, interpreter, problemData);
-        ISymbolicExpressionTreeNode replacementNode = constantNode;
-        SwitchNode(parent, node, replacementNode);
-        var newOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows);
-        double newR2 = OnlinePearsonsRSquaredCalculator.Calculate(targetValues, newOutput, out errorState);
-        if (errorState != OnlineCalculatorError.None) newR2 = 0.0;
+      return from node in tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPostfix().ToList()
+             select new Tuple<ISymbolicExpressionTreeNode, double>(node, CalculateImpact(tree, originalR2, node, interpreter, problemData, lowerEstimationLimit, upperEstimationLimit));
+    }
 
-        // impact = 0 if no change
-        // impact < 0 if new solution is better
-        // impact > 0 if new solution is worse
-        impactValues[node] = originalR2 - newR2;
-        SwitchNode(parent, replacementNode, node);
-      }
-      return impactValues;
+    private static double CalculateImpact(ISymbolicExpressionTree tree, double originalQuality, ISymbolicExpressionTreeNode node,
+                                          ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IRegressionProblemData problemData,
+                                          double lowerEstimationLimit, double upperEstimationLimit) {
+      var dataset = problemData.Dataset;
+      var rows = problemData.TrainingIndices.ToList();
+      string targetVariable = problemData.TargetVariable;
+      var targetValues = dataset.GetDoubleValues(targetVariable, rows).ToList();
+
+      var parent = node.Parent;
+      var constantNode = (ConstantTreeNode)new Constant().CreateTreeNode();
+      constantNode.Value = CalculateReplacementValue(node, tree, interpreter, problemData);
+      SwitchNode(parent, node, constantNode);
+      var newOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows)
+                                 .LimitToRange(lowerEstimationLimit, upperEstimationLimit)
+                                 .ToArray();
+      OnlineCalculatorError errorState;
+      double quality = OnlinePearsonsRSquaredCalculator.Calculate(targetValues, newOutput, out errorState);
+      if (errorState != OnlineCalculatorError.None) quality = 0.0;
+      SwitchNode(parent, constantNode, node);
+      // impact = 0 if no change
+      // impact < 0 if new solution is better
+      // impact > 0 if new solution is worse
+      return originalQuality - quality;
     }
   }