Changeset 4462

Timestamp:

09/21/10 14:18:06 (14 years ago)

Author:

gkronber

Message:

Changed symbolic simplifier to work for multi-variate models and return a symbolic expression tree that can be directly evaluated. #1142

Location:

branches/DataAnalysis

Files:

• HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/InteractiveSymbolicRegressionSolutionSimplifierView.cs (modified) (5 diffs)
• HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SymbolicSimplifier.cs (modified) (2 diffs)

branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/InteractiveSymbolicRegressionSolutionSimplifierView.cs

@@ -83 +83 @@
         SymbolicSimplifier simplifier = new SymbolicSimplifier();
         simplifiedExpressionTree = simplifier.Simplify(Content.Model.SymbolicExpressionTree);
-        SymbolicExpressionTreeNode root = new ProgramRootSymbol().CreateTreeNode();
-        SymbolicExpressionTreeNode start = new StartSymbol().CreateTreeNode();
-        root.AddSubTree(start);
-        start.AddSubTree(simplifiedExpressionTree.Root);
         int samplesStart = Content.ProblemData.TrainingSamplesStart.Value;
         int samplesEnd = Content.ProblemData.TrainingSamplesEnd.Value;
+        SymbolicExpressionTree tree = (SymbolicExpressionTree)simplifiedExpressionTree.Clone();
         double originalTrainingMeanSquaredError = SymbolicRegressionMeanSquaredErrorEvaluator.Calculate(
-            Content.Model.Interpreter, new SymbolicExpressionTree(root), Content.LowerEstimationLimit, Content.UpperEstimationLimit,
+            Content.Model.Interpreter, tree, Content.LowerEstimationLimit, Content.UpperEstimationLimit,
             Content.ProblemData.Dataset, Content.ProblemData.TargetVariable.Value,
             Enumerable.Range(samplesStart, samplesEnd - samplesStart));
@@ -96 +93 @@
         this.CalculateReplacementNodes();
 
-        this.CalculateNodeImpacts(new SymbolicExpressionTree(root), start, originalTrainingMeanSquaredError);
-        this.treeChart.Tree = simplifiedExpressionTree;
+        this.CalculateNodeImpacts(tree, tree.Root.SubTrees[0], originalTrainingMeanSquaredError);
+        this.treeChart.Tree = new SymbolicExpressionTree(simplifiedExpressionTree.Root.SubTrees[0].SubTrees[0]);
         this.PaintNodeImpacts();
       }
@@ -110 +107 @@
       SymbolicExpressionTree tree = new SymbolicExpressionTree(root);
       foreach (SymbolicExpressionTreeNode node in this.simplifiedExpressionTree.IterateNodesPrefix()) {
-        while (start.SubTrees.Count > 0) start.RemoveSubTree(0);
-        start.AddSubTree(node);
-        double constantTreeNodeValue = interpreter.GetSymbolicExpressionTreeValues(tree, Content.ProblemData.Dataset, trainingSamples).Median();
-        ConstantTreeNode constantTreeNode = MakeConstantTreeNode(constantTreeNodeValue);
-        replacementNodes[node] = constantTreeNode;
+        if (!(node.Symbol is ProgramRootSymbol || node.Symbol is StartSymbol)) {
+          while (start.SubTrees.Count > 0) start.RemoveSubTree(0);
+          start.AddSubTree(node);
+          double constantTreeNodeValue = interpreter.GetSymbolicExpressionTreeValues(tree, Content.ProblemData.Dataset, trainingSamples).Median();
+          ConstantTreeNode constantTreeNode = MakeConstantTreeNode(constantTreeNodeValue);
+          replacementNodes[node] = constantTreeNode;
+        }
       }
     }
@@ -169 +168 @@
         }
       }
-      this.treeChart.Tree = simplifiedExpressionTree;
-
-      SymbolicExpressionTreeNode root = new ProgramRootSymbol().CreateTreeNode();
-      SymbolicExpressionTreeNode start = new StartSymbol().CreateTreeNode();
-      root.AddSubTree(start);
-      SymbolicExpressionTree tree = new SymbolicExpressionTree(root);
-      start.AddSubTree(simplifiedExpressionTree.Root);
+      this.treeChart.Tree = new SymbolicExpressionTree(simplifiedExpressionTree.Root.SubTrees[0].SubTrees[0]);
+
+      SymbolicExpressionTree tree = (SymbolicExpressionTree)simplifiedExpressionTree.Clone();
 
       this.Content.ModelChanged -= new EventHandler(Content_ModelChanged);
@@ -189 +184 @@
       double min = impacts.Min();
       foreach (SymbolicExpressionTreeNode treeNode in simplifiedExpressionTree.IterateNodesPostfix()) {
-        if (!(treeNode is ConstantTreeNode)) {
+        if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
           double impact = this.nodeImpacts[treeNode];
           double replacementValue = this.replacementNodes[treeNode].Value;

branches/DataAnalysis/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SymbolicSimplifier.cs

@@ -44 +44 @@
       // macro expand (initially no argument trees)
       var macroExpandedTree = MacroExpand(clone, clone.SubTrees[0], new List<SymbolicExpressionTreeNode>());
-      return new SymbolicExpressionTree(GetSimplifiedTree(macroExpandedTree));
+      SymbolicExpressionTreeNode rootNode = (new ProgramRootSymbol()).CreateTreeNode();
+      rootNode.AddSubTree(GetSimplifiedTree(macroExpandedTree));
+      return new SymbolicExpressionTree(rootNode);
     }
 
@@ -63 +65 @@
         // return the correct argument sub-tree (already macro-expanded)
         return (SymbolicExpressionTreeNode)argumentTrees[argSym.ArgumentIndex].Clone();
-      } else if (node.Symbol is StartSymbol) {
-        return MacroExpand(root, subtrees[0], argumentTrees);
       } else {
         // recursive application