Changeset 12229 for branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3

Timestamp:

03/20/15 16:31:50 (9 years ago)

Author:

arapeanu

Message:

#2288: VariableInteractionNetworkView - calculates adjacency matrix from the mean impacts

Location:

branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3

Files:

• . (modified) (1 prop)
• HeuristicLab.VariableInteractionNetworks.Views-3.3.csproj (added)
• HeuristicLab.VariableInteractionNetworks.Views.csproj (deleted)
• VariableInteractionNetworkView.Designer.cs (modified) (1 diff)
• VariableInteractionNetworkView.cs (modified) (1 diff)

branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.Designer.cs

@@ -29 +29 @@
         private void InitializeComponent()
         {
-            components = new System.ComponentModel.Container();
+            this.groupBox1 = new System.Windows.Forms.GroupBox();
+            this.viewHost1 = new HeuristicLab.MainForm.WindowsForms.ViewHost();
+            this.groupBox1.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // groupBox1
+            // 
+            this.groupBox1.Controls.Add(this.viewHost1);
+            this.groupBox1.Location = new System.Drawing.Point(0, 3);
+            this.groupBox1.Name = "groupBox1";
+            this.groupBox1.Size = new System.Drawing.Size(779, 403);
+            this.groupBox1.TabIndex = 0;
+            this.groupBox1.TabStop = false;
+            this.groupBox1.Text = "Adjacency Matrix";
+            // 
+            // viewHost1
+            // 
+            this.viewHost1.Caption = "View";
+            this.viewHost1.Content = null;
+            this.viewHost1.Enabled = false;
+            this.viewHost1.Location = new System.Drawing.Point(6, 19);
+            this.viewHost1.Name = "viewHost1";
+            this.viewHost1.ReadOnly = false;
+            this.viewHost1.Size = new System.Drawing.Size(667, 382);
+            this.viewHost1.TabIndex = 0;
+            this.viewHost1.ViewsLabelVisible = true;
+            this.viewHost1.ViewType = null;
+            // 
+            // VariableInteractionNetworkView
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.Controls.Add(this.groupBox1);
+            this.Name = "VariableInteractionNetworkView";
+            this.Size = new System.Drawing.Size(676, 407);
+            this.groupBox1.ResumeLayout(false);
+            this.ResumeLayout(false);
+
         }
 
         #endregion
+
+        private System.Windows.Forms.GroupBox groupBox1;
+        private MainForm.WindowsForms.ViewHost viewHost1;
+
     }
 }

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

@@ -34 +34 @@
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
-
-
-namespace HeuristicLab.VariableInteractionNetworks.Views
-{
-    [View("VariableInteractionNetworkView")]
-    [Content(typeof(RunCollection), IsDefaultView = false)]
-    public sealed partial class VariableInteractionNetworkView : AsynchronousContentView
-    {
-        public new RunCollection Content
-        {
-            get { return (RunCollection)base.Content; }
-            set { base.Content = value; }
-        }
-
-        public VariableInteractionNetworkView()
-        {
-            InitializeComponent();
-            CalculateVariableInteractions();
-        }
-
-        protected override void DeregisterContentEvents()
-        {
-            // TODO: Deregister your event handlers here
-            base.DeregisterContentEvents();
-        }
-
-        protected override void RegisterContentEvents()
-        {
-            base.RegisterContentEvents();
-            // TODO: Register your event handlers here
-        }
-
-        #region Event Handlers (Content)
-        // TODO: Put event handlers of the content here
-        #endregion
-
-        protected override void OnContentChanged()
-        {
-            base.OnContentChanged();
-            if (Content == null)
-            {
-                // TODO: Add code when content has been changed and is null
-            }
-            else
-            {
-                // TODO: Add code when content has been changed and is not null
-            }
-        }
-
-
-        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 void CalculateVariableInteractions()
-        {
-            var runCollection = Content;
-
-            foreach (var g in runCollection.GroupBy(x => ((IRegressionProblem)x.Algorithm.Problem).ProblemData.TargetVariable))
-            {
-                CalculateVariableNetwork(g);
-            }
-        }
-
-        private void CalculateVariableNetwork(IEnumerable<IRun> runs)
-        {
-
-        }
-    }
+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";
+    public new RunCollection Content {
+      get { return (RunCollection)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public VariableInteractionNetworkView() {
+      InitializeComponent();
+    }
+
+    #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
+      } else {
+        // TODO: Add code when content has been changed and is not null
+        CalculateAdjacencyMatrix();
+      }
+    }
+    #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 void CalculateAdjacencyMatrix()
+    {
+        var runCollection = Content;
+        var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).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 adjMatrix = new DoubleMatrix(variableNames.Length, variableNames.Length);
+        var adjRow = groupRunCollection.Select(x => CalculateAdjacencyRows(x)).ToList();
+        var targets = groupRunCollection.Select(x => x.Key);
+
+        adjMatrix.RowNames = targets;
+        adjMatrix.ColumnNames = adjMatrix.RowNames;
+
+        for (int j = 0; j < groupRunCollection.Count; ++j) 
+        {
+            var g = groupRunCollection[j];
+            var matrix = CalculateAdjacencyRows(g);
+            var variables = new List<Tuple<string, double>>();
+            var columnNames = matrix.ColumnNames.ToList();
+            
+            for (int i = 0; i < matrix.Columns; ++i)
+            {
+                variables.Add(new Tuple<string, double>(columnNames[i], matrix[0, i]));
+            }
+            variables.Add(new Tuple<string, double>(g.Key, 0));
+            variables.Sort((a, b) => a.Item1.CompareTo(b.Item1));
+            for (int i = 0; i < variables.Count; ++i)
+            {
+                adjMatrix[j, i] = variables[i].Item2;
+            }
+        }
+        viewHost1.Content = adjMatrix;
+    }
+
+    private DoubleMatrix CalculateAdjacencyRows(IEnumerable<IRun> runs)
+    {
+        IEnumerable<DoubleMatrix> allVariableImpacts = (from run in runs
+                                                      select run.Results[variableImpactResultName]).Cast<DoubleMatrix>();
+        var variableNames = (from variableImpact in allVariableImpacts
+                                           from variableName in variableImpact.RowNames
+                                           select variableName)
+                                          .Distinct().ToArray();
+       
+        List<string> variableNamesList = (from variableName in variableNames
+                                          where GetVariableImpacts(variableName, allVariableImpacts).Any(x => !x.IsAlmost(0.0))
+                                          select variableName)
+                                         .ToList();
+
+        var inputVariables = runs.Select(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).InputVariables).ToArray();     
+        var runNames = runs.Select(x => x.Name).ToArray();
+        var runsArray = runs.ToArray();
+        DoubleMatrix varImpactMatrix = CalculateVariableImpactMatrix(runsArray, runNames);
+        var targetMatrix = new DoubleMatrix(1, variableNames.Length);
+
+        for (int i = 0; i < varImpactMatrix.Rows; ++i)
+        {
+            targetMatrix[0, i] = varImpactMatrix[i, runNames.Length];
+        }
+   
+        targetMatrix.RowNames = new[] { "Target" };
+        targetMatrix.ColumnNames = variableNames;
+
+        return targetMatrix;
+    }
+
+    //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++;
+            }
+        }
+    }
+
+    //adapted 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);
+                }
+            }
+        }
+        return matrix;
+    }
+  }
 }