"""Packs the checkpoint into the layout the C engine reads. Everything the engine needs is a matrix of shape [N, K] multiplied against activation windows of K contiguous floats, so the export repacks convolution kernels from PyTorch's [out, in, tap] order into [out, tap * in], materialises the parametric sinc filterbank, and merges the two LSTM bias vectors. Nothing is transformed at load time. python tools/export_weights.py writes /pyseg_weights.bin. tools/embed.py turns that into the C source a self-contained binary compiles in; it is kept separate because it needs nothing but the standard library and therefore runs anywhere, including inside a container build. """ import argparse import struct import sys from pathlib import Path import numpy as np from model import SINC_FILTERS, load_state_dict, sinc_filters MAGIC = b"PSG1" VERSION = 1 NAME_LEN = 24 ALIGN = 64 # Column count the sinc kernel is padded to. The 251 real taps are followed by # five zero weights so the kernel's K is a multiple of four and the innermost # loop needs no tail; the samples those zeros multiply are always in range # because the last window starts at sample 159740 of 160000. SINC_K = 256 def fnv1a(data: bytes) -> int: h = 0x811C9DC5 for b in data: h = ((h ^ b) * 0x01000193) & 0xFFFFFFFF return h class Blob: def __init__(self): self.tensors = [] def add(self, name: str, array: np.ndarray) -> None: if len(name) >= NAME_LEN: raise ValueError(f"name too long: {name}") data = np.ascontiguousarray(array, dtype=np.float32) self.tensors.append((name, data)) def pack(self) -> bytes: header = struct.calcsize("<4sIII") entry = struct.calcsize(f"<{NAME_LEN}sIII") offset = header + entry * len(self.tensors) offset = (offset + ALIGN - 1) // ALIGN * ALIGN table, payload, cursor = [], [], offset for name, data in self.tensors: raw = data.tobytes() table.append((name, cursor, len(raw), fnv1a(raw))) payload.append(raw) cursor += len(raw) pad = (-cursor) % ALIGN payload.append(b"\0" * pad) cursor += pad out = bytearray() out += struct.pack("<4sIII", MAGIC, VERSION, len(self.tensors), cursor) for name, off, nbytes, digest in table: out += struct.pack( f"<{NAME_LEN}sIII", name.encode(), off, nbytes, digest ) out += b"\0" * (offset - len(out)) for chunk in payload: out += chunk assert len(out) == cursor return bytes(out) def repack_conv(weight: np.ndarray) -> np.ndarray: """[out, in, tap] -> [out, tap * in], matching a window of tap frames. Activations are stored time-major, so the taps a kernel needs for one output step are tap consecutive frames of in channels each: one contiguous span whose element order is tap-major. """ out_ch, in_ch, taps = weight.shape return np.ascontiguousarray(weight.transpose(0, 2, 1).reshape(out_ch, taps * in_ch)) def build(sd: dict) -> Blob: blob = Blob() blob.add("wavnorm", np.stack([sd["sincnet.wav_norm1d.weight"], sd["sincnet.wav_norm1d.bias"]])) sinc = np.zeros((SINC_FILTERS, SINC_K), dtype=np.float32) sinc[:, : sinc_filters(sd).shape[1]] = sinc_filters(sd) blob.add("sinc_w", sinc) for i, tag in enumerate(("norm1", "norm2", "norm3")): blob.add(f"{tag}_w", sd[f"sincnet.norm1d.{i}.weight"]) blob.add(f"{tag}_b", sd[f"sincnet.norm1d.{i}.bias"]) for src, tag in ((1, "conv2"), (2, "conv3")): blob.add(f"{tag}_w", repack_conv(sd[f"sincnet.conv1d.{src}.weight"])) blob.add(f"{tag}_b", sd[f"sincnet.conv1d.{src}.bias"]) for layer in range(4): for tag, suffix in (("f", ""), ("b", "_reverse")): key = f"lstm{layer}{tag}" blob.add(f"{key}_ih", sd[f"lstm.weight_ih_l{layer}{suffix}"]) blob.add(f"{key}_hh", sd[f"lstm.weight_hh_l{layer}{suffix}"]) blob.add( f"{key}_bias", sd[f"lstm.bias_ih_l{layer}{suffix}"] + sd[f"lstm.bias_hh_l{layer}{suffix}"], ) for i in range(2): blob.add(f"lin{i}_w", sd[f"linear.{i}.weight"]) blob.add(f"lin{i}_b", sd[f"linear.{i}.bias"]) blob.add("cls_w", sd["classifier.weight"]) blob.add("cls_b", sd["classifier.bias"]) return blob def main() -> int: ap = argparse.ArgumentParser() ap.add_argument("outdir", nargs="?", default=".") args = ap.parse_args() outdir = Path(args.outdir) sd = load_state_dict() blob = build(sd) data = blob.pack() binpath = outdir / "pyseg_weights.bin" binpath.write_bytes(data) params = sum(t.size for _, t in blob.tensors) print(f"{binpath}: {len(blob.tensors)} tensors, {params} floats, {len(data) / 1e6:.2f} MB") for name, t in blob.tensors: print(f" {name:16s} {str(t.shape):16s}") return 0 if __name__ == "__main__": sys.exit(main())