umap-gpu 0.2.8 → 0.2.10

package/dist/index.js

@@ -1,95 +1,90 @@
 var H = Object.defineProperty;
-var V = (t, e, i) => e in t ? H(t, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : t[e] = i;
-var E = (t, e, i) => V(t, typeof e != "symbol" ? e + "" : e, i);
+var V = (e, t, r) => t in e ? H(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var G = (e, t, r) => V(e, typeof t != "symbol" ? t + "" : t, r);
 import { loadHnswlib as C } from "hnswlib-wasm";
-async function Y(t, e, i = {}) {
-  const { M: a = 16, efConstruction: s = 200, efSearch: p = 50 } = i, f = await C(), h = t[0].length, c = t.length, o = new f.HierarchicalNSW("l2", h, "");
-  o.initIndex(c, a, s, 200), o.setEfSearch(Math.max(p, e)), o.addItems(t, !1);
-  const n = [], r = [];
-  for (let l = 0; l < c; l++) {
-    const d = o.searchKnn(t[l], e + 1, void 0), u = d.neighbors.map((g, _) => ({ idx: g, dist: d.distances[_] })).filter(({ idx: g }) => g !== l).slice(0, e);
-    n.push(u.map(({ idx: g }) => g)), r.push(u.map(({ dist: g }) => g));
+async function Y(e, t, r = {}) {
+  const { M: s = 16, efConstruction: n = 200, efSearch: p = 50 } = r, f = await C(), d = e[0].length, c = e.length, a = new f.HierarchicalNSW("l2", d, "");
+  a.initIndex(c, s, n, 200), a.setEfSearch(Math.max(p, t)), a.addItems(e, !1);
+  const o = [], i = [];
+  for (let h = 0; h < c; h++) {
+    const l = a.searchKnn(e[h], t + 1, void 0), u = l.neighbors.map((g, m) => ({ idx: g, dist: l.distances[m] })).filter(({ idx: g }) => g !== h).slice(0, t);
+    o.push(u.map(({ idx: g }) => g)), i.push(u.map(({ dist: g }) => g));
   }
-  return { indices: n, distances: r };
+  return { indices: o, distances: i };
 }
-async function J(t, e, i = {}) {
-  const { M: a = 16, efConstruction: s = 200, efSearch: p = 50 } = i, f = await C(), h = t[0].length, c = t.length, o = new f.HierarchicalNSW("l2", h, "");
-  o.initIndex(c, a, s, 200), o.setEfSearch(Math.max(p, e)), o.addItems(t, !1);
-  const n = [], r = [];
-  for (let d = 0; d < c; d++) {
-    const u = o.searchKnn(t[d], e + 1, void 0), g = u.neighbors.map((_, w) => ({ idx: _, dist: u.distances[w] })).filter(({ idx: _ }) => _ !== d).slice(0, e);
-    n.push(g.map(({ idx: _ }) => _)), r.push(g.map(({ dist: _ }) => _));
+async function Q(e, t, r = {}) {
+  const { M: s = 16, efConstruction: n = 200, efSearch: p = 50 } = r, f = await C(), d = e[0].length, c = e.length, a = new f.HierarchicalNSW("l2", d, "");
+  a.initIndex(c, s, n, 200), a.setEfSearch(Math.max(p, t)), a.addItems(e, !1);
+  const o = [], i = [];
+  for (let l = 0; l < c; l++) {
+    const u = a.searchKnn(e[l], t + 1, void 0), g = u.neighbors.map((m, w) => ({ idx: m, dist: u.distances[w] })).filter(({ idx: m }) => m !== l).slice(0, t);
+    o.push(g.map(({ idx: m }) => m)), i.push(g.map(({ dist: m }) => m));
   }
-  return { knn: { indices: n, distances: r }, index: {
-    searchKnn(d, u) {
-      const g = [], _ = [];
-      for (const w of d) {
-        const y = o.searchKnn(w, u, void 0), b = y.neighbors.map((M, x) => ({ idx: M, dist: y.distances[x] })).sort((M, x) => M.dist - x.dist).slice(0, u);
-        g.push(b.map(({ idx: M }) => M)), _.push(b.map(({ dist: M }) => M));
+  return { knn: { indices: o, distances: i }, index: {
+    searchKnn(l, u) {
+      const g = [], m = [];
+      for (const w of l) {
+        const b = a.searchKnn(w, u, void 0), y = b.neighbors.map((v, x) => ({ idx: v, dist: b.distances[x] })).sort((v, x) => v.dist - x.dist).slice(0, u);
+        g.push(y.map(({ idx: v }) => v)), m.push(y.map(({ dist: v }) => v));
       }
-      return { indices: g, distances: _ };
+      return { indices: g, distances: m };
     }
   } };
 }
-function D(t, e, i, a = 1) {
-  const s = t.length, { sigmas: p, rhos: f } = L(e, i), h = [], c = [], o = [];
-  for (let r = 0; r < s; r++)
-    for (let l = 0; l < t[r].length; l++) {
-      const d = e[r][l], u = d <= f[r] ? 1 : Math.exp(-((d - f[r]) / p[r]));
-      h.push(r), c.push(t[r][l]), o.push(u);
+function D(e, t, r, s = 1) {
+  const n = e.length, { sigmas: p, rhos: f } = L(t, r), d = [], c = [], a = [];
+  for (let i = 0; i < n; i++)
+    for (let h = 0; h < e[i].length; h++) {
+      const l = t[i][h], u = l <= f[i] ? 1 : Math.exp(-((l - f[i]) / p[i]));
+      d.push(i), c.push(e[i][h]), a.push(u);
     }
-  return { ...X(h, c, o, s, a), nVertices: s };
+  return { ...X(d, c, a, n, s), nVertices: n };
 }
-function Q(t, e, i) {
-  const a = t.length, { sigmas: s, rhos: p } = L(e, i), f = [], h = [], c = [];
-  for (let o = 0; o < a; o++)
-    for (let n = 0; n < t[o].length; n++) {
-      const r = e[o][n], l = r <= p[o] ? 1 : Math.exp(-((r - p[o]) / s[o]));
-      f.push(o), h.push(t[o][n]), c.push(l);
+function J(e, t, r) {
+  const s = e.length, { sigmas: n, rhos: p } = L(t, r), f = [], d = [], c = [];
+  for (let a = 0; a < s; a++)
+    for (let o = 0; o < e[a].length; o++) {
+      const i = t[a][o], h = i <= p[a] ? 1 : Math.exp(-((i - p[a]) / n[a]));
+      f.push(a), d.push(e[a][o]), c.push(h);
     }
   return {
     rows: new Float32Array(f),
-    cols: new Float32Array(h),
+    cols: new Float32Array(d),
     vals: new Float32Array(c),
-    nVertices: a
+    nVertices: s
   };
 }
-function L(t, e) {
-  const a = t.length, s = new Float32Array(a), p = new Float32Array(a);
-  for (let f = 0; f < a; f++) {
-    const h = t[f];
-    p[f] = h.find((l) => l > 0) ?? 0;
-    let c = 0, o = 1 / 0, n = 1;
-    const r = Math.log2(e);
-    for (let l = 0; l < 64; l++) {
-      let d = 0;
-      for (let u = 1; u < h.length; u++)
-        d += Math.exp(-Math.max(0, h[u] - p[f]) / n);
-      if (Math.abs(d - r) < 1e-5) break;
-      d > r ? (o = n, n = (c + o) / 2) : (c = n, n = o === 1 / 0 ? n * 2 : (c + o) / 2);
+function L(e, t) {
+  const s = e.length, n = new Float32Array(s), p = new Float32Array(s);
+  for (let f = 0; f < s; f++) {
+    const d = e[f];
+    p[f] = d.find((h) => h > 0) ?? 0;
+    let c = 0, a = 1 / 0, o = 1;
+    const i = Math.log2(t);
+    for (let h = 0; h < 64; h++) {
+      let l = 0;
+      for (let u = 1; u < d.length; u++)
+        l += Math.exp(-Math.max(0, d[u] - p[f]) / o);
+      if (Math.abs(l - i) < 1e-5) break;
+      l > i ? (a = o, o = (c + a) / 2) : (c = o, o = a === 1 / 0 ? o * 2 : (c + a) / 2);
     }
-    s[f] = n;
+    n[f] = o;
   }
-  return { sigmas: s, rhos: p };
+  return { sigmas: n, rhos: p };
 }
-function X(t, e, i, a, s) {
-  const p = /* @__PURE__ */ new Map(), f = (n, r, l) => {
-    const d = n * a + r;
-    p.set(d, (p.get(d) ?? 0) + l);
-  };
-  for (let n = 0; n < t.length; n++)
-    f(t[n], e[n], i[n]), f(e[n], t[n], i[n]);
-  const h = [], c = [], o = [];
-  for (const [n, r] of p.entries()) {
-    const l = Math.floor(n / a), d = n % a;
-    h.push(l), c.push(d), o.push(
-      r > 1 ? s * (2 - r) + (1 - s) * (r - 1) : r
-    );
+function X(e, t, r, s, n) {
+  const p = /* @__PURE__ */ new Map();
+  for (let a = 0; a < e.length; a++)
+    p.set(e[a] * s + t[a], r[a]);
+  const f = [], d = [], c = [];
+  for (const [a, o] of p) {
+    const i = Math.floor(a / s), h = a % s, l = p.get(h * s + i) ?? 0, u = o + l - o * l, g = o * l;
+    f.push(i), d.push(h), c.push(n * u + (1 - n) * g);
   }
   return {
-    rows: new Float32Array(h),
-    cols: new Float32Array(c),
-    vals: new Float32Array(o)
+    rows: new Float32Array(f),
+    cols: new Float32Array(d),
+    vals: new Float32Array(c)
   };
 }
 const Z = `// UMAP SGD compute shader — processes one graph edge per GPU thread.
@@ -150,8 +145,14 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     dist_sq += diff * diff;
   }
 
-  let grad_coeff_attr = -2.0 * params.a * params.b * pow(dist_sq, params.b - 1.0)
-                        / (params.a * pow(dist_sq, params.b) + 1.0);
+  let pow_b = pow(dist_sq, params.b);
+  // Guard dist_sq == 0: b-1 is negative so pow(0, b-1) = +Inf.
+  // Mirror CPU: use pow_b / dist_sq only when dist_sq > 0, else 0.
+  let grad_coeff_attr = select(
+    -2.0 * params.a * params.b * (pow_b / dist_sq) / (params.a * pow_b + 1.0),
+    0.0,
+    dist_sq == 0.0
+  );
 
   for (var d = 0u; d < nc; d++) {
     let diff = embedding[i * nc + d] - embedding[j * nc + d];
@@ -197,13 +198,13 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
 `;
 class W {
   constructor() {
-    E(this, "device");
-    E(this, "pipeline");
+    G(this, "device");
+    G(this, "pipeline");
   }
   async init() {
-    const e = await navigator.gpu.requestAdapter();
-    if (!e) throw new Error("WebGPU not supported");
-    this.device = await e.requestDevice(), this.pipeline = this.device.createComputePipeline({
+    const t = await navigator.gpu.requestAdapter();
+    if (!t) throw new Error("WebGPU not supported");
+    this.device = await t.requestDevice(), this.pipeline = this.device.createComputePipeline({
       layout: "auto",
       compute: {
         module: this.device.createShaderModule({ code: Z }),
@@ -224,218 +225,218 @@ class W {
    * @param params      - UMAP curve parameters and repulsion settings
    * @returns Optimized embedding as Float32Array
    */
-  async optimize(e, i, a, s, p, f, h, c, o) {
-    const { device: n } = this, r = i.length, l = this.makeBuffer(
-      e,
+  async optimize(t, r, s, n, p, f, d, c, a) {
+    const { device: o } = this, i = r.length, h = this.makeBuffer(
+      t,
       GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
-    ), d = this.makeBuffer(i, GPUBufferUsage.STORAGE), u = this.makeBuffer(a, GPUBufferUsage.STORAGE), g = this.makeBuffer(s, GPUBufferUsage.STORAGE), _ = new Float32Array(r).fill(0), w = this.makeBuffer(_, GPUBufferUsage.STORAGE), y = new Float32Array(r);
-    for (let m = 0; m < r; m++)
-      y[m] = s[m] / c.negativeSampleRate;
-    const b = this.makeBuffer(y, GPUBufferUsage.STORAGE), M = new Uint32Array(r);
-    for (let m = 0; m < r; m++)
-      M[m] = Math.random() * 4294967295 | 0;
-    const x = this.makeBuffer(M, GPUBufferUsage.STORAGE), B = n.createBuffer({
+    ), l = this.makeBuffer(r, GPUBufferUsage.STORAGE), u = this.makeBuffer(s, GPUBufferUsage.STORAGE), g = this.makeBuffer(n, GPUBufferUsage.STORAGE), m = new Float32Array(i).fill(0), w = this.makeBuffer(m, GPUBufferUsage.STORAGE), b = new Float32Array(i);
+    for (let _ = 0; _ < i; _++)
+      b[_] = n[_] / c.negativeSampleRate;
+    const y = this.makeBuffer(b, GPUBufferUsage.STORAGE), v = new Uint32Array(i);
+    for (let _ = 0; _ < i; _++)
+      v[_] = Math.random() * 4294967295 | 0;
+    const x = this.makeBuffer(v, GPUBufferUsage.STORAGE), B = o.createBuffer({
       size: 40,
       usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
     });
-    for (let m = 0; m < h; m++) {
-      const F = 1 - m / h, A = new ArrayBuffer(40), v = new Uint32Array(A), N = new Float32Array(A);
-      v[0] = r, v[1] = p, v[2] = f, v[3] = m, v[4] = h, N[5] = F, N[6] = c.a, N[7] = c.b, N[8] = c.gamma, v[9] = c.negativeSampleRate, n.queue.writeBuffer(B, 0, A);
-      const S = n.createBindGroup({
+    for (let _ = 0; _ < d; _++) {
+      const F = 1 - _ / d, A = new ArrayBuffer(40), M = new Uint32Array(A), N = new Float32Array(A);
+      M[0] = i, M[1] = p, M[2] = f, M[3] = _, M[4] = d, N[5] = F, N[6] = c.a, N[7] = c.b, N[8] = c.gamma, M[9] = c.negativeSampleRate, o.queue.writeBuffer(B, 0, A);
+      const S = o.createBindGroup({
         layout: this.pipeline.getBindGroupLayout(0),
         entries: [
           { binding: 0, resource: { buffer: g } },
-          { binding: 1, resource: { buffer: d } },
+          { binding: 1, resource: { buffer: l } },
           { binding: 2, resource: { buffer: u } },
-          { binding: 3, resource: { buffer: l } },
+          { binding: 3, resource: { buffer: h } },
           { binding: 4, resource: { buffer: w } },
-          { binding: 5, resource: { buffer: b } },
+          { binding: 5, resource: { buffer: y } },
           { binding: 6, resource: { buffer: B } },
           { binding: 7, resource: { buffer: x } }
         ]
-      }), k = n.createCommandEncoder(), U = k.beginComputePass();
-      U.setPipeline(this.pipeline), U.setBindGroup(0, S), U.dispatchWorkgroups(Math.ceil(r / 256)), U.end(), n.queue.submit([k.finish()]), m % 10 === 0 && (await n.queue.onSubmittedWorkDone(), o == null || o(m, h));
+      }), O = o.createCommandEncoder(), U = O.beginComputePass();
+      U.setPipeline(this.pipeline), U.setBindGroup(0, S), U.dispatchWorkgroups(Math.ceil(i / 256)), U.end(), o.queue.submit([O.finish()]), _ % 10 === 0 && (await o.queue.onSubmittedWorkDone(), a == null || a(_, d));
     }
-    const G = n.createBuffer({
-      size: e.byteLength,
+    const E = o.createBuffer({
+      size: t.byteLength,
       usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-    }), R = n.createCommandEncoder();
-    R.copyBufferToBuffer(l, 0, G, 0, e.byteLength), n.queue.submit([R.finish()]), await G.mapAsync(GPUMapMode.READ);
-    const O = new Float32Array(G.getMappedRange().slice(0));
-    return G.unmap(), l.destroy(), d.destroy(), u.destroy(), g.destroy(), w.destroy(), b.destroy(), x.destroy(), B.destroy(), G.destroy(), O;
+    }), R = o.createCommandEncoder();
+    R.copyBufferToBuffer(h, 0, E, 0, t.byteLength), o.queue.submit([R.finish()]), await E.mapAsync(GPUMapMode.READ);
+    const k = new Float32Array(E.getMappedRange().slice(0));
+    return E.unmap(), h.destroy(), l.destroy(), u.destroy(), g.destroy(), w.destroy(), y.destroy(), x.destroy(), B.destroy(), E.destroy(), k;
   }
-  makeBuffer(e, i) {
-    const a = this.device.createBuffer({
-      size: e.byteLength,
-      usage: i,
+  makeBuffer(t, r) {
+    const s = this.device.createBuffer({
+      size: t.byteLength,
+      usage: r,
       mappedAtCreation: !0
     });
-    return e instanceof Float32Array ? new Float32Array(a.getMappedRange()).set(e) : new Uint32Array(a.getMappedRange()).set(e), a.unmap(), a;
+    return t instanceof Float32Array ? new Float32Array(s.getMappedRange()).set(t) : new Uint32Array(s.getMappedRange()).set(t), s.unmap(), s;
   }
 }
-function P(t) {
-  return Math.max(-4, Math.min(4, t));
+function q(e) {
+  return Math.max(-4, Math.min(4, e));
 }
-function q(t, e, i, a, s, p, f, h) {
-  const { a: c, b: o, gamma: n = 1, negativeSampleRate: r = 5 } = f, l = e.rows.length, d = new Uint32Array(e.rows), u = new Uint32Array(e.cols), g = new Float32Array(l).fill(0), _ = new Float32Array(l);
-  for (let w = 0; w < l; w++)
-    _[w] = i[w] / r;
+function z(e, t, r, s, n, p, f, d) {
+  const { a: c, b: a, gamma: o = 1, negativeSampleRate: i = 5 } = f, h = t.rows.length, l = new Uint32Array(t.rows), u = new Uint32Array(t.cols), g = new Float32Array(h).fill(0), m = new Float32Array(h);
+  for (let w = 0; w < h; w++)
+    m[w] = r[w] / i;
   for (let w = 0; w < p; w++) {
-    h == null || h(w, p);
-    const y = 1 - w / p;
-    for (let b = 0; b < l; b++) {
-      if (g[b] > w) continue;
-      const M = d[b], x = u[b];
+    d == null || d(w, p);
+    const b = 1 - w / p;
+    for (let y = 0; y < h; y++) {
+      if (g[y] > w) continue;
+      const v = l[y], x = u[y];
       let B = 0;
-      for (let m = 0; m < s; m++) {
-        const F = t[M * s + m] - t[x * s + m];
+      for (let _ = 0; _ < n; _++) {
+        const F = e[v * n + _] - e[x * n + _];
         B += F * F;
       }
-      const G = Math.pow(B, o), R = -2 * c * o * (B > 0 ? G / B : 0) / (c * G + 1);
-      for (let m = 0; m < s; m++) {
-        const F = t[M * s + m] - t[x * s + m], A = P(R * F);
-        t[M * s + m] += y * A;
+      const E = Math.pow(B, a), R = -2 * c * a * (B > 0 ? E / B : 0) / (c * E + 1);
+      for (let _ = 0; _ < n; _++) {
+        const F = e[v * n + _] - e[x * n + _], A = q(R * F);
+        e[v * n + _] += b * A, e[x * n + _] -= b * A;
       }
-      g[b] += i[b];
-      const O = _[b] > 0 ? Math.floor(i[b] / _[b]) : 0;
-      for (let m = 0; m < O; m++) {
-        const F = Math.floor(Math.random() * a);
-        if (F === M) continue;
+      g[y] += r[y];
+      const k = m[y] > 0 ? Math.floor(r[y] / m[y]) : 0;
+      for (let _ = 0; _ < k; _++) {
+        const F = Math.floor(Math.random() * s);
+        if (F === v) continue;
         let A = 0;
-        for (let S = 0; S < s; S++) {
-          const k = t[M * s + S] - t[F * s + S];
-          A += k * k;
+        for (let S = 0; S < n; S++) {
+          const O = e[v * n + S] - e[F * n + S];
+          A += O * O;
         }
-        const v = Math.pow(A, o), N = 2 * n * o / ((1e-3 + A) * (c * v + 1));
-        for (let S = 0; S < s; S++) {
-          const k = t[M * s + S] - t[F * s + S], U = P(N * k);
-          t[M * s + S] += y * U;
+        const M = Math.pow(A, a), N = 2 * o * a / ((1e-3 + A) * (c * M + 1));
+        for (let S = 0; S < n; S++) {
+          const O = e[v * n + S] - e[F * n + S], U = q(N * O);
+          e[v * n + S] += b * U;
         }
       }
-      _[b] += i[b] / r;
+      m[y] += r[y] / i;
     }
   }
-  return t;
+  return e;
 }
-function $(t, e, i, a, s, p, f, h, c, o) {
-  const { a: n, b: r, gamma: l = 1, negativeSampleRate: d = 5 } = c, u = i.rows.length, g = new Uint32Array(i.rows), _ = new Uint32Array(i.cols), w = new Float32Array(u).fill(0), y = new Float32Array(u);
-  for (let b = 0; b < u; b++)
-    y[b] = a[b] / d;
-  for (let b = 0; b < h; b++) {
-    const M = 1 - b / h;
+function $(e, t, r, s, n, p, f, d, c, a) {
+  const { a: o, b: i, gamma: h = 1, negativeSampleRate: l = 5 } = c, u = r.rows.length, g = new Uint32Array(r.rows), m = new Uint32Array(r.cols), w = new Float32Array(u).fill(0), b = new Float32Array(u);
+  for (let y = 0; y < u; y++)
+    b[y] = s[y] / l;
+  for (let y = 0; y < d; y++) {
+    const v = 1 - y / d;
     for (let x = 0; x < u; x++) {
-      if (w[x] > b) continue;
-      const B = g[x], G = _[x];
+      if (w[x] > y) continue;
+      const B = g[x], E = m[x];
       let R = 0;
       for (let A = 0; A < f; A++) {
-        const v = t[B * f + A] - e[G * f + A];
-        R += v * v;
+        const M = e[B * f + A] - t[E * f + A];
+        R += M * M;
       }
-      const O = Math.pow(R, r), m = -2 * n * r * (R > 0 ? O / R : 0) / (n * O + 1);
+      const k = Math.pow(R, i), _ = -2 * o * i * (R > 0 ? k / R : 0) / (o * k + 1);
       for (let A = 0; A < f; A++) {
-        const v = t[B * f + A] - e[G * f + A];
-        t[B * f + A] += M * P(m * v);
+        const M = e[B * f + A] - t[E * f + A];
+        e[B * f + A] += v * q(_ * M);
       }
-      w[x] += a[x];
-      const F = y[x] > 0 ? Math.floor(a[x] / y[x]) : 0;
+      w[x] += s[x];
+      const F = b[x] > 0 ? Math.floor(s[x] / b[x]) : 0;
       for (let A = 0; A < F; A++) {
-        const v = Math.floor(Math.random() * p);
-        if (v === G) continue;
+        const M = Math.floor(Math.random() * p);
+        if (M === E) continue;
         let N = 0;
         for (let U = 0; U < f; U++) {
-          const z = t[B * f + U] - e[v * f + U];
-          N += z * z;
+          const P = e[B * f + U] - t[M * f + U];
+          N += P * P;
         }
-        const S = Math.pow(N, r), k = 2 * l * r / ((1e-3 + N) * (n * S + 1));
+        const S = Math.pow(N, i), O = 2 * h * i / ((1e-3 + N) * (o * S + 1));
         for (let U = 0; U < f; U++) {
-          const z = t[B * f + U] - e[v * f + U];
-          t[B * f + U] += M * P(k * z);
+          const P = e[B * f + U] - t[M * f + U];
+          e[B * f + U] += v * q(O * P);
         }
       }
-      y[x] += a[x] / d;
+      b[x] += s[x] / l;
     }
   }
-  return t;
+  return e;
 }
 function K() {
   return typeof navigator < "u" && !!navigator.gpu;
 }
-async function ae(t, e = {}, i) {
+async function ae(e, t = {}, r) {
   const {
-    nComponents: a = 2,
-    nNeighbors: s = 15,
+    nComponents: s = 2,
+    nNeighbors: n = 15,
     minDist: p = 0.1,
     spread: f = 1,
-    hnsw: h = {}
-  } = e, c = e.nEpochs ?? (t.length > 1e4 ? 200 : 500);
+    hnsw: d = {}
+  } = t, c = t.nEpochs ?? (e.length > 1e4 ? 200 : 500);
   console.time("knn");
-  const { indices: o, distances: n } = await Y(t, s, {
-    M: h.M ?? 16,
-    efConstruction: h.efConstruction ?? 200,
-    efSearch: h.efSearch ?? 50
+  const { indices: a, distances: o } = await Y(e, n, {
+    M: d.M ?? 16,
+    efConstruction: d.efConstruction ?? 200,
+    efSearch: d.efSearch ?? 50
   });
   console.timeEnd("knn"), console.time("fuzzy-set");
-  const r = D(o, n, s);
+  const i = D(a, o, n);
   console.timeEnd("fuzzy-set");
-  const { a: l, b: d } = j(p, f), u = I(r.vals, c), g = t.length, _ = new Float32Array(g * a);
-  for (let y = 0; y < _.length; y++)
-    _[y] = Math.random() * 20 - 10;
+  const { a: h, b: l } = j(p, f), u = I(i.vals, c), g = e.length, m = new Float32Array(g * s);
+  for (let b = 0; b < m.length; b++)
+    m[b] = Math.random() * 20 - 10;
   console.time("sgd");
   let w;
   if (K())
     try {
-      const y = new W();
-      await y.init(), w = await y.optimize(
-        _,
-        new Uint32Array(r.rows),
-        new Uint32Array(r.cols),
+      const b = new W();
+      await b.init(), w = await b.optimize(
+        m,
+        new Uint32Array(i.rows),
+        new Uint32Array(i.cols),
         u,
         g,
-        a,
+        s,
         c,
-        { a: l, b: d, gamma: 1, negativeSampleRate: 5 },
-        i
+        { a: h, b: l, gamma: 1, negativeSampleRate: 5 },
+        r
       );
-    } catch (y) {
-      console.warn("WebGPU SGD failed, falling back to CPU:", y), w = q(_, r, u, g, a, c, { a: l, b: d }, i);
+    } catch (b) {
+      console.warn("WebGPU SGD failed, falling back to CPU:", b), w = z(m, i, u, g, s, c, { a: h, b: l }, r);
     }
   else
-    w = q(_, r, u, g, a, c, { a: l, b: d }, i);
+    w = z(m, i, u, g, s, c, { a: h, b: l }, r);
   return console.timeEnd("sgd"), w;
 }
-function j(t, e) {
-  if (Math.abs(e - 1) < 1e-6 && Math.abs(t - 0.1) < 1e-6)
+function j(e, t) {
+  if (Math.abs(t - 1) < 1e-6 && Math.abs(e - 0.1) < 1e-6)
     return { a: 1.9292, b: 0.7915 };
-  if (Math.abs(e - 1) < 1e-6 && Math.abs(t - 0) < 1e-6)
+  if (Math.abs(t - 1) < 1e-6 && Math.abs(e - 0) < 1e-6)
     return { a: 1.8956, b: 0.8006 };
-  if (Math.abs(e - 1) < 1e-6 && Math.abs(t - 0.5) < 1e-6)
+  if (Math.abs(t - 1) < 1e-6 && Math.abs(e - 0.5) < 1e-6)
     return { a: 1.5769, b: 0.8951 };
-  const i = ee(t, e);
-  return { a: te(t, e, i), b: i };
+  const r = ee(e, t);
+  return { a: te(e, t, r), b: r };
 }
-function ee(t, e) {
-  return 1 / (e * 1.2);
+function ee(e, t) {
+  return 1 / (t * 1.2);
 }
-function te(t, e, i) {
-  return t < 1e-6 ? 1.8956 : (1 / (1 + 1e-3) - 1) / -Math.pow(t, 2 * i);
+function te(e, t, r) {
+  return e < 1e-6 ? 1.8956 : (1 / (1 + 1e-3) - 1) / -Math.pow(e, 2 * r);
 }
 class re {
-  constructor(e = {}) {
-    E(this, "_nComponents");
-    E(this, "_nNeighbors");
-    E(this, "_minDist");
-    E(this, "_spread");
-    E(this, "_nEpochs");
-    E(this, "_hnswOpts");
-    E(this, "_a");
-    E(this, "_b");
+  constructor(t = {}) {
+    G(this, "_nComponents");
+    G(this, "_nNeighbors");
+    G(this, "_minDist");
+    G(this, "_spread");
+    G(this, "_nEpochs");
+    G(this, "_hnswOpts");
+    G(this, "_a");
+    G(this, "_b");
     /** The low-dimensional embedding produced by the last fit() call. */
-    E(this, "embedding", null);
-    E(this, "_hnswIndex", null);
-    E(this, "_nTrain", 0);
-    this._nComponents = e.nComponents ?? 2, this._nNeighbors = e.nNeighbors ?? 15, this._minDist = e.minDist ?? 0.1, this._spread = e.spread ?? 1, this._nEpochs = e.nEpochs, this._hnswOpts = e.hnsw ?? {};
-    const { a: i, b: a } = j(this._minDist, this._spread);
-    this._a = i, this._b = a;
+    G(this, "embedding", null);
+    G(this, "_hnswIndex", null);
+    G(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: r, b: s } = j(this._minDist, this._spread);
+    this._a = r, this._b = s;
   }
   /**
    * Train UMAP on `vectors`.
@@ -443,45 +444,45 @@ class re {
    * index so that transform() can project new points later.
    * Returns `this` for chaining.
    */
-  async fit(e, i) {
-    const a = e.length, s = this._nEpochs ?? (a > 1e4 ? 200 : 500), { M: p = 16, efConstruction: f = 200, efSearch: h = 50 } = this._hnswOpts;
+  async fit(t, r) {
+    const s = t.length, n = this._nEpochs ?? (s > 1e4 ? 200 : 500), { M: p = 16, efConstruction: f = 200, efSearch: d = 50 } = this._hnswOpts;
     console.time("knn");
-    const { knn: c, index: o } = await J(e, this._nNeighbors, {
+    const { knn: c, index: a } = await Q(t, this._nNeighbors, {
       M: p,
       efConstruction: f,
-      efSearch: h
+      efSearch: d
     });
-    this._hnswIndex = o, this._nTrain = a, console.timeEnd("knn"), console.time("fuzzy-set");
-    const n = D(c.indices, c.distances, this._nNeighbors);
+    this._hnswIndex = a, this._nTrain = s, console.timeEnd("knn"), console.time("fuzzy-set");
+    const o = D(c.indices, c.distances, this._nNeighbors);
     console.timeEnd("fuzzy-set");
-    const r = I(n.vals, s), l = new Float32Array(a * this._nComponents);
-    for (let d = 0; d < l.length; d++)
-      l[d] = Math.random() * 20 - 10;
+    const i = I(o.vals, n), h = new Float32Array(s * this._nComponents);
+    for (let l = 0; l < h.length; l++)
+      h[l] = Math.random() * 20 - 10;
     if (console.time("sgd"), K())
       try {
-        const d = new W();
-        await d.init(), this.embedding = await d.optimize(
-          l,
-          new Uint32Array(n.rows),
-          new Uint32Array(n.cols),
-          r,
-          a,
-          this._nComponents,
+        const l = new W();
+        await l.init(), this.embedding = await l.optimize(
+          h,
+          new Uint32Array(o.rows),
+          new Uint32Array(o.cols),
+          i,
           s,
+          this._nComponents,
+          n,
           { a: this._a, b: this._b, gamma: 1, negativeSampleRate: 5 },
-          i
+          r
         );
-      } catch (d) {
-        console.warn("WebGPU SGD failed, falling back to CPU:", d), this.embedding = q(l, n, r, a, this._nComponents, s, {
+      } catch (l) {
+        console.warn("WebGPU SGD failed, falling back to CPU:", l), this.embedding = z(h, o, i, s, this._nComponents, n, {
           a: this._a,
           b: this._b
-        }, i);
+        }, r);
       }
     else
-      this.embedding = q(l, n, r, a, this._nComponents, s, {
+      this.embedding = z(h, o, i, s, this._nComponents, n, {
         a: this._a,
         b: this._b
-      }, i);
+      }, r);
     return console.timeEnd("sgd"), this;
   }
   /**
@@ -495,35 +496,35 @@ class re {
    *   returned embedding to [0, 1].  The stored training embedding is never
    *   mutated.  Defaults to `false`.
    */
-  async transform(e, i = !1) {
+  async transform(t, r = !1) {
     if (!this._hnswIndex || !this.embedding)
       throw new Error("UMAP.transform() must be called after fit()");
-    const a = e.length, s = this._nEpochs ?? (this._nTrain > 1e4 ? 200 : 500), p = Math.max(100, Math.floor(s / 4)), f = this._hnswIndex.searchKnn(e, this._nNeighbors), h = Q(f.indices, f.distances, this._nNeighbors), c = new Uint32Array(h.rows), o = new Uint32Array(h.cols), n = new Float32Array(a), r = new Float32Array(a * this._nComponents);
+    const s = t.length, n = this._nEpochs ?? (this._nTrain > 1e4 ? 200 : 500), p = Math.max(100, Math.floor(n / 4)), f = this._hnswIndex.searchKnn(t, this._nNeighbors), d = J(f.indices, f.distances, this._nNeighbors), c = new Uint32Array(d.rows), a = new Uint32Array(d.cols), o = new Float32Array(s), i = new Float32Array(s * this._nComponents);
     for (let u = 0; u < c.length; u++) {
-      const g = c[u], _ = o[u], w = h.vals[u];
-      n[g] += w;
-      for (let y = 0; y < this._nComponents; y++)
-        r[g * this._nComponents + y] += w * this.embedding[_ * this._nComponents + y];
+      const g = c[u], m = a[u], w = d.vals[u];
+      o[g] += w;
+      for (let b = 0; b < this._nComponents; b++)
+        i[g * this._nComponents + b] += w * this.embedding[m * this._nComponents + b];
     }
-    for (let u = 0; u < a; u++)
-      if (n[u] > 0)
+    for (let u = 0; u < s; u++)
+      if (o[u] > 0)
         for (let g = 0; g < this._nComponents; g++)
-          r[u * this._nComponents + g] /= n[u];
+          i[u * this._nComponents + g] /= o[u];
       else
         for (let g = 0; g < this._nComponents; g++)
-          r[u * this._nComponents + g] = Math.random() * 20 - 10;
-    const l = I(h.vals, p), d = $(
-      r,
+          i[u * this._nComponents + g] = Math.random() * 20 - 10;
+    const h = I(d.vals, p), l = $(
+      i,
       this.embedding,
+      d,
       h,
-      l,
-      a,
+      s,
       this._nTrain,
       this._nComponents,
       p,
       { a: this._a, b: this._b }
     );
-    return i ? T(d, a, this._nComponents) : d;
+    return r ? T(l, s, this._nComponents) : l;
   }
   /**
    * Convenience method equivalent to `fit(vectors)` followed by
@@ -534,34 +535,34 @@ class re {
    *   returned embedding to [0, 1].  `this.embedding` is never mutated.
    *   Defaults to `false`.
    */
-  async fit_transform(e, i, a = !1) {
-    return await this.fit(e, i), a ? T(this.embedding, e.length, this._nComponents) : this.embedding;
+  async fit_transform(t, r, s = !1) {
+    return await this.fit(t, r), s ? T(this.embedding, t.length, this._nComponents) : this.embedding;
   }
 }
-function T(t, e, i) {
-  const a = new Float32Array(t.length);
-  for (let s = 0; s < i; s++) {
+function T(e, t, r) {
+  const s = new Float32Array(e.length);
+  for (let n = 0; n < r; n++) {
     let p = 1 / 0, f = -1 / 0;
-    for (let c = 0; c < e; c++) {
-      const o = t[c * i + s];
-      o < p && (p = o), o > f && (f = o);
+    for (let c = 0; c < t; c++) {
+      const a = e[c * r + n];
+      a < p && (p = a), a > f && (f = a);
     }
-    const h = f - p;
-    for (let c = 0; c < e; c++)
-      a[c * i + s] = h > 0 ? (t[c * i + s] - p) / h : 0;
+    const d = f - p;
+    for (let c = 0; c < t; c++)
+      s[c * r + n] = d > 0 ? (e[c * r + n] - p) / d : 0;
   }
-  return a;
+  return s;
 }
-function I(t, e) {
-  let i = -1 / 0;
-  for (let s = 0; s < t.length; s++)
-    t[s] > i && (i = t[s]);
-  const a = new Float32Array(t.length);
-  for (let s = 0; s < t.length; s++) {
-    const p = t[s] / i;
-    a[s] = p > 0 ? e / p : -1;
+function I(e, t) {
+  let r = -1 / 0;
+  for (let n = 0; n < e.length; n++)
+    e[n] > r && (r = e[n]);
+  const s = new Float32Array(e.length);
+  for (let n = 0; n < e.length; n++) {
+    const p = e[n] / r;
+    s[n] = p > 0 ? t / p : -1;
   }
-  return a;
+  return s;
 }
 export {
   re as UMAP,

package/package.json

@@ -1,17 +1,41 @@
 {
   "name": "umap-gpu",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "UMAP with HNSW kNN and WebGPU-accelerated SGD",
   "type": "module",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "dist/umap-gpu.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/umap-gpu.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
   "files": [
     "dist"
   ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "umap",
+    "dimensionality-reduction",
+    "webgpu",
+    "hnsw",
+    "machine-learning",
+    "gpu"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/Achuttarsing/umap-gpu"
   },
+  "bugs": {
+    "url": "https://github.com/Achuttarsing/umap-gpu/issues"
+  },
+  "homepage": "https://achuttarsing.github.io/umap-gpu",
   "scripts": {
     "build": "vite build && tsc",
     "dev": "vite",