oidn-web 0.4.0 → 0.5.0

package/benchmarks/results/webnn-smoke.md

@@ -1,76 +0,0 @@
-# oidn-web benchmark
-
-- Current: `e6b8577b1c69cc8ce979022717984aec5b9ea881`
-- TFJS baseline: `136c00c34aa5cf4561b4137034dbd643177f0a5f`
-- Input: 512x512, fixed tile 512, 1 runs after 0 warmup(s)
-- Adapter: apple
-
-| Runtime | Init ms | Median ms | P95 ms | Speedup | Precision |
-| --- | ---: | ---: | ---: | ---: | --- |
-| TFJS (136c00c) | 9.70 | 486.20 | 486.20 | 1.00x | fp32 |
-| WGSL FP32 | 38.50 | 43.10 | 43.10 | 11.28x | fp32 |
-| WGSL FP16 Direct | 28.50 | 34.10 | 34.10 | 14.26x | fp16 |
-| WGSL FP16 Implicit GEMM | 29.90 | 34.80 | 34.80 | 13.97x | fp16 |
-| WGSL FP16 Spatial (experimental) | 32.30 | 70.10 | 70.10 | 6.94x | fp16 |
-| WebNN FP16 (experimental) | skipped | - | - | - | Error: WebNN FP16 WebGPU interop failed: NotSupportedError: Failed to execute 'createExportableTensor' on 'MLContext': WebGPU Interop is not supported. |
-
-## Output validation
-
-Compared against sampled TFJS FP32 output.
-
-| Runtime | Status | MAE | RMSE | Max error | Samples |
-| --- | --- | ---: | ---: | ---: | ---: |
-| WGSL FP32 | pass | 1.11e-6 | 1.81e-6 | 1.36e-5 | 6144 |
-| WGSL FP16 Direct | pass | 1.02e-3 | 1.61e-3 | 1.24e-2 | 6144 |
-| WGSL FP16 Implicit GEMM | pass | 1.56e-3 | 2.55e-3 | 4.48e-2 | 6144 |
-| WGSL FP16 Spatial (experimental) | pass | 1.02e-3 | 1.61e-3 | 1.24e-2 | 6144 |
-
-## GPU hot layers
-
-### WGSL FP32
-
-Profiled GPU total: 36.56 ms
-
-| Node | GPU ms |
-| --- | ---: |
-| dec_conv1a | 6.87 |
-| dec_conv2a | 4.79 |
-| dec_conv1b | 4.17 |
-| enc_conv1b | 4.16 |
-| dec_conv3a | 2.32 |
-
-### WGSL FP16 Direct
-
-Profiled GPU total: 28.70 ms
-
-| Node | GPU ms |
-| --- | ---: |
-| dec_conv1a | 4.40 |
-| dec_conv1b | 3.43 |
-| enc_conv1b | 3.13 |
-| dec_conv2a | 2.99 |
-| dec_conv3a | 2.24 |
-
-### WGSL FP16 Implicit GEMM
-
-Profiled GPU total: 30.75 ms
-
-| Node | GPU ms |
-| --- | ---: |
-| dec_conv1a | 6.28 |
-| dec_conv2a | 4.14 |
-| enc_conv1b | 3.09 |
-| dec_conv1b | 2.98 |
-| dec_conv3a | 1.90 |
-
-### WGSL FP16 Spatial (experimental)
-
-Profiled GPU total: 64.85 ms
-
-| Node | GPU ms |
-| --- | ---: |
-| dec_conv1a | 23.57 |
-| dec_conv1b | 5.90 |
-| enc_conv1b | 5.86 |
-| dec_conv2b | 4.89 |
-| enc_conv2b | 4.34 |

package/scripts/inspect-model.mjs

@@ -1,64 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-
-import { parseTZA } from '../lib/tza.js';
-import {
-  detectUNetModelSpec,
-  validateUNetModel
-} from '../lib/modelSpec.js';
-
-const modelPath = process.argv[2];
-if (!modelPath) {
-  console.error('Usage: npm run model:inspect -- path/to/model.tza');
-  process.exit(2);
-}
-
-const absolutePath = resolve(modelPath);
-const file = await readFile(absolutePath);
-const arrayBuffer = file.buffer.slice(
-  file.byteOffset,
-  file.byteOffset + file.byteLength
-);
-const tensors = parseTZA(arrayBuffer);
-const tensorSignature = [...tensors]
-  .map(([name, tensor]) => ({
-    name,
-    dims: tensor.desc.dims,
-    layout: tensor.desc.layout,
-    dataType: tensor.desc.dataType,
-    bytes: tensor.data.byteLength
-  }))
-  .sort((left, right) => left.name.localeCompare(right.name));
-
-let model;
-let compatibilityError;
-try {
-  const spec = detectUNetModelSpec(tensors);
-  const validated = validateUNetModel(tensors, spec);
-  model = {
-    descriptor: spec.id,
-    family: spec.family,
-    inputChannels: validated.inputChannels,
-    outputChannels: validated.outputChannels,
-    dataType: validated.tensorDataType,
-    receptiveField: spec.receptiveField
-  };
-} catch (error) {
-  compatibilityError = error instanceof Error ? error.message : String(error);
-  process.exitCode = 1;
-}
-
-console.log(
-  JSON.stringify(
-    {
-      path: absolutePath,
-      sha256: createHash('sha256').update(file).digest('hex'),
-      model,
-      compatibilityError,
-      tensors: tensorSignature
-    },
-    null,
-    2
-  )
-);

package/tests/modelSpec.test.mjs

@@ -1,128 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import {
-  detectUNetModelSpec,
-  OIDN_UNET_LARGE_SPEC,
-  OIDN_UNET_SMALL_SPEC,
-  validateUNetModel
-} from '../lib/modelSpec.js';
-import { optimizeModelGraph, planModelExecution } from '../lib/graphOptimizer.js';
-import { HostTensor, TensorDesc } from '../lib/tza.js';
-
-function hostTensor(dims, layout = 'x', dataType = 'Float16') {
-  const desc = new TensorDesc();
-  desc.dims = [...dims];
-  desc.paddedDims = [...dims];
-  desc.layout = layout;
-  desc.dataType = dataType;
-  return new HostTensor(desc, new Uint8Array(desc.getByteSize()));
-}
-
-function makeModelTensors(spec, inputChannels = 3) {
-  const tensors = new Map();
-  const channels = new Map([[spec.input, inputChannels]]);
-
-  for (const node of spec.nodes) {
-    if (node.op === 'conv2d') {
-      const inChannels = channels.get(node.input);
-      assert.notEqual(inChannels, undefined);
-      const outChannels = node.id === spec.output ? 3 : 4;
-      tensors.set(
-        node.weight,
-        hostTensor([outChannels, inChannels, 3, 3], 'oihw')
-      );
-      tensors.set(node.bias, hostTensor([outChannels]));
-      channels.set(node.id, outChannels);
-    } else if (node.op === 'concat') {
-      channels.set(
-        node.id,
-        node.inputs.reduce((sum, input) => sum + channels.get(input), 0)
-      );
-    } else {
-      channels.set(node.id, channels.get(node.input));
-    }
-  }
-  return tensors;
-}
-
-test('detects and validates built-in small and large descriptors', () => {
-  for (const spec of [OIDN_UNET_SMALL_SPEC, OIDN_UNET_LARGE_SPEC]) {
-    const tensors = makeModelTensors(spec, 9);
-    assert.equal(detectUNetModelSpec(tensors), spec);
-    const validated = validateUNetModel(tensors);
-    assert.equal(validated.spec, spec);
-    assert.equal(validated.inputChannels, 9);
-    assert.equal(validated.outputChannels, 3);
-    assert.equal(validated.tensorDataType, 'Float16');
-  }
-});
-
-test('rejects an unknown topology instead of silently using a stale graph', () => {
-  const tensors = makeModelTensors(OIDN_UNET_SMALL_SPEC);
-  tensors.set('future_block.weight', hostTensor([4, 4, 3, 3], 'oihw'));
-  assert.throws(
-    () => detectUNetModelSpec(tensors),
-    /Unsupported OIDN model topology/
-  );
-});
-
-test('validates tensor byte length and graph channel flow', () => {
-  const tensors = makeModelTensors(OIDN_UNET_SMALL_SPEC);
-  tensors.get('enc_conv0.weight').data = new Uint8Array(2);
-  assert.throws(
-    () => validateUNetModel(tensors, OIDN_UNET_SMALL_SPEC),
-    /bytes, expected/
-  );
-
-  const wrongChannels = makeModelTensors(OIDN_UNET_SMALL_SPEC);
-  wrongChannels.set('enc_conv1.weight', hostTensor([4, 7, 3, 3], 'oihw'));
-  assert.throws(
-    () => validateUNetModel(wrongChannels, OIDN_UNET_SMALL_SPEC),
-    /expects 7 input channels/
-  );
-});
-
-test('fuses topology patterns without hard-coding a model family', () => {
-  const validated = validateUNetModel(
-    makeModelTensors(OIDN_UNET_SMALL_SPEC),
-    OIDN_UNET_SMALL_SPEC
-  );
-  const graph = optimizeModelGraph(validated);
-
-  assert.deepEqual(graph.fusions, {
-    convPool: 4,
-    upsampleConcatConv: 4
-  });
-  assert.equal(
-    graph.nodes.filter((node) => node.op === 'fusedConvReluMaxPool2d').length,
-    4
-  );
-  assert.equal(
-    graph.nodes.filter((node) => node.op === 'fusedUpsampleConcatConv2d')
-      .length,
-    4
-  );
-  assert.equal(graph.nodes.length, 16);
-});
-
-test('plans fused graph shapes and lifetimes', () => {
-  const validated = validateUNetModel(
-    makeModelTensors(OIDN_UNET_LARGE_SPEC, 9),
-    OIDN_UNET_LARGE_SPEC
-  );
-  const plan = planModelExecution(validated, 384, 256);
-
-  assert.deepEqual(plan.inputShape, { width: 384, height: 256, channels: 9 });
-  assert.deepEqual(plan.valueShapes.get('pool4'), {
-    width: 24,
-    height: 16,
-    channels: 4
-  });
-  assert.deepEqual(plan.valueShapes.get(OIDN_UNET_LARGE_SPEC.output), {
-    width: 384,
-    height: 256,
-    channels: 3
-  });
-  assert.equal(plan.plannedNodes.at(-1).lastUse, plan.nodes.length);
-});

package/tests/resourceLifecycle.test.mjs

@@ -1,383 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { validateUNetModel } from '../lib/modelSpec.js';
-import { OIDNResourceTracker } from '../lib/resourceTracker.js';
-import { HostTensor, TensorDesc } from '../lib/tza.js';
-import { NativeUNetExecutor } from '../lib/nativeUNet.js';
-import { WebNNUNetExecutor } from '../lib/webnnUNet.js';
-
-const TEST_SPEC = {
-  schemaVersion: 1,
-  id: 'resource-test-unet',
-  family: 'resource-test',
-  input: 'input',
-  output: 'output',
-  receptiveField: 3,
-  nodes: [
-    {
-      op: 'conv2d',
-      id: 'output',
-      input: 'input',
-      weight: 'output.weight',
-      bias: 'output.bias',
-      activation: 'identity',
-      padding: 'same'
-    }
-  ]
-};
-
-function hostTensor(dims, layout = 'x') {
-  const desc = new TensorDesc();
-  desc.dims = [...dims];
-  desc.paddedDims = [...dims];
-  desc.layout = layout;
-  desc.dataType = 'Float16';
-  return new HostTensor(desc, new Uint8Array(desc.getByteSize()));
-}
-
-function testModel() {
-  return validateUNetModel(
-    new Map([
-      ['output.weight', hostTensor([3, 3, 3, 3], 'oihw')],
-      ['output.bias', hostTensor([3])]
-    ]),
-    TEST_SPEC
-  );
-}
-
-class FakeResource {
-  destroyCalls = 0;
-
-  destroy() {
-    this.destroyCalls++;
-  }
-}
-
-class FakeBuffer extends FakeResource {
-  mapState = 'unmapped';
-
-  constructor(size = 16, mappedAtCreation = false) {
-    super();
-    this.data = new ArrayBuffer(size);
-    this.mapState = mappedAtCreation ? 'mapped' : 'unmapped';
-  }
-
-  getMappedRange() {
-    return this.data;
-  }
-
-  unmap() {
-    this.mapState = 'unmapped';
-  }
-}
-
-function fakeDevice() {
-  const device = {
-    features: new Set(['shader-f16']),
-    limits: {
-      maxComputeInvocationsPerWorkgroup: 256,
-      maxComputeWorkgroupSizeX: 256,
-      maxComputeWorkgroupSizeY: 256,
-      maxComputeWorkgroupStorageSize: 32768
-    },
-    failBindGroup: false,
-    failBufferAt: undefined,
-    createBufferCalls: 0,
-    buffers: [],
-    queue: {
-      submit() {},
-      onSubmittedWorkDone: () => Promise.resolve()
-    },
-    createShaderModule: () => ({}),
-    createComputePipeline: () => ({ getBindGroupLayout: () => ({}) }),
-    createComputePipelineAsync: async () => ({
-      getBindGroupLayout: () => ({})
-    }),
-    createBuffer(descriptor) {
-      this.createBufferCalls++;
-      if (this.createBufferCalls === this.failBufferAt) {
-        throw new Error('injected buffer allocation failure');
-      }
-      const buffer = new FakeBuffer(
-        descriptor.size,
-        descriptor.mappedAtCreation
-      );
-      this.buffers.push(buffer);
-      return buffer;
-    },
-    createBindGroup() {
-      if (this.failBindGroup) throw new Error('injected bind group failure');
-      return {};
-    },
-    createCommandEncoder: () => ({
-      beginComputePass: () => ({
-        setPipeline() {},
-        setBindGroup() {},
-        dispatchWorkgroups() {},
-        end() {}
-      }),
-      finish: () => ({})
-    })
-  };
-  return device;
-}
-
-function deferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((resolvePromise, rejectPromise) => {
-    resolve = resolvePromise;
-    reject = rejectPromise;
-  });
-  return { promise, resolve, reject };
-}
-
-async function withFakeWebNN(run, { build } = {}) {
-  const previous = {
-    navigator: Object.getOwnPropertyDescriptor(globalThis, 'navigator'),
-    builder: Object.getOwnPropertyDescriptor(globalThis, 'MLGraphBuilder'),
-    usage: Object.getOwnPropertyDescriptor(globalThis, 'GPUBufferUsage')
-  };
-  const device = fakeDevice();
-  const context = new FakeResource();
-  Object.assign(context, {
-    async createExportableTensor() {
-      return new FakeResource();
-    },
-    async exportToGPU() {
-      return device.createBuffer({ size: 16 });
-    },
-    dispatch() {},
-    opSupportLimits() {
-      const operand = { dataTypes: ['float16'] };
-      return { conv2d: { input: operand, filter: operand, output: operand } };
-    },
-    async readTensor() {
-      return new ArrayBuffer(0);
-    },
-    writeTensor() {}
-  });
-
-  class FakeBuilder {
-    input() {
-      return {};
-    }
-    constant() {
-      return {};
-    }
-    conv2d() {
-      return {};
-    }
-    relu(value) {
-      return value;
-    }
-    maxPool2d() {
-      return {};
-    }
-    resample2d() {
-      return {};
-    }
-    concat() {
-      return {};
-    }
-    async build(outputs) {
-      return build ? build(outputs) : new FakeResource();
-    }
-  }
-
-  Object.defineProperties(globalThis, {
-    navigator: {
-      configurable: true,
-      value: { ml: { createContext: async () => context } }
-    },
-    MLGraphBuilder: { configurable: true, value: FakeBuilder },
-    GPUBufferUsage: {
-      configurable: true,
-      value: {
-        STORAGE: 1,
-        COPY_SRC: 2,
-        COPY_DST: 4,
-        UNIFORM: 8,
-        QUERY_RESOLVE: 16,
-        MAP_READ: 32
-      }
-    }
-  });
-
-  try {
-    await run({ device, context });
-  } finally {
-    for (const [key, descriptor] of Object.entries(previous)) {
-      const name =
-        key === 'builder'
-          ? 'MLGraphBuilder'
-          : key === 'usage'
-          ? 'GPUBufferUsage'
-          : key;
-      if (descriptor) Object.defineProperty(globalThis, name, descriptor);
-      else delete globalThis[name];
-    }
-  }
-}
-
-test('resource tracker releases each owned handle exactly once', () => {
-  const tracker = new OIDNResourceTracker();
-  const buffer = new FakeResource();
-  tracker.track('gpu-buffer', buffer);
-  tracker.track('gpu-buffer', buffer);
-
-  assert.deepEqual(tracker.snapshot(), {
-    live: 1,
-    created: 1,
-    destroyed: 0,
-    peakLive: 1,
-    pending: 0,
-    byKind: {
-      'gpu-buffer': { created: 1, destroyed: 0, live: 1, peakLive: 1 }
-    }
-  });
-  tracker.release('gpu-buffer', buffer, () => buffer.destroy());
-  tracker.release('gpu-buffer', buffer, () => buffer.destroy());
-  assert.equal(buffer.destroyCalls, 1);
-  assert.equal(tracker.snapshot().live, 0);
-  assert.equal(tracker.snapshot().created, tracker.snapshot().destroyed);
-});
-
-test('native WGSL shape eviction and dispose release every owned GPU buffer', async () => {
-  await withFakeWebNN(async ({ device }) => {
-    const executor = new NativeUNetExecutor(device, testModel(), {
-      precision: 'fp16',
-      shapeCacheSize: 2,
-      kernel: 'direct'
-    });
-    const input = new FakeBuffer();
-    executor.execute([input], 16, 16);
-    executor.execute([input], 32, 16);
-    executor.execute([input], 48, 16);
-    await new Promise((resolve) => setImmediate(resolve));
-
-    const cached = executor.getResourceInfo();
-    assert.equal(cached.pending, 0);
-    assert.equal(cached.byKind['gpu-buffer'].live, 10);
-    assert.equal(cached.byKind['gpu-buffer'].destroyed, 4);
-
-    executor.dispose();
-    executor.dispose();
-    const disposed = executor.getResourceInfo();
-    assert.equal(disposed.pending, 0);
-    assert.equal(disposed.live, 0);
-    assert.equal(disposed.created, disposed.destroyed);
-    assert.ok(device.buffers.every((buffer) => buffer.destroyCalls === 1));
-    assert.equal(input.destroyCalls, 0);
-  });
-});
-
-test('native WGSL rolls back a partially allocated shape on failure', async () => {
-  await withFakeWebNN(async ({ device }) => {
-    const executor = new NativeUNetExecutor(device, testModel(), {
-      precision: 'fp16',
-      kernel: 'direct'
-    });
-    const baseline = executor.getResourceInfo().live;
-    device.failBufferAt = device.createBufferCalls + 3;
-
-    assert.throws(
-      () => executor.execute([new FakeBuffer()], 16, 16),
-      /injected buffer allocation failure/
-    );
-    assert.equal(executor.getResourceInfo().live, baseline);
-    executor.dispose();
-    assert.equal(executor.getResourceInfo().live, 0);
-    assert.ok(device.buffers.every((buffer) => buffer.destroyCalls === 1));
-  });
-});
-
-test('WebNN shape cache stays bounded and dispose returns to zero live resources', async () => {
-  await withFakeWebNN(async ({ device, context }) => {
-    const executor = new WebNNUNetExecutor(device, testModel(), {
-      precision: 'fp16',
-      shapeCacheSize: 2
-    });
-    await executor.prepare();
-    await executor.prewarm([
-      { width: 16, height: 16 },
-      { width: 32, height: 16 },
-      { width: 48, height: 16 }
-    ]);
-    await Promise.resolve();
-
-    const cached = executor.getResourceInfo();
-    assert.equal(cached.pending, 0);
-    assert.equal(cached.byKind['ml-context'].live, 1);
-    assert.equal(cached.byKind['ml-graph'].live, 2);
-    assert.equal(cached.byKind['ml-tensor'].live, 4);
-    assert.equal(cached.byKind['gpu-buffer'].live, 6);
-
-    executor.dispose();
-    executor.dispose();
-    const disposed = executor.getResourceInfo();
-    assert.equal(disposed.pending, 0);
-    assert.equal(disposed.live, 0);
-    assert.equal(disposed.created, disposed.destroyed);
-    assert.equal(context.destroyCalls, 1);
-    assert.ok(device.buffers.every((buffer) => buffer.destroyCalls === 1));
-  });
-});
-
-test('WebNN cleans a graph that finishes after dispose', async () => {
-  const build = deferred();
-  await withFakeWebNN(
-    async ({ device }) => {
-      const executor = new WebNNUNetExecutor(device, testModel(), {
-        precision: 'fp16'
-      });
-      await executor.prepare();
-      const prewarm = executor.prewarm([{ width: 16, height: 16 }]);
-      await Promise.resolve();
-      assert.equal(executor.getResourceInfo().pending, 1);
-
-      executor.dispose();
-      build.resolve(new FakeResource());
-      await assert.rejects(prewarm, /disposed/);
-
-      const resources = executor.getResourceInfo();
-      assert.equal(resources.pending, 0);
-      assert.equal(resources.live, 0);
-      assert.equal(resources.created, resources.destroyed);
-    },
-    { build: () => build.promise }
-  );
-});
-
-test('WebNN releases exported GPU buffers when command setup throws', async () => {
-  await withFakeWebNN(async ({ device }) => {
-    const executor = new WebNNUNetExecutor(device, testModel(), {
-      precision: 'fp16'
-    });
-    await executor.prepare();
-    await executor.prewarm([{ width: 16, height: 16 }]);
-    const baseline = executor.getResourceInfo().live;
-    device.failBindGroup = true;
-
-    await assert.rejects(
-      executor.execute([new FakeBuffer()], 16, 16),
-      /injected bind group failure/
-    );
-    assert.equal(executor.getResourceInfo().live, baseline);
-    executor.dispose();
-    assert.equal(executor.getResourceInfo().live, 0);
-  });
-});
-
-test('WebNN prepare failures destroy the partially initialized context', async () => {
-  await withFakeWebNN(async ({ device, context }) => {
-    context.opSupportLimits = () => ({});
-    const executor = new WebNNUNetExecutor(device, testModel(), {
-      precision: 'fp16'
-    });
-    await assert.rejects(executor.prepare(), /does not support FP16/);
-    assert.equal(context.destroyCalls, 1);
-    assert.equal(executor.getResourceInfo().live, 0);
-  });
-});