tensorgrad 0.0.9 → 0.0.12

package/README.md

@@ -1,119 +1,119 @@
-# tensorgrad
-
-A tiny TypeScript-native tensor library with autograd that compiles directly
-to WebGPU. Designed for training small models in the browser — without
-hand-writing WGSL kernels and without dragging in a 5 MB ML framework.
-
-```sh
-npm i tensorgrad
-```
-
-Roughly **3000 lines of zero-dependency TypeScript**, ~10 KB gzipped after
-build. Targets WebGPU only. Static shapes only. Forward + reverse-mode
-autograd; Adam optimizer; the whole training pipeline runs as compiled WGSL.
-
-## Quick example
-
-A 2-layer MLP fitting `y = sin(x)`:
-
-```ts
-import {
-  Module, compileModule,
-  add, mul, sub, sumLast, reshape, matmul, relu,
-  type Tensor,
-} from 'tensorgrad'
-
-class Linear extends Module {
-  W: Tensor; b: Tensor
-  constructor(public inDim: number, public outDim: number) {
-    super()
-    this.W = this.param([inDim, outDim])              // randn, scale 0.02
-    this.b = this.param([outDim], { init: 'zeros' })
-  }
-}
-
-class MLP extends Module {
-  l1 = new Linear(1, 64)
-  l2 = new Linear(64, 64)
-  l3 = new Linear(64, 1)
-}
-
-const linear = (p: Linear, x: Tensor) => add(matmul(x, p.W), p.b)
-
-function forward(m: MLP, x: Tensor): Tensor {
-  return linear(m.l3, relu(linear(m.l2, relu(linear(m.l1, x)))))
-}
-
-function loss(m: MLP, x: Tensor, y: Tensor): Tensor {
-  const diff = sub(forward(m, x), y)
-  return mul(sumLast(reshape(mul(diff, diff), [B])), 1 / B)
-}
-
-const B = 256
-const compiled = await compileModule(() => new MLP(), loss, {
-  adam: { lr: 0.005 },
-  inputs: [
-    { name: 'x', shape: [B, 1], dtype: 'f32' },
-    { name: 'y', shape: [B, 1], dtype: 'f32' },
-  ],
-})
-
-compiled.uploadInitialParams()  // applies the per-param init declared above
-
-for (let step = 0; step < 1000; step++) {
-  const { x, y } = generateBatch()
-  const lossVal = await compiled.step({ x, y })
-  if (step % 100 === 0) console.log('step', step, 'loss', lossVal)
-}
-```
-
-That's the whole user-facing surface for this model: `Module` for parameter
-storage, plain functions for the forward pass, `compileModule` to JIT-compile
-to WGSL with autograd + Adam wired in. No decorators, no `tf.GradientTape`,
-no `register_pytree_node`.
-
-For a more involved example — a 3-layer transformer trained from scratch on
-2-digit addition — see the [`samples/`](./samples) workspace
-(`pnpm --filter samples dev`).
-
-## What this library is for
-
-Small browser-side ML where you want to *train* the model, not just run
-inference of a pretrained model. Educational artifacts, interactive
-demos, on-device personalization, "transformer from scratch in your browser"
-blog posts. Roughly the niche where the model is small enough to fit
-comfortably in a browser tab but where you still want autograd and a real
-optimizer.
-
-If you want to ship inference of a pretrained model, use
-[ONNX Runtime Web](https://github.com/microsoft/onnxruntime) or
-[transformers.js](https://github.com/xenova/transformers.js).
-If you need full JAX (vmap / pmap / dynamic shapes / multi-backend), use
-[jax-js](https://github.com/jax-js/jax).
-
-## Scope (deliberately small)
-
-The library only does what it does because of what it doesn't do. The
-load-bearing "out of scope" decisions are:
-
-- **WebGPU only** — no Wasm or WebGL fallback.
-- **Static shapes only** — every shape is fixed at compile time. This is
-  what lets us bake constants into the WGSL instead of carrying shape
-  uniforms.
-- **`grad` is the only transformation** — no `vmap`, `pmap`, `jvp`,
-  `custom_vjp`. Batch your data explicitly.
-- **`f32` only** — no dtype promotion, no mixed precision.
-- **Closed op set** — about 25 ops, listed in `SPEC.md`. Compositions of
-  those handle most needs (GELU, RMS norm, etc. are a few lines on top).
-- **Adam lives in the IR** — bias correction included; no CPU↔GPU
-  round-trip per step.
-
-## Status
-
-Alpha. Two real working models (a transformer training to <0.1 loss on
-addition, an MLP fitting `sin`). API may change before 1.0. Filing issues
-welcome.
-
-## License
-
-MIT
+# tensorgrad
+
+A tiny TypeScript-native tensor library with autograd that compiles directly
+to WebGPU. Designed for training small models in the browser — without
+hand-writing WGSL kernels and without dragging in a 5 MB ML framework.
+
+```sh
+npm i tensorgrad
+```
+
+Roughly **3000 lines of zero-dependency TypeScript**, ~10 KB gzipped after
+build. Targets WebGPU only. Static shapes only. Forward + reverse-mode
+autograd; Adam optimizer; the whole training pipeline runs as compiled WGSL.
+
+## Quick example
+
+A 2-layer MLP fitting `y = sin(x)`:
+
+```ts
+import {
+  Module, compileModule,
+  add, mul, sub, sumLast, reshape, matmul, relu,
+  type Tensor,
+} from 'tensorgrad'
+
+class Linear extends Module {
+  W: Tensor; b: Tensor
+  constructor(public inDim: number, public outDim: number) {
+    super()
+    this.W = this.param([inDim, outDim])              // randn, scale 0.02
+    this.b = this.param([outDim], { init: 'zeros' })
+  }
+}
+
+class MLP extends Module {
+  l1 = new Linear(1, 64)
+  l2 = new Linear(64, 64)
+  l3 = new Linear(64, 1)
+}
+
+const linear = (p: Linear, x: Tensor) => add(matmul(x, p.W), p.b)
+
+function forward(m: MLP, x: Tensor): Tensor {
+  return linear(m.l3, relu(linear(m.l2, relu(linear(m.l1, x)))))
+}
+
+function loss(m: MLP, { x, y }: { x: Tensor; y: Tensor }): Tensor {
+  const diff = sub(forward(m, x), y)
+  return mul(sumLast(reshape(mul(diff, diff), [B])), 1 / B)
+}
+
+const B = 256
+const compiled = await compileModule(() => new MLP(), loss, {
+  adam: { lr: 0.005 },
+  inputs: {
+    x: { shape: [B, 1], dtype: 'f32' },
+    y: { shape: [B, 1], dtype: 'f32' },
+  },
+})
+
+// Initial params are uploaded automatically — no manual step needed.
+
+for (let step = 0; step < 1000; step++) {
+  const { x, y } = generateBatch()
+  const lossVal = await compiled.step({ x, y })
+  if (step % 100 === 0) console.log('step', step, 'loss', lossVal)
+}
+```
+
+That's the whole user-facing surface for this model: `Module` for parameter
+storage, plain functions for the forward pass, `compileModule` to JIT-compile
+to WGSL with autograd + Adam wired in. No decorators, no `tf.GradientTape`,
+no `register_pytree_node`.
+
+For a more involved example — a 3-layer transformer trained from scratch on
+2-digit addition — see the [`samples/`](./samples) workspace
+(`pnpm --filter samples dev`).
+
+## What this library is for
+
+Small browser-side ML where you want to *train* the model, not just run
+inference of a pretrained model. Educational artifacts, interactive
+demos, on-device personalization, "transformer from scratch in your browser"
+blog posts. Roughly the niche where the model is small enough to fit
+comfortably in a browser tab but where you still want autograd and a real
+optimizer.
+
+If you want to ship inference of a pretrained model, use
+[ONNX Runtime Web](https://github.com/microsoft/onnxruntime) or
+[transformers.js](https://github.com/xenova/transformers.js).
+If you need full JAX (vmap / pmap / dynamic shapes / multi-backend), use
+[jax-js](https://github.com/jax-js/jax).
+
+## Scope (deliberately small)
+
+The library only does what it does because of what it doesn't do. The
+load-bearing "out of scope" decisions are:
+
+- **WebGPU only** — no Wasm or WebGL fallback.
+- **Static shapes only** — every shape is fixed at compile time. This is
+  what lets us bake constants into the WGSL instead of carrying shape
+  uniforms.
+- **`grad` is the only transformation** — no `vmap`, `pmap`, `jvp`,
+  `custom_vjp`. Batch your data explicitly.
+- **`f32` only** — no dtype promotion, no mixed precision.
+- **Closed op set** — about 25 ops, listed in `SPEC.md`. Compositions of
+  those handle most needs (GELU, RMS norm, etc. are a few lines on top).
+- **Adam lives in the IR** — bias correction included; no CPU↔GPU
+  round-trip per step.
+
+## Status
+
+Alpha. Two real working models (a transformer training to <0.1 loss on
+addition, an MLP fitting `sin`). API may change before 1.0. Filing issues
+welcome.
+
+## License
+
+MIT

package/dist/compile.d.ts

@@ -5,14 +5,29 @@ import { type BufferPlan } from './buffers.js';
 import { type KernelSpec } from './codegen.js';
 import { type CompiledRuntime, type CompiledForward, type RuntimeOpts } from './runtime.js';
 import { Module } from './module.js';
-/** Declares one input tensor of the model's forward function. Order matches
- *  the function's parameter list (after `model`). The `name` is used at
- *  runtime to upload data via `step({ [name]: data })`. */
+/** Declares one input tensor of the model's forward function. The name is the
+ *  key in the `inputs:` Record at compile time and the key on the `step()`/
+ *  `run()` data object at runtime. */
 export interface InputDecl {
-    name: string;
     shape: Shape;
     dtype?: Dtype;
 }
+/** Inputs declaration: a Record from input name to its shape/dtype. The name
+ *  doubles as the key the forward fn destructures and the key the runtime
+ *  expects in `step({...})` / `run({...})`. */
+export type InputDecls = Record<string, InputDecl>;
+/** Maps an `InputDecls` Record to its forward-time tensor counterpart —
+ *  same keys, each value is a Tensor. Used to type the forward function's
+ *  `inputs` argument from the declared shape Record. */
+export type InputsTensors<I extends InputDecls> = {
+    [K in keyof I]: Tensor;
+};
+/** Forward function shape: takes the materialized model and a Record of
+ *  named input tensors (matching the declared `inputs:` keys), returns the
+ *  output tensor (loss for compileModule; logits/etc. for compileForward).
+ *  The second generic flows from the inputs declaration so destructuring
+ *  the input record stays typed. */
+export type ForwardFn<M extends Module, I extends InputDecls = InputDecls> = (m: M, inputs: InputsTensors<I>) => Tensor;
 export interface CompiledIR {
     graph: GradResult['graph'];
     paramGrads: GradResult['paramGrads'];
@@ -26,18 +41,45 @@ export declare function compileToIR(traceFn: () => Tensor): CompiledIR;
 export declare function compile(traceFn: () => Tensor, opts?: RuntimeOpts): Promise<CompiledRuntime & {
     ir: CompiledIR;
 }>;
-export interface CompileModuleOptions extends RuntimeOpts {
-    /** Per-step data inputs to the forward function. Order matches the forward
-     *  function's parameters (after the model). e.g. for
-     *  `(model, tokens, targets, mask) => loss`, inputs is
-     *  `[{name:'tokens',...}, {name:'targets',...}, {name:'mask',...}]`. */
-    inputs?: InputDecl[];
+export interface CompileModuleOptions<I extends InputDecls = InputDecls> extends RuntimeOpts {
+    /** Per-step data inputs to the forward function, keyed by name. The forward
+     *  fn destructures these out of its second argument; runtime calls to
+     *  `step()` / `run()` pass typed arrays under the same keys. */
+    inputs?: I;
     /** Adam hyperparameters. If omitted, no optimizer is appended (forward-only). */
     adam?: AdamConfig;
 }
-export interface CompileForwardOptions extends RuntimeOpts {
-    /** Per-step data inputs to the forward function. */
-    inputs?: InputDecl[];
+export interface CompileForwardOptions<I extends InputDecls = InputDecls> extends RuntimeOpts {
+    /** Per-step data inputs to the forward function, keyed by name. */
+    inputs?: I;
+}
+/** Forward-only compile options as taken by the `compileForward` *method* on
+ *  a training runtime — no `device` (inherited) and no `sharedParams`
+ *  (auto-supplied from the train graph's params). */
+export interface CompileForwardMethodOptions<I extends InputDecls = InputDecls> {
+    inputs?: I;
+}
+/** Returned by `compileModule`. Adds training-graph extras (auto-init, reset,
+ *  sibling-graph compile) on top of the base runtime. */
+export interface CompiledModule<M extends Module> extends CompiledRuntime {
+    ir: CompiledIR;
+    /** Number of dispatchable kernels (excludes leaf no-ops). */
+    kernelCount: number;
+    /** Re-initialize all params from their declared init specs and zero the
+     *  optimizer state. Use to start training over without recompiling. */
+    reset(): void;
+    /** Compile a sibling forward-only graph (e.g., a B=1 inference graph or a
+     *  B=N held-out eval graph) that shares this runtime's device and param
+     *  buffers. Pass the forward fn (typically distinct from your loss fn —
+     *  it returns logits, not a scalar) and any shape changes via `inputs`.
+     *  Auto-initialization is a no-op since params are shared. */
+    compileForward<I extends InputDecls>(forward: ForwardFn<M, I>, opts?: CompileForwardMethodOptions<I>): Promise<CompiledForwardModule>;
+}
+/** Returned by `compileForward` (and by the `compileForward` method). */
+export interface CompiledForwardModule extends CompiledForward {
+    ir: CompiledIR;
+    /** Number of dispatchable kernels (excludes leaf no-ops). */
+    kernelCount: number;
 }
 /**
  * Compile a Module-based model. Pass a *factory* `() => new Model()`, not the
@@ -45,37 +87,44 @@ export interface CompileForwardOptions extends RuntimeOpts {
  * field becomes a real `Tensor`), so the instance is consumed and shouldn't be
  * referenced afterwards. Re-call the factory if you need a fresh tree.
  *
- * The forward function takes the materialized model and returns the loss
- * tensor.
+ * The forward function takes the materialized model and a Record of named
+ * input tensors, returns the loss tensor. Inputs are matched by name with the
+ * `inputs:` declaration:
+ *
+ *   inputs: {
+ *     tokens:  { shape: [B, T], dtype: 'i32' },
+ *     targets: { shape: [B, T], dtype: 'i32' },
+ *   }
+ *   forward: (m, { tokens, targets }) => …
  *
  * Walks the module tree to materialize params with auto-derived names, then
- * runs trace → grad → adam → buffer plan → codegen → runtime.
+ * runs trace → grad → adam → buffer plan → codegen → runtime. Initial
+ * parameter values are uploaded automatically before this function returns;
+ * call `reset()` later to re-randomize.
  *
  * If `opts.adam` is set, the runtime's `step()` automatically tracks an
  * internal step count and injects the bias-corrected `lrt` scalar each call;
  * users don't need to provide it themselves.
  */
-export declare function compileModule<M extends Module>(modelFactory: () => M, forward: (m: M, ...inputs: Tensor[]) => Tensor, opts?: CompileModuleOptions): Promise<CompiledRuntime & {
-    ir: CompiledIR;
-    uploadInitialParams: () => void;
-}>;
+export declare function compileModule<M extends Module, I extends InputDecls = InputDecls>(modelFactory: () => M, forward: ForwardFn<M, I>, opts?: CompileModuleOptions<I>): Promise<CompiledModule<M>>;
 /**
  * Compile a Module-based model in forward-only mode (no autograd, no Adam).
  * The forward function returns the output tensor (e.g., logits) instead of a
  * scalar loss; runtime exposes `run(inputs)` returning the full output as a
  * `Float32Array`.
  *
+ * **Prefer the `compileForward` method on a training runtime** when both
+ * graphs use the same Module class — it auto-supplies `device` and
+ * `sharedParams`. This standalone form is for forward-only models with no
+ * training graph at all, or for sharing params across a different model.
+ *
  * **Sharing params with a training compile.** Pass `opts.sharedParams =
  * trainCompiled.params` to bind this graph's param buffers to an existing
  * training runtime's GPU buffers — every train step is then immediately
- * visible to `run()` calls here, no copies. The forward graph's
- * `uploadInitialParams()` skips any param covered by `sharedParams`.
+ * visible to `run()` calls here, no copies.
  *
- * Typical use: a B=1 inference graph alongside a B=512 training graph,
- * built from the same `Module` factory.
+ * Initial param values are uploaded automatically for params *not* covered
+ * by `sharedParams` (those are owned by the sibling compile).
  */
-export declare function compileForward<M extends Module>(modelFactory: () => M, forward: (m: M, ...inputs: Tensor[]) => Tensor, opts?: CompileForwardOptions): Promise<CompiledForward & {
-    ir: CompiledIR;
-    uploadInitialParams: () => void;
-}>;
+export declare function compileForward<M extends Module, I extends InputDecls = InputDecls>(modelFactory: () => M, forward: ForwardFn<M, I>, opts?: CompileForwardOptions<I>): Promise<CompiledForwardModule>;
 //# sourceMappingURL=compile.d.ts.map

package/dist/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEnD,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAuC,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAChI,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAA;AAEvD;;2DAE2D;AAC3D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,KAAK,CAAA;IACZ,KAAK,CAAC,EAAE,KAAK,CAAA;CACd;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,CAAA;IAC1B,UAAU,EAAE,UAAU,CAAC,YAAY,CAAC,CAAA;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,UAAU,EAAE,CAAA;CACtB;AAED,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,MAAM,GAAG,UAAU,CAM7D;AAED,0EAA0E;AAC1E,wBAAsB,OAAO,CAAC,OAAO,EAAE,MAAM,MAAM,EAAE,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,eAAe,GAAG;IAAE,EAAE,EAAE,UAAU,CAAA;CAAE,CAAC,CAK1H;AAMD,MAAM,WAAW,oBAAqB,SAAQ,WAAW;IACvD;;;4EAGwE;IACxE,MAAM,CAAC,EAAE,SAAS,EAAE,CAAA;IACpB,iFAAiF;IACjF,IAAI,CAAC,EAAE,UAAU,CAAA;CAClB;AAED,MAAM,WAAW,qBAAsB,SAAQ,WAAW;IACxD,oDAAoD;IACpD,MAAM,CAAC,EAAE,SAAS,EAAE,CAAA;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,CAAC,SAAS,MAAM,EAClD,YAAY,EAAE,MAAM,CAAC,EACrB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,KAAK,MAAM,EAC9C,IAAI,GAAE,oBAAyB,GAC9B,OAAO,CAAC,eAAe,GAAG;IAAE,EAAE,EAAE,UAAU,CAAC;IAAC,mBAAmB,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC,CA6DhF;AA4BD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,EACnD,YAAY,EAAE,MAAM,CAAC,EACrB,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,KAAK,MAAM,EAC9C,IAAI,GAAE,qBAA0B,GAC/B,OAAO,CAAC,eAAe,GAAG;IAAE,EAAE,EAAE,UAAU,CAAC;IAAC,mBAAmB,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC,CA0BhF"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"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"}