@elarsaks/umap-wasm 0.4.6 → 0.4.8

package/dist/umap.d.ts

@@ -99,7 +99,6 @@ export declare class UMAP {
     private optimizeLayout;
     private optimizeLayoutBatchWasm;
     private materializeEmbeddingFromWasm;
-    private advanceRngState;
     private getNEpochs;
 }
 export declare function euclidean(x: Vector, y: Vector): number;

package/dist/umap.js

@@ -484,6 +484,8 @@ export class UMAP {
         if (this.useWasmOptimizer && wasmBridge.isWasmAvailable()) {
             const { head, tail, nEpochs, nVertices, a, b } = this.optimizationState;
             this.wasmOptimizerState = wasmBridge.createOptimizerState(head, tail, headEmbedding, tailEmbedding, epochsPerSample, epochsPerNegativeSample, moveOther, learningRate, repulsionStrength, a, b, dim, nEpochs, nVertices);
+            this.rngState = BigInt(Math.floor(this.random() * 0xFFFFFFFF));
+            this.wasmOptimizerState.set_rng_seed(this.rngState);
         }
     }
     initializeOptimization() {
@@ -507,8 +509,7 @@ export class UMAP {
     }
     optimizeLayoutStep(n) {
         if (this.useWasmOptimizer && this.wasmOptimizerState) {
-            wasmBridge.optimizeLayoutStepInPlaceWasm(this.wasmOptimizerState, this.rngState);
-            this.advanceRngState(1);
+            wasmBridge.optimizeLayoutStepInPlaceWasm(this.wasmOptimizerState);
             this.optimizationState.currentEpoch += 1;
             return this.materializeEmbeddingFromWasm();
         }
@@ -657,8 +658,7 @@ export class UMAP {
         if (actualSteps <= 0) {
             return 0;
         }
-        wasmBridge.optimizeLayoutBatchInPlaceWasm(this.wasmOptimizerState, this.rngState, actualSteps);
-        this.advanceRngState(actualSteps);
+        wasmBridge.optimizeLayoutBatchInPlaceWasm(this.wasmOptimizerState, actualSteps);
         this.optimizationState.currentEpoch += actualSteps;
         return actualSteps;
     }
@@ -680,13 +680,6 @@ export class UMAP {
         this.embedding = embedding;
         return embedding;
     }
-    advanceRngState(steps) {
-        const A = BigInt('6364136223846793005');
-        const C = BigInt('1442695040888963407');
-        for (let i = 0; i < steps; i++) {
-            this.rngState = (this.rngState * A + C) & BigInt('0xFFFFFFFFFFFFFFFF');
-        }
-    }
     getNEpochs() {
         const graph = this.graph;
         if (this.nEpochs > 0) {

package/dist/wasmBridge.d.ts

@@ -64,16 +64,18 @@ export declare function wasmSparseMatrixGetAllTyped(matrix: WasmSparseMatrix): {
 export declare function nnDescentWasm(data: number[][], leafArray: ArrayLike<number>[], nNeighbors: number, nIters?: number, maxCandidates?: number, delta?: number, rho?: number, rpTreeInit?: boolean, distanceMetric?: string, seed?: number): number[][][];
 export declare function nnDescentWasmFlat(flatData: Float64Array, nSamples: number, dim: number, flatLeafArray: Int32Array, nLeaves: number, leafSize: number, nNeighbors: number, nIters?: number, maxCandidates?: number, delta?: number, rho?: number, rpTreeInit?: boolean, distanceMetric?: string, seed?: number): number[];
 export interface WasmOptimizerState {
-    head_embedding: Float64Array;
+    head_embedding: Float32Array;
     current_epoch: number;
     n_epochs: number;
     head_embedding_ptr(): number;
     head_embedding_len(): number;
+    set_rng_seed(seed: bigint): void;
+    rng_seed(): bigint;
     free(): void;
 }
 export declare function createOptimizerState(head: number[], tail: number[], headEmbedding: number[][], tailEmbedding: number[][], epochsPerSample: number[], epochsPerNegativeSample: number[], moveOther: boolean, initialAlpha: number, gamma: number, a: number, b: number, dim: number, nEpochs: number, nVertices: number): WasmOptimizerState;
-export declare function optimizeLayoutStepWasm(state: WasmOptimizerState, rngSeed: bigint): Float64Array;
-export declare function optimizeLayoutStepInPlaceWasm(state: WasmOptimizerState, rngSeed: bigint): void;
-export declare function optimizeLayoutBatchWasm(state: WasmOptimizerState, rngSeed: bigint, nSteps: number): Float64Array;
-export declare function optimizeLayoutBatchInPlaceWasm(state: WasmOptimizerState, rngSeed: bigint, nSteps: number): void;
-export declare function getOptimizerEmbeddingView(state: WasmOptimizerState): Float64Array;
+export declare function optimizeLayoutStepWasm(state: WasmOptimizerState): Float32Array;
+export declare function optimizeLayoutStepInPlaceWasm(state: WasmOptimizerState): void;
+export declare function optimizeLayoutBatchWasm(state: WasmOptimizerState, nSteps: number): Float32Array;
+export declare function optimizeLayoutBatchInPlaceWasm(state: WasmOptimizerState, nSteps: number): void;
+export declare function getOptimizerEmbeddingView(state: WasmOptimizerState): Float32Array;

package/dist/wasmBridge.js

@@ -273,8 +273,8 @@ export function nnDescentWasmFlat(flatData, nSamples, dim, flatLeafArray, nLeave
 export function createOptimizerState(head, tail, headEmbedding, tailEmbedding, epochsPerSample, epochsPerNegativeSample, moveOther, initialAlpha, gamma, a, b, dim, nEpochs, nVertices) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    const flatHeadEmbedding = new Float64Array(headEmbedding.length * dim);
-    const flatTailEmbedding = new Float64Array(tailEmbedding.length * dim);
+    const flatHeadEmbedding = new Float32Array(headEmbedding.length * dim);
+    const flatTailEmbedding = new Float32Array(tailEmbedding.length * dim);
     for (let i = 0; i < headEmbedding.length; i++) {
         for (let j = 0; j < dim; j++) {
             flatHeadEmbedding[i * dim + j] = headEmbedding[i][j];
@@ -287,29 +287,29 @@ export function createOptimizerState(head, tail, headEmbedding, tailEmbedding, e
     }
     const headArray = new Uint32Array(head);
     const tailArray = new Uint32Array(tail);
-    const epochsPerSampleArray = new Float64Array(epochsPerSample);
-    const epochsPerNegativeSampleArray = new Float64Array(epochsPerNegativeSample);
+    const epochsPerSampleArray = new Float32Array(epochsPerSample);
+    const epochsPerNegativeSampleArray = new Float32Array(epochsPerNegativeSample);
     return new wasmModule.OptimizerState(headArray, tailArray, flatHeadEmbedding, flatTailEmbedding, epochsPerSampleArray, epochsPerNegativeSampleArray, moveOther, initialAlpha, gamma, a, b, dim, nEpochs, nVertices);
 }
-export function optimizeLayoutStepWasm(state, rngSeed) {
+export function optimizeLayoutStepWasm(state) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    return wasmModule.optimize_layout_step(state, rngSeed);
+    return wasmModule.optimize_layout_step(state);
 }
-export function optimizeLayoutStepInPlaceWasm(state, rngSeed) {
+export function optimizeLayoutStepInPlaceWasm(state) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    wasmModule.optimize_layout_step_in_place(state, rngSeed);
+    wasmModule.optimize_layout_step_in_place(state);
 }
-export function optimizeLayoutBatchWasm(state, rngSeed, nSteps) {
+export function optimizeLayoutBatchWasm(state, nSteps) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    return wasmModule.optimize_layout_batch(state, rngSeed, nSteps);
+    return wasmModule.optimize_layout_batch(state, nSteps);
 }
-export function optimizeLayoutBatchInPlaceWasm(state, rngSeed, nSteps) {
+export function optimizeLayoutBatchInPlaceWasm(state, nSteps) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    wasmModule.optimize_layout_batch_in_place(state, rngSeed, nSteps);
+    wasmModule.optimize_layout_batch_in_place(state, nSteps);
 }
 export function getOptimizerEmbeddingView(state) {
     if (!wasmModule)
@@ -322,5 +322,5 @@ export function getOptimizerEmbeddingView(state) {
     if (!memory?.buffer) {
         throw new Error('WASM memory is not available');
     }
-    return new Float64Array(memory.buffer, ptr, len);
+    return new Float32Array(memory.buffer, ptr, len);
 }

package/lib/umap-js.js

@@ -6747,8 +6747,8 @@ function nnDescentWasmFlat(flatData, nSamples, dim, flatLeafArray, nLeaves, leaf
 function createOptimizerState(head, tail, headEmbedding, tailEmbedding, epochsPerSample, epochsPerNegativeSample, moveOther, initialAlpha, gamma, a, b, dim, nEpochs, nVertices) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    const flatHeadEmbedding = new Float64Array(headEmbedding.length * dim);
-    const flatTailEmbedding = new Float64Array(tailEmbedding.length * dim);
+    const flatHeadEmbedding = new Float32Array(headEmbedding.length * dim);
+    const flatTailEmbedding = new Float32Array(tailEmbedding.length * dim);
     for (let i = 0; i < headEmbedding.length; i++) {
         for (let j = 0; j < dim; j++) {
             flatHeadEmbedding[i * dim + j] = headEmbedding[i][j];
@@ -6761,29 +6761,29 @@ function createOptimizerState(head, tail, headEmbedding, tailEmbedding, epochsPe
     }
     const headArray = new Uint32Array(head);
     const tailArray = new Uint32Array(tail);
-    const epochsPerSampleArray = new Float64Array(epochsPerSample);
-    const epochsPerNegativeSampleArray = new Float64Array(epochsPerNegativeSample);
+    const epochsPerSampleArray = new Float32Array(epochsPerSample);
+    const epochsPerNegativeSampleArray = new Float32Array(epochsPerNegativeSample);
     return new wasmModule.OptimizerState(headArray, tailArray, flatHeadEmbedding, flatTailEmbedding, epochsPerSampleArray, epochsPerNegativeSampleArray, moveOther, initialAlpha, gamma, a, b, dim, nEpochs, nVertices);
 }
-function optimizeLayoutStepWasm(state, rngSeed) {
+function optimizeLayoutStepWasm(state) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    return wasmModule.optimize_layout_step(state, rngSeed);
+    return wasmModule.optimize_layout_step(state);
 }
-function optimizeLayoutStepInPlaceWasm(state, rngSeed) {
+function optimizeLayoutStepInPlaceWasm(state) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    wasmModule.optimize_layout_step_in_place(state, rngSeed);
+    wasmModule.optimize_layout_step_in_place(state);
 }
-function optimizeLayoutBatchWasm(state, rngSeed, nSteps) {
+function optimizeLayoutBatchWasm(state, nSteps) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    return wasmModule.optimize_layout_batch(state, rngSeed, nSteps);
+    return wasmModule.optimize_layout_batch(state, nSteps);
 }
-function optimizeLayoutBatchInPlaceWasm(state, rngSeed, nSteps) {
+function optimizeLayoutBatchInPlaceWasm(state, nSteps) {
     if (!wasmModule)
         throw new Error('WASM module not initialized');
-    wasmModule.optimize_layout_batch_in_place(state, rngSeed, nSteps);
+    wasmModule.optimize_layout_batch_in_place(state, nSteps);
 }
 function getOptimizerEmbeddingView(state) {
     if (!wasmModule)
@@ -6796,7 +6796,7 @@ function getOptimizerEmbeddingView(state) {
     if (!memory?.buffer) {
         throw new Error('WASM memory is not available');
     }
-    return new Float64Array(memory.buffer, ptr, len);
+    return new Float32Array(memory.buffer, ptr, len);
 }
 
 ;// ./src/tree.ts
@@ -8118,6 +8118,8 @@ class UMAP {
         if (this.useWasmOptimizer && isWasmAvailable()) {
             const { head, tail, nEpochs, nVertices, a, b } = this.optimizationState;
             this.wasmOptimizerState = createOptimizerState(head, tail, headEmbedding, tailEmbedding, epochsPerSample, epochsPerNegativeSample, moveOther, learningRate, repulsionStrength, a, b, dim, nEpochs, nVertices);
+            this.rngState = BigInt(Math.floor(this.random() * 0xFFFFFFFF));
+            this.wasmOptimizerState.set_rng_seed(this.rngState);
         }
     }
     initializeOptimization() {
@@ -8141,8 +8143,7 @@ class UMAP {
     }
     optimizeLayoutStep(n) {
         if (this.useWasmOptimizer && this.wasmOptimizerState) {
-            optimizeLayoutStepInPlaceWasm(this.wasmOptimizerState, this.rngState);
-            this.advanceRngState(1);
+            optimizeLayoutStepInPlaceWasm(this.wasmOptimizerState);
             this.optimizationState.currentEpoch += 1;
             return this.materializeEmbeddingFromWasm();
         }
@@ -8291,8 +8292,7 @@ class UMAP {
         if (actualSteps <= 0) {
             return 0;
         }
-        optimizeLayoutBatchInPlaceWasm(this.wasmOptimizerState, this.rngState, actualSteps);
-        this.advanceRngState(actualSteps);
+        optimizeLayoutBatchInPlaceWasm(this.wasmOptimizerState, actualSteps);
         this.optimizationState.currentEpoch += actualSteps;
         return actualSteps;
     }
@@ -8314,13 +8314,6 @@ class UMAP {
         this.embedding = embedding;
         return embedding;
     }
-    advanceRngState(steps) {
-        const A = BigInt('6364136223846793005');
-        const C = BigInt('1442695040888963407');
-        for (let i = 0; i < steps; i++) {
-            this.rngState = (this.rngState * A + C) & BigInt('0xFFFFFFFFFFFFFFFF');
-        }
-    }
     getNEpochs() {
         const graph = this.graph;
         if (this.nEpochs > 0) {