pca-web 0.1.0

package/dist/webgpu/kernels.js

@@ -0,0 +1,147 @@
+/**
+ * WGSL GEMM kernels with near-f64 accuracy on f32-only hardware.
+ *
+ * Design constraint discovered empirically (Chrome/Dawn on Metal): the MSL
+ * compiler applies fast-math — classic Dekker/Knuth error-free
+ * transformations (two_sum, split) are algebraically folded to zero, and
+ * multiply-add pairs are contracted into fma, so double-single (df64)
+ * accumulation silently degrades to f32. What DOES survive, verified by
+ * on-device probes:
+ *   - fma(a, b, -a*b) computes the exact f32 multiplication error
+ *   - single float ops are correctly rounded (no cross-op guarantees)
+ *   - i32 conversions and integer adds are exact and untouched by fast-math
+ *
+ * So products use fma-exact two_prod, and ACCUMULATION is exact integer
+ * binning: every product term is decomposed — exactly, via power-of-two
+ * scaling and fma residuals — into 5 levels of 13-bit integers on a fixed
+ * per-dispatch grid (exponent E bounds every |a·b| term), accumulated in
+ * i32 (no rounding at all), and recombined in float64 on the CPU. The only
+ * error is the truncated tail below the last grid level:
+ *   |error| ≤ K·7·2^(E-65) ≤ maxProduct·2^-45
+ * comparable to true f64 accumulation. Inputs are (hi, lo) f32 pairs of the
+ * f64 values; the three significant cross products (+ the tiny lo·lo term)
+ * feed the binner, preserving ~48 significant bits end to end.
+ *
+ * One tiled kernel template covers all four op(A)·op(B) transpose variants;
+ * only the injected index expressions differ.
+ */
+export const TILE = 16;
+/**
+ * Per-level bin capacity is 2^13; with ≤7 terms per MAC each contributing
+ * |n| ≤ 2^13 per level, i32 overflows at K ≈ 2^31/(7·2^13) ≈ 37k. The
+ * engine splits the K dimension at this bound and sums chunks in f64.
+ */
+export const MAX_K_PER_DISPATCH = 30000;
+/** i32 bin levels per output element (13 bits each → 65 bits of grid). */
+export const BIN_LEVELS = 5;
+/** i32 slots per output element in the C buffer (BIN_LEVELS padded to 8). */
+export const OUT_SLOTS = 8;
+/**
+ * Builds the GEMM shader for C(M×N) = op(A)·op(B) over K = [kStart, kStart+kCount).
+ *
+ * Physical shapes: A is M×K_total when !ta, K_total×M when ta; B is
+ * K_total×N when !tb, N×K_total when tb. All row-major, ds-encoded
+ * (array<vec2f> of hi/lo pairs). C is array<i32>, OUT_SLOTS per element.
+ */
+export function gemmShader(ta, tb) {
+    // Element (i, l) of op(A) and (l, j) of op(B) in physical storage
+    // (kTotal is the stride of the K dimension in the untransposed layout).
+    const aIndex = ta ? 'l * dims.m + i' : 'i * dims.kTotal + l';
+    const bIndex = tb ? 'j * dims.kTotal + l' : 'l * dims.n + j';
+    return /* wgsl */ `
+struct Dims {
+  m: u32,
+  n: u32,
+  kTotal: u32,
+  kStart: u32,
+  kCount: u32,
+  e: i32,      // grid exponent: every |product term| < 2^e
+  pad0: u32,
+  pad1: u32,
+}
+
+@group(0) @binding(0) var<storage, read> matA: array<vec2f>;
+@group(0) @binding(1) var<storage, read> matB: array<vec2f>;
+@group(0) @binding(2) var<storage, read_write> matC: array<i32>;
+@group(0) @binding(3) var<uniform> dims: Dims;
+
+var<workgroup> tileA: array<vec2f, ${TILE * TILE}>;
+var<workgroup> tileB: array<vec2f, ${TILE * TILE}>;
+
+fn loadA(i: u32, l: u32) -> vec2f {
+  if (i < dims.m && l < dims.kStart + dims.kCount) {
+    return matA[${aIndex}];
+  }
+  return vec2f(0.0, 0.0);
+}
+
+fn loadB(l: u32, j: u32) -> vec2f {
+  if (l < dims.kStart + dims.kCount && j < dims.n) {
+    return matB[${bIndex}];
+  }
+  return vec2f(0.0, 0.0);
+}
+
+// Decomposes x exactly into 13-bit integers on grids 2^(e-13)…2^(e-65) and
+// adds them to the bins. Every step is exact: power-of-two scaling shifts
+// the exponent only, i32() truncates exactly, and the fma residual is
+// representable (bits of x strictly below the level's grid).
+fn binAdd(x: f32, acc: ptr<function, array<i32, ${BIN_LEVELS}>>) {
+  var r = x;
+  for (var lvl = 0; lvl < ${BIN_LEVELS}; lvl++) {
+    let g = ldexp(1.0, dims.e - 13 * (lvl + 1));
+    let n = i32(r * ldexp(1.0, 13 * (lvl + 1) - dims.e));
+    (*acc)[lvl] += n;
+    r = fma(-f32(n), g, r);
+  }
+}
+
+@compute @workgroup_size(${TILE}, ${TILE})
+fn main(
+  @builtin(workgroup_id) wg: vec3u,
+  @builtin(local_invocation_id) lid: vec3u,
+) {
+  let row = wg.y * ${TILE}u + lid.y;
+  let col = wg.x * ${TILE}u + lid.x;
+  var acc: array<i32, ${BIN_LEVELS}>;
+  for (var lvl = 0; lvl < ${BIN_LEVELS}; lvl++) {
+    acc[lvl] = 0;
+  }
+  let numTiles = (dims.kCount + ${TILE}u - 1u) / ${TILE}u;
+  for (var t = 0u; t < numTiles; t++) {
+    let kA = dims.kStart + t * ${TILE}u + lid.x;
+    let kB = dims.kStart + t * ${TILE}u + lid.y;
+    tileA[lid.y * ${TILE}u + lid.x] = loadA(row, kA);
+    tileB[lid.y * ${TILE}u + lid.x] = loadB(kB, col);
+    workgroupBarrier();
+    for (var m = 0u; m < ${TILE}u; m++) {
+      let a = tileA[lid.y * ${TILE}u + m];
+      let b = tileB[m * ${TILE}u + lid.x];
+      // Exact ds cross products via fma (verified exact on-device).
+      let p1 = a.x * b.x;
+      let e1 = fma(a.x, b.x, -p1);
+      let p2 = a.x * b.y;
+      let e2 = fma(a.x, b.y, -p2);
+      let p3 = a.y * b.x;
+      let e3 = fma(a.y, b.x, -p3);
+      let p4 = a.y * b.y; // ≤ 2^-48·|a·b| — plain product suffices
+      binAdd(p1, &acc);
+      binAdd(e1, &acc);
+      binAdd(p2, &acc);
+      binAdd(e2, &acc);
+      binAdd(p3, &acc);
+      binAdd(e3, &acc);
+      binAdd(p4, &acc);
+    }
+    workgroupBarrier();
+  }
+  if (row < dims.m && col < dims.n) {
+    let base = (row * dims.n + col) * ${OUT_SLOTS}u;
+    for (var lvl = 0u; lvl < ${BIN_LEVELS}u; lvl++) {
+      matC[base + lvl] = acc[lvl];
+    }
+  }
+}
+`;
+}
+//# sourceMappingURL=kernels.js.map

package/dist/webgpu/kernels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernels.js","sourceRoot":"","sources":["../../src/webgpu/kernels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;AAEvB;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,CAAC;AAExC,0EAA0E;AAC1E,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC;AAE5B,6EAA6E;AAC7E,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC;AAE3B;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,EAAW,EAAE,EAAW;IACjD,kEAAkE;IAClE,wEAAwE;IACxE,MAAM,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,qBAAqB,CAAC;IAC7D,MAAM,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,gBAAgB,CAAC;IAC7D,OAAO,UAAU,CAAC;;;;;;;;;;;;;;;;;qCAiBiB,IAAI,GAAG,IAAI;qCACX,IAAI,GAAG,IAAI;;;;kBAI9B,MAAM;;;;;;;kBAON,MAAM;;;;;;;;;kDAS0B,UAAU;;4BAEhC,UAAU;;;;;;;;2BAQX,IAAI,KAAK,IAAI;;;;;qBAKnB,IAAI;qBACJ,IAAI;wBACD,UAAU;4BACN,UAAU;;;kCAGJ,IAAI,aAAa,IAAI;;iCAEtB,IAAI;iCACJ,IAAI;oBACjB,IAAI;oBACJ,IAAI;;2BAEG,IAAI;8BACD,IAAI;0BACR,IAAI;;;;;;;;;;;;;;;;;;;;wCAoBU,SAAS;+BAClB,UAAU;;;;;CAKxC,CAAC;AACF,CAAC"}

package/dist/worker/client.d.ts

@@ -0,0 +1,174 @@
+/**
+ * `pca-web/client` — main-thread async proxies for estimators running in a
+ * pca-web worker: `WorkerPCA` and `WorkerIncrementalPCA`.
+ *
+ * Import discipline (enforced by a dist-graph test): this module pulls in
+ * only matrix/types/validation/model/protocol — never estimator or solver
+ * code — so apps that fit exclusively in the worker don't bundle the
+ * solvers twice.
+ *
+ * Fitted attributes are mirrored synchronously on the client: every fit
+ * piggybacks the resulting model on its response, so `components`,
+ * `explainedVariance`, `exportModel()`, … work without a round-trip once
+ * the fit promise resolves.
+ */
+import { Matrix, type MatrixInput } from '../matrix.js';
+import { type AnyPCAModel, type IncrementalPCAModel, type PCAModel } from '../model.js';
+import type { PCAFitProgress } from '../progress.js';
+import type { AbortSignalLike } from '../scheduling.js';
+import type { FloatArray } from '../types.js';
+import { type PCAWorkerLike, type ProgressOptions, type QueueableRequest, type WireIPCAOptions, type WireMatrix, type WirePCAOptions, type WireProgress, type WireValue, type WorkerEstimatorInfo, type WorkerFactory, type WorkerMethod } from './protocol.js';
+declare global {
+    interface ImportMeta {
+        url: string;
+    }
+}
+/** Thrown into in-flight calls when `terminate()` hard-kills the worker. */
+export declare class WorkerTerminatedError extends Error {
+    readonly name = "WorkerTerminatedError";
+    constructor(message?: string);
+}
+/** Client-side abort wiring accepts a real AbortSignal when events are needed. */
+interface EventfulAbortSignal extends AbortSignalLike {
+    addEventListener?: (type: 'abort', listener: () => void, opts?: {
+        once?: boolean;
+    }) => void;
+    removeEventListener?: (type: 'abort', listener: () => void) => void;
+}
+/** Per-fit options for the worker proxies. */
+export interface WorkerFitOptions {
+    signal?: EventfulAbortSignal;
+    /**
+     * Transfer the input's buffer to the worker instead of copying (the
+     * caller's array becomes unusable). Views are tight-sliced first, so a
+     * subarray's parent buffer is never touched either way.
+     */
+    transfer?: boolean;
+    onProgress?: (event: PCAFitProgress) => void;
+    progress?: ProgressOptions;
+}
+/** Options shared by both proxies' constructors. */
+export interface WorkerClientOptions {
+    /**
+     * The worker (or MessagePort, or Node worker_threads port) to run on, or
+     * a factory producing one. Clients given the same port instance share
+     * one connection. Omit to spawn the packaged default worker — see the
+     * README's bundler recipes if your bundler cannot resolve it.
+     */
+    worker?: PCAWorkerLike | WorkerFactory;
+    /** Default progress callback for all fits (per-call options override). */
+    onProgress?: (event: PCAFitProgress) => void;
+    /** Default progress tuning (throttle interval, snapshots). */
+    progress?: ProgressOptions;
+}
+export interface WorkerPCAOptions extends WirePCAOptions, WorkerClientOptions {
+    /** Where fits run: 'cpu' (default) or 'webgpu' (falls back to CPU). */
+    backend?: 'cpu' | 'webgpu';
+}
+export interface WorkerIncrementalPCAOptions extends WireIPCAOptions, WorkerClientOptions {
+}
+export type { WorkerEstimatorInfo } from './protocol.js';
+declare class Connection {
+    readonly port: PCAWorkerLike;
+    private readonly pending;
+    private nextId;
+    private readyResolve;
+    private readonly readyPromise;
+    private dead;
+    constructor(port: PCAWorkerLike);
+    private readonly listener;
+    allocId(): number;
+    ready(): Promise<void>;
+    post(msg: {
+        t: 'abort';
+        targetId: number;
+    }): void;
+    request(msg: QueueableRequest, transfer?: ArrayBufferLike[], onProgress?: (e: WireProgress) => void): Promise<{
+        value: WireValue;
+        model?: AnyPCAModel;
+    }>;
+    /** Hard-kill: rejects all in-flight calls and poisons future ones. */
+    terminate(): void;
+}
+declare abstract class WorkerEstimatorBase<M extends AnyPCAModel> {
+    protected readonly conn: Connection;
+    protected readonly estId: string;
+    protected readonly ownsWorker: boolean;
+    protected readonly defaultOnProgress?: (event: PCAFitProgress) => void;
+    protected readonly defaultProgress?: ProgressOptions;
+    protected model_: M | null;
+    protected whitenOpt: boolean;
+    private readonly createDone;
+    private disposed;
+    protected constructor(estimator: 'pca' | 'ipca', backend: 'cpu' | 'webgpu', wireOptions: WirePCAOptions | WireIPCAOptions, client: WorkerClientOptions, hydrate?: M);
+    /** Resolves when the worker handshake and this estimator's create are done. */
+    ready(): Promise<void>;
+    /** Graceful shutdown of this estimator (terminates owned workers too). */
+    dispose(): Promise<void>;
+    /**
+     * Hard-kill the worker: all in-flight calls reject and subsequent calls
+     * keep rejecting with WorkerTerminatedError.
+     */
+    terminate(): void;
+    protected mirror(): M;
+    protected call(method: WorkerMethod, payload: {
+        x?: WireMatrix;
+        model?: AnyPCAModel;
+        returnModel?: boolean;
+    }, transfer?: ArrayBufferLike[], fit?: WorkerFitOptions): Promise<WireValue>;
+    protected wireX(X: MatrixInput, fit?: WorkerFitOptions): {
+        x: WireMatrix;
+        transfer: ArrayBufferLike[];
+    };
+    protected callMatrix(method: WorkerMethod, X?: MatrixInput): Promise<Matrix>;
+    get components(): Matrix;
+    get explainedVariance(): FloatArray;
+    get explainedVarianceRatio(): FloatArray;
+    get singularValues(): FloatArray;
+    get mean(): FloatArray;
+    get nComponents(): number;
+    get nFeaturesIn(): number;
+    get noiseVariance(): number;
+    get whiten(): boolean;
+    getFeatureNamesOut(): string[];
+    /** The current model as an independent copy (sync, from the mirror). */
+    exportModel(): M;
+    /** Rehydrates worker and mirror from a serialized model. */
+    importModel(model: M): Promise<this>;
+    /** Which backend actually executes, plus adapter details. */
+    info(): Promise<WorkerEstimatorInfo>;
+    transform(X: MatrixInput): Promise<Matrix>;
+    inverseTransform(X: MatrixInput): Promise<Matrix>;
+    getCovariance(): Promise<Matrix>;
+    getPrecision(): Promise<Matrix>;
+}
+export declare class WorkerPCA extends WorkerEstimatorBase<PCAModel> {
+    constructor(options?: WorkerPCAOptions, /** @internal use fromModel */ hydrate?: PCAModel);
+    /**
+     * Creates a proxy already hydrated with a fitted model — the worker
+     * adopts it (pipelined with create) and the sync mirror is available
+     * immediately.
+     */
+    static fromModel(model: PCAModel, options?: WorkerPCAOptions): WorkerPCA;
+    fit(X: MatrixInput, options?: WorkerFitOptions): Promise<this>;
+    fitTransform(X: MatrixInput, options?: WorkerFitOptions): Promise<Matrix>;
+    scoreSamples(X: MatrixInput): Promise<FloatArray>;
+    score(X: MatrixInput): Promise<number>;
+    get nSamples(): number;
+    /** The solver the last fit actually used. */
+    get resolvedSvdSolver(): PCAModel['svdSolver'];
+}
+export declare class WorkerIncrementalPCA extends WorkerEstimatorBase<IncrementalPCAModel> {
+    constructor(options?: WorkerIncrementalPCAOptions, 
+    /** @internal use fromModel */ hydrate?: IncrementalPCAModel);
+    static fromModel(model: IncrementalPCAModel, options?: WorkerIncrementalPCAOptions): WorkerIncrementalPCA;
+    fit(X: MatrixInput, options?: WorkerFitOptions): Promise<this>;
+    fitTransform(X: MatrixInput, options?: WorkerFitOptions): Promise<Matrix>;
+    /** One incremental batch — sklearn's partial_fit, off-thread. */
+    partialFit(X: MatrixInput, options?: WorkerFitOptions): Promise<this>;
+    get variance(): Float64Array;
+    get nSamplesSeen(): number;
+    get batchSize(): number;
+}
+export type { PCAWorkerLike, ProgressOptions, WireMatrix, WorkerFactory, } from './protocol.js';
+//# sourceMappingURL=client.d.ts.map

package/dist/worker/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/worker/client.ts"],"names":[],"mappings":"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"}