@driftengine/texture 4.0.0

package/src/tensor/graph.ts

@@ -0,0 +1,244 @@
+/**
+ * A network as a graph of the runtime's operators, checked before it runs and evaluated on the CPU.
+ *
+ * **Validation says what is wrong in words, and names what it is about**: an operator the runtime
+ * lacks, a value read before anything writes it, a shape that does not fit the node that reads it,
+ * an output nothing produces. A graph is checked when it is loaded — a model is refused then, with
+ * the reason, rather than at its first frame with a picture of zeros.
+ *
+ * **The evaluator is the reference**, which the device runner is held to: it sizes every value and
+ * its scratch once, when it is created, and a run writes into those buffers and allocates nothing.
+ * What it gives up is memory: every intermediate value keeps its own buffer, which is the plainest
+ * thing to compare against and the device runner's job to improve on.
+ */
+import { fromHalfBits } from '../half.ts';
+import { OPERATORS, type Attributes } from './operators.ts';
+import { planReuse } from '@driftengine/core';
+
+export interface GraphValue {
+  readonly name: string;
+  readonly shape: readonly number[];
+}
+
+export interface GraphNode {
+  readonly op: string;
+  readonly inputs: readonly string[];
+  readonly output: string;
+  readonly attributes: Attributes;
+}
+
+export interface GraphTensor {
+  readonly shape: readonly number[];
+  readonly data: Float32Array;
+}
+
+export interface NetworkGraph {
+  readonly inputs: readonly GraphValue[];
+  readonly outputs: readonly string[];
+  readonly nodes: readonly GraphNode[];
+  readonly tensors: ReadonlyMap<string, GraphTensor>;
+}
+
+const size = (shape: readonly number[]): number => shape.reduce((total, d) => total * d, 1);
+
+/** Every value's shape, or the first reason the graph cannot run. */
+function inferShapes(graph: NetworkGraph): Map<string, readonly number[]> | string {
+  const shapes = new Map<string, readonly number[]>();
+  for (const input of graph.inputs) shapes.set(input.name, input.shape);
+  for (const [name, tensor] of graph.tensors) {
+    if (tensor.data.length !== size(tensor.shape)) {
+      return `tensor "${name}" holds ${tensor.data.length} values and its shape [${tensor.shape.join(', ')}] needs ${size(tensor.shape)}`;
+    }
+    shapes.set(name, tensor.shape);
+  }
+  for (const node of graph.nodes) {
+    const operator = OPERATORS.get(node.op);
+    if (operator === undefined) {
+      return `the runtime has no operator "${node.op}" (writing "${node.output}")`;
+    }
+    const [fewest, most] = operator.arity;
+    if (node.inputs.length < fewest || node.inputs.length > most) {
+      return `${node.op} writing "${node.output}" takes ${fewest} to ${most} inputs and was given ${node.inputs.length}`;
+    }
+    const inputShapes: (readonly number[])[] = [];
+    for (const input of node.inputs) {
+      const shape = shapes.get(input);
+      if (shape === undefined)
+        return `${node.op} writing "${node.output}" reads "${input}", which nothing writes`;
+      inputShapes.push(shape);
+    }
+    if (shapes.has(node.output)) return `"${node.output}" is written twice`;
+    const ranks = operator.ranks ?? [];
+    for (let i = 0; i < inputShapes.length && i < ranks.length; i += 1) {
+      const rank = (inputShapes[i] as readonly number[]).length;
+      if (rank !== ranks[i]) {
+        return `${node.op} writing "${node.output}": "${node.inputs[i]}" has rank ${rank} and this input takes rank ${ranks[i]}`;
+      }
+    }
+    const shape = operator.shape(inputShapes, node.attributes);
+    if (typeof shape === 'string') return `${node.op} writing "${node.output}": ${shape}`;
+    shapes.set(node.output, shape);
+  }
+  for (const output of graph.outputs) {
+    if (!shapes.has(output)) return `the output "${output}" is written by nothing`;
+  }
+  return shapes;
+}
+
+/**
+ * A graph as a file stores it: its tensors in either precision, half as the bits a device uploads.
+ * `@driftengine/drft`'s `DrftGraph` is one, structurally, which is how the two packages meet
+ * without either importing the other.
+ */
+export interface StoredGraph {
+  readonly inputs: readonly GraphValue[];
+  readonly outputs: readonly string[];
+  readonly nodes: readonly GraphNode[];
+  readonly tensors: readonly {
+    readonly name: string;
+    readonly shape: readonly number[];
+    readonly data: Float32Array | Uint16Array;
+  }[];
+}
+
+/**
+ * A stored graph as one the runtime runs, half-precision tensors decoded to single; validated, and
+ * refused naming what is wrong — an operator the runtime lacks is a fact about the model, and this
+ * is when a caller learns it.
+ */
+export function graphFromStored(stored: StoredGraph): NetworkGraph {
+  const tensors = new Map<string, GraphTensor>();
+  for (const tensor of stored.tensors) {
+    const data =
+      tensor.data instanceof Uint16Array
+        ? Float32Array.from(tensor.data, (bits) => fromHalfBits(bits))
+        : tensor.data;
+    tensors.set(tensor.name, { shape: tensor.shape, data });
+  }
+  const graph: NetworkGraph = {
+    inputs: stored.inputs,
+    outputs: stored.outputs,
+    nodes: stored.nodes,
+    tensors,
+  };
+  const problem = validateGraph(graph);
+  if (problem !== null) throw new Error(`network graph: ${problem}`);
+  return graph;
+}
+
+/** Every value's shape — inputs, tensors and intermediates — refused, with the reason, if invalid. */
+export function graphShapes(graph: NetworkGraph): ReadonlyMap<string, readonly number[]> {
+  const shapes = inferShapes(graph);
+  if (typeof shapes === 'string') throw new Error(`network graph: ${shapes}`);
+  return shapes;
+}
+
+/**
+ * A graph as `@driftengine/core`'s runner takes it: its tensors listed by name, and every value's
+ * shape as inferred here — **nothing evaluated and nothing sized**, where asking an evaluator for its
+ * shapes would allocate every intermediate value first. Structural, because core does not import
+ * this package; the shapes are this module's, so there is one copy of every operator's rule.
+ */
+export function graphForDevice(graph: NetworkGraph): {
+  readonly inputs: readonly GraphValue[];
+  readonly outputs: readonly string[];
+  readonly nodes: readonly GraphNode[];
+  readonly tensors: readonly {
+    readonly name: string;
+    readonly shape: readonly number[];
+    readonly data: Float32Array;
+  }[];
+  readonly shapes: ReadonlyMap<string, readonly number[]>;
+} {
+  return {
+    inputs: graph.inputs,
+    outputs: graph.outputs,
+    nodes: graph.nodes,
+    tensors: [...graph.tensors].map(([name, tensor]) => ({ name, ...tensor })),
+    shapes: graphShapes(graph),
+  };
+}
+
+/** Null when the graph can run; otherwise the reason, naming what it is about. */
+export function validateGraph(graph: NetworkGraph): string | null {
+  const shapes = inferShapes(graph);
+  return typeof shapes === 'string' ? shapes : null;
+}
+
+export interface GraphEvaluator {
+  /** Every value's shape, inputs, tensors and intermediates alike. */
+  readonly shapes: ReadonlyMap<string, readonly number[]>;
+  /**
+   * Evaluate with these inputs. The returned arrays are the evaluator's own and are overwritten by
+   * the next run.
+   */
+  run(inputs: ReadonlyMap<string, Float32Array>): Map<string, Float32Array>;
+}
+
+/**
+ * Validate, size every value once, and return something that evaluates without allocating.
+ *
+ * **Values that cannot be alive at once share a buffer**, by `planReuse` — the rule the device's
+ * runner plans by too. Weights and inputs stay in the caller's own arrays and are planned by
+ * neither. What it buys is the difference between holding every value of a graph and holding the
+ * few alive at any moment: OWLv2's image graph at 960² is 3,647 MB of values and 196 MB in ten buffers,
+ * which is the difference between a reference that runs on an ordinary machine and one that is
+ * killed for its memory.
+ */
+export function createGraphEvaluator(graph: NetworkGraph): GraphEvaluator {
+  const shapes = inferShapes(graph);
+  if (typeof shapes === 'string') throw new Error(`network graph: ${shapes}`);
+  const buffers = new Map<string, Float32Array>();
+  for (const [name, tensor] of graph.tensors) buffers.set(name, tensor.data);
+  const plan = planReuse({ nodes: graph.nodes, held: [], outputs: graph.outputs }, (name) =>
+    size(shapes.get(name) as readonly number[]),
+  );
+  const slots = plan.sizes.map((values) => new Float32Array(values));
+  /* A buffer is as large as the largest value it holds, so each value takes a view of its own. */
+  for (const [name, slot] of plan.slotOf) {
+    const room = size(shapes.get(name) as readonly number[]);
+    const held = slots[slot] as Float32Array;
+    buffers.set(name, held.length === room ? held : held.subarray(0, room));
+  }
+  let scratchSize = 0;
+  for (const node of graph.nodes) {
+    const operator = OPERATORS.get(node.op);
+    const inputShapes = node.inputs.map((input) => shapes.get(input) as readonly number[]);
+    scratchSize = Math.max(scratchSize, operator?.scratch?.(inputShapes, node.attributes) ?? 0);
+  }
+  const scratch = new Float32Array(scratchSize);
+  const outputs = new Map<string, Float32Array>();
+
+  return {
+    shapes,
+    run(inputs) {
+      for (const input of graph.inputs) {
+        const data = inputs.get(input.name);
+        if (data === undefined)
+          throw new Error(`network graph: no value for the input "${input.name}"`);
+        if (data.length !== size(input.shape)) {
+          throw new Error(
+            `network graph: "${input.name}" holds ${data.length} values and needs ${size(input.shape)}`,
+          );
+        }
+        buffers.set(input.name, data);
+      }
+      for (const node of graph.nodes) {
+        const operator = OPERATORS.get(node.op);
+        if (operator === undefined) continue;
+        const values = node.inputs.map((input) => buffers.get(input) as Float32Array);
+        const inputShapes = node.inputs.map((input) => shapes.get(input) as readonly number[]);
+        operator.evaluate(
+          values,
+          inputShapes,
+          node.attributes,
+          buffers.get(node.output) as Float32Array,
+          scratch,
+        );
+      }
+      outputs.clear();
+      for (const output of graph.outputs) outputs.set(output, buffers.get(output) as Float32Array);
+      return outputs;
+    },
+  };
+}

package/src/tensor/linear.ts

@@ -0,0 +1,153 @@
+/**
+ * The dense operators a transformer is built from: matrix multiply, bias, layer norm, GELU, softmax.
+ *
+ * **The references the device kernels are held to**, which is why they are written for exactness
+ * rather than speed: every sum accumulates in double precision and is rounded once, on the way into
+ * the caller's single-precision output. A kernel that disagrees with one of these is wrong, not
+ * this.
+ *
+ * **Contiguous row-major arrays with their dimensions, and nothing that allocates.** A strided view
+ * that permutes without copying would make every operator handle strides, and every device kernel
+ * would materialise the permutation anyway; so a permutation is a copy into a buffer the caller
+ * owns, and the operators stay one loop each.
+ *
+ * **The exact GELU, `x·Φ(x)`, and never the tanh approximation.** The two differ by 4e-4 at 3, and
+ * a port of a network trained with one and evaluated with the other is a different network. `erf`
+ * is here for that reason, accurate to double precision.
+ */
+
+/**
+ * `out[m×n] = a[m×k] · b`, where `b` is `k×n`, or `n×k` read as its transpose when `transposeB`.
+ * The offsets are where each matrix starts in its array, which is how one head of many is taken.
+ */
+export function matmul(
+  out: Float32Array,
+  a: Float32Array,
+  b: Float32Array,
+  m: number,
+  k: number,
+  n: number,
+  transposeB = false,
+  outAt = 0,
+  aAt = 0,
+  bAt = 0,
+): void {
+  for (let row = 0; row < m; row += 1) {
+    const aRow = aAt + row * k;
+    for (let col = 0; col < n; col += 1) {
+      let sum = 0;
+      if (transposeB) {
+        const bRow = bAt + col * k;
+        for (let i = 0; i < k; i += 1) sum += (a[aRow + i] as number) * (b[bRow + i] as number);
+      } else {
+        for (let i = 0; i < k; i += 1) {
+          sum += (a[aRow + i] as number) * (b[bAt + i * n + col] as number);
+        }
+      }
+      out[outAt + row * n + col] = sum;
+    }
+  }
+}
+
+/** Add `bias[cols]` to every one of `rows` rows of `x`, in place. */
+export function addBias(x: Float32Array, rows: number, cols: number, bias: Float32Array): void {
+  for (let row = 0; row < rows; row += 1) {
+    for (let col = 0; col < cols; col += 1) {
+      x[row * cols + col] = (x[row * cols + col] as number) + (bias[col] as number);
+    }
+  }
+}
+
+/**
+ * Each row normalised to zero mean and unit variance, then scaled by `gamma` and shifted by `beta`.
+ *
+ * **The population variance, divided by the row's length and not one less**, which is what the
+ * upstream frameworks compute and therefore what their trained weights expect.
+ */
+export function layerNorm(
+  x: Float32Array,
+  rows: number,
+  cols: number,
+  gamma: Float32Array,
+  beta: Float32Array,
+  epsilon: number,
+  out: Float32Array,
+): void {
+  for (let row = 0; row < rows; row += 1) {
+    const at = row * cols;
+    let mean = 0;
+    for (let col = 0; col < cols; col += 1) mean += x[at + col] as number;
+    mean /= cols;
+    let variance = 0;
+    for (let col = 0; col < cols; col += 1) variance += ((x[at + col] as number) - mean) ** 2;
+    variance /= cols;
+    const scale = 1 / Math.sqrt(variance + epsilon);
+    for (let col = 0; col < cols; col += 1) {
+      const normal = variance + epsilon === 0 ? 0 : ((x[at + col] as number) - mean) * scale;
+      out[at + col] = normal * (gamma[col] as number) + (beta[col] as number);
+    }
+  }
+}
+
+const TWO_OVER_ROOT_PI = 2 / Math.sqrt(Math.PI);
+
+/**
+ * The error function, to double precision.
+ *
+ * A Maclaurin series below 3, where its alternating terms peak near 170 at `x = 3` and cost about
+ * three digits to cancellation — still 1e-13; a continued fraction for the complement above, which
+ * converges fastest exactly where the series is worst; and ±1 past 6, where the complement is below
+ * a double's last place.
+ */
+export function erf(x: number): number {
+  const sign = x < 0 ? -1 : 1;
+  const a = Math.abs(x);
+  if (a >= 6) return sign;
+  if (a < 3) {
+    let term = a;
+    let sum = a;
+    const square = a * a;
+    for (let n = 1; n < 100; n += 1) {
+      term *= -square / n;
+      const next = term / (2 * n + 1);
+      sum += next;
+      if (Math.abs(next) < 1e-17 * Math.abs(sum)) break;
+    }
+    return sign * TWO_OVER_ROOT_PI * sum;
+  }
+  /* erfc(a) = exp(−a²)/√π · 1/(a + ½/(a + 1/(a + 3/2/(a + ...)))), evaluated from the tail up. */
+  let fraction = 0;
+  for (let n = 60; n >= 1; n -= 1) fraction = n / 2 / (a + fraction);
+  const complement = Math.exp(-a * a) / Math.sqrt(Math.PI) / (a + fraction);
+  return sign * (1 - complement);
+}
+
+/** `x·Φ(x)`, the exact GELU, from `x` into `out`. */
+export function gelu(x: Float32Array, out: Float32Array): void {
+  for (let i = 0; i < x.length; i += 1) {
+    const value = x[i] as number;
+    out[i] = 0.5 * value * (1 + erf(value / Math.SQRT2));
+  }
+}
+
+/** The logistic, `1/(1 + e^−x)`, from `x` into `out`: 1 far to the right, and 0 far to the left. */
+export function sigmoid(x: Float32Array, out: Float32Array): void {
+  for (let i = 0; i < x.length; i += 1) out[i] = 1 / (1 + Math.exp(-(x[i] as number)));
+}
+
+/**
+ * Each row of `x` to a distribution, stably: the row's largest value is subtracted before the
+ * exponential, so logits near a thousand give their logistic rather than `Infinity / Infinity`.
+ */
+export function softmax(x: Float32Array, rows: number, cols: number, out: Float32Array): void {
+  for (let row = 0; row < rows; row += 1) {
+    const at = row * cols;
+    let largest = -Infinity;
+    for (let col = 0; col < cols; col += 1) largest = Math.max(largest, x[at + col] as number);
+    let total = 0;
+    for (let col = 0; col < cols; col += 1) total += Math.exp((x[at + col] as number) - largest);
+    for (let col = 0; col < cols; col += 1) {
+      out[at + col] = Math.exp((x[at + col] as number) - largest) / total;
+    }
+  }
+}

package/src/tensor/operatorKit.ts

@@ -0,0 +1,76 @@
+/**
+ * What every operator table shares: the shape of an operator, and the few helpers they all read
+ * their attributes and shapes with.
+ */
+export type AttributeValue = number | string | boolean | readonly number[];
+export type Attributes = Readonly<Record<string, AttributeValue>>;
+export type Shape = readonly number[];
+
+export interface Operator {
+  /** How many inputs it takes, fewest and most. */
+  readonly arity: readonly [number, number];
+  /**
+   * The rank each input must have, in order, where it matters. **Checked before `shape` runs**,
+   * because an operator reading an image as `[channels, height, width]` reads a value with one more
+   * axis as its first three and validates it — and then declares an output it fills only part of.
+   */
+  readonly ranks?: readonly number[];
+  shape(inputs: readonly Shape[], attributes: Attributes): number[] | string;
+  /** Scratch values it needs beyond its output, if any. */
+  scratch?(inputs: readonly Shape[], attributes: Attributes): number;
+  evaluate(
+    inputs: readonly Float32Array[],
+    shapes: readonly Shape[],
+    attributes: Attributes,
+    out: Float32Array,
+    scratch: Float32Array,
+  ): void;
+}
+
+export const num = (attributes: Attributes, name: string, fallback?: number): number => {
+  const value = attributes[name];
+  if (typeof value === 'number') return value;
+  if (fallback !== undefined) return fallback;
+  throw new RangeError(`attribute "${name}" must be a number`);
+};
+
+export const list = (attributes: Attributes, name: string): readonly number[] => {
+  const value = attributes[name];
+  return Array.isArray(value) ? (value as readonly number[]) : [];
+};
+
+export const same = (a: Shape, b: Shape): boolean =>
+  a.length === b.length && a.every((d, i) => d === b[i]);
+
+export const elementwise = (apply: (a: number, b: number) => number): Operator => ({
+  arity: [2, 2],
+  shape: ([a, b]) => {
+    const x = a as Shape;
+    const y = b as Shape;
+    if (same(x, y) || (y.length === 1 && y[0] === x[x.length - 1])) return [...x];
+    return `[${y.join(', ')}] is neither [${x.join(', ')}] nor its last dimension`;
+  },
+  evaluate: ([a, b], _shapes, _attributes, out) => {
+    const left = a as Float32Array;
+    const right = b as Float32Array;
+    const n = right.length;
+    for (let i = 0; i < left.length; i += 1) {
+      out[i] = apply(left[i] as number, right[i % n] as number);
+    }
+  },
+});
+
+/* Strides of a row-major shape. */
+export function strides(shape: Shape): number[] {
+  const out = new Array<number>(shape.length).fill(1);
+  for (let d = shape.length - 2; d >= 0; d -= 1) {
+    out[d] = (out[d + 1] as number) * (shape[d + 1] as number);
+  }
+  return out;
+}
+
+export const product = (shape: Shape, from = 0, to = shape.length): number => {
+  let total = 1;
+  for (let d = from; d < to; d += 1) total *= shape[d] as number;
+  return total;
+};

package/src/tensor/operators.ts

@@ -0,0 +1,28 @@
+/**
+ * The operators a graph may name: what each one's output shape is, and how it is evaluated.
+ *
+ * **One table, and a graph naming anything not in it is refused at validation, by name** — the
+ * runtime lacking an operator is a fact about the model, and a caller learns it when the model is
+ * loaded rather than at its first frame. Adding an operator is adding a row here, with its reference
+ * in `linear.ts`, `attention.ts` or `spatial.ts` and its device kernel in core.
+ *
+ * **`linear` is the upstream layer, `x·Wᵀ + b`, with its weight in the upstream layout `[out][in]`,
+ * and the bias added in double precision before the one rounding** — which is what makes a
+ * perceptron written as a graph agree with `evalNetwork` bit for bit, and is the evidence there is
+ * one runtime rather than two.
+ *
+ * Shapes are checked before anything runs; a shape function returns the output shape, or a sentence
+ * saying why there is none.
+ */
+import { DENSE_OPERATORS } from './denseOperators.ts';
+import type { Operator } from './operatorKit.ts';
+import { SHAPE_OPERATORS } from './shapeOperators.ts';
+import { SPATIAL_OPERATORS } from './spatialOperators.ts';
+
+export type { AttributeValue, Attributes, Operator } from './operatorKit.ts';
+
+export const OPERATORS: ReadonlyMap<string, Operator> = new Map<string, Operator>([
+  ...DENSE_OPERATORS,
+  ...SPATIAL_OPERATORS,
+  ...SHAPE_OPERATORS,
+]);

package/src/tensor/resize.ts

@@ -0,0 +1,140 @@
+/**
+ * Resizing a channel-major image, `[channels][height][width]`, by the upstream's conventions.
+ *
+ * **They are followed exactly, because they are the bug every port has.** Without aligned corners
+ * a destination pixel reads source `(i + ½)·scale − ½`, and for bilinear a negative source is
+ * clamped to zero; with aligned corners it reads `i·(in − 1)/(out − 1)`, and an output of one reads
+ * source zero. Bicubic uses the cubic convolution kernel with `a = −0.75`, not the −0.5 of the
+ * textbooks, and clamps its four taps to the border rather than its coordinate. Nearest reads
+ * `⌊i·scale⌋`, PyTorch's legacy `nearest` rather than `nearest-exact`.
+ */
+const CUBIC_A = -0.75;
+
+/* The cubic convolution kernel's two pieces, for |x| ≤ 1 and 1 < |x| < 2. */
+function cubicNear(x: number): number {
+  return ((CUBIC_A + 2) * x - (CUBIC_A + 3)) * x * x + 1;
+}
+
+function cubicFar(x: number): number {
+  return ((CUBIC_A * x - 5 * CUBIC_A) * x + 8 * CUBIC_A) * x - 4 * CUBIC_A;
+}
+
+/*
+ * Where destination index `i` reads from, in the upstream's convention. Without aligned corners a
+ * destination pixel covers `input / output` source pixels — unless a step is given, which is what
+ * PyTorch's interpolate uses when it is handed a scale factor: the factor's inverse, not the ratio
+ * of the sizes it rounded to.
+ */
+function sourceOf(
+  i: number,
+  input: number,
+  output: number,
+  align: boolean,
+  cubic: boolean,
+  step?: number,
+): number {
+  if (align) return output <= 1 ? 0 : (i * (input - 1)) / (output - 1);
+  const source = step === undefined ? ((i + 0.5) * input) / output - 0.5 : (i + 0.5) * step - 0.5;
+  return !cubic && source < 0 ? 0 : source;
+}
+
+function clampIndex(i: number, size: number): number {
+  return i < 0 ? 0 : i >= size ? size - 1 : i;
+}
+
+/**
+ * `out[channels][outH][outW]` resized from `input[channels][inH][inW]`. `step`, without aligned
+ * corners, is the source pixels a destination pixel covers, vertically and then horizontally, where
+ * it is not the ratio of the sizes.
+ */
+export function resize(
+  out: Float32Array,
+  input: Float32Array,
+  channels: number,
+  inH: number,
+  inW: number,
+  outH: number,
+  outW: number,
+  mode: 'bilinear' | 'bicubic' | 'nearest',
+  alignCorners: boolean,
+  step?: readonly [number, number],
+): void {
+  if (mode === 'nearest') {
+    nearest(out, input, channels, inH, inW, outH, outW, step);
+    return;
+  }
+  const cubic = mode === 'bicubic';
+  const wx = [0, 0, 0, 0];
+  const wy = [0, 0, 0, 0];
+  for (let c = 0; c < channels; c += 1) {
+    const plane = c * inH * inW;
+    for (let y = 0; y < outH; y += 1) {
+      const sy = sourceOf(y, inH, outH, alignCorners, cubic, step?.[0]);
+      const y0 = Math.floor(sy);
+      const ty = sy - y0;
+      for (let x = 0; x < outW; x += 1) {
+        const sx = sourceOf(x, inW, outW, alignCorners, cubic, step?.[1]);
+        const x0 = Math.floor(sx);
+        const tx = sx - x0;
+        let value = 0;
+        if (cubic) {
+          wx[0] = cubicFar(tx + 1);
+          wx[1] = cubicNear(tx);
+          wx[2] = cubicNear(1 - tx);
+          wx[3] = cubicFar(2 - tx);
+          wy[0] = cubicFar(ty + 1);
+          wy[1] = cubicNear(ty);
+          wy[2] = cubicNear(1 - ty);
+          wy[3] = cubicFar(2 - ty);
+          for (let j = 0; j < 4; j += 1) {
+            const row = plane + clampIndex(y0 - 1 + j, inH) * inW;
+            let across = 0;
+            for (let i = 0; i < 4; i += 1) {
+              across += (wx[i] as number) * (input[row + clampIndex(x0 - 1 + i, inW)] as number);
+            }
+            value += (wy[j] as number) * across;
+          }
+        } else {
+          const x1 = Math.min(x0 + 1, inW - 1);
+          const y1 = Math.min(y0 + 1, inH - 1);
+          const top =
+            (input[plane + y0 * inW + x0] as number) * (1 - tx) +
+            (input[plane + y0 * inW + x1] as number) * tx;
+          const bottom =
+            (input[plane + y1 * inW + x0] as number) * (1 - tx) +
+            (input[plane + y1 * inW + x1] as number) * tx;
+          value = top * (1 - ty) + bottom * ty;
+        }
+        out[(c * outH + y) * outW + x] = value;
+      }
+    }
+  }
+}
+
+/*
+ * PyTorch's `nearest`: destination `i` reads source `⌊i·scale⌋`, clamped to the last, the product
+ * taken in single precision as its kernel takes it — `scale` the step where the node gives one, as
+ * a resize by a scale factor does, and the sizes' ratio otherwise.
+ */
+function nearest(
+  out: Float32Array,
+  input: Float32Array,
+  channels: number,
+  inH: number,
+  inW: number,
+  outH: number,
+  outW: number,
+  step?: readonly [number, number],
+): void {
+  const scaleY = Math.fround(step?.[0] ?? inH / outH);
+  const scaleX = Math.fround(step?.[1] ?? inW / outW);
+  for (let c = 0; c < channels; c += 1) {
+    for (let y = 0; y < outH; y += 1) {
+      const sy = Math.min(Math.floor(Math.fround(y * scaleY)), inH - 1);
+      for (let x = 0; x < outW; x += 1) {
+        const sx = Math.min(Math.floor(Math.fround(x * scaleX)), inW - 1);
+        out[(c * outH + y) * outW + x] = input[(c * inH + sy) * inW + sx] as number;
+      }
+    }
+  }
+}