Changeset 8388 for branches/HeuristicLab.TreeSimplifier/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs

Timestamp:

08/02/12 15:05:26 (12 years ago)

Author:

bburlacu

Message:

#1763: Rebranched the TreeSimplifier project to fix merging errors. Added functionality to insert symbols into the tree, fixed bug when deleting tree nodes.

Location:

branches/HeuristicLab.TreeSimplifier

Files:

• . (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Views (copied) (copied from trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Views)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4 (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs (modified) (9 diffs)

branches/HeuristicLab.TreeSimplifier/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4

@@ +1 @@
+*.user
 bin
 obj
-*.user
-HeuristicLabProblemsDataAnalysisSymbolicViewsPlugin.cs
-*.vs10x
-Plugin.cs

@@ +1 @@
+*.user
 bin
 obj
-*.user
-HeuristicLabProblemsDataAnalysisSymbolicViewsPlugin.cs
-*.vs10x
-Plugin.cs

branches/HeuristicLab.TreeSimplifier/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Drawing;
 using System.Linq;
 using System.Windows.Forms;
 using HeuristicLab.Common;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
@@ -34 +36 @@
     private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> replacementNodes;
     private Dictionary<ISymbolicExpressionTreeNode, double> nodeImpacts;
+    private Dictionary<ISymbolicExpressionTreeNode, double> originalValues;
+    private Dictionary<ISymbolicExpressionTreeNode, string> originalVariableNames;
     private bool updateInProgress = false;
+    private ISymbolicExpressionTree model;
 
     public InteractiveSymbolicDataAnalysisSolutionSimplifierView() {
       InitializeComponent();
-      this.replacementNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
-      this.nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
-      this.Caption = "Interactive Solution Simplifier";
+      replacementNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
+      nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
+      originalValues = new Dictionary<ISymbolicExpressionTreeNode, double>();
+      originalVariableNames = new Dictionary<ISymbolicExpressionTreeNode, string>();
+      Caption = "Interactive Solution Simplifier";
     }
 
@@ -50 +57 @@
     protected override void RegisterContentEvents() {
       base.RegisterContentEvents();
-      Content.ModelChanged += new EventHandler(Content_ModelChanged);
-      Content.ProblemDataChanged += new EventHandler(Content_ProblemDataChanged);
+      Content.ModelChanged += Content_ModelChanged;
+      Content.ProblemDataChanged += Content_ProblemDataChanged;
     }
     protected override void DeregisterContentEvents() {
       base.DeregisterContentEvents();
-      Content.ModelChanged -= new EventHandler(Content_ModelChanged);
-      Content.ProblemDataChanged -= new EventHandler(Content_ProblemDataChanged);
+      Content.ModelChanged -= Content_ModelChanged;
+      Content.ProblemDataChanged -= Content_ProblemDataChanged;
     }
 
@@ -67 +74 @@
 
     protected virtual void OnModelChanged() {
-      this.CalculateReplacementNodesAndNodeImpacts();
+      model = (model == null) ? (ISymbolicExpressionTree)Content.Model.SymbolicExpressionTree.Clone() : Content.Model.SymbolicExpressionTree;
+      CalculateReplacementNodesAndNodeImpacts(model);
+      PaintModel();
     }
 
     protected virtual void OnProblemDataChanged() {
-      this.CalculateReplacementNodesAndNodeImpacts();
+      CalculateReplacementNodesAndNodeImpacts();
+      PaintModel();
     }
 
     protected override void OnContentChanged() {
+      model = (model == null) ? (ISymbolicExpressionTree)Content.Model.SymbolicExpressionTree.Clone() : Content.Model.SymbolicExpressionTree;
       base.OnContentChanged();
-      this.CalculateReplacementNodesAndNodeImpacts();
-      this.viewHost.Content = this.Content;
+      CalculateReplacementNodesAndNodeImpacts(model);
+      PaintModel();
+      viewHost.Content = this.Content;
     }
 
     private void CalculateReplacementNodesAndNodeImpacts() {
-      if (Content != null && Content.Model != null && Content.ProblemData != null) {
-        var tree = Content.Model.SymbolicExpressionTree;
-        var replacementValues = CalculateReplacementValues(tree);
-        foreach (var pair in replacementValues) {
-          if (!(pair.Key is ConstantTreeNode)) {
-            replacementNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
-          }
-        }
-        nodeImpacts = CalculateImpactValues(Content.Model.SymbolicExpressionTree);
-
-        if (!updateInProgress) {
-          // automatically fold all branches with impact = 1
-          List<ISymbolicExpressionTreeNode> nodeList = Content.Model.SymbolicExpressionTree.Root.GetSubtree(0).IterateNodesPrefix().ToList();
-          foreach (var parent in nodeList) {
-            for (int subTreeIndex = 0; subTreeIndex < parent.SubtreeCount; subTreeIndex++) {
-              var child = parent.GetSubtree(subTreeIndex);
-              if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(0.0)) {
-                SwitchNodeWithReplacementNode(parent, subTreeIndex);
-              }
+      if (Content == null || Content.Model == null || Content.ProblemData == null) return;
+      var tree = model;
+      var replacementValues = CalculateReplacementValues(tree);
+      foreach (var pair in replacementValues.Where(pair => !(pair.Key is ConstantTreeNode))) {
+        replacementNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
+      }
+      nodeImpacts = CalculateImpactValues(tree);
+
+      if (!updateInProgress) {
+        // automatically fold all branches with impact = 0
+        List<ISymbolicExpressionTreeNode> nodeList = tree.Root.GetSubtree(0).IterateNodesPrefix().ToList();
+        foreach (var parent in nodeList) {
+          for (int subTreeIndex = 0; subTreeIndex < parent.SubtreeCount; subTreeIndex++) {
+            var child = parent.GetSubtree(subTreeIndex);
+            if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(0.0)) {
+              SwitchNodeWithReplacementNode(parent, subTreeIndex);
             }
           }
         }
-
-        // show only interesting part of solution 
-        if (tree.Root.SubtreeCount > 1)
-          this.treeChart.Tree = new SymbolicExpressionTree(tree.Root); // RPB + ADFs
-        else
-          this.treeChart.Tree = new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0)); // 1st child of RPB
-        this.PaintNodeImpacts();
-      }
+      }
+      PaintModel();
+    }
+
+    private void CalculateReplacementNodesAndNodeImpacts(ISymbolicExpressionTree tree) {
+      var replacementValues = CalculateReplacementValues(tree);
+      foreach (var pair in replacementValues.Where(pair => !(pair.Key is ConstantTreeNode))) {
+        replacementNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
+      }
+      nodeImpacts = CalculateImpactValues(tree);
+
+      if (!updateInProgress) {
+        // automatically fold all branches with impact = 0
+        List<ISymbolicExpressionTreeNode> nodeList = tree.Root.GetSubtree(0).IterateNodesPrefix().ToList();
+        foreach (var parent in nodeList) {
+          for (int subTreeIndex = 0; subTreeIndex < parent.SubtreeCount; subTreeIndex++) {
+            var child = parent.GetSubtree(subTreeIndex);
+            if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(0.0)) {
+              SwitchNodeWithReplacementNode(parent, subTreeIndex);
+            }
+          }
+        }
+      }
+      PaintModel();
+    }
+
+    private void PaintModel() {
+      // show only interesting part of solution 
+      treeChart.Tree = model.Root.SubtreeCount > 1 ? new SymbolicExpressionTree(model.Root) : new SymbolicExpressionTree(model.Root.GetSubtree(0).GetSubtree(0));
+      PaintNodeImpacts();
     }
 
@@ -127 +158 @@
 
     private void treeChart_SymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
-      VisualSymbolicExpressionTreeNode visualTreeNode = (VisualSymbolicExpressionTreeNode)sender;
-      var tree = Content.Model.SymbolicExpressionTree;
+      if (!treeChart.TreeValid) return;
+      var visualNode = (VisualSymbolicExpressionTreeNode)sender;
+      var symbExprTreeNode = (SymbolicExpressionTreeNode)visualNode.SymbolicExpressionTreeNode;
+      if (symbExprTreeNode == null) return;
+      var tree = model;
+      // check if the node value/weight has been altered
+      // if so, the first double click will return the node to its original value/weight/variable name
+      // the next double click will replace the ConstantNode with the original SymbolicExpressionTreeNode
+      if (originalVariableNames.ContainsKey(symbExprTreeNode)) {
+        var variable = (VariableTreeNode)symbExprTreeNode;
+        variable.VariableName = originalVariableNames[symbExprTreeNode];
+        originalVariableNames.Remove(variable);
+        updateInProgress = true;
+        UpdateModel(tree);
+        updateInProgress = false;
+        return;
+      }
+      if (originalValues.ContainsKey(symbExprTreeNode)) {
+        double value = originalValues[symbExprTreeNode];
+        if (symbExprTreeNode.Symbol is Constant)
+          ((ConstantTreeNode)symbExprTreeNode).Value = value;
+        else if (symbExprTreeNode.Symbol is Variable)
+          ((VariableTreeNode)symbExprTreeNode).Weight = value;
+        originalValues.Remove(symbExprTreeNode);
+        updateInProgress = true;
+        UpdateModel(tree);
+        updateInProgress = false;
+        return;
+      }
       foreach (SymbolicExpressionTreeNode treeNode in tree.IterateNodesPostfix()) {
         for (int i = 0; i < treeNode.SubtreeCount; i++) {
           ISymbolicExpressionTreeNode subTree = treeNode.GetSubtree(i);
           // only allow to replace nodes for which a replacement value is known (replacement value for ADF nodes are not available)
-          if (subTree == visualTreeNode.SymbolicExpressionTreeNode && replacementNodes.ContainsKey(subTree)) {
+          if (subTree == symbExprTreeNode && replacementNodes.ContainsKey(subTree)) {
             SwitchNodeWithReplacementNode(treeNode, i);
-
             // show only interesting part of solution 
-            if (tree.Root.SubtreeCount > 1)
-              this.treeChart.Tree = new SymbolicExpressionTree(tree.Root); // RPB + ADFs
-            else
-              this.treeChart.Tree = new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0)); // 1st child of RPB
-
+            treeChart.Tree = tree.Root.SubtreeCount > 1 ? new SymbolicExpressionTree(tree.Root) : new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0));
             updateInProgress = true;
             UpdateModel(tree);
@@ -149 +202 @@
         }
       }
+    }
+
+    private void treeChart_SymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
+      // do stuff
+    }
+
+    private void treeChart_SymbolicExpressionTreeChanged(object sender, EventArgs e) {
+      CalculateReplacementNodesAndNodeImpacts(treeChart.Tree);
+      PaintModel();
+    }
+
+    private void treeChart_SymbolicExpressionTreeNodeChanged(object sender, EventArgs e) {
+      var dialog = (ValueChangeDialog)sender;
+      bool flag1 = false, flag2 = false;
+      if (dialog.Content is VariableTreeNode) {
+        var variable = (VariableTreeNode)dialog.Content;
+        var weight = double.Parse(dialog.NewValueTextBox.Text);
+        var name = (string)dialog.VariableNameComboBox.SelectedItem;
+        if (!variable.Weight.Equals(weight)) {
+          flag1 = true;
+          originalValues[variable] = variable.Weight;
+          variable.Weight = weight;
+        }
+        if (!variable.VariableName.Equals(name)) {
+          flag2 = true;
+          originalVariableNames[variable] = variable.VariableName;
+          variable.VariableName = name;
+        }
+      } else if (dialog.Content is ConstantTreeNode) {
+        var constant = (ConstantTreeNode)dialog.Content;
+        var value = double.Parse(dialog.NewValueTextBox.Text);
+        if (!constant.Value.Equals(value)) {
+          flag1 = true;
+          originalValues[constant] = constant.Value;
+          constant.Value = value;
+
+        }
+      }
+      if (flag1 || flag2) {
+        CalculateReplacementNodesAndNodeImpacts();
+        PaintModel();
+      }
+    }
+
+    private void treeChart_SymbolicExpressionTreeNodeInserted(object sender, EventArgs e) {
     }
 
@@ -167 +265 @@
       double max = impacts.Max();
       double min = impacts.Min();
-      foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
+      foreach (ISymbolicExpressionTreeNode treeNode in model.IterateNodesPostfix()) {
+        VisualSymbolicExpressionTreeNode visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
+        bool flag1 = replacementNodes.ContainsKey(treeNode);
+        bool flag2 = originalValues.ContainsKey(treeNode);
+        bool flag3 = treeNode is ConstantTreeNode;
+
+        if (flag2) // constant or variable node was changed
+          visualTree.ToolTip += Environment.NewLine + "Original value: " + originalValues[treeNode];
+        else if (flag1 && flag3) // symbol node was folded to a constant
+          visualTree.ToolTip += Environment.NewLine + "Original node: " + replacementNodes[treeNode];
+
         if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
           double impact = nodeImpacts[treeNode];
-          VisualSymbolicExpressionTreeNode visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
 
           // impact = 0 if no change
@@ -196 +303 @@
 
     private void PaintCollapsedNodes() {
-      foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
-        if (treeNode is ConstantTreeNode && replacementNodes.ContainsKey(treeNode))
-          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = Color.DarkOrange;
-        else {
-          VisualSymbolicExpressionTreeNode visNode = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
-          if (visNode != null)
-            visNode.LineColor = Color.Black;
+      foreach (ISymbolicExpressionTreeNode treeNode in model.IterateNodesPostfix()) {
+        bool flag1 = replacementNodes.ContainsKey(treeNode);
+        bool flag2 = originalValues.ContainsKey(treeNode);
+        if (flag1 && treeNode is ConstantTreeNode) {
+          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = flag2 ? Color.DarkViolet : Color.DarkOrange;
+        } else if (flag2) {
+          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = Color.DodgerBlue;
         }
       }
@@ -208 +315 @@
 
     private void btnSimplify_Click(object sender, EventArgs e) {
-      SymbolicDataAnalysisExpressionTreeSimplifier simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
-      var simplifiedExpressionTree = simplifier.Simplify(Content.Model.SymbolicExpressionTree);
+      var simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
+      var simplifiedExpressionTree = simplifier.Simplify(model);
       UpdateModel(simplifiedExpressionTree);
     }
 
     protected abstract void btnOptimizeConstants_Click(object sender, EventArgs e);
+
+    private void btnPrune_Click(object sender, EventArgs e) {
+      btnPrune.Enabled = false;
+      backgroundWorker1.RunWorkerAsync();
+    }
+
+    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) {
+      var worker = sender as BackgroundWorker;
+      PruneTree(worker);
+    }
+
+    private void PruneTree(BackgroundWorker worker) {
+      var tree = model;
+      // get all tree nodes starting from depth 2 (below the root and start nodes) 
+      foreach (var node in GetNodesAtDepth(tree, new IntRange(2, tree.Depth))) {
+        if (worker.CancellationPending)
+          break; // pruning cancelled
+        if (!(node.Symbol is Constant) && nodeImpacts.ContainsKey(node) && nodeImpacts[node] < 0.001) {
+          SwitchNodeWithReplacementNode(node.Parent, node.Parent.IndexOfSubtree(node));
+          nodeImpacts = CalculateImpactValues(tree);
+          // we do not refresh the replacementValues because they won't change when folding nodes with such low impacts (<0.001)
+        }
+      }
+    }
+
+    private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
+      if (e.Cancelled) {
+        // The user canceled the operation.
+      } else if (e.Error != null) {
+        // There was an error during the operation.
+        // Error-handling
+      } else {
+        // The operation completed normally. We can update the model
+        UpdateModel(model);
+      }
+      btnPrune.Enabled = true;
+    }
+
+    #region helpers
+    private static IEnumerable<ISymbolicExpressionTreeNode> GetNodesAtDepth(ISymbolicExpressionTree tree, IntRange depthRange) {
+      var treeDepth = tree.Root.GetDepth();
+      return from node in tree.Root.IterateNodesPostfix()
+             let depth = treeDepth - node.GetDepth()
+             where depthRange.Start <= depth
+             where depth <= depthRange.End
+             select node;
+    }
+    #endregion
   }
 }

@@ +1 @@
+*.user
 bin
 obj
-*.user
-HeuristicLabProblemsDataAnalysisSymbolicViewsPlugin.cs
-*.vs10x
-Plugin.cs