simulation/scripts/export_sonic_dynamic_batch.py

#!/usr/bin/env python3
"""Re-export the SONIC v1.1 ONNX pair with a dynamic batch dimension.

The checkpoints NVIDIA ships are traced at batch 1, so an RL rollout would need
one inference call per environment per control tick. Both graphs are batch
agnostic apart from bookkeeping:

* the decoder is pure MatMul/Add/Sigmoid and only needs its declared shapes
  relaxed;
* the encoder additionally has Reshape targets that spell the batch out as a
  literal ``1``. None of them uses ``-1`` elsewhere, so the leading dim can be
  replaced by ``-1`` and inferred instead.

Writes ``model_{encoder,decoder}_batch.onnx`` next to the originals and checks
that a batched call reproduces the per-sample batch-1 result.

    python scripts/export_sonic_dynamic_batch.py [--checkpoint DIR] [--batch N]
"""

from __future__ import annotations

import argparse
import os
from pathlib import Path

import numpy as np
import onnx
from onnx import numpy_helper

_DEFAULT_CKPT = Path(__file__).resolve().parents[2] / "checkpoints" / "sonic" / "sonic_v1_1"
_BATCH_SYMBOL = "batch"


def _relax_value_info(vi) -> bool:
    dim = vi.type.tensor_type.shape.dim
    if not dim:
        return False
    if dim[0].dim_value == 1:
        dim[0].ClearField("dim_value")
        dim[0].dim_param = _BATCH_SYMBOL
        return True
    return False


def _relax_reshape_targets(graph) -> int:
    """Turn a literal leading ``1`` in Reshape targets into ``-1``."""
    consumed: dict[str, list[str]] = {}
    for node in graph.node:
        if node.op_type == "Reshape" and len(node.input) > 1:
            consumed.setdefault(node.input[1], []).append(node.name)

    patched = 0
    for node in graph.node:
        if node.op_type != "Constant" or node.output[0] not in consumed:
            continue
        for attr in node.attribute:
            if attr.name != "value":
                continue
            arr = numpy_helper.to_array(attr.t)
            if arr.ndim != 1 or arr.size == 0 or arr[0] != 1 or (arr == -1).any():
                continue
            new = arr.copy()
            new[0] = -1
            attr.t.CopyFrom(numpy_helper.from_array(new, attr.t.name))
            patched += 1
    return patched


def _rebuild_encoder_onehot(graph, num_encoders: int = 3) -> bool:
    """Replace the traced encoder-index one-hot with a batch-aware equivalent.

    ``EncodersOnlyWrapper`` builds the one-hot by scattering into
    ``torch.zeros((batch, num_encoders))`` at ``torch.arange(batch)``. At batch 1
    the arange folds to the constant ``[0]`` and the zeros tensor freezes at
    shape ``[1, 3]``, so the ScatterND can only ever fill row 0. Rebuild it as
    ``onehot[b, k] = (encoder_index[b] == k)``, which broadcasts over any batch.
    """
    scatter = next((n for n in graph.node if n.op_type == "ScatterND"), None)
    if scatter is None:
        return False
    index = next(n for n in graph.node if n.op_type == "Cast" and n.output[0] == "/Cast_output_0")

    axes = onnx.helper.make_node(
        "Constant",
        [],
        ["sonic_onehot_axes"],
        value=numpy_helper.from_array(np.array([1], dtype=np.int64), "sonic_onehot_axes_v"),
    )
    ids = onnx.helper.make_node(
        "Constant",
        [],
        ["sonic_onehot_ids"],
        value=numpy_helper.from_array(
            np.arange(num_encoders, dtype=np.int64), "sonic_onehot_ids_v"
        ),
    )
    col = onnx.helper.make_node("Unsqueeze", [index.output[0], "sonic_onehot_axes"], ["sonic_onehot_col"])
    eq = onnx.helper.make_node("Equal", ["sonic_onehot_col", "sonic_onehot_ids"], ["sonic_onehot_eq"])
    cast = onnx.helper.make_node(
        "Cast", ["sonic_onehot_eq"], [scatter.output[0]], to=onnx.TensorProto.FLOAT
    )

    at = list(graph.node).index(scatter)
    graph.node.remove(scatter)
    for offset, node in enumerate((axes, ids, col, eq, cast)):
        graph.node.insert(at + offset, node)
    return True


def make_dynamic(src: Path, dst: Path) -> None:
    model = onnx.load(str(src))
    if _rebuild_encoder_onehot(model.graph):
        print(f"{src.name}: rebuilt encoder-index one-hot for dynamic batch")
    n_reshape = _relax_reshape_targets(model.graph)
    n_io = sum(_relax_value_info(vi) for vi in list(model.graph.input) + list(model.graph.output))
    # Stale inferred shapes would contradict the new symbolic batch.
    del model.graph.value_info[:]

    onnx.checker.check_model(model)
    onnx.save(model, str(dst))
    print(f"{src.name} -> {dst.name}: {n_reshape} reshape targets, {n_io} io dims relaxed")


def verify(src: Path, dst: Path, dim_in: int, batch: int, seed: int) -> float:
    import onnxruntime as ort

    opts = ort.SessionOptions()
    opts.log_severity_level = 3
    # A PBS job owns a cpuset, not the whole host. Left to its defaults ORT sizes
    # its pool from the host CPU count and every worker fails pthread_setaffinity_np.
    try:
        opts.intra_op_num_threads = max(1, min(8, len(os.sched_getaffinity(0))))
    except (AttributeError, OSError):
        opts.intra_op_num_threads = 4
    opts.inter_op_num_threads = 1
    one = ort.InferenceSession(str(src), opts, providers=["CPUExecutionProvider"])
    many = ort.InferenceSession(str(dst), opts, providers=["CPUExecutionProvider"])

    rng = np.random.default_rng(seed)
    x = rng.normal(size=(batch, dim_in)).astype(np.float32)
    if dim_in == 1751:  # encoder_index must stay a valid mode id
        x[:, 0] = rng.integers(0, 3, size=batch)

    batched = many.run(None, {many.get_inputs()[0].name: x})[0]
    single = np.concatenate(
        [one.run(None, {one.get_inputs()[0].name: x[i : i + 1]})[0] for i in range(batch)], axis=0
    )
    err = float(np.abs(batched - single).max())
    print(f"  batch={batch} vs {batch}x batch-1: max abs diff {err:.3e}  shape {batched.shape}")
    return err


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--checkpoint", type=Path, default=_DEFAULT_CKPT)
    ap.add_argument("--batch", type=int, default=8)
    ap.add_argument("--seed", type=int, default=0)
    args = ap.parse_args()

    worst = 0.0
    for stem, dim_in in (("model_encoder", 1751), ("model_decoder", 994)):
        src = args.checkpoint / f"{stem}.onnx"
        dst = args.checkpoint / f"{stem}_batch.onnx"
        if not src.is_file():
            raise SystemExit(f"missing {src}")
        make_dynamic(src, dst)
        worst = max(worst, verify(src, dst, dim_in, args.batch, args.seed))

    ok = worst < 1e-4
    print(f"\n{'OK' if ok else 'MISMATCH'}: worst max abs diff {worst:.3e}")
    return 0 if ok else 1


if __name__ == "__main__":
    raise SystemExit(main())