Changeset 16295 for branches/2288_HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/RunCollectionVariableInteractionNetworkView.cs

Timestamp:

11/13/18 15:22:18 (5 years ago)

Author:

bburlacu

Message:

#2288: Refactor code (use HL impacts calculator instead of manually calculating impacts, various fixes and improvements)

File:

• branches/2288_HeuristicLab.VariableInteractionNetworks/HeuristicLab.VariableInteractionNetworks.Views/3.3/RunCollectionVariableInteractionNetworkView.cs (modified) (3 diffs)

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

@@ -111 +111 @@
       var targetImpacts = new Dictionary<string, Tuple<IEnumerable<IRun>, Dictionary<string, double>>>();
 
+      var groups = runs.GroupBy(run => {
+        var sol = (IRegressionSolution)run.Results.Values.Single(x => x is IRegressionSolution);
+        return Concatenate(sol.ProblemData.AllowedInputVariables) + sol.ProblemData.TargetVariable;
+      });
+
       if (useBest) {
         // build network using only the best run for each target
+        foreach (var group in groups) {
+          var solutions = group.Select(run => Tuple.Create(run, (IRegressionSolution)run.Results.Values.Single(sol => sol is IRegressionSolution)));
+          var best = solutions.OrderBy(x => x.Item2.TrainingRSquared).Last();
+          var impacts = RegressionSolutionVariableImpactsCalculator.CalculateImpacts(best.Item2, RegressionSolutionVariableImpactsCalculator.DataPartitionEnum.All, RegressionSolutionVariableImpactsCalculator.ReplacementMethodEnum.Shuffle).ToDictionary(x => x.Item1, x => x.Item2);
+
+          targetImpacts[best.Item2.ProblemData.TargetVariable] = Tuple.Create(new[] { best.Item1 }.AsEnumerable(), impacts);
+        }
       } else {
-        var groups = runs.GroupBy(run => {
-          var sol = (IRegressionSolution)run.Results.Values.Single(x => x is IRegressionSolution);
-          return Concatenate(sol.ProblemData.AllowedInputVariables) + sol.ProblemData.TargetVariable;
-        });
-
         foreach (var group in groups) {
           // calculate average impacts
@@ -131 +138 @@
             }
             var md = dataset.ToModifiable();
-            var impacts = CalculateImpacts(sol, md, originalValues, medians, estimationLimits);
-            foreach (var pair in impacts) {
-              if (averageImpacts.ContainsKey(pair.Key))
-                averageImpacts[pair.Key] += pair.Value;
+
+            var impacts = RegressionSolutionVariableImpactsCalculator.CalculateImpacts(sol, RegressionSolutionVariableImpactsCalculator.DataPartitionEnum.All, RegressionSolutionVariableImpactsCalculator.ReplacementMethodEnum.Shuffle);
+            foreach (var t in impacts) {
+              if (averageImpacts.ContainsKey(t.Item1))
+                averageImpacts[t.Item1] += t.Item2;
               else {
-                averageImpacts[pair.Key] = pair.Value;
+                averageImpacts[t.Item1] = t.Item2;
               }
             }
           }
+
           var count = group.Count();
-          var keys = averageImpacts.Keys.ToList();
-          foreach (var v in keys) {
+          foreach (var v in averageImpacts.Keys) {
             averageImpacts[v] /= count;
           }
 
-          targetImpacts[solution.ProblemData.TargetVariable] = new Tuple<IEnumerable<IRun>, Dictionary<string, double>>(group, averageImpacts);
+          targetImpacts[solution.ProblemData.TargetVariable] = Tuple.Create(group.AsEnumerable(), averageImpacts);
         }
       }
       return targetImpacts;
-    }
-
-    private static Dictionary<string, double> CalculateImpacts(IRegressionSolution solution, ModifiableDataset dataset,
-      Dictionary<string, List<double>> originalValues, Dictionary<string, List<double>> medianValues, DoubleLimit estimationLimits = null) {
-      var impacts = new Dictionary<string, double>();
-
-      var model = solution.Model;
-      var pd = solution.ProblemData;
-
-      var rows = pd.TrainingIndices.ToList();
-      var targetValues = pd.Dataset.GetDoubleValues(pd.TargetVariable, rows).ToList();
-
-
-      foreach (var v in pd.AllowedInputVariables) {
-        dataset.ReplaceVariable(v, medianValues[v]);
-
-        var estimatedValues = model.GetEstimatedValues(dataset, rows);
-        if (estimationLimits != null)
-          estimatedValues = estimatedValues.LimitToRange(estimationLimits.Lower, estimationLimits.Upper);
-
-        OnlineCalculatorError error;
-        var r = OnlinePearsonsRCalculator.Calculate(targetValues, estimatedValues, out error);
-        var newQuality = error == OnlineCalculatorError.None ? r * r : double.NaN;
-        var originalQuality = solution.TrainingRSquared;
-        impacts[v] = originalQuality - newQuality;
-
-        dataset.ReplaceVariable(v, originalValues[v]);
-      }
-      return impacts;
     }
 
     public static Dictionary<string, Tuple<IEnumerable<IRun>, Dictionary<string, double>>> CalculateVariableImpactsFromRunResults(RunCollection runs,
       string qualityResultName, bool maximization, string impactsResultName, bool useBestRunsPerTarget = false) {
-      var targets = runs.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
+
+      Func<IRun, double> getQuality = run => ((DoubleValue)run.Results[qualityResultName]).Value;
+      var targetGroups = runs.GroupBy(x => ((IRegressionProblemData)x.Parameters["ProblemData"]).TargetVariable).ToList();
       var targetImpacts = new Dictionary<string, Tuple<IEnumerable<IRun>, Dictionary<string, double>>>();
 
-      Func<IRun, double> getQualityValue = run => ((DoubleValue)run.Results[qualityResultName]).Value;
-
       if (useBestRunsPerTarget) {
-        var bestRunsPerTarget = maximization
-          ? targets.Select(x => x.OrderBy(getQualityValue).Last())
-          : targets.Select(x => x.OrderBy(getQualityValue).First());
-
-        foreach (var run in bestRunsPerTarget) {
-          var pd = (IRegressionProblemData)run.Parameters["ProblemData"];
-          var target = pd.TargetVariable;
-          var impacts = (DoubleMatrix)run.Results[impactsResultName];
-          targetImpacts[target] = new Tuple<IEnumerable<IRun>, Dictionary<string, double>>(new[] { run }, impacts.RowNames.Select((x, i) => new { Name = x, Index = i }).ToDictionary(x => x.Name, x => impacts[x.Index, 0]));
+        foreach (var group in targetGroups) {
+          var ordered = group.OrderBy(getQuality);
+          var best = maximization ? ordered.Last() : ordered.First();
+          var pd = (IRegressionProblemData)best.Parameters["ProblemData"];
+          var target = group.Key;
+          var impacts = (DoubleMatrix)best.Results[impactsResultName];
+          targetImpacts[target] = Tuple.Create((IEnumerable<IRun>)new[] { best }, impacts.RowNames.Select((x, i) => new { x, i }).ToDictionary(x => x.x, x => impacts[x.i, 0]));
         }
       } else {
-        foreach (var target in targets) {
+        foreach (var target in targetGroups) {
           var averageImpacts = CalculateAverageImpacts(new RunCollection(target), impactsResultName);
           targetImpacts[target.Key] = new Tuple<IEnumerable<IRun>, Dictionary<string, double>>(target, averageImpacts);
@@ -460 +437 @@
       worker.DoWork += (o, e) => {
         ControlsEnable(false);
-        var impacts = CalculateVariableImpactsOnline(Content, false);
+        var impacts = CalculateVariableImpactsOnline(Content, impactAggregationComboBox.SelectedIndex == 0);
         variableInteractionNetwork = CreateNetwork(impacts);
         var threshold = impactThresholdTrackBar.Minimum + (double)impactThresholdTrackBar.Value / impactThresholdTrackBar.Maximum;