Changeset 14788 for branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEAlgorithm.cs

Timestamp:

03/27/17 17:27:03 (7 years ago)

Author:

gkronber

Message:

#2700: refactoring

File:

• branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEAlgorithm.cs (modified) (8 diffs)

branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEAlgorithm.cs

@@ -29 +29 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -72 +71 @@
     private const string ClassesParameterName = "ClassNames";
     private const string NormalizationParameterName = "Normalization";
+    #endregion
+
+    #region result names
+    private const string IterationResultName = "Iteration";
+    private const string ErrorResultName = "Error";
+    private const string ErrorPlotResultName = "Error plot";
+    private const string ScatterPlotResultName = "Scatterplot";
+    private const string DataResultName = "Projected data";
     #endregion
 
@@ -209 +216 @@
     #endregion
 
-    public override void Stop() {
-      base.Stop();
-      if (tsne != null) tsne.Running = false;
-    }
+    [Storable]
+    private Dictionary<string, List<int>> dataRowNames;    // TODO
+    [Storable]
+    private Dictionary<string, ScatterPlotDataRow> dataRows; // TODO
+
 
     protected override void Run(CancellationToken cancellationToken) {
-      var dataRowNames = new Dictionary<string, List<int>>();
-      var rows = new Dictionary<string, ScatterPlotDataRow>();
+      var problemData = Problem.ProblemData;
+
+      // set up and run tSNE
+      if (SetSeedRandomly) Seed = new System.Random().Next();
+      var random = new MersenneTwister((uint)Seed);
+      var dataset = problemData.Dataset;
+      var allowedInputVariables = problemData.AllowedInputVariables.ToArray();
+      var data = new double[dataset.Rows][];
+      for (var row = 0; row < dataset.Rows; row++) data[row] = allowedInputVariables.Select(col => dataset.GetDoubleValue(col, row)).ToArray();
+      if (Normalization) data = NormalizeData(data);
+
+      var tsneState = TSNE<double[]>.CreateState(data, Distance, random, NewDimensions, Perplexity, Theta, StopLyingIteration, MomentumSwitchIteration, InitialMomentum, FinalMomentum, Eta);
+
+      SetUpResults(data);
+      for (int iter = 0; iter < MaxIterations && !cancellationToken.IsCancellationRequested; iter++)
+      {
+        TSNE<double[]>.Iterate(tsneState);
+        Analyze(tsneState);
+      }
+    }
+
+    private void SetUpResults(IReadOnlyCollection<double[]> data) {
+      if (Results == null) return;
+      var results = Results;
+      dataRowNames = new Dictionary<string, List<int>>();
+      dataRows = new Dictionary<string, ScatterPlotDataRow>();
       var problemData = Problem.ProblemData;
 
@@ -235 +267 @@
             var contourname = GetContourName(i, min, max, contours);
             dataRowNames.Add(contourname, new List<int>());
-            rows.Add(contourname, new ScatterPlotDataRow(contourname, "", new List<Point2D<double>>()));
-            rows[contourname].VisualProperties.Color = GetHeatMapColor(i, contours);
-            rows[contourname].VisualProperties.PointSize = i + 3;
+            dataRows.Add(contourname, new ScatterPlotDataRow(contourname, "", new List<Point2D<double>>()));
+            dataRows[contourname].VisualProperties.Color = GetHeatMapColor(i, contours);
+            dataRows[contourname].VisualProperties.PointSize = i + 3;
           }
           for (var i = 0; i < classValues.Length; i++) {
@@ -248 +280 @@
       }
 
-      // set up and run tSNE
-      if (SetSeedRandomly) Seed = new System.Random().Next();
-      var random = new MersenneTwister((uint)Seed);
-      tsne = new TSNE<double[]>(Distance, random, Results, MaxIterations, StopLyingIteration, MomentumSwitchIteration, InitialMomentum, FinalMomentum, Eta, dataRowNames, rows);
-      var dataset = problemData.Dataset;
-      var allowedInputVariables = problemData.AllowedInputVariables.ToArray();
-      var data = new double[dataset.Rows][];
-      for (var row = 0; row < dataset.Rows; row++) data[row] = allowedInputVariables.Select(col => dataset.GetDoubleValue(col, row)).ToArray();
-      if (Normalization) data = NormalizeData(data);
-      tsne.Run(data, NewDimensions, Perplexity, Theta);
+      if (!results.ContainsKey(IterationResultName)) results.Add(new Result(IterationResultName, new IntValue(0)));
+      else ((IntValue)results[IterationResultName].Value).Value = 0;
+
+      if (!results.ContainsKey(ErrorResultName)) results.Add(new Result(ErrorResultName, new DoubleValue(0)));
+      else ((DoubleValue)results[ErrorResultName].Value).Value = 0;
+
+      if (!results.ContainsKey(ErrorPlotResultName)) results.Add(new Result(ErrorPlotResultName, new DataTable(ErrorPlotResultName, "Development of errors during gradient descent")));
+      else results[ErrorPlotResultName].Value = new DataTable(ErrorPlotResultName, "Development of errors during gradient descent");
+
+      var plot = results[ErrorPlotResultName].Value as DataTable;
+      if (plot == null) throw new ArgumentException("could not create/access error data table in results collection");
+
+      if (!plot.Rows.ContainsKey("errors")) plot.Rows.Add(new DataRow("errors"));
+      plot.Rows["errors"].Values.Clear();
+
+      results.Add(new Result(ScatterPlotResultName, "Plot of the projected data", new ScatterPlot(DataResultName, "")));
+      results.Add(new Result(DataResultName, "Projected Data", new DoubleMatrix()));
+    }
+
+    private void Analyze(TSNE<double[]>.TSNEState tsneState) {
+      if (Results == null) return;
+      var results = Results;
+      var plot = results[ErrorPlotResultName].Value as DataTable;
+      if (plot == null) throw new ArgumentException("Could not create/access error data table in results collection.");
+      var errors = plot.Rows["errors"].Values;
+      var c = tsneState.EvaluateError();
+      errors.Add(c);
+      ((IntValue)results[IterationResultName].Value).Value = tsneState.iter + 1;
+      ((DoubleValue)results[ErrorResultName].Value).Value = errors.Last();
+
+      var ndata = Normalize(tsneState.newData);
+      results[DataResultName].Value = new DoubleMatrix(ndata);
+      var splot = results[ScatterPlotResultName].Value as ScatterPlot;
+      FillScatterPlot(ndata, splot);
+    }
+
+    private void FillScatterPlot(double[,] lowDimData, ScatterPlot plot) {
+      foreach (var rowName in dataRowNames.Keys) {
+        if (!plot.Rows.ContainsKey(rowName))
+          plot.Rows.Add(dataRows.ContainsKey(rowName) ? dataRows[rowName] : new ScatterPlotDataRow(rowName, "", new List<Point2D<double>>()));
+        plot.Rows[rowName].Points.Replace(dataRowNames[rowName].Select(i => new Point2D<double>(lowDimData[i, 0], lowDimData[i, 1])));
+      }
+    }
+
+    private static double[,] Normalize(double[,] data) {
+      var max = new double[data.GetLength(1)];
+      var min = new double[data.GetLength(1)];
+      var res = new double[data.GetLength(0), data.GetLength(1)];
+      for (var i = 0; i < max.Length; i++) max[i] = min[i] = data[0, i];
+      for (var i = 0; i < data.GetLength(0); i++)
+        for (var j = 0; j < data.GetLength(1); j++) {
+          var v = data[i, j];
+          max[j] = Math.Max(max[j], v);
+          min[j] = Math.Min(min[j], v);
+        }
+      for (var i = 0; i < data.GetLength(0); i++) {
+        for (var j = 0; j < data.GetLength(1); j++) {
+          res[i, j] = (data[i, j] - (max[j] + min[j]) / 2) / (max[j] - min[j]);
+        }
+      }
+      return res;
     }
 
@@ -276 +359 @@
       return nData;
     }
+
     private static Color GetHeatMapColor(int contourNr, int noContours) {
       var q = (double)contourNr / noContours;  // q in [0,1]
@@ -281 +365 @@
       return c;
     }
+
     private static string GetContourName(double value, double min, double max, int noContours) {
       var size = (max - min) / noContours;
@@ -286 +371 @@
       return GetContourName(contourNr, min, max, noContours);
     }
+
     private static string GetContourName(int i, double min, double max, int noContours) {
       var size = (max - min) / noContours;