Changeset 13727 for branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/RunCollectionVariableInteractionNetworkView.cs

Timestamp:

03/24/16 14:03:06 (8 years ago)

Author:

bburlacu

Message:

#2288: Added directed graph chart and layout class for the visualization of knowledge network graphs. Added RunCollectionVariableInteractionNetworkView and removed the old view.

File:

• branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/RunCollectionVariableInteractionNetworkView.cs (moved) (moved from branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.cs) (2 diffs)

branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/RunCollectionVariableInteractionNetworkView.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -25 +25 @@
 using System.Drawing;
 using System.Linq;
+using System.Text;
 using System.Windows.Forms;
 using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Core.Views;
 using HeuristicLab.Data;
 using HeuristicLab.MainForm;
-using HeuristicLab.MainForm.WindowsForms;
 using HeuristicLab.Optimization;
 using HeuristicLab.Problems.DataAnalysis;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
-using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
-using System.Collections;
-
-namespace HeuristicLab.VariableInteractionNetworks.Views
-{
-    [View("Variable Interaction Network")]
-    [Content(typeof(RunCollection), IsDefaultView = false)]
-
-    public sealed partial class VariableInteractionNetworkView : AsynchronousContentView
-    {
-        private const string variableImpactResultName = "Variable impacts";
-        private const string TrainingBestSolutionParameterName = "Best training solution";
-
-        public new RunCollection Content
-        {
-            get { return (RunCollection)base.Content; }
-            set { base.Content = value; }
-        }
-
-        public VariableInteractionNetworkView()
-        {
-            InitializeComponent();
-        }
-
-        internal class NoFocusTrackBar : System.Windows.Forms.TrackBar
-        {
-            [System.Runtime.InteropServices.DllImport("user32.dll")]
-            public extern static int SendMessage(IntPtr hWnd, uint msg, int wParam, int lParam);
-
-            private static int MakeParam(int loWord, int hiWord)
-            {
-                return (hiWord << 16) | (loWord & 0xffff);
+using HeuristicLab.Visualization;
+using Rectangle = HeuristicLab.Visualization.Rectangle;
+
+namespace HeuristicLab.VariableInteractionNetworks.Views {
+  [View("Variable Interaction Network")]
+  [Content(typeof(RunCollection), IsDefaultView = false)]
+
+  public sealed partial class RunCollectionVariableInteractionNetworkView : ItemView {
+    public RunCollectionVariableInteractionNetworkView() {
+      InitializeComponent();
+      ConfigureNodeShapes();
+    }
+
+    public new RunCollection Content {
+      get { return (RunCollection)base.Content; }
+      set {
+        if (value != null && value != Content) {
+          base.Content = value;
+        }
+      }
+    }
+
+    private static VariableInteractionNetwork BuildNetworkFromSolutionQualities(RunCollection runs, double threshold, bool useBestRunsPerTarget = false) {
+      var nodes = new Dictionary<string, IVertex>();
+      var vn = new VariableInteractionNetwork();
+      var targets = runs.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
+      var targetQualities = new Dictionary<string, double>();
+      var targetInputs = new Dictionary<string, List<string>>();
+
+      if (useBestRunsPerTarget) {
+        foreach (var target in targets) {
+          var bestRun = target.OrderBy(x => ((DoubleValue)x.Results["Best training solution quality"]).Value).First();
+          var bestQuality = ((DoubleValue)bestRun.Results["Best training solution quality"]).Value;
+          var pd = (IRegressionProblemData)bestRun.Parameters["ProblemData"];
+          if (threshold > bestQuality) continue; // skip if quality is below the treshold
+          targetQualities[target.Key] = bestQuality;
+          targetInputs[target.Key] = pd.AllowedInputVariables.ToList();
+        }
+      } else {
+        foreach (var target in targets) {
+          var avgQuality = CalculateAverageQuality(new RunCollection(target));
+          if (threshold > avgQuality) continue;
+          targetQualities[target.Key] = avgQuality;
+          var pd = (IRegressionProblemData)target.First().Parameters["ProblemData"];
+          targetInputs[target.Key] = pd.AllowedInputVariables.ToList();
+        }
+      }
+
+      foreach (var ti in targetQualities) {
+        var target = ti.Key;
+        var variables = targetInputs[ti.Key];
+        var quality = ti.Value;
+        IVertex targetNode;
+
+        if (!nodes.TryGetValue(target, out targetNode)) {
+          targetNode = new VariableNetworkNode { Label = target };
+          vn.AddVertex(targetNode);
+          nodes[target] = targetNode;
+        }
+
+        IVertex variableNode;
+        if (variables.Count > 0) {
+          var variableList = new List<string>(variables);
+          variableList.Add(target);
+          var junctionLabel = Concatenate(variableList);
+          IVertex junctionNode;
+          if (!nodes.TryGetValue(junctionLabel, out junctionNode)) {
+            junctionNode = new JunctionNetworkNode { Label = string.Empty };
+            vn.AddVertex(junctionNode);
+            nodes[junctionLabel] = junctionNode;
+          }
+          IArc arc;
+          foreach (var v in variables) {
+            var impact = quality;
+            if (!nodes.TryGetValue(v, out variableNode)) {
+              variableNode = new VariableNetworkNode { Label = v };
+              vn.AddVertex(variableNode);
+              nodes[v] = variableNode;
             }
-
-            protected override void OnGotFocus(EventArgs e)
-            {
-                base.OnGotFocus(e);
-                SendMessage(this.Handle, 0x0128, MakeParam(1, 0x1), 0);
+            arc = new Arc(variableNode, junctionNode) { Weight = impact };
+            vn.AddArc(arc);
+          }
+          arc = new Arc(junctionNode, targetNode) { Weight = junctionNode.InArcs.Sum(x => x.Weight) };
+          vn.AddArc(arc);
+        } else {
+          foreach (var v in variables) {
+            var impact = quality;
+            if (!nodes.TryGetValue(v, out variableNode)) {
+              variableNode = new VariableNetworkNode { Label = v };
+              vn.AddVertex(variableNode);
+              nodes[v] = variableNode;
             }
-        }
-
-        #region events
-
-        //  #region Event Handlers (Content)
-        protected override void OnContentChanged()
-        {
-            base.OnContentChanged();
-            if (Content == null)
-            {
-                // TODO: Add code when content has been changed and is null
+            var arc = new Arc(variableNode, targetNode) { Weight = impact };
+            vn.AddArc(arc);
+          }
+        }
+      }
+
+      return vn;
+    }
+
+    private static VariableInteractionNetwork BuildNetworkFromVariableImpacts(RunCollection runs, string qualityResultName, bool maximization, string impactsResultName, double threshold, bool useBestRunsPerTarget = false) {
+      var nodes = new Dictionary<string, IVertex>();
+      var vn = new VariableInteractionNetwork();
+      var targets = runs.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
+
+      var targetImpacts = new Dictionary<string, Dictionary<string, double>>();
+
+      if (useBestRunsPerTarget) {
+        var bestRunsPerTarget = maximization ?
+          targets.Select(x => x.OrderBy(y => ((DoubleValue)y.Results[qualityResultName]).Value).Last()) :
+          targets.Select(x => x.OrderBy(y => ((DoubleValue)y.Results[qualityResultName]).Value).First());
+
+        foreach (var run in bestRunsPerTarget) {
+          var pd = (IRegressionProblemData)run.Parameters["ProblemData"];
+          var target = pd.TargetVariable;
+          var impacts = (DoubleMatrix)run.Results[impactsResultName];
+          targetImpacts[target] = impacts.RowNames.Select((x, i) => new { Name = x, Index = i }).ToDictionary(x => x.Name, x => impacts[x.Index, 0]);
+        }
+      } else {
+        foreach (var target in targets) {
+          var averageImpacts = CalculateAverageImpacts(new RunCollection(target), impactsResultName);
+          targetImpacts[target.Key] = averageImpacts;
+        }
+      }
+
+      foreach (var ti in targetImpacts) {
+        var target = ti.Key;
+        var variableImpacts = ti.Value;
+        IVertex targetNode;
+
+        var variables = variableImpacts.Keys.Where(x => variableImpacts[x] >= threshold).ToList();
+        if (variables.Count == 0) continue;
+
+        if (!nodes.TryGetValue(target, out targetNode)) {
+          targetNode = new VariableNetworkNode { Label = target };
+          vn.AddVertex(targetNode);
+          nodes[target] = targetNode;
+        }
+
+        IVertex variableNode;
+        if (variables.Count > 1) {
+          var variableList = new List<string>(variables) { target };
+          var junctionLabel = Concatenate(variableList);
+          IVertex junctionNode;
+          if (!nodes.TryGetValue(junctionLabel, out junctionNode)) {
+            junctionNode = new JunctionNetworkNode { Label = string.Empty };
+            vn.AddVertex(junctionNode);
+            nodes[junctionLabel] = junctionNode;
+          }
+          IArc arc;
+          foreach (var v in variables) {
+            var impact = variableImpacts[v];
+            if (!nodes.TryGetValue(v, out variableNode)) {
+              variableNode = new VariableNetworkNode { Label = v };
+              vn.AddVertex(variableNode);
+              nodes[v] = variableNode;
             }
-            else
-            {
-                // TODO: Add code when content has been changed and is not null
-                viewHost2.Content = CalculateNodeImportance(CalculateAdjacencyMatrix());
-                var adjMatrix = CalculateAdjacencyMatrix();
-                viewHost1.Content = adjMatrix;
-                viewHost3.Content = (DoubleMatrix)adjMatrix.Clone();
-                trackBar1.Minimum = (int)(1000 * GetMinNonNullElement(adjMatrix));
-                trackBar1.Maximum = (int)(1000 * (adjMatrix.Max()));
+            arc = new Arc(variableNode, junctionNode) { Weight = impact };
+            vn.AddArc(arc);
+          }
+          arc = new Arc(junctionNode, targetNode) { Weight = junctionNode.InArcs.Sum(x => x.Weight) };
+          vn.AddArc(arc);
+        } else {
+          foreach (var v in variables) {
+            var impact = variableImpacts[v];
+            if (!nodes.TryGetValue(v, out variableNode)) {
+              variableNode = new VariableNetworkNode { Label = v };
+              vn.AddVertex(variableNode);
+              nodes[v] = variableNode;
             }
-        }
-        #endregion
-
-        protected override void SetEnabledStateOfControls()
-        {
-            base.SetEnabledStateOfControls();
-            // TODO: Enable or disable controls based on whether the content is null or the view is set readonly
-        }
-
-        #region Event Handlers (child controls)
-        // TODO: Put event handlers of child controls here.
-        #endregion
-
-        private DoubleMatrix CalculateAdjacencyMatrix()
-        {
-            var runCollection = Content;
-            var inputVariables = ((IRegressionProblemData)runCollection.First().Parameters["ProblemData"]).InputVariables.Select(x => x.Value).ToList();
-            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).OrderBy(x => inputVariables.IndexOf(x.Key)).ToList();
-
-            var allVariableImpacts = runCollection.Select(run => (DoubleMatrix)run.Results[variableImpactResultName]);
-            var variableNames = (from variableImpact in allVariableImpacts
-                                 from variableName in variableImpact.RowNames
-                                 select variableName).Distinct().ToArray();
-           
-            var vars = new List<Tuple<int, string>>();
-            
-            var allowedInputs = ((IRegressionProblemData)groupRunCollection[0].First().Parameters["ProblemData"]).AllowedInputVariables.ToList();
-
-            var adjMatrix = new DoubleMatrix(variableNames.Length, variableNames.Length);
-
-            for (int i = 0; i < adjMatrix.Rows; ++i)
-            {
-                int inputIndex = allowedInputs.FindIndex(x => x == variableNames[i]);
-                vars.Add(new Tuple<int, string>(inputIndex, variableNames[i]));
-            }
-
-            vars.Sort((a, b) => a.Item1.CompareTo(b.Item1));
-
-            for (int i = 0; i < adjMatrix.Rows; ++i)
-            {
-                variableNames[i] = vars[i].Item2;
-            }
-            adjMatrix.RowNames = variableNames;
-            adjMatrix.ColumnNames = adjMatrix.RowNames;
-
-            for (int j = 0; j < groupRunCollection.Count; ++j)
-            {
-                var g = groupRunCollection[j];
-                
-                var matrix = CalculateAdjacencyRows(g);
-                var variables = new List<double>();
-
-                for (int i = 0; i < matrix.Columns; ++i)
-                {
-                    variables.Add(matrix[0, i]);
-                }
-                
-                for (int i = 0; i < variables.Count; ++i)
-                {
-                    if (i == j)
-                    {
-                        adjMatrix[i, i] = 0;
-                        variables.Insert(i, 0);
-                    }
-                    else
-                        adjMatrix[j, i] = variables[i];
-                }
-            }
-            return adjMatrix;
-        }
-
-        private DoubleMatrix CalculateAdjacencyRows(IEnumerable<IRun> runs)
-        {
-            var runNames = runs.Select(x => x.Name).ToArray();
-            var runsArray = runs.ToArray();
-            DoubleMatrix varImpactMatrix = CalculateVariableImpactMatrix(runsArray, runNames);
-          
-            var targetMatrix = new DoubleMatrix(1, varImpactMatrix.Rows);
-
-            for (int i = 0; i < varImpactMatrix.Rows; ++i)
-            {
-                targetMatrix[0, i] = varImpactMatrix[i, runNames.Length];
-            }
-
-            targetMatrix.RowNames = new[] { "Impacts" };
-            targetMatrix.ColumnNames = varImpactMatrix.RowNames;
-            return targetMatrix;
-        }
-
-        private DoubleMatrix UpdateAdjacencyMatrixByThresholdAndTargetVariable(double threshold, string targetVariable, DoubleMatrix adjMatrix)
-        {
-            var originalMatrix = (DoubleMatrix)viewHost1.Content;
-            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
-            string[] targets = adjMatrix.RowNames.ToArray();
-            var targetIndex = Array.IndexOf(targets, targetVariable);
-
-            for (int j = 0; j < groupRunCollection.Count; ++j)
-            {
-                double originalValue = originalMatrix[targetIndex, j];
-                adjMatrix[targetIndex, j] = (originalValue <= Math.Max(threshold, Double.Parse(genThreshold.Text))) ? 0 : originalValue;
-            }
-            return adjMatrix;
-        }
-
-        private DoubleMatrix UpdateAdjacencyMatrixByThreshold(double threshold, DoubleMatrix adjMatrix)
-        {
-            var originalMatrix = (DoubleMatrix)viewHost1.Content;
-            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
-
-            for (int i = 0; i < adjMatrix.Rows; ++i)
-            {
-                for (int j = 0; j < adjMatrix.Columns; ++j)
-                {
-                    double originalValue = originalMatrix[i, j];
-                    adjMatrix[i, j] = originalValue <= threshold ? 0 : originalValue;
-                }
-            }
-            return adjMatrix;
-        }
-
-        private double GetMinNonNullElement(DoubleMatrix adjMatrix)
-        {
-            double min = adjMatrix.Max();
-            for (int i = 0; i < adjMatrix.Rows; i++)
-            {
-                for (int j = 0; j < adjMatrix.Columns; j++)
-                {                  
-                    min = (min > adjMatrix[i, j] && adjMatrix[i, j] != 0) ? adjMatrix[i, j] : min;
-                }
-            }
-            return min;
-        }
-
-        private double GetMaxFromRow(int rowIndex, DoubleMatrix adjMatrix)
-        {
-            double max = adjMatrix.Min();
-            for (int j = 0; j < adjMatrix.Columns; ++j)
-            {
-                max = (max < adjMatrix[rowIndex, j] && adjMatrix[rowIndex, j] != 0) ? adjMatrix[rowIndex, j] : max;
-            }
-            return max;
-        }
-
-        private DoubleMatrix CalculateNodeImportance(DoubleMatrix adjMatrix)
-        {
-            DoubleMatrix nodeImportance = new DoubleMatrix(adjMatrix.Rows, 1);
-            var variables = new List<Tuple<string, double>>();
-            var rowNames = adjMatrix.RowNames.ToList();
-            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
-            double[] meanQuality = new double[groupRunCollection.Count];
-
-            for (int j = 0; j < groupRunCollection.Count; ++j)
-            {
-                var g = groupRunCollection[j];
-                meanQuality[j] = g.Average(x => ((IRegressionSolution)x.Results[TrainingBestSolutionParameterName]).TrainingRSquared);
-            }
-
-            for (int i = 0; i < adjMatrix.Columns; ++i)
-            {
-                for (int j = 0; j < adjMatrix.Rows; ++j)
-                {
-                    nodeImportance[i, 0] += adjMatrix[j, i] * meanQuality[j];
-                }
-                nodeImportance[i, 0] /= (adjMatrix.Rows - 1);
-                variables.Add(new Tuple<string, double>(rowNames[i], nodeImportance[i, 0]));
-            }
-
-            variables.Sort((b, a) => a.Item2.CompareTo(b.Item2));
-
-            for (int i = 0; i < nodeImportance.Rows; ++i)
-            {
-                nodeImportance[i, 0] = variables[i].Item2;
-                rowNames[i] = variables[i].Item1;
-            }
-
-            nodeImportance.RowNames = rowNames;
-            nodeImportance.ColumnNames = new[] { "Node Importance" };
-            return nodeImportance;
-        }
-
-        //modified from RunCollectionVariableImpactView
-        private DoubleMatrix CalculateVariableImpactMatrix(IRun[] runs, string[] runNames)
-        {
-            IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
-                                                            select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
-            IEnumerable<string> variableNames = (from variableImpact in allVariableImpacts
-                                                 from variableName in variableImpact.RowNames
-                                                 select variableName).Distinct();
-
-            // filter variableNames: only include names that have at least one non-zero value in a run
-            List<string> variableNamesList = (from variableName in variableNames
-                                              where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
-                                              select variableName).ToList();
-
-            List<string> columnNames = new List<string>(runNames);
-            columnNames.Add("Mean");
-
-            int numberOfRuns = runs.Length;
-
-            DoubleMatrix matrix = new DoubleMatrix(variableNamesList.Count, numberOfRuns + 1);
-            matrix.SortableView = true;
-            matrix.ColumnNames = columnNames;
-
-            List<List<double>> variableImpactsOverRuns = (from variableName in variableNamesList
-                                                          select GetVariableImpacts(variableName, allVariableImpacts).ToList()).ToList();
-
-            for (int row = 0; row < variableImpactsOverRuns.Count; row++)
-            {
-                matrix[row, numberOfRuns] = Math.Round(variableImpactsOverRuns[row].Average(), 3);
-            }
-
-            // fill matrix with impacts from runs
-            for (int i = 0; i < runs.Length; i++)
-            {
-                IRun run = runs[i];
-                DoubleMatrix runVariableImpacts = (DoubleMatrix)run.Results[variableImpactResultName];
-                for (int j = 0; j < runVariableImpacts.Rows; j++)
-                {
-                    int rowIndex = variableNamesList.FindIndex(s => s == runVariableImpacts.RowNames.ElementAt(j));
-                    if (rowIndex > -1)
-                    {
-                        matrix[rowIndex, i] = Math.Round(runVariableImpacts[j, 0], 3);
-                    }
-                }
-            }
-
-            // sort by median
-            var sortedMatrix = (DoubleMatrix)matrix.Clone();
-            var sortedIndexes = from i in Enumerable.Range(0, sortedMatrix.Rows)
-                                orderby matrix[i, numberOfRuns]
-                                select i;
-
-            int targetIndex = 0;
-            foreach (var sourceIndex in sortedIndexes)
-            {
-                for (int c = 0; c < matrix.Columns; c++)
-                    sortedMatrix[targetIndex, c] = matrix[sourceIndex, c];
-                targetIndex++;
-            }
-            sortedMatrix.RowNames = sortedIndexes.Select(i => variableNamesList[i]);
-
-            var vars = new List<Tuple<int, string, double>>();
-            var rowNames = sortedMatrix.RowNames.ToList();
-
-            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
-            var inputs = ((IRegressionProblemData)groupRunCollection[0].First().Parameters["ProblemData"]).InputVariables.ToList();
-            List<string> inp = (from input in inputs 
-                                select (input.ToString())).ToList();
-
-            for (int i = 0; i < sortedMatrix.Rows; ++i)
-            {
-                int inputIndex = inp.FindIndex(x => x == rowNames[i]);
-                vars.Add(new Tuple<int, string, double>(inputIndex, rowNames[i], sortedMatrix[i, runNames.Length]));
-            }
-
-                vars.Sort((a, b) => a.Item1.CompareTo(b.Item1));
-               
-            for (int i = 0; i < sortedMatrix.Rows; ++i)
-            {
-                sortedMatrix[i, runNames.Length] = vars[i].Item3;
-                rowNames[i] = vars[i].Item2;
-            }
-            sortedMatrix.RowNames = rowNames;
-
-            return sortedMatrix;
-        }
-
-        //taken from RunCollectionVariableImpactView
-        private IEnumerable<double> GetVariableImpacts(string variableName, IEnumerable<DoubleMatrix> allVariableImpacts)
-        {
-            foreach (DoubleMatrix runVariableImpacts in allVariableImpacts)
-            {
-                int row = 0;
-                foreach (string rowName in runVariableImpacts.RowNames)
-                {
-                    if (rowName == variableName)
-                        yield return runVariableImpacts[row, 0];
-                    row++;
-                }
-            }
-        }
-
-        private void trackBar1_ValueChanged(object sender, EventArgs e)
-        {
-            genThreshold.Text = (0.001 * trackBar1.Value).ToString();
-            textBox1.Text = (0.001 * trackBar1.Minimum).ToString();
-            textBox2.Text = (0.001 * trackBar1.Maximum).ToString();
-            viewHost3.Content = UpdateAdjacencyMatrixByThreshold(0.001 * trackBar1.Value, (DoubleMatrix)viewHost3.Content);
-        }
-
-        private void mouseDownEvent(TrackBar tb, MouseEventArgs e)
-        {
-                double percentage = (double)e.X / (double)(tb.Width - 6);
-                double clickPos = percentage * (tb.Maximum - tb.Minimum);
-                try
-                {
-                    tb.Value = (int)clickPos + tb.Minimum;
-                }
-                catch
-                {
-                    MessageBox.Show("Value outside range!");
-                    return;
-                }
-        }
-
-        private void trackBar1_MouseDown(object sender, MouseEventArgs e)
-        {
-            mouseDownEvent(trackBar1, e);
-        }
-
-        private void trackBar2_MouseDown(object sender, MouseEventArgs e)
-        {
-            if (targetVariablesCombo.SelectedIndex < 0)
-            {
-                return;
-            }
-            else
-            {
-                mouseDownEvent(trackBar2, e);
-            }
-        }
-
-        private void trackBar2_ValueChanged(object sender, EventArgs e)
-        {
-            targetThreshold.Text = (0.001 * trackBar2.Value).ToString();
-
-            if (targetVariablesCombo.SelectedIndex < 0)
-            {
-                MessageBox.Show("Please select target variable!");
-                return;
-            }
-            else
-            {
-                string selectedItem = (string)targetVariablesCombo.Items[targetVariablesCombo.SelectedIndex];
-                viewHost3.Content = UpdateAdjacencyMatrixByThresholdAndTargetVariable(0.001 * trackBar2.Value, selectedItem, (DoubleMatrix)viewHost3.Content);
-            }
-        }
-
-        private void genThresholdEvent()
-        {
-            this.errorProvider.SetError(genThreshold, "");
-
-            if (genThreshold.Text != "")
-            {
-                if (Double.Parse(genThreshold.Text) >= GetMinNonNullElement((DoubleMatrix)viewHost1.Content) && Double.Parse(genThreshold.Text) <= ((DoubleMatrix)viewHost1.Content).Max())
-                {
-                    genThreshold.Select(genThreshold.Text.Length, 0);
-                    trackBar1.Value = (int)(1000 * Double.Parse(genThreshold.Text));
-                    viewHost3.Content = UpdateAdjacencyMatrixByThreshold(Double.Parse(genThreshold.Text), (DoubleMatrix)viewHost3.Content);
-                }
-                else
-                {
-                    this.errorProvider.SetError(genThreshold, "Value out of range!");
-                }
-            }
-            else
-            {
-                MessageBox.Show("Please select a threshold!");
-                this.errorProvider.SetError(genThreshold, "");
-                return;
-            }
-        }
-
-        private void genThreshold_TextChanged(object sender, EventArgs e)
-        {
-            genThresholdEvent();
-        }
-
-        private void genThreshold_KeyDown(object sender, KeyEventArgs e)
-        {
-            if (e.KeyCode == Keys.Enter)
-                genThresholdEvent();        
-        }
-
-        private void targetThresholdEvent()
-        {
-            this.errorProvider2.SetError(targetThreshold, "");
-
-            if (targetVariablesCombo.SelectedIndex < 0)
-            {
-                return;
-            }
-            else
-            {
-                string selectedItem = (string)targetVariablesCombo.Items[targetVariablesCombo.SelectedIndex];
-                if (Double.Parse(targetThreshold.Text) >= Double.Parse(textBox3.Text) && Double.Parse(targetThreshold.Text) <= Double.Parse(textBox4.Text))
-                {
-                    trackBar2.Value = (int)(1000 * Double.Parse(targetThreshold.Text));
-                }
-                else
-                {
-                    this.errorProvider2.SetError(targetThreshold, "Value out of range!");
-                    return;
-                }
-            }
-        }
-
-        private void targetThreshold_TextChanged(object sender, EventArgs e)
-        {
-            targetThresholdEvent();
-        }
-
-        private void targetThreshold_KeyDown(object sender, KeyEventArgs e)
-        {
-            if (e.KeyCode == Keys.Enter)
-            {
-                targetThresholdEvent();
-            }
-        }
-
-        private void targetVariablesCombo_Dropdown(object sender, System.EventArgs e)
-        {
-            targetVariablesCombo.Items.Clear();
-            string[] targetVariables = ((DoubleMatrix)viewHost3.Content).RowNames.ToArray();
-            targetVariablesCombo.Items.AddRange(targetVariables);
-        }
-
-        private void targetVariablesCombo_SelectedIndexChanged(object sender, System.EventArgs e)
-        {
-            var targetIndex = targetVariablesCombo.SelectedIndex;
-            string selectedItem = (string)targetVariablesCombo.Items[targetIndex];
-            trackBar2.Minimum = 0;
-            trackBar2.Maximum = (int)(1000 * GetMaxFromRow(targetIndex, (DoubleMatrix)viewHost1.Content));
-            textBox3.Text = trackBar2.Minimum.ToString();
-            textBox4.Text = (0.001 * trackBar2.Maximum).ToString();
-            UpdateAdjacencyMatrixByThresholdAndTargetVariable(0.001 * trackBar2.Value, selectedItem, (DoubleMatrix)viewHost3.Content);
-        }
-    }
+            var arc = new Arc(variableNode, targetNode) { Weight = impact };
+            vn.AddArc(arc);
+          }
+        }
+      }
+      return vn;
+    }
+
+    private static double CalculateAverageQuality(RunCollection runs) {
+      var pd = (IRegressionProblemData)runs.First().Parameters["ProblemData"];
+      var target = pd.TargetVariable;
+      var inputs = pd.AllowedInputVariables;
+
+      if (!runs.All(x => {
+        var problemData = (IRegressionProblemData)x.Parameters["ProblemData"];
+        return target == problemData.TargetVariable && inputs.SequenceEqual(problemData.AllowedInputVariables);
+      })) {
+        throw new ArgumentException("All runs must have the same target and inputs.");
+      }
+      return runs.Average(x => ((DoubleValue)x.Results["Best training solution quality"]).Value);
+    }
+
+    private static Dictionary<string, double> CalculateAverageImpacts(RunCollection runs, string resultName) {
+      var pd = (IRegressionProblemData)runs.First().Parameters["ProblemData"];
+      var target = pd.TargetVariable;
+      var inputs = pd.AllowedInputVariables.ToList();
+
+      var impacts = inputs.ToDictionary(x => x, x => 0d);
+
+      // check if all the runs have the same target and same inputs
+      if (!runs.All(x => {
+        var problemData = (IRegressionProblemData)x.Parameters["ProblemData"];
+        return target == problemData.TargetVariable && inputs.SequenceEqual(problemData.AllowedInputVariables);
+      })) {
+        throw new ArgumentException("All runs must have the same target and inputs.");
+      }
+
+      foreach (var run in runs) {
+        var impactsMatrix = (DoubleMatrix)run.Results[resultName];
+
+        int i = 0;
+        foreach (var v in impactsMatrix.RowNames) {
+          impacts[v] += impactsMatrix[i, 0];
+          ++i;
+        }
+      }
+
+      foreach (var v in inputs) {
+        impacts[v] /= runs.Count;
+      }
+
+      return impacts;
+    }
+
+    private static string Concatenate(IEnumerable<string> strings) {
+      var sb = new StringBuilder();
+      foreach (var s in strings) {
+        sb.Append(s);
+      }
+      return sb.ToString();
+    }
+
+    private void ConfigureNodeShapes() {
+      graphChart.ClearShapes();
+      var font = new Font(FontFamily.GenericSansSerif, 12);
+      graphChart.AddShape(typeof(VariableNetworkNode), new LabeledPrimitive(new Ellipse(graphChart.Chart, new PointD(0, 0), new PointD(30, 30), Pens.Black, Brushes.White), "", font));
+      graphChart.AddShape(typeof(JunctionNetworkNode), new LabeledPrimitive(new Rectangle(graphChart.Chart, new PointD(0, 0), new PointD(15, 15), Pens.Black, Brushes.DarkGray), "", font));
+    }
+
+    #region events
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      var run = Content.First();
+      var pd = (IRegressionProblemData)run.Parameters["ProblemData"];
+      var variables = new HashSet<string>(new List<string>(pd.Dataset.DoubleVariables));
+      impactResultNameComboBox.Items.Clear();
+      foreach (var result in run.Results.Where(x => x.Value is DoubleMatrix)) {
+        var m = (DoubleMatrix)result.Value;
+        if (m.RowNames.All(x => variables.Contains(x)))
+          impactResultNameComboBox.Items.Add(result.Key);
+      }
+      qualityResultNameComboBox.Items.Clear();
+      foreach (var result in run.Results.Where(x => x.Value is DoubleValue)) {
+        qualityResultNameComboBox.Items.Add(result.Key);
+      }
+      if (impactResultNameComboBox.Items.Count > 0) {
+        impactResultNameComboBox.Text = (string)impactResultNameComboBox.Items[0];
+      }
+      if (qualityResultNameComboBox.Items.Count > 0) {
+        qualityResultNameComboBox.Text = (string)qualityResultNameComboBox.Items[0];
+      }
+      if (impactResultNameComboBox.Items.Count > 0 && qualityResultNameComboBox.Items.Count > 0)
+        NetworkConfigurationChanged(this, EventArgs.Empty);
+    }
+
+    private void TextBoxValidating(object sender, CancelEventArgs e) {
+      double v;
+      string errorMsg = "Could not parse the entered value. Please input a real number.";
+      var tb = (TextBox)sender;
+      if (!double.TryParse(tb.Text, out v)) {
+        e.Cancel = true;
+        tb.Select(0, tb.Text.Length);
+
+        // Set the ErrorProvider error with the text to display. 
+        this.errorProvider.SetError(tb, errorMsg);
+        errorProvider.BlinkStyle = ErrorBlinkStyle.NeverBlink;
+        errorProvider.SetIconPadding(tb, -20);
+      }
+    }
+
+    private void NetworkConfigurationBoxValidated(object sender, EventArgs e) {
+      var tb = (TextBox)sender;
+      errorProvider.SetError(tb, string.Empty);
+      NetworkConfigurationChanged(sender, e);
+    }
+
+    private void LayoutConfigurationBoxValidated(object sender, EventArgs e) {
+      var tb = (TextBox)sender;
+      errorProvider.SetError(tb, string.Empty);
+      LayoutConfigurationChanged(sender, e);
+    }
+
+    private void NetworkConfigurationChanged(object sender, EventArgs e) {
+      var useBest = impactAggregationComboBox.SelectedIndex <= 0;
+      var threshold = double.Parse(impactThresholdTextBox.Text);
+      var qualityResultName = qualityResultNameComboBox.Text;
+      var impactsResultName = impactResultNameComboBox.Text;
+      if (string.IsNullOrEmpty(qualityResultName) || string.IsNullOrEmpty(impactsResultName))
+        return;
+      var maximization = maximizationCheckBox.Checked;
+      var network = BuildNetworkFromVariableImpacts(Content, qualityResultName, maximization, impactsResultName, threshold, useBest);
+      if (network.Vertices.Any())
+        graphChart.Graph = network;
+    }
+
+    private void LayoutConfigurationChanged(object sender, EventArgs e) {
+      ConstrainedForceDirectedLayout.EdgeRouting routingMode;
+      switch (edgeRoutingComboBox.SelectedIndex) {
+        case 0:
+          routingMode = ConstrainedForceDirectedLayout.EdgeRouting.None;
+          break;
+        case 1:
+          routingMode = ConstrainedForceDirectedLayout.EdgeRouting.Polyline;
+          break;
+        case 2:
+          routingMode = ConstrainedForceDirectedLayout.EdgeRouting.Orthogonal;
+          break;
+        default:
+          throw new ArgumentException("Invalid edge routing mode.");
+      }
+      var idealEdgeLength = double.Parse(idealEdgeLengthTextBox.Text);
+      if (routingMode == graphChart.RoutingMode && idealEdgeLength.IsAlmost(graphChart.IdealEdgeLength)) return;
+      graphChart.RoutingMode = routingMode;
+      graphChart.PerformEdgeRouting = routingMode != ConstrainedForceDirectedLayout.EdgeRouting.None;
+      graphChart.IdealEdgeLength = idealEdgeLength;
+      graphChart.Draw();
+    }
+    #endregion
+  }
 }