wasm-bhtsne 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Francesco Iannelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+<div align="center"> <h1 align="center"> wasm-bhtsne </h1> </div>
+
+<div align="center">
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+This is the wasm version of the [bhtsne](https://github.com/frjnn/bhtsne) crate.
+
+Parallel implementations of Barnes-Hut and exact implementations of the t-SNE algorithm written in Rust to run in wasm. The tree-accelerated version of the algorithm is described with fine detail in [this paper](http://lvdmaaten.github.io/publications/papers/JMLR_2014.pdf) by [Laurens van der Maaten](https://github.com/lvdmaaten). The exact, original, version of the algorithm is described in [this other paper](https://www.jmlr.org/papers/volume9/vandermaaten08a/vandermaaten08a.pdf) by [G. Hinton](https://www.cs.toronto.edu/~hinton/) and Laurens van der Maaten.
+Additional implementations of the algorithm, are listed at [this page](http://lvdmaaten.github.io/tsne/).
+
+## Installation 
+
+Add this line to your `Cargo.toml`:
+```toml
+[dependencies]
+bhtsne = "0.5.2"
+```
+### Documentation
+
+The API documentation is available [here](https://docs.rs/bhtsne).
+
+### Example
+
+The implementation supports custom data types and custom defined metrics. For instance, general vector data can be handled in the following way.
+
+```javascript
+import {tSNE} from "wasm-bhtsne";
+
+const data = [];
+
+for (let i = 0; i < 300; i++) {
+    const randomNumber = Math.random();
+    data.push(randomNumber);
+}
+
+const tsne_encoder = new tSNE(data, 4);
+tsne_encoder.exact();
+const embedded_stuff = tsne_encoder.embedding();
+
+console.log(embedded_stuff);
+```
+
+In the example euclidean distance is used, but any other distance metric on data types of choice, such as strings, can be defined and plugged in. 
+
+## Parallelism 
+Being built on [rayon](https://github.com/rayon-rs/rayon), the algorithm uses the same number of threads as the number of CPUs available. Do note that on systems with hyperthreading enabled this equals the number of logical cores and not the physical ones. See [rayon's FAQs](https://github.com/rayon-rs/rayon/blob/master/FAQ.md) for additional informations.
+
+## MNIST embedding
+The following embedding has been obtained by preprocessing the [MNIST](https://git-disl.github.io/GTDLBench/datasets/mnist_datasets/) train set using PCA to reduce its 
+dimensionality to 50. It took approximately **3 minutes and 6 seconds** on a 2.0GHz quad-core 10th-generation i5 MacBook Pro. 
+![mnist](imgs/mnist_embedding.png) 

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "wasm-bhtsne",
+  "collaborators": [
+    "lv291 <baiunco291@proton.me>"
+  ],
+  "description": "Exact and Barnes-Hut implementations of t-SNE in wasm",
+  "version": "0.1.2",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Lv-291/wasm-bhtsne"
+  },
+  "files": [
+    "wasm_bhtsne_bg.wasm",
+    "wasm_bhtsne.js",
+    "wasm_bhtsne_bg.js",
+    "wasm_bhtsne.d.ts"
+  ],
+  "module": "wasm_bhtsne.js",
+  "types": "wasm_bhtsne.d.ts",
+  "sideEffects": [
+    "./wasm_bhtsne.js",
+    "./snippets/*"
+  ]
+}

package/wasm_bhtsne.d.ts

@@ -0,0 +1,103 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+* t-distributed stochastic neighbor embedding. Provides a parallel implementation of both the
+* exact version of the algorithm and the tree accelerated one leveraging space partitioning trees.
+*/
+export class tSNE {
+  free(): void;
+/**
+* @param {Float32Array} data
+* @param {number} d
+*/
+  constructor(data: Float32Array, d: number);
+/**
+* Returns the computed embedding.
+* @returns {Float32Array}
+*/
+  embedding(): Float32Array;
+/**
+* Performs a parallel exact version of the t-SNE algorithm. Pairwise distances between samples
+* in the input space will be computed accordingly to the supplied function `distance_f`.
+*
+* # Arguments
+*
+* `distance_f` - distance function.
+*
+* **Do note** that such a distance function needs not to be a metric distance, i.e. it is not
+* necessary for it so satisfy the triangle inequality. Consequently, the squared euclidean
+* distance, and many other, can be used.
+*/
+  exact(): void;
+/**
+* Sets a new value for the embedding dimension.
+*
+* # Arguments
+*
+* `embedding_dim` - new value for the embedding space dimensionality.
+*/
+  embedding_dim: number;
+/**
+* Sets new epochs, i.e the maximum number of fitting iterations.
+*
+* # Arguments
+*
+* `epochs` - new value for the epochs.
+*/
+  epochs: number;
+/**
+* Sets a new final momentum.
+*
+* # Arguments
+*
+* `final_momentum` - new value for the final momentum.
+*/
+  final_momentum: number;
+/**
+* Sets a new learning rate.
+*
+* # Arguments
+*
+* `learning_rate` - new value for the learning rate.
+*/
+  learning_rate: number;
+/**
+* Sets a new momentum.
+*
+* # Arguments
+*
+* `momentum` - new value for the momentum.
+*/
+  momentum: number;
+/**
+* Sets a new momentum switch epoch, i.e. the epoch after which the algorithm switches to
+* `final_momentum` for the map update.
+*
+* # Arguments
+*
+* `momentum_switch_epoch` - new value for the momentum switch epoch.
+*/
+  momentum_switch_epoch: number;
+/**
+* Sets a new perplexity value.
+*
+* # Arguments
+*
+* `perplexity` - new value for the perplexity. It's used so that the bandwidth of the Gaussian
+*  kernels, is set in such a way that the perplexity of each the conditional distribution *Pi*
+*  equals a predefined perplexity *u*.
+*
+* A good value for perplexity lies between 5.0 and 50.0.
+*/
+  perplexity: number;
+/**
+* Sets a new stop lying epoch, i.e. the epoch after which the P distribution values become
+* true, as defined in the original implementation. For epochs < `stop_lying_epoch` the values
+* of the P distribution are multiplied by a factor equal to `12.0`.
+*
+* # Arguments
+*
+* `stop_lying_epoch` - new value for the stop lying epoch.
+*/
+  stop_lying_epoch: number;
+}

package/wasm_bhtsne.js

@@ -0,0 +1,4 @@
+import * as wasm from "./wasm_bhtsne_bg.wasm";
+import { __wbg_set_wasm } from "./wasm_bhtsne_bg.js";
+__wbg_set_wasm(wasm);
+export * from "./wasm_bhtsne_bg.js";

package/wasm_bhtsne_bg.js

@@ -0,0 +1,484 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+let cachedFloat32Memory0 = null;
+
+function getFloat32Memory0() {
+    if (cachedFloat32Memory0 === null || cachedFloat32Memory0.byteLength === 0) {
+        cachedFloat32Memory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32Memory0;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32Memory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32Memory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
+
+let cachedTextEncoder = new lTextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+/**
+* t-distributed stochastic neighbor embedding. Provides a parallel implementation of both the
+* exact version of the algorithm and the tree accelerated one leveraging space partitioning trees.
+*/
+export class tSNE {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(tSNE.prototype);
+        obj.__wbg_ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tsne_free(ptr);
+    }
+    /**
+    * @param {Float32Array} data
+    * @param {number} d
+    */
+    constructor(data, d) {
+        const ptr0 = passArrayF32ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tsne_new(ptr0, len0, d);
+        return tSNE.__wrap(ret);
+    }
+    /**
+    * Sets a new learning rate.
+    *
+    * # Arguments
+    *
+    * `learning_rate` - new value for the learning rate.
+    * @param {number} learning_rate
+    */
+    set learning_rate(learning_rate) {
+        wasm.tsne_set_learning_rate(this.__wbg_ptr, learning_rate);
+    }
+    /**
+    * Sets new epochs, i.e the maximum number of fitting iterations.
+    *
+    * # Arguments
+    *
+    * `epochs` - new value for the epochs.
+    * @param {number} epochs
+    */
+    set epochs(epochs) {
+        wasm.tsne_set_epochs(this.__wbg_ptr, epochs);
+    }
+    /**
+    * Sets a new momentum.
+    *
+    * # Arguments
+    *
+    * `momentum` - new value for the momentum.
+    * @param {number} momentum
+    */
+    set momentum(momentum) {
+        wasm.tsne_set_momentum(this.__wbg_ptr, momentum);
+    }
+    /**
+    * Sets a new final momentum.
+    *
+    * # Arguments
+    *
+    * `final_momentum` - new value for the final momentum.
+    * @param {number} final_momentum
+    */
+    set final_momentum(final_momentum) {
+        wasm.tsne_set_final_momentum(this.__wbg_ptr, final_momentum);
+    }
+    /**
+    * Sets a new momentum switch epoch, i.e. the epoch after which the algorithm switches to
+    * `final_momentum` for the map update.
+    *
+    * # Arguments
+    *
+    * `momentum_switch_epoch` - new value for the momentum switch epoch.
+    * @param {number} momentum_switch_epoch
+    */
+    set momentum_switch_epoch(momentum_switch_epoch) {
+        wasm.tsne_set_momentum_switch_epoch(this.__wbg_ptr, momentum_switch_epoch);
+    }
+    /**
+    * Sets a new stop lying epoch, i.e. the epoch after which the P distribution values become
+    * true, as defined in the original implementation. For epochs < `stop_lying_epoch` the values
+    * of the P distribution are multiplied by a factor equal to `12.0`.
+    *
+    * # Arguments
+    *
+    * `stop_lying_epoch` - new value for the stop lying epoch.
+    * @param {number} stop_lying_epoch
+    */
+    set stop_lying_epoch(stop_lying_epoch) {
+        wasm.tsne_set_stop_lying_epoch(this.__wbg_ptr, stop_lying_epoch);
+    }
+    /**
+    * Sets a new value for the embedding dimension.
+    *
+    * # Arguments
+    *
+    * `embedding_dim` - new value for the embedding space dimensionality.
+    * @param {number} embedding_dim
+    */
+    set embedding_dim(embedding_dim) {
+        wasm.tsne_set_embedding_dim(this.__wbg_ptr, embedding_dim);
+    }
+    /**
+    * Sets a new perplexity value.
+    *
+    * # Arguments
+    *
+    * `perplexity` - new value for the perplexity. It's used so that the bandwidth of the Gaussian
+    *  kernels, is set in such a way that the perplexity of each the conditional distribution *Pi*
+    *  equals a predefined perplexity *u*.
+    *
+    * A good value for perplexity lies between 5.0 and 50.0.
+    * @param {number} perplexity
+    */
+    set perplexity(perplexity) {
+        wasm.tsne_set_perplexity(this.__wbg_ptr, perplexity);
+    }
+    /**
+    * Returns the computed embedding.
+    * @returns {Float32Array}
+    */
+    embedding() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.tsne_embedding(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var v1 = getArrayF32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Performs a parallel exact version of the t-SNE algorithm. Pairwise distances between samples
+    * in the input space will be computed accordingly to the supplied function `distance_f`.
+    *
+    * # Arguments
+    *
+    * `distance_f` - distance function.
+    *
+    * **Do note** that such a distance function needs not to be a metric distance, i.e. it is not
+    * necessary for it so satisfy the triangle inequality. Consequently, the squared euclidean
+    * distance, and many other, can be used.
+    */
+    exact() {
+        wasm.tsne_exact(this.__wbg_ptr);
+    }
+}
+
+export function __wbg_new_abda76e883ba8a5f() {
+    const ret = new Error();
+    return addHeapObject(ret);
+};
+
+export function __wbg_stack_658279fe44541cf6(arg0, arg1) {
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+export function __wbg_error_f851667af71bcfc6(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+};
+
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};
+
+export function __wbg_randomFillSync_dc1e9a60c158336d() { return handleError(function (arg0, arg1) {
+    getObject(arg0).randomFillSync(takeObject(arg1));
+}, arguments) };
+
+export function __wbg_getRandomValues_37fa2ca9e4e07fab() { return handleError(function (arg0, arg1) {
+    getObject(arg0).getRandomValues(getObject(arg1));
+}, arguments) };
+
+export function __wbg_crypto_c48a774b022d20ac(arg0) {
+    const ret = getObject(arg0).crypto;
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_is_object(arg0) {
+    const val = getObject(arg0);
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+export function __wbg_process_298734cf255a885d(arg0) {
+    const ret = getObject(arg0).process;
+    return addHeapObject(ret);
+};
+
+export function __wbg_versions_e2e78e134e3e5d01(arg0) {
+    const ret = getObject(arg0).versions;
+    return addHeapObject(ret);
+};
+
+export function __wbg_node_1cd7a5d853dbea79(arg0) {
+    const ret = getObject(arg0).node;
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_is_string(arg0) {
+    const ret = typeof(getObject(arg0)) === 'string';
+    return ret;
+};
+
+export function __wbg_require_8f08ceecec0f4fee() { return handleError(function () {
+    const ret = module.require;
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbindgen_string_new(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+export function __wbg_msCrypto_bcb970640f50a1e8(arg0) {
+    const ret = getObject(arg0).msCrypto;
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_is_function(arg0) {
+    const ret = typeof(getObject(arg0)) === 'function';
+    return ret;
+};
+
+export function __wbg_newnoargs_581967eacc0e2604(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_call_cb65541d95d71282() { return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).call(getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_self_1ff1d729e9aae938() { return handleError(function () {
+    const ret = self.self;
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_window_5f4faef6c12b79ec() { return handleError(function () {
+    const ret = window.window;
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_globalThis_1d39714405582d3c() { return handleError(function () {
+    const ret = globalThis.globalThis;
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_global_651f05c6a0944d1c() { return handleError(function () {
+    const ret = global.global;
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbindgen_is_undefined(arg0) {
+    const ret = getObject(arg0) === undefined;
+    return ret;
+};
+
+export function __wbg_call_01734de55d61e11d() { return handleError(function (arg0, arg1, arg2) {
+    const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_buffer_085ec1f694018c4f(arg0) {
+    const ret = getObject(arg0).buffer;
+    return addHeapObject(ret);
+};
+
+export function __wbg_newwithbyteoffsetandlength_6da8e527659b86aa(arg0, arg1, arg2) {
+    const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_8125e318e6245eed(arg0) {
+    const ret = new Uint8Array(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_set_5cf90238115182c3(arg0, arg1, arg2) {
+    getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+};
+
+export function __wbg_newwithlength_e5d69174d6984cd7(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_subarray_13db269f57aa838d(arg0, arg1, arg2) {
+    const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_object_clone_ref(arg0) {
+    const ret = getObject(arg0);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_throw(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbindgen_memory() {
+    const ret = wasm.memory;
+    return addHeapObject(ret);
+};
+