umap-gpu 0.2.14 → 0.2.15

package/dist/index.js

@@ -1,56 +1,56 @@
 var te = Object.defineProperty;
 var ne = (e, t, f) => t in e ? te(e, t, { enumerable: !0, configurable: !0, writable: !0, value: f }) : e[t] = f;
-var C = (e, t, f) => ne(e, typeof t != "symbol" ? t + "" : t, f);
+var R = (e, t, f) => ne(e, typeof t != "symbol" ? t + "" : t, f);
 import { loadHnswlib as H } from "hnswlib-wasm";
 async function se(e, t, f = {}) {
-  const { M: a = 16, efConstruction: s = 200, efSearch: u = 50 } = f, c = await H(), d = e[0].length, i = e.length, n = new c.HierarchicalNSW("l2", d, "");
-  n.initIndex(i, a, s, 200), n.setEfSearch(Math.max(u, t)), n.addItems(e, !1);
-  const r = [], o = [];
-  for (let h = 0; h < i; h++) {
+  const { M: a = 16, efConstruction: s = 200, efSearch: u = 50 } = f, c = await H(), d = e[0].length, o = e.length, n = new c.HierarchicalNSW("l2", d, "");
+  n.initIndex(o, a, s, 200), n.setEfSearch(Math.max(u, t)), n.addItems(e, !1);
+  const r = [], i = [];
+  for (let h = 0; h < o; h++) {
     const l = n.searchKnn(e[h], t + 1, void 0), p = l.neighbors.map((g, _) => ({ idx: g, dist: l.distances[_] })).filter(({ idx: g }) => g !== h).slice(0, t);
-    r.push(p.map(({ idx: g }) => g)), o.push(p.map(({ dist: g }) => Math.sqrt(g)));
+    r.push(p.map(({ idx: g }) => g)), i.push(p.map(({ dist: g }) => Math.sqrt(g)));
   }
-  return { indices: r, distances: o };
+  return { indices: r, distances: i };
 }
 async function ae(e, t, f = {}) {
-  const { M: a = 16, efConstruction: s = 200, efSearch: u = 50 } = f, c = await H(), d = e[0].length, i = e.length, n = new c.HierarchicalNSW("l2", d, "");
-  n.initIndex(i, a, s, 200), n.setEfSearch(Math.max(u, t)), n.addItems(e, !1);
-  const r = [], o = [];
-  for (let l = 0; l < i; l++) {
+  const { M: a = 16, efConstruction: s = 200, efSearch: u = 50 } = f, c = await H(), d = e[0].length, o = e.length, n = new c.HierarchicalNSW("l2", d, "");
+  n.initIndex(o, a, s, 200), n.setEfSearch(Math.max(u, t)), n.addItems(e, !1);
+  const r = [], i = [];
+  for (let l = 0; l < o; l++) {
     const p = n.searchKnn(e[l], t + 1, void 0), g = p.neighbors.map((_, m) => ({ idx: _, dist: p.distances[m] })).filter(({ idx: _ }) => _ !== l).slice(0, t);
-    r.push(g.map(({ idx: _ }) => _)), o.push(g.map(({ dist: _ }) => Math.sqrt(_)));
+    r.push(g.map(({ idx: _ }) => _)), i.push(g.map(({ dist: _ }) => Math.sqrt(_)));
   }
-  return { knn: { indices: r, distances: o }, index: {
+  return { knn: { indices: r, distances: i }, index: {
     searchKnn(l, p) {
       const g = [], _ = [];
       for (const m of l) {
-        const y = n.searchKnn(m, p, void 0), b = y.neighbors.map((x, v) => ({ idx: x, dist: y.distances[v] })).sort((x, v) => x.dist - v.dist).slice(0, p);
-        g.push(b.map(({ idx: x }) => x)), _.push(b.map(({ dist: x }) => Math.sqrt(x)));
+        const b = n.searchKnn(m, p, void 0), y = b.neighbors.map((x, v) => ({ idx: x, dist: b.distances[v] })).sort((x, v) => x.dist - v.dist).slice(0, p);
+        g.push(y.map(({ idx: x }) => x)), _.push(y.map(({ dist: x }) => Math.sqrt(x)));
       }
       return { indices: g, distances: _ };
     }
   } };
 }
 function V(e, t, f, a = 1) {
-  const s = e.length, { sigmas: u, rhos: c } = Y(t, f), d = [], i = [], n = [];
-  for (let o = 0; o < s; o++)
-    for (let h = 0; h < e[o].length; h++) {
-      const l = t[o][h], p = l <= c[o] ? 1 : Math.exp(-((l - c[o]) / u[o]));
-      d.push(o), i.push(e[o][h]), n.push(p);
+  const s = e.length, { sigmas: u, rhos: c } = Y(t, f), d = [], o = [], n = [];
+  for (let i = 0; i < s; i++)
+    for (let h = 0; h < e[i].length; h++) {
+      const l = t[i][h], p = l <= c[i] ? 1 : Math.exp(-((l - c[i]) / u[i]));
+      d.push(i), o.push(e[i][h]), n.push(p);
     }
-  return { ...oe(d, i, n, s, a), nVertices: s };
+  return { ...ie(d, o, n, s, a), nVertices: s };
 }
 function re(e, t, f) {
-  const a = e.length, { sigmas: s, rhos: u } = Y(t, f), c = [], d = [], i = [];
+  const a = e.length, { sigmas: s, rhos: u } = Y(t, f), c = [], d = [], o = [];
   for (let n = 0; n < a; n++)
     for (let r = 0; r < e[n].length; r++) {
-      const o = t[n][r], h = o <= u[n] ? 1 : Math.exp(-((o - u[n]) / s[n]));
-      c.push(n), d.push(e[n][r]), i.push(h);
+      const i = t[n][r], h = i <= u[n] ? 1 : Math.exp(-((i - u[n]) / s[n]));
+      c.push(n), d.push(e[n][r]), o.push(h);
     }
   return {
     rows: new Uint32Array(c),
     cols: new Uint32Array(d),
-    vals: new Float32Array(i),
+    vals: new Float32Array(o),
     nVertices: a
   };
 }
@@ -59,35 +59,35 @@ function Y(e, t) {
   for (let c = 0; c < a; c++) {
     const d = e[c];
     u[c] = d.find((h) => h > 0) ?? 0;
-    let i = 0, n = 1 / 0, r = 1;
-    const o = Math.log2(t);
+    let o = 0, n = 1 / 0, r = 1;
+    const i = Math.log2(t);
     for (let h = 0; h < 64; h++) {
       let l = 0;
       for (let p = 0; p < d.length; p++)
         l += Math.exp(-Math.max(0, d[p] - u[c]) / r);
-      if (Math.abs(l - o) < 1e-5) break;
-      l > o ? (n = r, r = (i + n) / 2) : (i = r, r = n === 1 / 0 ? r * 2 : (i + n) / 2);
+      if (Math.abs(l - i) < 1e-5) break;
+      l > i ? (n = r, r = (o + n) / 2) : (o = r, r = n === 1 / 0 ? r * 2 : (o + n) / 2);
     }
     s[c] = r;
   }
   return { sigmas: s, rhos: u };
 }
-function oe(e, t, f, a, s) {
+function ie(e, t, f, a, s) {
   const u = /* @__PURE__ */ new Map();
   for (let n = 0; n < e.length; n++)
     u.set(e[n] * a + t[n], f[n]);
-  const c = [], d = [], i = [];
+  const c = [], d = [], o = [];
   for (const [n, r] of u) {
-    const o = Math.floor(n / a), h = n % a, l = u.get(h * a + o) ?? 0, p = r + l - r * l, g = r * l;
-    c.push(o), d.push(h), i.push(s * p + (1 - s) * g);
+    const i = Math.floor(n / a), h = n % a, l = u.get(h * a + i) ?? 0, p = r + l - r * l, g = r * l;
+    c.push(i), d.push(h), o.push(s * p + (1 - s) * g);
   }
   return {
     rows: new Uint32Array(c),
     cols: new Uint32Array(d),
-    vals: new Float32Array(i)
+    vals: new Float32Array(o)
   };
 }
-const ie = `// UMAP SGD compute shader — processes one graph edge per GPU thread.
+const oe = `// UMAP SGD compute shader — processes one graph edge per GPU thread.
 // Computes attraction and repulsion forces and accumulates them atomically
 // into a forces buffer. A separate apply-forces pass then updates embeddings,
 // eliminating write-write races on shared vertex positions.
@@ -181,7 +181,10 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     epoch_of_next_negative_sample[edge_idx] += f32(n_neg) * epochs_per_neg;
   }
 
-  var rng = xorshift(rng_seeds[edge_idx] + params.current_epoch * 6364136223u);
+  // 2654435761u is the 32-bit golden-ratio hash constant (0x9E3779B1),
+  // which fits in u32 unlike the 64-bit LCG value 6364136223 used originally.
+  // Bug 14 fix: the original constant exceeded u32 range and failed WGSL validation.
+  var rng = xorshift(rng_seeds[edge_idx] + params.current_epoch * 2654435761u);
 
   for (var s = 0u; s < n_neg; s++) {
     rng = xorshift(rng);
@@ -250,9 +253,9 @@ async function he() {
 }
 class X {
   constructor() {
-    C(this, "device");
-    C(this, "sgdPipeline");
-    C(this, "applyForcesPipeline");
+    R(this, "device");
+    R(this, "sgdPipeline");
+    R(this, "applyForcesPipeline");
   }
   async init() {
     const t = await Q();
@@ -260,7 +263,7 @@ class X {
     this.device = t, this.sgdPipeline = this.device.createComputePipeline({
       layout: "auto",
       compute: {
-        module: this.device.createShaderModule({ code: ie }),
+        module: this.device.createShaderModule({ code: oe }),
         entryPoint: "main"
       }
     }), this.applyForcesPipeline = this.device.createComputePipeline({
@@ -284,22 +287,22 @@ class X {
    * @param params      - UMAP curve parameters and repulsion settings
    * @returns Optimized embedding as Float32Array
    */
-  async optimize(t, f, a, s, u, c, d, i, n) {
-    const { device: r } = this, o = f.length, h = u * c, l = this.makeBuffer(
+  async optimize(t, f, a, s, u, c, d, o, n) {
+    const { device: r } = this, i = f.length, h = u * c, l = this.makeBuffer(
       t,
       GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
-    ), p = this.makeBuffer(f, GPUBufferUsage.STORAGE), g = this.makeBuffer(a, GPUBufferUsage.STORAGE), _ = this.makeBuffer(s, GPUBufferUsage.STORAGE), m = new Float32Array(s), y = this.makeBuffer(m, GPUBufferUsage.STORAGE), b = new Float32Array(o);
-    for (let A = 0; A < o; A++)
-      b[A] = s[A] / i.negativeSampleRate;
-    const x = this.makeBuffer(b, GPUBufferUsage.STORAGE), v = new Uint32Array(o);
-    for (let A = 0; A < o; A++)
+    ), p = this.makeBuffer(f, GPUBufferUsage.STORAGE), g = this.makeBuffer(a, GPUBufferUsage.STORAGE), _ = this.makeBuffer(s, GPUBufferUsage.STORAGE), m = new Float32Array(s), b = this.makeBuffer(m, GPUBufferUsage.STORAGE), y = new Float32Array(i);
+    for (let A = 0; A < i; A++)
+      y[A] = s[A] / o.negativeSampleRate;
+    const x = this.makeBuffer(y, GPUBufferUsage.STORAGE), v = new Uint32Array(i);
+    for (let A = 0; A < i; A++)
       v[A] = Math.random() * 4294967295 | 0;
-    const P = this.makeBuffer(v, GPUBufferUsage.STORAGE), G = r.createBuffer({
+    const G = this.makeBuffer(v, GPUBufferUsage.STORAGE), P = r.createBuffer({
       size: h * 4,
       usage: GPUBufferUsage.STORAGE,
       mappedAtCreation: !0
     });
-    new Int32Array(G.getMappedRange()).fill(0), G.unmap();
+    new Int32Array(P.getMappedRange()).fill(0), P.unmap();
     const U = r.createBuffer({
       size: 40,
       usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
@@ -313,37 +316,37 @@ class X {
         { binding: 1, resource: { buffer: p } },
         { binding: 2, resource: { buffer: g } },
         { binding: 3, resource: { buffer: l } },
-        { binding: 4, resource: { buffer: y } },
+        { binding: 4, resource: { buffer: b } },
         { binding: 5, resource: { buffer: x } },
         { binding: 6, resource: { buffer: U } },
-        { binding: 7, resource: { buffer: P } },
-        { binding: 8, resource: { buffer: G } }
+        { binding: 7, resource: { buffer: G } },
+        { binding: 8, resource: { buffer: P } }
       ]
     }), M = r.createBindGroup({
       layout: this.applyForcesPipeline.getBindGroupLayout(0),
       entries: [
         { binding: 0, resource: { buffer: l } },
-        { binding: 1, resource: { buffer: G } },
+        { binding: 1, resource: { buffer: P } },
         { binding: 2, resource: { buffer: F } }
       ]
     });
     for (let A = 0; A < d; A++) {
       const B = 1 - A / d, O = new ArrayBuffer(40), S = new Uint32Array(O), k = new Float32Array(O);
-      S[0] = o, S[1] = u, S[2] = c, S[3] = A, S[4] = d, k[5] = B, k[6] = i.a, k[7] = i.b, k[8] = i.gamma, S[9] = i.negativeSampleRate, r.queue.writeBuffer(U, 0, O);
+      S[0] = i, S[1] = u, S[2] = c, S[3] = A, S[4] = d, k[5] = B, k[6] = o.a, k[7] = o.b, k[8] = o.gamma, S[9] = o.negativeSampleRate, r.queue.writeBuffer(U, 0, O);
       const D = new ArrayBuffer(16), $ = new Uint32Array(D), ee = new Float32Array(D);
       $[0] = h, ee[1] = B, r.queue.writeBuffer(F, 0, D);
       const T = r.createCommandEncoder(), q = T.beginComputePass();
-      q.setPipeline(this.sgdPipeline), q.setBindGroup(0, N), q.dispatchWorkgroups(Math.ceil(o / 256)), q.end();
-      const I = T.beginComputePass();
-      I.setPipeline(this.applyForcesPipeline), I.setBindGroup(0, M), I.dispatchWorkgroups(Math.ceil(h / 256)), I.end(), r.queue.submit([T.finish()]), A % 10 === 0 && (await r.queue.onSubmittedWorkDone(), n == null || n(A, d));
+      q.setPipeline(this.sgdPipeline), q.setBindGroup(0, N), q.dispatchWorkgroups(Math.ceil(i / 256)), q.end();
+      const L = T.beginComputePass();
+      L.setPipeline(this.applyForcesPipeline), L.setBindGroup(0, M), L.dispatchWorkgroups(Math.ceil(h / 256)), L.end(), r.queue.submit([T.finish()]), A % 10 === 0 && (await r.queue.onSubmittedWorkDone(), n == null || n(A, d));
     }
     const E = r.createBuffer({
       size: t.byteLength,
       usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
     }), w = r.createCommandEncoder();
     w.copyBufferToBuffer(l, 0, E, 0, t.byteLength), r.queue.submit([w.finish()]), await E.mapAsync(GPUMapMode.READ);
-    const R = new Float32Array(E.getMappedRange().slice(0));
-    return E.unmap(), l.destroy(), p.destroy(), g.destroy(), _.destroy(), y.destroy(), x.destroy(), P.destroy(), G.destroy(), U.destroy(), F.destroy(), E.destroy(), R;
+    const C = new Float32Array(E.getMappedRange().slice(0));
+    return E.unmap(), l.destroy(), p.destroy(), g.destroy(), _.destroy(), b.destroy(), x.destroy(), G.destroy(), P.destroy(), U.destroy(), F.destroy(), E.destroy(), C;
   }
   makeBuffer(t, f) {
     const a = this.device.createBuffer({
@@ -354,34 +357,34 @@ class X {
     return t instanceof Float32Array ? new Float32Array(a.getMappedRange()).set(t) : new Uint32Array(a.getMappedRange()).set(t), a.unmap(), a;
   }
 }
-function j(e) {
+function I(e) {
   return Math.max(-4, Math.min(4, e));
 }
-function L(e, t, f, a, s, u, c, d) {
-  const { a: i, b: n, gamma: r = 1, negativeSampleRate: o = 5 } = c, h = t.rows.length, l = new Uint32Array(t.rows), p = new Uint32Array(t.cols), g = new Float32Array(f), _ = new Float32Array(h);
+function j(e, t, f, a, s, u, c, d) {
+  const { a: o, b: n, gamma: r = 1, negativeSampleRate: i = 5 } = c, h = t.rows.length, l = new Uint32Array(t.rows), p = new Uint32Array(t.cols), g = new Float32Array(f), _ = new Float32Array(h);
   for (let m = 0; m < h; m++)
-    _[m] = f[m] / o;
+    _[m] = f[m] / i;
   for (let m = 0; m < u; m++) {
     d == null || d(m, u);
-    const y = 1 - m / u;
-    for (let b = 0; b < h; b++) {
-      if (g[b] > m) continue;
-      const x = l[b], v = p[b];
-      let P = 0;
+    const b = 1 - m / u;
+    for (let y = 0; y < h; y++) {
+      if (g[y] > m) continue;
+      const x = l[y], v = p[y];
+      let G = 0;
       for (let M = 0; M < s; M++) {
         const E = e[x * s + M] - e[v * s + M];
-        P += E * E;
+        G += E * E;
       }
-      const G = Math.pow(P, n), U = -2 * i * n * (P > 0 ? G / P : 0) / (i * G + 1);
+      const P = Math.pow(G, n), U = -2 * o * n * (G > 0 ? P / G : 0) / (o * P + 1);
       for (let M = 0; M < s; M++) {
-        const E = e[x * s + M] - e[v * s + M], w = j(U * E);
-        e[x * s + M] += y * w, e[v * s + M] -= y * w;
+        const E = e[x * s + M] - e[v * s + M], w = I(U * E);
+        e[x * s + M] += b * w, e[v * s + M] -= b * w;
       }
-      g[b] += f[b];
-      const F = f[b] / o, N = Math.max(0, Math.floor(
-        (m - _[b]) / F
+      g[y] += f[y];
+      const F = f[y] / i, N = Math.max(0, Math.floor(
+        (m - _[y]) / F
       ));
-      _[b] += N * F;
+      _[y] += N * F;
       for (let M = 0; M < N; M++) {
         const E = Math.floor(Math.random() * a);
         if (E === x) continue;
@@ -390,52 +393,52 @@ function L(e, t, f, a, s, u, c, d) {
           const O = e[x * s + B] - e[E * s + B];
           w += O * O;
         }
-        const R = Math.pow(w, n), A = 2 * r * n / ((1e-3 + w) * (i * R + 1));
+        const C = Math.pow(w, n), A = 2 * r * n / ((1e-3 + w) * (o * C + 1));
         for (let B = 0; B < s; B++) {
-          const O = e[x * s + B] - e[E * s + B], S = j(A * O);
-          e[x * s + B] += y * S;
+          const O = e[x * s + B] - e[E * s + B], S = I(A * O);
+          e[x * s + B] += b * S;
         }
       }
     }
   }
   return e;
 }
-function fe(e, t, f, a, s, u, c, d, i, n) {
-  const { a: r, b: o, gamma: h = 1, negativeSampleRate: l = 5 } = i, p = f.rows.length, g = new Uint32Array(f.rows), _ = new Uint32Array(f.cols), m = new Float32Array(a), y = new Float32Array(p);
-  for (let b = 0; b < p; b++)
-    y[b] = a[b] / l;
-  for (let b = 0; b < d; b++) {
-    const x = 1 - b / d;
+function fe(e, t, f, a, s, u, c, d, o, n) {
+  const { a: r, b: i, gamma: h = 1, negativeSampleRate: l = 5 } = o, p = f.rows.length, g = new Uint32Array(f.rows), _ = new Uint32Array(f.cols), m = new Float32Array(a), b = new Float32Array(p);
+  for (let y = 0; y < p; y++)
+    b[y] = a[y] / l;
+  for (let y = 0; y < d; y++) {
+    const x = 1 - y / d;
     for (let v = 0; v < p; v++) {
-      if (m[v] > b) continue;
-      const P = g[v], G = _[v];
+      if (m[v] > y) continue;
+      const G = g[v], P = _[v];
       let U = 0;
       for (let w = 0; w < c; w++) {
-        const R = e[P * c + w] - t[G * c + w];
-        U += R * R;
+        const C = e[G * c + w] - t[P * c + w];
+        U += C * C;
       }
-      const F = Math.pow(U, o), N = -2 * r * o * (U > 0 ? F / U : 0) / (r * F + 1);
+      const F = Math.pow(U, i), N = -2 * r * i * (U > 0 ? F / U : 0) / (r * F + 1);
       for (let w = 0; w < c; w++) {
-        const R = e[P * c + w] - t[G * c + w];
-        e[P * c + w] += x * j(N * R);
+        const C = e[G * c + w] - t[P * c + w];
+        e[G * c + w] += x * I(N * C);
       }
       m[v] += a[v];
       const M = a[v] / l, E = Math.max(0, Math.floor(
-        (b - y[v]) / M
+        (y - b[v]) / M
       ));
-      y[v] += E * M;
+      b[v] += E * M;
       for (let w = 0; w < E; w++) {
-        const R = Math.floor(Math.random() * u);
-        if (R === G) continue;
+        const C = Math.floor(Math.random() * u);
+        if (C === P) continue;
         let A = 0;
         for (let S = 0; S < c; S++) {
-          const k = e[P * c + S] - t[R * c + S];
+          const k = e[G * c + S] - t[C * c + S];
           A += k * k;
         }
-        const B = Math.pow(A, o), O = 2 * h * o / ((1e-3 + A) * (r * B + 1));
+        const B = Math.pow(A, i), O = 2 * h * i / ((1e-3 + A) * (r * B + 1));
         for (let S = 0; S < c; S++) {
-          const k = e[P * c + S] - t[R * c + S];
-          e[P * c + S] += x * j(O * k);
+          const k = e[G * c + S] - t[C * c + S];
+          e[G * c + S] += x * I(O * k);
         }
       }
     }
@@ -449,7 +452,7 @@ async function pe(e, t = {}, f) {
     minDist: u = 0.1,
     spread: c = 1,
     hnsw: d = {}
-  } = t, i = t.nEpochs ?? (e.length > 1e4 ? 200 : 500);
+  } = t, o = t.nEpochs ?? (e.length > 1e4 ? 200 : 500);
   console.time("knn");
   const { indices: n, distances: r } = await se(e, s, {
     M: d.M ?? 16,
@@ -457,32 +460,32 @@ async function pe(e, t = {}, f) {
     efSearch: d.efSearch ?? 50
   });
   console.timeEnd("knn"), console.time("fuzzy-set");
-  const o = V(n, r, s);
+  const i = V(n, r, s);
   console.timeEnd("fuzzy-set");
-  const { a: h, b: l } = Z(u, c), p = W(o.vals), g = e.length, _ = new Float32Array(g * a);
-  for (let y = 0; y < _.length; y++)
-    _[y] = Math.random() * 20 - 10;
+  const { a: h, b: l } = Z(u, c), p = W(i.vals), g = e.length, _ = new Float32Array(g * a);
+  for (let b = 0; b < _.length; b++)
+    _[b] = Math.random() * 20 - 10;
   console.time("sgd");
   let m;
   if (J())
     try {
-      const y = new X();
-      await y.init(), m = await y.optimize(
+      const b = new X();
+      await b.init(), m = await b.optimize(
         _,
-        new Uint32Array(o.rows),
-        new Uint32Array(o.cols),
+        new Uint32Array(i.rows),
+        new Uint32Array(i.cols),
         p,
         g,
         a,
-        i,
+        o,
         { a: h, b: l, gamma: 1, negativeSampleRate: 5 },
         f
       );
-    } catch (y) {
-      console.warn("WebGPU SGD failed, falling back to CPU:", y), m = L(_, o, p, g, a, i, { a: h, b: l }, f);
+    } catch (b) {
+      console.warn("WebGPU SGD failed, falling back to CPU:", b), m = j(_, i, p, g, a, o, { a: h, b: l }, f);
     }
   else
-    m = L(_, o, p, g, a, i, { a: h, b: l }, f);
+    m = j(_, i, p, g, a, o, { a: h, b: l }, f);
   return console.timeEnd("sgd"), m;
 }
 function Z(e, t) {
@@ -490,45 +493,45 @@ function Z(e, t) {
 }
 function de(e, t) {
   const a = [], s = [];
-  for (let i = 0; i < 299; i++) {
-    const n = (i + 1) / 299 * t * 3;
+  for (let o = 0; o < 299; o++) {
+    const n = (o + 1) / 299 * t * 3;
     a.push(n), s.push(n < e ? 1 : Math.exp(-(n - e) / t));
   }
   let u = 1, c = 1, d = 1e-3;
-  for (let i = 0; i < 500; i++) {
-    let n = 0, r = 0, o = 0, h = 0, l = 0, p = 0;
+  for (let o = 0; o < 500; o++) {
+    let n = 0, r = 0, i = 0, h = 0, l = 0, p = 0;
     for (let U = 0; U < 299; U++) {
       const F = a[U], N = Math.pow(F, 2 * c), M = 1 + u * N, w = 1 / M - s[U];
       p += w * w;
-      const R = M * M, A = -N / R, B = F > 0 ? -2 * Math.log(F) * u * N / R : 0;
-      n += A * w, r += B * w, o += A * A, h += B * B, l += A * B;
+      const C = M * M, A = -N / C, B = F > 0 ? -2 * Math.log(F) * u * N / C : 0;
+      n += A * w, r += B * w, i += A * A, h += B * B, l += A * B;
     }
-    const g = o + d, _ = h + d, m = l, y = g * _ - m * m;
-    if (Math.abs(y) < 1e-20) break;
-    const b = -(_ * n - m * r) / y, x = -(g * r - m * n) / y, v = Math.max(1e-4, u + b), P = Math.max(1e-4, c + x);
-    let G = 0;
+    const g = i + d, _ = h + d, m = l, b = g * _ - m * m;
+    if (Math.abs(b) < 1e-20) break;
+    const y = -(_ * n - m * r) / b, x = -(g * r - m * n) / b, v = Math.max(1e-4, u + y), G = Math.max(1e-4, c + x);
+    let P = 0;
     for (let U = 0; U < 299; U++) {
-      const F = Math.pow(a[U], 2 * P), N = 1 / (1 + v * F) - s[U];
-      G += N * N;
+      const F = Math.pow(a[U], 2 * G), N = 1 / (1 + v * F) - s[U];
+      P += N * N;
     }
-    if (G < p ? (u = v, c = P, d = Math.max(1e-10, d / 10)) : d = Math.min(1e10, d * 10), Math.abs(b) < 1e-8 && Math.abs(x) < 1e-8) break;
+    if (P < p ? (u = v, c = G, d = Math.max(1e-10, d / 10)) : d = Math.min(1e10, d * 10), Math.abs(y) < 1e-8 && Math.abs(x) < 1e-8) break;
   }
   return { a: u, b: c };
 }
 class ge {
   constructor(t = {}) {
-    C(this, "_nComponents");
-    C(this, "_nNeighbors");
-    C(this, "_minDist");
-    C(this, "_spread");
-    C(this, "_nEpochs");
-    C(this, "_hnswOpts");
-    C(this, "_a");
-    C(this, "_b");
+    R(this, "_nComponents");
+    R(this, "_nNeighbors");
+    R(this, "_minDist");
+    R(this, "_spread");
+    R(this, "_nEpochs");
+    R(this, "_hnswOpts");
+    R(this, "_a");
+    R(this, "_b");
     /** The low-dimensional embedding produced by the last fit() call. */
-    C(this, "embedding", null);
-    C(this, "_hnswIndex", null);
-    C(this, "_nTrain", 0);
+    R(this, "embedding", null);
+    R(this, "_hnswIndex", null);
+    R(this, "_nTrain", 0);
     this._nComponents = t.nComponents ?? 2, this._nNeighbors = t.nNeighbors ?? 15, this._minDist = t.minDist ?? 0.1, this._spread = t.spread ?? 1, this._nEpochs = t.nEpochs, this._hnswOpts = t.hnsw ?? {};
     const { a: f, b: a } = Z(this._minDist, this._spread);
     this._a = f, this._b = a;
@@ -542,15 +545,15 @@ class ge {
   async fit(t, f) {
     const a = t.length, s = this._nEpochs ?? (a > 1e4 ? 200 : 500), { M: u = 16, efConstruction: c = 200, efSearch: d = 50 } = this._hnswOpts;
     console.time("knn");
-    const { knn: i, index: n } = await ae(t, this._nNeighbors, {
+    const { knn: o, index: n } = await ae(t, this._nNeighbors, {
       M: u,
       efConstruction: c,
       efSearch: d
     });
     this._hnswIndex = n, this._nTrain = a, console.timeEnd("knn"), console.time("fuzzy-set");
-    const r = V(i.indices, i.distances, this._nNeighbors);
+    const r = V(o.indices, o.distances, this._nNeighbors);
     console.timeEnd("fuzzy-set");
-    const o = W(r.vals), h = new Float32Array(a * this._nComponents);
+    const i = W(r.vals), h = new Float32Array(a * this._nComponents);
     for (let l = 0; l < h.length; l++)
       h[l] = Math.random() * 20 - 10;
     if (console.time("sgd"), J())
@@ -560,7 +563,7 @@ class ge {
           h,
           new Uint32Array(r.rows),
           new Uint32Array(r.cols),
-          o,
+          i,
           a,
           this._nComponents,
           s,
@@ -568,13 +571,13 @@ class ge {
           f
         );
       } catch (l) {
-        console.warn("WebGPU SGD failed, falling back to CPU:", l), this.embedding = L(h, r, o, a, this._nComponents, s, {
+        console.warn("WebGPU SGD failed, falling back to CPU:", l), this.embedding = j(h, r, i, a, this._nComponents, s, {
           a: this._a,
           b: this._b
         }, f);
       }
     else
-      this.embedding = L(h, r, o, a, this._nComponents, s, {
+      this.embedding = j(h, r, i, a, this._nComponents, s, {
         a: this._a,
         b: this._b
       }, f);
@@ -594,22 +597,22 @@ class ge {
   async transform(t, f = !1) {
     if (!this._hnswIndex || !this.embedding)
       throw new Error("UMAP.transform() must be called after fit()");
-    const a = t.length, s = this._nEpochs ?? (this._nTrain > 1e4 ? 200 : 500), u = Math.max(100, Math.floor(s / 4)), c = this._hnswIndex.searchKnn(t, this._nNeighbors), d = re(c.indices, c.distances, this._nNeighbors), i = new Uint32Array(d.rows), n = new Uint32Array(d.cols), r = new Float32Array(a), o = new Float32Array(a * this._nComponents);
-    for (let p = 0; p < i.length; p++) {
-      const g = i[p], _ = n[p], m = d.vals[p];
+    const a = t.length, s = this._nEpochs ?? (this._nTrain > 1e4 ? 200 : 500), u = Math.max(100, Math.floor(s / 4)), c = this._hnswIndex.searchKnn(t, this._nNeighbors), d = re(c.indices, c.distances, this._nNeighbors), o = new Uint32Array(d.rows), n = new Uint32Array(d.cols), r = new Float32Array(a), i = new Float32Array(a * this._nComponents);
+    for (let p = 0; p < o.length; p++) {
+      const g = o[p], _ = n[p], m = d.vals[p];
       r[g] += m;
-      for (let y = 0; y < this._nComponents; y++)
-        o[g * this._nComponents + y] += m * this.embedding[_ * this._nComponents + y];
+      for (let b = 0; b < this._nComponents; b++)
+        i[g * this._nComponents + b] += m * this.embedding[_ * this._nComponents + b];
     }
     for (let p = 0; p < a; p++)
       if (r[p] > 0)
         for (let g = 0; g < this._nComponents; g++)
-          o[p * this._nComponents + g] /= r[p];
+          i[p * this._nComponents + g] /= r[p];
       else
         for (let g = 0; g < this._nComponents; g++)
-          o[p * this._nComponents + g] = Math.random() * 20 - 10;
+          i[p * this._nComponents + g] = Math.random() * 20 - 10;
     const h = W(d.vals), l = fe(
-      o,
+      i,
       this.embedding,
       d,
       h,
@@ -638,13 +641,13 @@ function K(e, t, f) {
   const a = new Float32Array(e.length);
   for (let s = 0; s < f; s++) {
     let u = 1 / 0, c = -1 / 0;
-    for (let i = 0; i < t; i++) {
-      const n = e[i * f + s];
+    for (let o = 0; o < t; o++) {
+      const n = e[o * f + s];
       n < u && (u = n), n > c && (c = n);
     }
     const d = c - u;
-    for (let i = 0; i < t; i++)
-      a[i * f + s] = d > 0 ? (e[i * f + s] - u) / d : 0;
+    for (let o = 0; o < t; o++)
+      a[o * f + s] = d > 0 ? (e[o * f + s] - u) / d : 0;
   }
   return a;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umap-gpu",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "description": "UMAP with HNSW kNN and WebGPU-accelerated SGD",
   "type": "module",
   "main": "dist/index.js",
@@ -55,7 +55,8 @@
     "vite": "^5.0.0",
     "vitepress": "^1.6.4",
     "vitepress-plugin-llms": "^1.11.0",
-    "vitest": "^4.0.18"
+    "vitest": "^4.0.18",
+    "webgpu": "^0.3.8"
   },
   "license": "MIT"
 }