Fix #60 - Can now handle datasets with dimensions > points

Stop Math.floor calculations causing zeros & ddd test for points < dimensions. Pass this verbose from tsne to knn, and extra knn logging. (#63)

src/dataset_util.ts

@@ -142,7 +142,8 @@ export function generateKNNClusterTexture(
     numNeighbors: number): {knnGraph: WebGLTexture, dataShape: RearrangedData} {
   // Computing data shape
   const pointsPerRow =
-      Math.floor(Math.sqrt(numPoints * numNeighbors) / numNeighbors);
+      Math.max(1,
+        Math.floor(Math.sqrt(numPoints * numNeighbors) / numNeighbors));
   const numRows = Math.ceil(numPoints / pointsPerRow);
   const dataShape =
       {numPoints, pixelsPerPoint: numNeighbors, numRows, pointsPerRow};
@@ -178,7 +179,8 @@ export function generateKNNLineTexture(numPoints: number, numNeighbors: number):
     {knnGraph: WebGLTexture, dataShape: RearrangedData} {
   // Computing data shape
   const pointsPerRow =
-      Math.floor(Math.sqrt(numPoints * numNeighbors) / numNeighbors);
+      Math.max(1,
+        Math.floor(Math.sqrt(numPoints * numNeighbors) / numNeighbors));
   const numRows = Math.ceil(numPoints / pointsPerRow);
   const dataShape =
       {numPoints, pixelsPerPoint: numNeighbors, numRows, pointsPerRow};

src/knn.ts

@@ -142,6 +142,9 @@ export class KNNEstimator {
         initNeigh[(i * numNeighs + n) * 2 + 1] = 10e30;
       }
     }
+    this.log('knn-textureWidth', this.knnDataShape.pointsPerRow *
+              this.knnDataShape.pixelsPerPoint);
+    this.log('knn-textureHeight', this.knnDataShape.numRows);
     this.knnTexture0 = gl_util.createAndConfigureTexture(
         this.gpgpu.gl,
         this.knnDataShape.pointsPerRow * this.knnDataShape.pixelsPerPoint,
@@ -154,13 +157,18 @@ export class KNNEstimator {
   }
 
   private initilizeCustomWebGLPrograms(distanceComputationSource: string) {
+    this.log('knn Create programs/buffers start');
     this.copyDistancesProgram = knn_util.createCopyDistancesProgram(this.gpgpu);
+    this.log('knn Create indices program');
     this.copyIndicesProgram = knn_util.createCopyIndicesProgram(this.gpgpu);
 
+    this.log('knn Create brute force knn program, numNeighs', this.numNeighs);
     this.bruteForceKNNProgram = knn_util.createBruteForceKNNProgram(
         this.gpgpu, this.numNeighs, distanceComputationSource);
+    this.log('knn Create random sampling force knn program');
     this.randomSamplingKNNProgram = knn_util.createRandomSamplingKNNProgram(
         this.gpgpu, this.numNeighs, distanceComputationSource);
+    this.log('knn Create descent program');
     this.kNNDescentProgram = knn_util.createKNNDescentProgram(
         this.gpgpu, this.numNeighs, distanceComputationSource);
 
@@ -170,8 +178,10 @@ export class KNNEstimator {
         linesVertexId[i] = i;
       }
     }
+    this.log('knn Create static vertex start');
     this.linesVertexIdBuffer = tf.webgl.webgl_util.createStaticVertexBuffer(
         this.gpgpu.gl, linesVertexId);
+    this.log('knn Create programs/buffers done');
   }
 
   iterateBruteForce() {

src/tensor_to_data_texture.ts

@@ -45,7 +45,8 @@ export async function tensorToDataTexture(tensor: tf.Tensor):
   const numChannels = 4;
   const pixelsPerPoint = Math.ceil(numDimensions / numChannels);
   const pointsPerRow =
-      Math.floor(Math.sqrt(numPoints * pixelsPerPoint) / pixelsPerPoint);
+      Math.max(1,
+        Math.floor(Math.sqrt(numPoints * pixelsPerPoint) / pixelsPerPoint));
   const numRows = Math.ceil(numPoints / pointsPerRow);
 
   const tensorData = tensor.dataSync();

src/tsne.ts

@@ -156,7 +156,7 @@ export class TSNE {
 
     this.knnEstimator = new KNNEstimator(
         this.packedData.texture, this.packedData.shape, this.numPoints,
-        this.numDimensions, this.numNeighbors, false);
+        this.numDimensions, this.numNeighbors, this.verbose);
 
     this.optimizer = new TSNEOptimizer(this.numPoints, false);
     const exaggerationPolyline = [

src/tsne_optimizer.ts

@@ -309,7 +309,8 @@ export class TSNEOptimizer {
                                         indices: Uint32Array): Promise<void> {
     // Computing the shape of the knnGraphTexture
     const pointsPerRow =
-        Math.floor(Math.sqrt(numPoints * numNeighbors) / numNeighbors);
+        Math.max(1,
+          Math.floor(Math.sqrt(numPoints * numNeighbors) / numNeighbors));
     const numRows = Math.ceil(numPoints / pointsPerRow);
     const dataShape =
         {numPoints, pixelsPerPoint : numNeighbors, numRows, pointsPerRow};

src/tsne_test.ts

@@ -20,10 +20,9 @@ import * as tf_tsne from './tsne';
 
 /**
  * Returns a simple dataset for testing
+ * Defaults to numPoints = 300, numDimensions = 10
  */
-function generateData() {
-  const numPoints = 300;
-  const numDimensions = 10;
+function generateData(numPoints = 300, numDimensions = 10) {
   const data = tf.tidy(() => {
     return tf.linspace(0, 1, numPoints * numDimensions)
         .reshape([ numPoints, numDimensions ])
@@ -79,3 +78,34 @@ describe('TSNE class', () => {
        data.dispose();
      });
 });
+
+describe('TSNE class', () => {
+  it('iterateKnn and iterate also work when the number of ' +
+    'dimensions is larger than the number of points',
+    async () => {
+      const data = generateData(100, 20000);
+      const testOpt = tf_tsne.tsne(data, {
+          perplexity : 15,
+          verbose : false,
+          knnMode : 'auto',
+      });
+
+      try {
+        await testOpt.iterateKnn(10);
+      } catch(e) {
+        fail('iterateKnn threw exception: ${e}');
+      }
+
+      try {
+        await testOpt.iterate(10);
+      } catch(e) {
+        fail('iterate threw exception: ${e}');
+      }
+
+      const coords = await testOpt.coordinates();
+      expect(coords.shape[0]).toBe(100);
+      expect(coords.shape[1]).toBe(2);
+      data.dispose();
+      return;
+    });
+});