Changeset 8935 for branches/HeuristicLab.TreeSimplifier/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationSolutionImpactValuesCalculator.cs

Timestamp:

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

Author:

bburlacu

Message:

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

File:

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

branches/HeuristicLab.TreeSimplifier/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationSolutionImpactValuesCalculator.cs

@@ -1 @@
-using System.Collections.Generic;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
@@ -6 +28 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
   public class SymbolicDiscriminantFunctionClassificationSolutionImpactValuesCalculator : 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 classificationProblemData,
-                                                                                 double lowerEstimationLimit, double upperEstimationLimit) {
+
+    public override IEnumerable<Tuple<ISymbolicExpressionTreeNode, double>> CalculateImpactValues(ISymbolicExpressionTree tree,
+                                                                                                  ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+                                                                                                  IDataAnalysisProblemData classificationProblemData,
+                                                                                                  double lowerEstimationLimit, double upperEstimationLimit) {
       var problemData = (IClassificationProblemData)classificationProblemData;
       var dataset = problemData.Dataset;
       var rows = problemData.TrainingIndices;
       string targetVariable = problemData.TargetVariable;
-      Dictionary<ISymbolicExpressionTreeNode, double> impactValues = new Dictionary<ISymbolicExpressionTreeNode, double>();
-      List<ISymbolicExpressionTreeNode> nodes = tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPostfix().ToList();
-
       var targetClassValues = dataset.GetDoubleValues(targetVariable, rows);
-      var originalOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows)
-        .LimitToRange(lowerEstimationLimit, upperEstimationLimit)
-        .ToArray();
+      var originalOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows).LimitToRange(lowerEstimationLimit, upperEstimationLimit).ToArray();
       OnlineCalculatorError errorState;
       double originalGini = NormalizedGiniCalculator.Calculate(targetClassValues, originalOutput, out errorState);
       if (errorState != OnlineCalculatorError.None) originalGini = 0.0;
 
-      foreach (ISymbolicExpressionTreeNode node in nodes) {
-        var parent = node.Parent;
-        var constantNode = ((ConstantTreeNode)new Constant().CreateTreeNode());
-        constantNode.Value = CalculateReplacementValue(node, tree, interpreter, classificationProblemData);
-        ISymbolicExpressionTreeNode replacementNode = constantNode;
-        SwitchNode(parent, node, replacementNode);
-        var newOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows)
-          .LimitToRange(lowerEstimationLimit, upperEstimationLimit)
-          .ToArray();
-        double newGini = NormalizedGiniCalculator.Calculate(targetClassValues, newOutput, out errorState);
-        if (errorState != OnlineCalculatorError.None) newGini = 0.0;
+      return from node in tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPostfix()
+             select new Tuple<ISymbolicExpressionTreeNode, double>(node, CalculateImpact(tree, originalGini, 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] = originalGini - newGini;
-        SwitchNode(parent, replacementNode, node);
-      }
-      return impactValues;
+    private static double CalculateImpact(ISymbolicExpressionTree tree, double originalQuality, ISymbolicExpressionTreeNode node,
+                                          ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, IClassificationProblemData 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 = NormalizedGiniCalculator.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;
     }
   }