Changeset 14512

Timestamp:

12/20/16 15:50:11 (8 years ago)

Author:

bwerth

Message:

#2700 worked in several comments from mkommend, extended analysis during algorithm run, added more Distances, made algorithm stoppable

Location:

branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4

Files:

• . (modified) (1 prop)
• Distances (added)
• Distances/AngularDistance.cs (added)
• Distances/DataPointDistance.cs (added)
• Distances/DistanceBase.cs (added)
• Distances/EuclidianDistance.cs (added)
• Distances/InnerProductDistance.cs (added)
• Distances/ManhattenDistance.cs (added)
• HeuristicLab.Algorithms.DataAnalysis-3.4.csproj (modified) (3 diffs)
• Interfaces/TSNEInterfaces (added)
• Interfaces/TSNEInterfaces/ICell.cs (added)
• Interfaces/TSNEInterfaces/IDataPoint.cs (added)
• Interfaces/TSNEInterfaces/IDistance.cs (added)
• Interfaces/TSNEInterfaces/IHeap.cs (added)
• Interfaces/TSNEInterfaces/IKernelFunction.cs (added)
• Interfaces/TSNEInterfaces/ISPTree.cs (added)
• Interfaces/TSNEInterfaces/ITSNE.cs (added)
• Interfaces/TSNEInterfaces/IVPTree.cs (added)
• TSNE/Distances/DataPointDistance.cs (modified) (1 diff)
• TSNE/Distances/DistanceBase.cs (modified) (1 diff)
• TSNE/Distances/EuclidianDistance.cs (modified) (1 diff)
• TSNE/Distances/FuctionalDistance.cs (added)
• TSNE/Distances/InnerProductDistance.cs (added)
• TSNE/TSNE.cs (modified) (8 diffs)
• TSNE/TSNEAnalysis.cs (modified) (11 diffs)

branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4

@@ +1 @@
+*.user
+*.vs10x
+.vs
+HeuristicLab.Algorithms.DataAnalysis-3.4.csproj.user
+HeuristicLabAlgorithmsDataAnalysisPlugin.cs
+Plugin.cs
 bin
 obj
-HeuristicLabAlgorithmsDataAnalysisPlugin.cs
-HeuristicLab.Algorithms.DataAnalysis-3.4.csproj.user
-*.vs10x
-Plugin.cs
-*.user
-.vs

@@ +1 @@
+*.user
+*.vs10x
+.vs
+HeuristicLab.Algorithms.DataAnalysis-3.4.csproj.user
+HeuristicLabAlgorithmsDataAnalysisPlugin.cs
+Plugin.cs
 bin
 obj
-HeuristicLabAlgorithmsDataAnalysisPlugin.cs
-HeuristicLab.Algorithms.DataAnalysis-3.4.csproj.user
-*.vs10x
-Plugin.cs
-*.user
-.vs

branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj

@@ -331 +331 @@
     <Compile Include="Interfaces\ISupportVectorMachineSolution.cs" />
     <Compile Include="Interfaces\IDataAnalysisAlgorithm.cs" />
+    <Compile Include="Interfaces\TSNEInterfaces\IKernelFunction.cs" />
     <Compile Include="kMeans\KMeansClustering.cs" />
     <Compile Include="kMeans\KMeansClusteringModel.cs" />
@@ -337 +338 @@
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="KPCA\SelfOrganizingMap.cs" />
+    <Compile Include="KPCA\KernelFunctions\CicularKernel.cs" />
+    <Compile Include="KPCA\KernelFunctions\GaussianKernel.cs" />
+    <Compile Include="KPCA\KernelFunctions\InverseMultiquadraticKernel .cs" />
+    <Compile Include="KPCA\KernelFunctions\LaplacianKernel.cs" />
+    <Compile Include="KPCA\KernelFunctions\MultiquadraticKernel.cs" />
+    <Compile Include="KPCA\KernelFunctions\NoKernel.cs" />
+    <Compile Include="KPCA\KernelFunctions\PolysplineKernel.cs" />
+    <Compile Include="KPCA\KernelFunctions\RadialBasisKernelBase.cs" />
+    <Compile Include="KPCA\KernelFunctions\ThinPlatePolysplineKernel.cs" />
+    <Compile Include="KPCA\KernelFunctions\TricubicKernel.cs" />
+    <Compile Include="KPCA\KernelPrincipleComponentAnalysis.cs" />
+    <Compile Include="KPCA\Isomap.cs" />
+    <Compile Include="KPCA\KPCA.cs" />
+    <Compile Include="KPCA\MatrixUtilities.cs" />
     <Compile Include="Linear\AlglibUtil.cs" />
     <Compile Include="Linear\Scaling.cs" />
@@ -415 +431 @@
     <Compile Include="TSNE\Cell.cs" />
     <Compile Include="TSNE\DataPoint.cs" />
+    <Compile Include="TSNE\Distances\FuctionalDistance.cs" />
     <Compile Include="TSNE\Distances\DistanceBase.cs" />
     <Compile Include="TSNE\Distances\DataPointDistance.cs" />
     <Compile Include="TSNE\Distances\EuclidianDistance.cs" />
-    <Compile Include="TSNE\TSNEInterfaces\IDistance.cs" />
+    <Compile Include="Interfaces\TSNEInterfaces\IDistance.cs" />
+    <Compile Include="TSNE\Distances\InnerProductDistance.cs" />
     <Compile Include="TSNE\TSNEAnalysis.cs" />
     <Compile Include="TSNE\PriorityQueue.cs" />
     <Compile Include="TSNE\SPtree.cs" />
     <Compile Include="TSNE\TSNE.cs" />
-    <Compile Include="TSNE\TSNEInterfaces\ICell.cs" />
-    <Compile Include="TSNE\TSNEInterfaces\IDataPoint.cs" />
-    <Compile Include="TSNE\TSNEInterfaces\IHeap.cs" />
-    <Compile Include="TSNE\TSNEInterfaces\ISPTree.cs" />
-    <Compile Include="TSNE\TSNEInterfaces\ITSNE.cs" />
-    <Compile Include="TSNE\TSNEInterfaces\IVPTree.cs" />
+    <Compile Include="Interfaces\TSNEInterfaces\ICell.cs" />
+    <Compile Include="Interfaces\TSNEInterfaces\IDataPoint.cs" />
+    <Compile Include="Interfaces\TSNEInterfaces\IHeap.cs" />
+    <Compile Include="Interfaces\TSNEInterfaces\ISPTree.cs" />
+    <Compile Include="Interfaces\TSNEInterfaces\ITSNE.cs" />
+    <Compile Include="Interfaces\TSNEInterfaces\IVPTree.cs" />
     <Compile Include="TSNE\TSNEUtils.cs" />
     <Compile Include="TSNE\VPTree.cs" />

branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/DataPointDistance.cs

@@ -20 +20 @@
 #endregion
 
-using HeuristicLab.Algorithms.DataAnalysis.Distances;
 using HeuristicLab.Common;
 using HeuristicLab.Core;

branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/DistanceBase.cs

@@ -25 +25 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Algorithms.DataAnalysis.Distances {
+namespace HeuristicLab.Algorithms.DataAnalysis {
   [StorableClass]
   public abstract class DistanceBase<T> : Item, IDistance<T> {

branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/Distances/EuclidianDistance.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
-using HeuristicLab.Algorithms.DataAnalysis.Distances;
 using HeuristicLab.Common;
 using HeuristicLab.Core;

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

@@ -57 +57 @@
 using System.Collections.Generic;
 using System.Linq;
+using HeuristicLab.Analysis;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -70 +71 @@
     private const string IterationResultName = "Iteration";
     private const string ErrorResultName = "Error";
+    private const string ErrorPlotResultName = "ErrorPlot";
+    private const string ScatterPlotResultName = "Scatterplot";
+    private const string DataResultName = "Projected Data";
 
     #region Properties
@@ -90 +94 @@
     [Storable]
     private ResultCollection results;
+    [Storable]
+    private Dictionary<string, List<int>> dataRowLookup;
+    [Storable]
+    private Dictionary<string, ScatterPlotDataRow> dataRows;
+    #endregion
+
+    #region Stopping 
+    public volatile bool Running;
     #endregion
 
@@ -105 +117 @@
       random = cloner.Clone(random);
       results = cloner.Clone(results);
+      dataRowLookup = original.dataRowLookup.ToDictionary(entry => entry.Key, entry => entry.Value.Select(x => x).ToList());
+      dataRows = original.dataRows.ToDictionary(entry => entry.Key, entry => cloner.Clone(entry.Value));
     }
     public override IDeepCloneable Clone(Cloner cloner) { return new TSNE<T>(this, cloner); }
-    public TSNE(IDistance<T> distance, IRandom random, ResultCollection results = null, int maxIter = 1000, int stopLyingIter = 250, int momSwitchIter = 250, double momentum = .5, double finalMomentum = .8, double eta = 200.0) {
+    public TSNE(IDistance<T> distance, IRandom random, ResultCollection results = null, int maxIter = 1000, int stopLyingIter = 250, int momSwitchIter = 250, double momentum = .5, double finalMomentum = .8, double eta = 200.0, Dictionary<string, List<int>> dataRowLookup = null, Dictionary<string, ScatterPlotDataRow> dataRows = null) {
       this.distance = distance;
       this.maxIter = maxIter;
@@ -117 +131 @@
       this.random = random;
       this.results = results;
+      this.dataRowLookup = dataRowLookup;
+      if (dataRows != null)
+        this.dataRows = dataRows;
+      else { this.dataRows = new Dictionary<string, ScatterPlotDataRow>(); }
     }
     #endregion
@@ -124 +142 @@
       var noDatapoints = data.Length;
       if (noDatapoints - 1 < 3 * perplexity) throw new ArgumentException("Perplexity too large for the number of data points!");
-
-      if (results != null) {
-        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;
-      }
-
-      // Determine whether we are using an exact algorithm
+      SetUpResults(data);
+      Running = true;
       var exact = Math.Abs(theta) < double.Epsilon;
       var newData = new double[noDatapoints, newDimensions];
@@ -141 +150 @@
       var gains = new double[noDatapoints, newDimensions];
       for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < newDimensions; j++) gains[i, j] = 1.0;
-
-      // Compute input similarities for exact t-SNE
       double[,] p = null;
       int[] rowP = null;
       int[] colP = null;
       double[] valP = null;
-      if (exact) {
-        // Compute similarities
-        p = new double[noDatapoints, noDatapoints];
-        ComputeGaussianPerplexity(data, noDatapoints, p, perplexity);
-        // Symmetrize input similarities
-        for (var n = 0; n < noDatapoints; n++) {
-          for (var m = n + 1; m < noDatapoints; m++) {
-            p[n, m] += p[m, n];
-            p[m, n] = p[n, m];
-          }
-        }
-        var sumP = .0;
-        for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < noDatapoints; j++) sumP += p[i, j];
-        for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < noDatapoints; j++) p[i, j] /= sumP;
-      } // Compute input similarities for approximate t-SNE
-      else {
-        // Compute asymmetric pairwise input similarities
-        ComputeGaussianPerplexity(data, noDatapoints, out rowP, out colP, out valP, perplexity, (int)(3 * perplexity));
-        // Symmetrize input similarities
-        int[] sRowP, symColP;
-        double[] sValP;
-        SymmetrizeMatrix(rowP, colP, valP, out sRowP, out symColP, out sValP);
-        rowP = sRowP;
-        colP = symColP;
-        valP = sValP;
-        var sumP = .0;
-        for (var i = 0; i < rowP[noDatapoints]; i++) sumP += valP[i];
-        for (var i = 0; i < rowP[noDatapoints]; i++) valP[i] /= sumP;
-      }
+      var rand = new NormalDistributedRandom(random, 0, 1);
+
+      //Calculate Similarities
+      if (exact) p = CalculateExactSimilarites(data, perplexity);
+      else CalculateApproximateSimilarities(data, perplexity, out rowP, out colP, out valP);
 
       // Lie about the P-values
-      if (exact) {
-        for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < noDatapoints; j++) p[i, j] *= 12.0;
-      } else {
-        for (var i = 0; i < rowP[noDatapoints]; i++) valP[i] *= 12.0;
-      }
-
-      var rand = new NormalDistributedRandom(random, 0, 1);
+      if (exact) for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < noDatapoints; j++) p[i, j] *= 12.0;
+      else for (var i = 0; i < rowP[noDatapoints]; i++) valP[i] *= 12.0;
+
       // Initialize solution (randomly)
-      for (var i = 0; i < noDatapoints; i++)
-        for (var j = 0; j < newDimensions; j++)
-          newData[i, j] = rand.NextDouble() * .0001;
+      for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < newDimensions; j++) newData[i, j] = rand.NextDouble() * .0001;
 
       // Perform main training loop
-      for (var iter = 0; iter < maxIter; iter++) {
-
-        // Compute (approximate) gradient
+      for (var iter = 0; iter < maxIter && Running; iter++) {
         if (exact) ComputeExactGradient(p, newData, noDatapoints, newDimensions, dY);
         else ComputeGradient(rowP, colP, valP, newData, noDatapoints, newDimensions, dY, theta);
-
         // Update gains
-        for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < newDimensions; j++)
-            gains[i, j] = Math.Sign(dY[i, j]) != Math.Sign(uY[i, j]) ? gains[i, j] + .2 : gains[i, j] * .8;
+        for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < newDimensions; j++) gains[i, j] = Math.Sign(dY[i, j]) != Math.Sign(uY[i, j]) ? gains[i, j] + .2 : gains[i, j] * .8;
         for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < newDimensions; j++) if (gains[i, j] < .01) gains[i, j] = .01;
-
         // Perform gradient update (with momentum and gains)
         for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < newDimensions; j++) uY[i, j] = currentMomentum * uY[i, j] - eta * gains[i, j] * dY[i, j];
         for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < newDimensions; j++) newData[i, j] = newData[i, j] + uY[i, j];
-
         // Make solution zero-mean
         ZeroMean(newData);
-
         // Stop lying about the P-values after a while, and switch momentum
         if (iter == stopLyingIter) {
-          if (exact) {
-            for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < noDatapoints; j++) p[i, j] /= 12.0;
-          } else {
-            for (var i = 0; i < rowP[noDatapoints]; i++) valP[i] /= 12.0;
-          }
+          if (exact) for (var i = 0; i < noDatapoints; i++) for (var j = 0; j < noDatapoints; j++) p[i, j] /= 12.0;
+          else for (var i = 0; i < rowP[noDatapoints]; i++) valP[i] /= 12.0;
         }
         if (iter == momSwitchIter) currentMomentum = finalMomentum;
 
-        if (results == null) continue;
-        var errors = new List<double>();
-        // Print out progress
-        var c = exact
-          ? EvaluateError(p, newData, noDatapoints, newDimensions)
-          : EvaluateError(rowP, colP, valP, newData, theta);
-        errors.Add(c);
-        ((IntValue)results[IterationResultName].Value).Value = iter + 1;
-        ((DoubleValue)results[ErrorResultName].Value).Value = errors.Last();
+        Analyze(exact, iter, p, rowP, colP, valP, newData, noDatapoints, newDimensions, theta);
       }
       return newData;
@@ -234 +193 @@
       return new TSNE<TR>(distance, random).Run(data, newDimensions, perplexity, theta);
     }
+    public static double[,] Run<TR>(TR[] data, int newDimensions, double perplexity, double theta, Func<TR, TR, double> distance, IRandom random) where TR : class, IDeepCloneable {
+      return new TSNE<TR>(new FuctionalDistance<TR>(distance), random).Run(data, newDimensions, perplexity, theta);
+    }
 
     #region helpers
+
+    private void SetUpResults(IReadOnlyCollection<T> data) {
+      if (dataRowLookup == null) {
+        dataRowLookup = new Dictionary<string, List<int>>();
+        dataRowLookup.Add("Data", Enumerable.Range(0, data.Count).ToList());
+      }
+      if (results == null) return;
+      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 Gradiant descent")));
+      else results[ErrorPlotResultName].Value = new DataTable(ErrorPlotResultName, "Development of errors during Gradiant descent");
+
+      var plot = results[ErrorPlotResultName].Value as DataTable;
+      if (plot == null) throw new ArgumentException("could not create/access Error-DataTable 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(bool exact, int iter, double[,] p, int[] rowP, int[] colP, double[] valP, double[,] newData, int noDatapoints, int newDimensions, double theta) {
+      if (results == null) return;
+      var plot = results[ErrorPlotResultName].Value as DataTable;
+      if (plot == null) throw new ArgumentException("Could not create/access Error-DataTable in Results-Collection. Was it removed by some effect?");
+      var errors = plot.Rows["errors"].Values;
+      var c = exact
+        ? EvaluateError(p, newData, noDatapoints, newDimensions)
+        : EvaluateError(rowP, colP, valP, newData, theta);
+      errors.Add(c);
+      ((IntValue)results[IterationResultName].Value).Value = iter + 1;
+      ((DoubleValue)results[ErrorResultName].Value).Value = errors.Last();
+
+      var ndata = Normalize(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 dataRowLookup.Keys) {
+        if (!plot.Rows.ContainsKey(rowName)) {
+          plot.Rows.Add(dataRows.ContainsKey(rowName) ? dataRows[rowName] : new ScatterPlotDataRow(rowName, "", new List<Point2D<double>>()));
+        } else plot.Rows[rowName].Points.Clear();
+        plot.Rows[rowName].Points.AddRange(dataRowLookup[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;
+    }
+    private void CalculateApproximateSimilarities(T[] data, double perplexity, out int[] rowP, out int[] colP, out double[] valP) {
+      // Compute asymmetric pairwise input similarities
+      ComputeGaussianPerplexity(data, data.Length, out rowP, out colP, out valP, perplexity, (int)(3 * perplexity));
+      // Symmetrize input similarities
+      int[] sRowP, symColP;
+      double[] sValP;
+      SymmetrizeMatrix(rowP, colP, valP, out sRowP, out symColP, out sValP);
+      rowP = sRowP;
+      colP = symColP;
+      valP = sValP;
+      var sumP = .0;
+      for (var i = 0; i < rowP[data.Length]; i++) sumP += valP[i];
+      for (var i = 0; i < rowP[data.Length]; i++) valP[i] /= sumP;
+    }
+    private double[,] CalculateExactSimilarites(T[] data, double perplexity) {
+      // Compute similarities
+      var p = new double[data.Length, data.Length];
+      ComputeGaussianPerplexity(data, data.Length, p, perplexity);
+      // Symmetrize input similarities
+      for (var n = 0; n < data.Length; n++) {
+        for (var m = n + 1; m < data.Length; m++) {
+          p[n, m] += p[m, n];
+          p[m, n] = p[n, m];
+        }
+      }
+      var sumP = .0;
+      for (var i = 0; i < data.Length; i++) for (var j = 0; j < data.Length; j++) sumP += p[i, j];
+      for (var i = 0; i < data.Length; i++) for (var j = 0; j < data.Length; j++) p[i, j] /= sumP;
+      return p;
+    }
+
     private void ComputeGaussianPerplexity(IReadOnlyList<T> x, int n, out int[] rowP, out int[] colP, out double[] valP, double perplexity, int k) {
       if (perplexity > k) throw new ArgumentException("Perplexity should be lower than K!");

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

@@ -20 +20 @@
 #endregion
 
-using System;
+using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
 using HeuristicLab.Analysis;
@@ -27 +28 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -60 +60 @@
     private const string SetSeedRandomlyParameterName = "SetSeedRandomly";
     private const string SeedParameterName = "Seed";
+    private const string ClassesParameterName = "ClassNames";
     #endregion
 
@@ -67 +68 @@
       get { return Parameters[PerplexityParameterName] as IFixedValueParameter<DoubleValue>; }
     }
-    public IFixedValueParameter<DoubleValue> ThetaParameter
-    {
-      get { return Parameters[ThetaParameterName] as IFixedValueParameter<DoubleValue>; }
+    public OptionalValueParameter<DoubleValue> ThetaParameter
+    {
+      get { return Parameters[ThetaParameterName] as OptionalValueParameter<DoubleValue>; }
     }
     public IFixedValueParameter<IntValue> NewDimensionsParameter
@@ -110 +111 @@
     {
       get { return Parameters[SeedParameterName] as IFixedValueParameter<IntValue>; }
+    }
+    public IFixedValueParameter<StringValue> ClassesParameter
+    {
+      get { return Parameters[ClassesParameterName] as IFixedValueParameter<StringValue>; }
     }
     #endregion
@@ -124 +129 @@
     public double Theta
     {
-      get { return ThetaParameter.Value.Value; }
+      get { return ThetaParameter.Value == null ? 0 : ThetaParameter.Value.Value; }
     }
     public int NewDimensions
@@ -152 +157 @@
     public double Eta
     {
-      get { return EtaParameter.Value.Value; }
+      get
+      {
+        return EtaParameter.Value == null ? 0 : EtaParameter.Value.Value;
+      }
     }
     public bool SetSeedRandomly
@@ -162 +170 @@
       get { return (uint)SeedParameter.Value.Value; }
     }
+    public string Classes
+    {
+      get { return ClassesParameter.Value.Value; }
+    }
+
+    [Storable]
+    public TSNE<RealVector> tsne;
     #endregion
 
@@ -172 +187 @@
       Problem = new RegressionProblem();
       Parameters.Add(new ValueParameter<IDistance<RealVector>>(DistanceParameterName, "The distance function used to differentiate similar from non-similar points", new EuclidianDistance()));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(PerplexityParameterName, "Perplexity-Parameter of TSNE. Comparable to k in a k-nearest neighbour algorithm", new DoubleValue(25)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(ThetaParameterName, "Value describing how much appoximated gradients my differ from exact gradients. Set to 0 for exact calculation", new DoubleValue(0.1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(PerplexityParameterName, "Perplexity-Parameter of TSNE. Comparable to k in a k-nearest neighbour algorithm. Recommended Value is Floor(number of points /3) or lower", new DoubleValue(25)));
+      Parameters.Add(new OptionalValueParameter<DoubleValue>(ThetaParameterName, "Value describing how much appoximated gradients my differ from exact gradients. Set to 0 for exact calculation and in [0,1] otherwise \n CAUTION: exact calculation of forces requires building a non-sparse N*N matrix where N is the number of data points\n This may exceed memory limitations", new DoubleValue(0.1)));
       Parameters.Add(new FixedValueParameter<IntValue>(NewDimensionsParameterName, "Dimensionality of projected space (usually 2 for easy visual analysis", new IntValue(2)));
       Parameters.Add(new FixedValueParameter<IntValue>(MaxIterationsParameterName, "Maximum number of iterations for gradient descent", new IntValue(1000)));
@@ -183 +198 @@
       Parameters.Add(new FixedValueParameter<BoolValue>(SetSeedRandomlyParameterName, "If the seed should be random", new BoolValue(true)));
       Parameters.Add(new FixedValueParameter<IntValue>(SeedParameterName, "The seed used if it should not be random", new IntValue(0)));
+      Parameters.Add(new FixedValueParameter<StringValue>(ClassesParameterName, "name of the column specifying the class lables of each data point. \n if the lable column can not be found Training/Test is used as labels", new StringValue("none")));
     }
     #endregion
 
     protected override void Run() {
-      var lowDimData = new DoubleMatrix(GetProjectedData(Problem.ProblemData));
-      Results.Add(new Result(ScatterPlotResultName, "Plot of the projected data", CreateScatterPlot(lowDimData, Problem.ProblemData)));
-      Results.Add(new Result(DataResultName, "Projected Data", lowDimData));
-    }
-
-    private ScatterPlot CreateScatterPlot(DoubleMatrix lowDimData, IDataAnalysisProblemData problemData) {
-      var plot = new ScatterPlot(DataResultName, "");
-      Normalize(lowDimData);
-      plot.Rows.Add(new ScatterPlotDataRow("Training", "Points of the training set", problemData.TrainingIndices.Select(i => new Point2D<double>(lowDimData[i, 0], lowDimData[i, 1]))));
-      plot.Rows.Add(new ScatterPlotDataRow("Test", "Points of the test set", problemData.TestIndices.Select(i => new Point2D<double>(lowDimData[i, 0], lowDimData[i, 1]))));
-      return plot;
-    }
-
-    private double[,] GetProjectedData(IDataAnalysisProblemData problemData) {
+      var data = CalculateProjectedData(Problem.ProblemData);
+      var lowDimData = new DoubleMatrix(data);
+    }
+
+    public override void Stop() {
+      base.Stop();
+      if (tsne != null) tsne.Running = false;
+    }
+
+    private double[,] CalculateProjectedData(IDataAnalysisProblemData problemData) {
+      var DataRowNames = new Dictionary<string, List<int>>();
+      var rows = new Dictionary<string, ScatterPlotDataRow>();
+
+      if (problemData.Dataset.VariableNames.Contains(Classes)) {
+        if ((problemData.Dataset as Dataset).VariableHasType<string>(Classes)) {
+          var classes = problemData.Dataset.GetStringValues(Classes).ToArray();
+          for (int i = 0; i < classes.Length; i++) {
+            if (!DataRowNames.ContainsKey(classes[i])) DataRowNames.Add(classes[i], new List<int>());
+            DataRowNames[classes[i]].Add(i); //always succeeds
+          }
+        } else if ((problemData.Dataset as Dataset).VariableHasType<double>(Classes)) {
+          var classValues = problemData.Dataset.GetDoubleValues(Classes).ToArray();
+          var max = classValues.Max() + 0.1;
+          var min = classValues.Min() - 0.1;
+          var contours = 8;
+          for (int i = 0; i < contours; i++) {
+            var name = GetContourName(i, min, max, contours);
+            DataRowNames.Add(name, new List<int>());
+            rows.Add(name, new ScatterPlotDataRow(name, "", new List<Point2D<double>>()));
+            rows[name].VisualProperties.Color = GetHeatMapColor(i, contours);
+            rows[name].VisualProperties.PointSize = i+3;
+          }
+          for (int i = 0; i < classValues.Length; i++) {
+            DataRowNames[GetContourName(classValues[i], min, max, contours)].Add(i); //always succeeds
+          }
+
+        }
+
+
+      } else {
+        DataRowNames.Add("Training", problemData.TrainingIndices.ToList());
+        DataRowNames.Add("Test", problemData.TestIndices.ToList());
+      }
+
       var random = SetSeedRandomly ? new MersenneTwister() : new MersenneTwister(Seed);
-      var tsne = new TSNE<RealVector>(Distance, random, Results, MaxIterations, StopLyingIteration, MomentumSwitchIteration, InitialMomentum, FinalMomentum, Eta);
+      tsne = new TSNE<RealVector>(Distance, random, Results, MaxIterations, StopLyingIteration, MomentumSwitchIteration, InitialMomentum, FinalMomentum, Eta, DataRowNames, rows);
       var dataset = problemData.Dataset;
       var allowedInputVariables = problemData.AllowedInputVariables.ToArray();
@@ -210 +256 @@
     }
 
-    private static void Normalize(DoubleMatrix data) {
-      var max = new double[data.Columns];
-      var min = new double[data.Columns];
-      for (var i = 0; i < max.Length; i++) max[i] = min[i] = data[0, i];
-      for (var i = 0; i < data.Rows; i++)
-        for (var j = 0; j < data.Columns; 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.Rows; i++) {
-        for (var j = 0; j < data.Columns; j++) {
-          data[i, j] = (data[i, j] - (max[j] + min[j]) / 2) / (max[j] - min[j]);
-        }
-      }
-
-    }
+    private static Color GetHeatMapColor(int contourNr, int noContours) {
+      var q = (double)contourNr / noContours;  // q in [0,1]
+      var c = q < 0.5 ? Color.FromArgb((int)(q * 2 * 255), 255, 0) : Color.FromArgb(255, (int)((1 - q) * 2 * 255), 0);
+      return c;
+    }
+    private static string GetContourName(double value, double min, double max, int noContours) {
+      var size = (max - min) / noContours;
+      var contourNr = (int)((value - min) / size);
+      return GetContourName(contourNr, min, max, noContours);
+    }
+    private static string GetContourName(int i, double min, double max, int noContours) {
+      var size = (max - min) / noContours;
+      return "[" + (min + i * size) + ";" + (min + (i + 1) * size) + ")";
+    }
+
   }
 }

@@ +1 @@
+*.user
+*.vs10x
+.vs
+HeuristicLab.Algorithms.DataAnalysis-3.4.csproj.user
+HeuristicLabAlgorithmsDataAnalysisPlugin.cs
+Plugin.cs
 bin
 obj
-HeuristicLabAlgorithmsDataAnalysisPlugin.cs
-HeuristicLab.Algorithms.DataAnalysis-3.4.csproj.user
-*.vs10x
-Plugin.cs
-*.user
-.vs