Changeset 12568 for branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.cs

Timestamp:

07/01/15 21:06:50 (9 years ago)

Author:

arapeanu

Message:

#2288: Fixed bug in SymbolicDataAnalysisVariableImpactsAnalyzer (simplification before optimization) and in VariableInteractionNetworkView for computing the adjacency matrix and sorting the variable impacts matrix

File:

• branches/HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/VariableInteractionNetworkView.cs (modified) (7 diffs)

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

@@ -87 +87 @@
             {
                 // TODO: Add code when content has been changed and is not null
-                viewHost2.Content = CalculateNodeImportance(CalculateAdjacencyMatrix());     
+                viewHost2.Content = CalculateNodeImportance(CalculateAdjacencyMatrix());
                 var adjMatrix = CalculateAdjacencyMatrix();
                 viewHost1.Content = adjMatrix;
@@ -110 +110 @@
         {
             var runCollection = Content;
-            var groupRunCollection = Content.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
+            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]);
@@ -116 +117 @@
                                  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);
 
-            adjMatrix.RowNames = groupRunCollection.Select(x => x.Key);
+            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<Tuple<string, double>>();
-                var columnNames = matrix.ColumnNames.ToList();
+                var variables = new List<double>();
 
                 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));
+                    variables.Add(matrix[0, i]);
+                }
+                
                 for (int i = 0; i < variables.Count; ++i)
                 {
-                    adjMatrix[j, i] = variables[i].Item2;
-
+                    if (i == j)
+                    {
+                        adjMatrix[i, i] = 0;
+                        variables.Insert(i, 0);
+                    }
+                    else
+                        adjMatrix[j, i] = variables[i];
                 }
             }
@@ -144 +167 @@
         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 runNames = runs.Select(x => x.Name).ToArray();
             var runsArray = runs.ToArray();
             DoubleMatrix varImpactMatrix = CalculateVariableImpactMatrix(runsArray, runNames);
-            var targetMatrix = new DoubleMatrix(1, variableNames.Length);
+          
+            var targetMatrix = new DoubleMatrix(1, varImpactMatrix.Rows);
 
             for (int i = 0; i < varImpactMatrix.Rows; ++i)
@@ -165 +178 @@
             }
 
-            targetMatrix.RowNames = new[] { "Target" };
-            targetMatrix.ColumnNames = variableNames;
-
+            targetMatrix.RowNames = new[] { "Impacts" };
+            targetMatrix.ColumnNames = varImpactMatrix.RowNames;
             return targetMatrix;
         }
@@ -262 +274 @@
         }
 
-        //adapted from RunCollectionVariableImpactView
+        //modified from RunCollectionVariableImpactView
         private DoubleMatrix CalculateVariableImpactMatrix(IRun[] runs, string[] runNames)
         {
@@ -307 +319 @@
                 }
             }
-            return matrix;
+
+            // 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;
         }