Changeset 14248 for branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Views

Timestamp:

08/09/16 15:18:32 (8 years ago)

Author:

gkronber

Message:

#2650: added support for factor variables to target variation view together with Philipp

Location:

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Views/3.4

Files:

• Controls/DensityChart.cs (modified) (2 diffs)
• Controls/FactorGradientChart.Designer.cs (added)
• Controls/FactorGradientChart.cs (added)
• Controls/GradientChart.cs (modified) (9 diffs)
• HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj (modified) (2 diffs)
• Interfaces/IGradientChart.cs (added)
• Regression/RegressionSolutionTargetResponseGradientView.cs (modified) (17 diffs)

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Views/3.4/Controls/DensityChart.cs

@@ -30 +30 @@
     }
 
+    public void UpdateChart(IList<string> data, double minimumHeight = 0.1) {
+      if (data == null || !data.Any())
+        return;
+      UpdateChartWithBuckets(CalculateBuckets(data));
+    }
+
+
     public void UpdateChart(IList<double> data, double min, double max, int numBuckets, double minimumHeight = 0.1) {
       if (data == null || numBuckets < 0 || min > max || max < min)
         return;
 
-      var buckets = CalculateBuckets(data, numBuckets, min, max);
+      UpdateChartWithBuckets(CalculateBuckets(data, numBuckets, min, max));
+    }
 
+
+    private void UpdateChartWithBuckets(double[] buckets) {
       // set minimum height of all non-zero buckets on 10% of maximum
       double minHeight = buckets.Max() * 0.1;
@@ -69 +79 @@
       return buckets;
     }
+    private double[] CalculateBuckets(IList<string> data) {
+      return data.GroupBy(val => val).OrderBy(g => g.Key).Select(g => (double)g.Count()).Concat(new double[] { 0.0 }).ToArray();
+    }
   }
 }

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Views/3.4/Controls/GradientChart.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Drawing;
@@ -34 +35 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Views {
-  public partial class GradientChart : UserControl {
+  public partial class GradientChart : UserControl, IGradientChart {
     private ModifiableDataset sharedFixedVariables; // used for syncronising variable values between charts
     private ModifiableDataset internalDataset; // holds the x values for each point drawn
@@ -319 +320 @@
         if (updateOnFinish)
           Update();
-      }
-      catch (OperationCanceledException) { }
-      catch (AggregateException ae) {
+      } catch (OperationCanceledException) { } catch (AggregateException ae) {
         if (!ae.InnerExceptions.Any(e => e is OperationCanceledException))
           throw;
@@ -347 +346 @@
       try {
         chart.ChartAreas[0].RecalculateAxesScale();
-      }
-      catch (InvalidOperationException) {
+      } catch (InvalidOperationException) {
         // Can occur if eg. axis min == axis max
       }
@@ -381 +379 @@
         xvalues.Add(xmin + i * step);
 
-      var variables = sharedFixedVariables.DoubleVariables.ToList();
-      internalDataset = new ModifiableDataset(variables,
-        variables.Select(x => x == FreeVariable
-          ? xvalues
-          : Enumerable.Repeat(sharedFixedVariables.GetDoubleValue(x, 0), xvalues.Count).ToList()
-        )
-      );
+      if (sharedFixedVariables == null)
+        return;
+
+      var variables = sharedFixedVariables.VariableNames.ToList();
+      var values = new List<IList>();
+      foreach (var varName in variables) {
+        if (varName == FreeVariable) {
+          values.Add(xvalues);
+        } else if (sharedFixedVariables.VariableHasType<double>(varName)) {
+          values.Add(Enumerable.Repeat(sharedFixedVariables.GetDoubleValue(varName, 0), xvalues.Count).ToList());
+        } else if (sharedFixedVariables.VariableHasType<string>(varName)) {
+          values.Add(Enumerable.Repeat(sharedFixedVariables.GetStringValue(varName, 0), xvalues.Count).ToList());
+        }
+      }
+
+      internalDataset = new ModifiableDataset(variables, values);
     }
 
@@ -552 +559 @@
 
     private static bool SolutionsCompatible(IEnumerable<IRegressionSolution> solutions) {
-      foreach (var solution1 in solutions) {
-        var variables1 = solution1.ProblemData.Dataset.DoubleVariables;
-        foreach (var solution2 in solutions) {
-          if (solution1 == solution2)
-            continue;
-          var variables2 = solution2.ProblemData.Dataset.DoubleVariables;
-          if (!variables1.All(variables2.Contains))
-            return false;
+      var refSolution = solutions.First();
+      var refSolVars = refSolution.ProblemData.Dataset.VariableNames;
+      foreach (var solution in solutions.Skip(1)) {
+        var variables1 = solution.ProblemData.Dataset.VariableNames;
+        if (!variables1.All(refSolVars.Contains))
+          return false;
+
+        foreach (var factorVar in variables1.Where(solution.ProblemData.Dataset.VariableHasType<string>)) {
+          var distinctVals = refSolution.ProblemData.Dataset.GetStringValues(factorVar).Distinct();
+          if (solution.ProblemData.Dataset.GetStringValues(factorVar).Any(val => !distinctVals.Contains(val))) return false;
         }
       }
@@ -608 +617 @@
     private void sharedFixedVariables_ItemChanged(object o, EventArgs<int, int> e) {
       if (o != sharedFixedVariables) return;
-      var variables = sharedFixedVariables.DoubleVariables.ToList();
+      var variables = sharedFixedVariables.VariableNames.ToList();
       var rowIndex = e.Value;
       var columnIndex = e.Value2;
@@ -614 +623 @@
       var variableName = variables[columnIndex];
       if (variableName == FreeVariable) return;
-      var v = sharedFixedVariables.GetDoubleValue(variableName, rowIndex);
-      var values = new List<double>(Enumerable.Repeat(v, DrawingSteps));
-      internalDataset.ReplaceVariable(variableName, values);
+      if (internalDataset.VariableHasType<double>(variableName)) {
+        var v = sharedFixedVariables.GetDoubleValue(variableName, rowIndex);
+        var values = new List<double>(Enumerable.Repeat(v, internalDataset.Rows));
+        internalDataset.ReplaceVariable(variableName, values);
+      } else if (internalDataset.VariableHasType<string>(variableName)) {
+        var v = sharedFixedVariables.GetStringValue(variableName, rowIndex);
+        var values = new List<String>(Enumerable.Repeat(v, internalDataset.Rows));
+        internalDataset.ReplaceVariable(variableName, values);
+      } else {
+        // unsupported type 
+        throw new NotSupportedException();
+      }
     }
 
@@ -635 +653 @@
       UpdateCursor();
     }
-    void UpdateCursor() {
+    private void UpdateCursor() {
       var x = VerticalLineAnnotation.X;
       sharedFixedVariables.SetVariableValue(x, FreeVariable, 0);

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Views/3.4/HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj

@@ -132 +132 @@
       <DependentUpon>DensityTrackbar.cs</DependentUpon>
     </Compile>
+    <Compile Include="Controls\FactorGradientChart.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Controls\FactorGradientChart.Designer.cs">
+      <DependentUpon>FactorGradientChart.cs</DependentUpon>
+    </Compile>
     <Compile Include="FeatureCorrelation\TimeframeFeatureCorrelationCalculator.cs" />
     <Compile Include="FeatureCorrelation\AbstractFeatureCorrelationCalculator.cs" />
@@ -207 +213 @@
       <DependentUpon>GradientChartConfigurationDialog.cs</DependentUpon>
     </Compile>
+    <Compile Include="Interfaces\IGradientChart.cs" />
     <Compile Include="Interfaces\IDataPreprocessorStarter.cs" />
     <Compile Include="MenuItems\ShrinkDataAnalysisRunsMenuItem.cs" />

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionTargetResponseGradientView.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Drawing;
@@ -34 +35 @@
   [Content(typeof(IRegressionSolution))]
   public partial class RegressionSolutionTargetResponseGradientView : DataAnalysisSolutionEvaluationView {
-    private readonly Dictionary<string, GradientChart> gradientCharts;
+    private readonly Dictionary<string, IGradientChart> gradientCharts;
     private readonly Dictionary<string, DensityChart> densityCharts;
     private readonly Dictionary<string, Panel> groupingPanels;
@@ -47 +48 @@
       }
     }
-    private IEnumerable<GradientChart> VisibleGradientCharts {
+    private IEnumerable<IGradientChart> VisibleGradientCharts {
       get { return VisibleVariables.Select(v => gradientCharts[v]); }
     }
@@ -59 +60 @@
     public RegressionSolutionTargetResponseGradientView() {
       InitializeComponent();
-      gradientCharts = new Dictionary<string, GradientChart>();
+      gradientCharts = new Dictionary<string, IGradientChart>();
       densityCharts = new Dictionary<string, DensityChart>();
       groupingPanels = new Dictionary<string, Panel>();
@@ -112 +113 @@
       // create dataset
       var allowedInputVariables = Content.ProblemData.AllowedInputVariables;
-      var variableValues = allowedInputVariables.Select(x => new List<double> { problemData.Dataset.GetDoubleValues(x, problemData.TrainingIndices).Median() });
-      var sharedFixedVariables = new ModifiableDataset(allowedInputVariables, variableValues);
+      var doubleVariables = allowedInputVariables.Where(problemData.Dataset.VariableHasType<double>);
+      var doubleVariableValues = (IEnumerable<IList>)doubleVariables.Select(x => new List<double> { problemData.Dataset.GetDoubleValues(x, problemData.TrainingIndices).Median() });
+
+      var factorVariables = allowedInputVariables.Where(problemData.Dataset.VariableHasType<string>);
+      var factorVariableValues = (IEnumerable<IList>)factorVariables.Select(x => new List<string> {
+        problemData.Dataset.GetStringValues(x, problemData.TrainingIndices)
+        .GroupBy(val => val).OrderByDescending(g => g.Count()).First().Key // most frequent value
+      });
+
+      var sharedFixedVariables = new ModifiableDataset(doubleVariables.Concat(factorVariables), doubleVariableValues.Concat(factorVariableValues));
+
 
       // create controls
@@ -119 +129 @@
       densityCharts.Clear();
       groupingPanels.Clear();
-      foreach (var variableName in allowedInputVariables) {
+      foreach (var variableName in doubleVariables) {
         var gradientChart = CreateGradientChart(variableName, sharedFixedVariables);
         gradientCharts.Add(variableName, gradientChart);
@@ -147 +157 @@
         // Initially, the inner plot areas are not initialized for hidden charts (scollpanel, ...)
         // This event handler listens for the paint event once (where everything is already initialized) to do some manual layouting.
-        gradientChart.ChartPostPaint += OnGradientChartOnChartPostPaint;
+        gradientChart.ChartPostPaint += OnGradientChartPostPaint;
 
         var panel = new Panel() {
@@ -159 +169 @@
         groupingPanels.Add(variableName, panel);
       }
-
+      foreach (var variableName in factorVariables) {
+        var gradientChart = CreateFactorGradientChart(variableName, sharedFixedVariables);
+        gradientCharts.Add(variableName, gradientChart);
+
+        var densityChart = new DensityChart() {
+          Anchor = AnchorStyles.Left | AnchorStyles.Top | AnchorStyles.Right,
+          Margin = Padding.Empty,
+          Height = 12,
+          Visible = false,
+          Top = (int)(gradientChart.Height * 0.1),
+        };
+        densityCharts.Add(variableName, densityChart);
+        gradientChart.ZoomChanged += (o, e) => {
+          var gradient = (FactorGradientChart)o;
+          var density = densityCharts[gradient.FreeVariable];
+          density.Visible = densityComboBox.SelectedIndex != 0 && !gradient.IsZoomed;
+          if (density.Visible)
+            UpdateDensityChart(density, gradient.FreeVariable);
+        };
+        gradientChart.SizeChanged += (o, e) => {
+          var gradient = (FactorGradientChart)o;
+          var density = densityCharts[gradient.FreeVariable];
+          density.Top = (int)(gradient.Height * 0.1);
+        };
+
+        // Initially, the inner plot areas are not initialized for hidden charts (scollpanel, ...)
+        // This event handler listens for the paint event once (where everything is already initialized) to do some manual layouting.
+        gradientChart.ChartPostPaint += OnFactorGradientChartPostPaint;
+
+        var panel = new Panel() {
+          Dock = DockStyle.Fill,
+          Margin = Padding.Empty,
+          BackColor = Color.White
+        };
+
+        panel.Controls.Add(densityChart);
+        panel.Controls.Add(gradientChart);
+        groupingPanels.Add(variableName, panel);
+      }
       // update variable list
       variableListView.ItemChecked -= variableListView_ItemChecked;
@@ -173 +221 @@
     }
 
-    private void OnGradientChartOnChartPostPaint(object o, EventArgs e) {
+    private void OnGradientChartPostPaint(object o, EventArgs e) {
       var gradient = (GradientChart)o;
       var density = densityCharts[gradient.FreeVariable];
@@ -186 +234 @@
       // removed after succesful layouting due to performance reasons
       if (gcPlotPosition.Width != 0)
-        gradient.ChartPostPaint -= OnGradientChartOnChartPostPaint;
+        gradient.ChartPostPaint -= OnGradientChartPostPaint;
+    }
+
+    private void OnFactorGradientChartPostPaint(object o, EventArgs e) {
+      var gradient = (FactorGradientChart)o;
+      var density = densityCharts[gradient.FreeVariable];
+
+      density.Width = gradient.Width;
+
+      var gcPlotPosition = gradient.InnerPlotPosition;
+      density.Left = (int)(gcPlotPosition.X / 100.0 * gradient.Width);
+      density.Width = (int)(gcPlotPosition.Width / 100.0 * gradient.Width);
+      gradient.UpdateTitlePosition();
+
+      // removed after succesful layouting due to performance reasons
+      if (gcPlotPosition.Width != 0)
+        gradient.ChartPostPaint -= OnFactorGradientChartPostPaint;
     }
 
@@ -192 +256 @@
       foreach (var variable in VisibleVariables) {
         var gradientChart = gradientCharts[variable];
-        await gradientChart.RecalculateAsync();
+        await gradientChart.RecalculateAsync(false, false);
       }
       gradientChartTableLayout.SuspendLayout();
@@ -201 +265 @@
       gradientChartTableLayout.Refresh();
       foreach (var variable in VisibleVariables) {
-        var densityChart = densityCharts[variable];
-        UpdateDensityChart(densityChart, variable);
+        DensityChart densityChart;
+        if (densityCharts.TryGetValue(variable, out densityChart)) {
+          UpdateDensityChart(densityChart, variable);
+        }
       }
     }
@@ -215 +281 @@
       };
       gradientChart.VariableValueChanged += async (o, e) => {
-        var recalculations = VisibleGradientCharts.Except(new[] { (GradientChart)o }).Select(async chart => {
-          await chart.RecalculateAsync(updateOnFinish: false, resetYAxis: false);
-        }).ToList();
+        var recalculations = VisibleGradientCharts
+          .Except(new[] { (IGradientChart)o })
+          .Select(async chart => {
+            await chart.RecalculateAsync(updateOnFinish: false, resetYAxis: false);
+          }).ToList();
         await Task.WhenAll(recalculations);
 
@@ -228 +296 @@
       return gradientChart;
     }
-
+    private FactorGradientChart CreateFactorGradientChart(string variableName, ModifiableDataset sharedFixedVariables) {
+      var gradientChart = new FactorGradientChart {
+        Dock = DockStyle.Fill,
+        Margin = Padding.Empty,
+        ShowLegend = false,
+        ShowCursor = true,
+        YAxisTicks = 5,
+      };
+      gradientChart.VariableValueChanged += async (o, e) => {
+        var recalculations = VisibleGradientCharts
+          .Except(new[] { (FactorGradientChart)o })
+          .Select(async chart => {
+            await chart.RecalculateAsync(updateOnFinish: false, resetYAxis: false);
+          }).ToList();
+        await Task.WhenAll(recalculations);
+
+        if (recalculations.All(t => t.IsCompleted))
+          SetupYAxis();
+      };
+      var variableValues = Content.ProblemData.Dataset.GetStringValues(variableName).Distinct().OrderBy(n => n).ToList();
+      gradientChart.Configure(new[] { Content }, sharedFixedVariables, variableName, variableValues);
+      gradientChart.SolutionAdded += gradientChart_SolutionAdded;
+      gradientChart.SolutionRemoved += gradientChart_SolutionRemoved;
+      return gradientChart;
+    }
     private void SetupYAxis() {
       double axisMin, axisMax;
@@ -319 +411 @@
       if (item.Checked) {
         tl.Controls.Add(chartsPanel);
-        await gradientChart.RecalculateAsync();
+        await gradientChart.RecalculateAsync(false, false);
       } else {
         tl.Controls.Remove(chartsPanel);
@@ -383 +475 @@
         indices = GetDensityIndices(densityComboBox.SelectedIndex).ToList();
       }
-      var data = Content.ProblemData.Dataset.GetDoubleValues(variable, indices).ToList();
-      var gradientChart = gradientCharts[variable];
-      var min = gradientChart.FixedXAxisMin;
-      var max = gradientChart.FixedXAxisMax;
-      var buckets = gradientChart.DrawingSteps;
-      if (min.HasValue && max.HasValue) {
-        densityChart.UpdateChart(data, min.Value, max.Value, buckets);
-        densityChart.Width = gradientChart.Width;
-
-        var gcPlotPosition = gradientChart.InnerPlotPosition;
-        densityChart.Left = (int)(gcPlotPosition.X / 100.0 * gradientChart.Width);
-        densityChart.Width = (int)(gcPlotPosition.Width / 100.0 * gradientChart.Width);
-
-        densityChart.Visible = true;
-      }
-
-      gradientChart.UpdateTitlePosition();
+      if (Content.ProblemData.Dataset.VariableHasType<double>(variable)) {
+        var data = Content.ProblemData.Dataset.GetDoubleValues(variable, indices).ToList();
+        var gradientChart = gradientCharts[variable] as GradientChart;
+        if (gradientChart != null) {
+          var min = gradientChart.FixedXAxisMin;
+          var max = gradientChart.FixedXAxisMax;
+          var buckets = gradientChart.DrawingSteps;
+          if (min.HasValue && max.HasValue) {
+            densityChart.UpdateChart(data, min.Value, max.Value, buckets);
+            densityChart.Width = gradientChart.Width;
+
+            var gcPlotPosition = gradientChart.InnerPlotPosition;
+            densityChart.Left = (int)(gcPlotPosition.X / 100.0 * gradientChart.Width);
+            densityChart.Width = (int)(gcPlotPosition.Width / 100.0 * gradientChart.Width);
+
+            densityChart.Visible = true;
+          }
+          gradientChart.UpdateTitlePosition();
+        }
+      } else if (Content.ProblemData.Dataset.VariableHasType<string>(variable)) {
+        var data = Content.ProblemData.Dataset.GetStringValues(variable).ToList();
+        var gradientChart = gradientCharts[variable] as FactorGradientChart;
+        if (gradientChart != null) {
+          densityChart.UpdateChart(data);
+          densityChart.Width = gradientChart.Width;
+
+          var gcPlotPosition = gradientChart.InnerPlotPosition;
+          densityChart.Left = (int)(gcPlotPosition.X / 100.0 * gradientChart.Width);
+          densityChart.Width = (int)(gcPlotPosition.Width / 100.0 * gradientChart.Width);
+
+          densityChart.Visible = true;
+
+          gradientChart.UpdateTitlePosition();
+        }
+      }
     }
 
@@ -422 +532 @@
         var densityChart = densityCharts[variable];
         // recalculate and refresh
-        await gradientChart.RecalculateAsync();
+        await gradientChart.RecalculateAsync(false, false);
         gradientChart.Refresh();
         UpdateDensityChart(densityChart, variable);