source: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs @ 5736

Last change on this file since 5736 was 5736, checked in by gkronber, 11 years ago

#1418 implemented linear scaling for classification solutions, fixed bugs interactive simplifier view for classification solutions.

File size: 8.9 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Drawing;
25using System.Linq;
26using System.Windows.Forms;
27using HeuristicLab.Common;
28using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
29using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
30using HeuristicLab.MainForm.WindowsForms;
31using HeuristicLab.Problems.DataAnalysis.Symbolic;
32
33namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
34  public abstract partial class InteractiveSymbolicDataAnalysisSolutionSimplifierView : AsynchronousContentView {
35    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> replacementNodes;
36    private Dictionary<ISymbolicExpressionTreeNode, double> nodeImpacts;
37
38    public InteractiveSymbolicDataAnalysisSolutionSimplifierView() {
39      InitializeComponent();
40      this.replacementNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
41      this.nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
42      this.Caption = "Interactive Solution Simplifier";
43    }
44
45    public new ISymbolicDataAnalysisSolution Content {
46      get { return (ISymbolicDataAnalysisSolution)base.Content; }
47      set { base.Content = value; }
48    }
49
50    protected override void RegisterContentEvents() {
51      base.RegisterContentEvents();
52      Content.ModelChanged += new EventHandler(Content_ModelChanged);
53      Content.ProblemDataChanged += new EventHandler(Content_ProblemDataChanged);
54    }
55    protected override void DeregisterContentEvents() {
56      base.DeregisterContentEvents();
57      Content.ModelChanged -= new EventHandler(Content_ModelChanged);
58      Content.ProblemDataChanged -= new EventHandler(Content_ProblemDataChanged);
59    }
60
61    private void Content_ModelChanged(object sender, EventArgs e) {
62      OnModelChanged();
63    }
64    private void Content_ProblemDataChanged(object sender, EventArgs e) {
65      OnProblemDataChanged();
66    }
67
68    protected virtual void OnModelChanged() {
69      this.CalculateReplacementNodesAndNodeImpacts();
70    }
71
72    protected virtual void OnProblemDataChanged() {
73      this.CalculateReplacementNodesAndNodeImpacts();
74    }
75
76    protected override void OnContentChanged() {
77      base.OnContentChanged();
78      this.CalculateReplacementNodesAndNodeImpacts();
79      this.viewHost.Content = this.Content;
80    }
81
82    private void CalculateReplacementNodesAndNodeImpacts() {
83      if (Content != null && Content.Model != null && Content.ProblemData != null) {
84        var tree = Content.Model.SymbolicExpressionTree;
85        var replacementValues = CalculateReplacementValues(tree);
86        foreach (var pair in replacementValues) {
87          if (!(pair.Key is ConstantTreeNode)) {
88            replacementNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
89          }
90        }
91        nodeImpacts = CalculateImpactValues(Content.Model.SymbolicExpressionTree);
92
93        // automatically fold all branches with impact = 1
94        List<ISymbolicExpressionTreeNode> nodeList = Content.Model.SymbolicExpressionTree.Root.GetSubtree(0).IterateNodesPrefix().ToList();
95        foreach (var parent in nodeList) {
96          for (int subTreeIndex = 0; subTreeIndex < parent.SubtreesCount; subTreeIndex++) {
97            var child = parent.GetSubtree(subTreeIndex);
98            if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(1.0)) {
99              SwitchNodeWithReplacementNode(parent, subTreeIndex);
100            }
101          }
102        }
103        // show only interesting part of solution
104        this.treeChart.Tree = new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0));
105        this.PaintNodeImpacts();
106      }
107    }
108
109    protected abstract Dictionary<ISymbolicExpressionTreeNode, double> CalculateReplacementValues(ISymbolicExpressionTree tree);
110    protected abstract Dictionary<ISymbolicExpressionTreeNode, double> CalculateImpactValues(ISymbolicExpressionTree tree);
111    protected abstract void UpdateModel(ISymbolicExpressionTree tree);
112
113    private ConstantTreeNode MakeConstantTreeNode(double value) {
114      Constant constant = new Constant();
115      constant.MinValue = value - 1;
116      constant.MaxValue = value + 1;
117      ConstantTreeNode constantTreeNode = (ConstantTreeNode)constant.CreateTreeNode();
118      constantTreeNode.Value = value;
119      return constantTreeNode;
120    }
121
122    private void treeChart_SymbolicExpressionTreeNodeDoubleClicked(object sender, MouseEventArgs e) {
123      VisualSymbolicExpressionTreeNode visualTreeNode = (VisualSymbolicExpressionTreeNode)sender;
124      var tree = Content.Model.SymbolicExpressionTree;
125      foreach (SymbolicExpressionTreeNode treeNode in tree.IterateNodesPostfix()) {
126        for (int i = 0; i < treeNode.SubtreesCount; i++) {
127          ISymbolicExpressionTreeNode subTree = treeNode.GetSubtree(i);
128          if (subTree == visualTreeNode.SymbolicExpressionTreeNode) {
129            SwitchNodeWithReplacementNode(treeNode, i);
130          }
131        }
132      }
133
134      // show only interesting part of solution
135      this.treeChart.Tree = new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0));
136
137      UpdateModel(tree);
138    }
139
140    private void SwitchNodeWithReplacementNode(ISymbolicExpressionTreeNode parent, int subTreeIndex) {
141      ISymbolicExpressionTreeNode subTree = parent.GetSubtree(subTreeIndex);
142      parent.RemoveSubtree(subTreeIndex);
143      if (replacementNodes.ContainsKey(subTree)) {
144        var replacementNode = replacementNodes[subTree];
145        parent.InsertSubtree(subTreeIndex, replacementNode);
146        // exchange key and value
147        replacementNodes.Remove(subTree);
148        replacementNodes.Add(replacementNode, subTree);
149      }
150    }
151
152    private void PaintNodeImpacts() {
153      var impacts = nodeImpacts.Values;
154      double max = impacts.Max();
155      double min = impacts.Min();
156      foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
157        if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
158          double impact = nodeImpacts[treeNode];
159          VisualSymbolicExpressionTreeNode visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
160
161          // impact = 0 if no change
162          // impact < 0 if new solution is better
163          // impact > 0 if new solution is worse
164          if (impact < 0.0) {
165            // min is guaranteed to be < 0
166            visualTree.FillColor = Color.FromArgb((int)(impact / min * 255), Color.Red);
167          } else if (impact.IsAlmost(0.0)) {
168            visualTree.FillColor = Color.White;
169          } else {
170            // max is guaranteed to be > 0
171            visualTree.FillColor = Color.FromArgb((int)(impact / max * 255), Color.Green);
172          }
173          visualTree.ToolTip += Environment.NewLine + "Node impact: " + impact;
174          var constantReplacementNode = replacementNodes[treeNode] as ConstantTreeNode;
175          if (constantReplacementNode != null) {
176            visualTree.ToolTip += Environment.NewLine + "Replacement value: " + constantReplacementNode.Value;
177          }
178        }
179      }
180      this.PaintCollapsedNodes();
181      this.treeChart.Repaint();
182    }
183
184    private void PaintCollapsedNodes() {
185      foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPostfix()) {
186        if (treeNode is ConstantTreeNode && replacementNodes.ContainsKey(treeNode))
187          this.treeChart.GetVisualSymbolicExpressionTreeNode(treeNode).LineColor = Color.DarkOrange;
188        else {
189          VisualSymbolicExpressionTreeNode visNode = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
190          if (visNode != null)
191            visNode.LineColor = Color.Black;
192        }
193      }
194    }
195
196    private void btnSimplify_Click(object sender, EventArgs e) {
197      SymbolicDataAnalysisExpressionTreeSimplifier simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
198      var simplifiedExpressionTree = simplifier.Simplify(Content.Model.SymbolicExpressionTree);
199      UpdateModel(simplifiedExpressionTree);
200    }
201  }
202}
Note: See TracBrowser for help on using the repository browser.