Changeset 14807 for branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEStatic.cs

Timestamp:

03/30/17 19:06:44 (7 years ago)

Author:

gkronber

Message:

#2700: support clone, persistence and pause/resume

File:

• branches/TSNE/HeuristicLab.Algorithms.DataAnalysis/3.4/TSNE/TSNEStatic.cs (modified) (5 diffs)

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

@@ -60 +60 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Random;
@@ -65 +66 @@
 namespace HeuristicLab.Algorithms.DataAnalysis {
   [StorableClass]
-  public class TSNE<T> {
+  public class TSNEStatic<T> {
 
     [StorableClass]
@@ -166 +167 @@
       }
 
+      [StorableConstructor]
+      public TSNEState(bool deserializing)  { }
       public TSNEState(T[] data, IDistance<T> distance, IRandom random, int newDimensions, double perplexity, double theta, int stopLyingIter, int momSwitchIter, double momentum, double finalMomentum, double eta) {
         this.distance = distance;
@@ -525 +528 @@
         for(var i = 0; i < noElem; i++) symValP[i] /= 2.0;
       }
-
     }
 
-    public static TSNEState CreateState(T[] data, IDistance<T> distance, IRandom random, int newDimensions = 2, double perplexity = 25, double theta = 0,
-      int stopLyingIter = 250, int momSwitchIter = 250, double momentum = .5, double finalMomentum = .8, double eta = 200.0
+    /// <summary>
+    /// Simple interface to tSNE
+    /// </summary>
+    /// <param name="data"></param>
+    /// <param name="distance">The distance function used to differentiate similar from non-similar points, e.g. Euclidean distance.</param>
+    /// <param name="random">Random number generator</param>
+    /// <param name="newDimensions">Dimensionality of projected space (usually 2 for easy visual analysis).</param>
+    /// <param name="perplexity">Perplexity parameter of tSNE. Comparable to k in a k-nearest neighbour algorithm. Recommended value is floor(number of points /3) or lower</param>
+    /// <param name="iterations">Maximum number of iterations for gradient descent.</param>
+    /// <param name="theta">Value describing how much appoximated gradients my differ from exact gradients. Set to 0 for exact calculation and in [0,1] otherwise. CAUTION: exact calculation of forces requires building a non-sparse N*N matrix where N is the number of data points. This may exceed memory limitations.</param>
+    /// <param name="stopLyingIter">Number of iterations after which p is no longer approximated.</param>
+    /// <param name="momSwitchIter">Number of iterations after which the momentum in the gradient descent is switched.</param>
+    /// <param name="momentum">The initial momentum in the gradient descent.</param>
+    /// <param name="finalMomentum">The final momentum in gradient descent (after momentum switch).</param>
+    /// <param name="eta">Gradient descent learning rate.</param>
+    /// <returns></returns>
+    public static double[,] Run(T[] data, IDistance<T> distance, IRandom random,
+      int newDimensions = 2, double perplexity = 25, int iterations = 1000,
+      double theta = 0,
+      int stopLyingIter = 250, int momSwitchIter = 250, double momentum = .5,
+      double finalMomentum = .8, double eta = 200.0
+      ) {
+      var state = CreateState(data, distance, random, newDimensions, perplexity,
+        theta, stopLyingIter, momSwitchIter, momentum, finalMomentum, eta);
+
+      for(int i = 0; i < iterations - 1; i++) {
+        Iterate(state);
+      }
+      return Iterate(state);
+    }
+
+    public static TSNEState CreateState(T[] data, IDistance<T> distance, IRandom random,
+      int newDimensions = 2, double perplexity = 25, double theta = 0,
+      int stopLyingIter = 250, int momSwitchIter = 250, double momentum = .5,
+      double finalMomentum = .8, double eta = 200.0
       ) {
       return new TSNEState(data, distance, random, newDimensions, perplexity, theta, stopLyingIter, momSwitchIter, momentum, finalMomentum, eta);
@@ -564 +599 @@
       // Make solution zero-mean
       ZeroMean(state.newData);
+
       // Stop lying about the P-values after a while, and switch momentum
-
       if(state.iter == state.stopLyingIter) {
         if(state.exact)
-          for(var i = 0; i < state.noDatapoints; i++) for(var j = 0; j < state.noDatapoints; j++) state.p[i, j] /= 12.0;                                   //XXX why 12?
+          for(var i = 0; i < state.noDatapoints; i++)
+            for(var j = 0; j < state.noDatapoints; j++)
+              state.p[i, j] /= 12.0;                                   //XXX why 12?
         else
-          for(var i = 0; i < state.rowP[state.noDatapoints]; i++) state.valP[i] /= 12.0;                       // XXX are we not scaling all values? 
+          for(var i = 0; i < state.rowP[state.noDatapoints]; i++)
+            state.valP[i] /= 12.0;                       // XXX are we not scaling all values? 
       }