Remove host code; update README

README.md

@@ -33,7 +33,7 @@ All comparisons are against NeMo's own embedding of the same audio (the `.nemo`
 
 | Check | Clips | Cosine to NeMo (min / mean) | Notes |
 |---|---|---|---|
-| WAV → Python host → Core AI (Mac, GPU) | 40 VoxCeleb1-test, 4.1–64.7 s | **0.9999987** / 0.9999993 | the whole package: mel front end, windowed host, graph |
+| WAV → Python host → Core AI (Mac, GPU) | 40 VoxCeleb1-test, 4.1–64.7 s | **0.9999987** / 0.9999993 | the whole pipeline: mel front end, windowed host, graph |
 | NeMo's mel → Swift host → Core AI (iPhone, GPU) | same 40 | **0.9999987** / 0.9999993 | all embeddings finite |
 
 Because the embeddings agree with NeMo's to within 1.3e-6 in cosine, verification behaves as the original does.
@@ -49,13 +49,10 @@ re-scored on that benchmark.
 | `frontend/mel_fb.f32` | slaney mel filterbank [80, 257], float32 little-endian (the checkpoint's own buffer) |
 | `frontend/mel_window.f32` | Hann window [400], periodic=False (the checkpoint's own buffer) |
 | `frontend/config.json` | front-end constants: 16 kHz, n_fft 512, hop 160, win 400, 80 mels, 192-d embedding, threshold 0.7 |
-| `python/titanet_coreai.py` | standalone Python host: mel front end + windowed scan, numpy only |
-| `swift/` | Swift host for iOS / macOS apps: `MelFrontend.swift`, `Host.swift`, `SpeakerEngine.swift` |
 
 ## Input
 
 - **16 kHz, mono**, float samples in [-1, 1]. The model was trained on 16 kHz audio; resample anything else first.
-  The Python CLI reads WAV through `soundfile` and refuses other sample rates rather than resampling silently.
 - Any length from one 10 ms frame up. A few seconds of speech gives a stable embedding.
 - The front end is NeMo's `AudioToMelSpectrogramPreprocessor` in eval mode, reproduced step for step: pre-emphasis
   0.97, centred 512-point STFT (hop 160, Hann 400), power, 80 slaney mel bins, `log(x + 2^-24)`, per-feature

README.md~

@@ -1,141 +0,0 @@
----
-license: cc-by-4.0
-base_model: nvidia/speakerverification_en_titanet_large
-language:
-- en
-library_name: coreai
-tags:
-- coreai
-- apple
-- ios
-- on-device
-- speaker-verification
-- speaker-recognition
-- speaker-embedding
-- titanet
-- audio
----
-
-# TitaNet-Large for Core AI
-
-[NVIDIA TitaNet-Large](https://huggingface.co/nvidia/speakerverification_en_titanet_large) (23M parameters) ported
-to Apple's **Core AI** runtime for on-device speaker verification and identification on iPhone, iPad and Mac.
-Give it 16 kHz mono speech and it returns NeMo's 192-d speaker embedding, numerically matching the original:
-**cosine ≥ 0.9999987 against NeMo's `get_embedding` on real recordings from 4 to 65 seconds.**
-
-One small bundle (47 MB) handles audio of any length: the graph is compiled for a single 5.12 s window, and a short
-host loop sweeps that window over the clip and rebuilds the model's global statistics exactly. On an iPhone it peaks
-at **117 MB** of memory and embeds a 65-second clip in **1.1 s** on the GPU.
-
-## Results
-
-All comparisons are against NeMo's own embedding of the same audio (the `.nemo` checkpoint, `get_embedding`).
-
-| Check | Clips | Cosine to NeMo (min / mean) | Notes |
-|---|---|---|---|
-| WAV → Python host → Core AI (Mac, GPU) | 40 VoxCeleb1-test, 4.1–64.7 s | **0.9999987** / 0.9999993 | the whole package: mel front end, windowed host, graph |
-| NeMo's mel → Swift host → Core AI (iPhone, GPU) | same 40 | **0.9999987** / 0.9999993 | all embeddings finite |
-
-Because the embeddings agree with NeMo's to within 1.3e-6 in cosine, verification behaves as the original does.
-NVIDIA reports **0.66 % EER on VoxCeleb1 (cleaned trials)** for the base model; this port was not separately
-re-scored on that benchmark.
-
-## Files
-
-| Path | What it is |
-|---|---|
-| `titanet.aimodel/` | the Core AI bundle: functions `scan` and `head`, fp16 weights, fp32 compute |
-| `export.json` | window length (512 frames), context margin (46), function signatures, precision recipe |
-| `frontend/mel_fb.f32` | slaney mel filterbank [80, 257], float32 little-endian (the checkpoint's own buffer) |
-| `frontend/mel_window.f32` | Hann window [400], periodic=False (the checkpoint's own buffer) |
-| `frontend/config.json` | front-end constants: 16 kHz, n_fft 512, hop 160, win 400, 80 mels, 192-d embedding, threshold 0.7 |
-| `python/titanet_coreai.py` | standalone Python host: mel front end + windowed scan, numpy only |
-| `swift/` | Swift host for iOS / macOS apps: `MelFrontend.swift`, `Host.swift`, `SpeakerEngine.swift` |
-
-## Input
-
-- **16 kHz, mono**, float samples in [-1, 1]. The model was trained on 16 kHz audio; resample anything else first.
-  The Python CLI reads WAV through `soundfile` and refuses other sample rates rather than resampling silently.
-- Any length from one 10 ms frame up. A few seconds of speech gives a stable embedding.
-- The front end is NeMo's `AudioToMelSpectrogramPreprocessor` in eval mode, reproduced step for step: pre-emphasis
-  0.97, centred 512-point STFT (hop 160, Hann 400), power, 80 slaney mel bins, `log(x + 2^-24)`, per-feature
-  normalization over the valid frames. The filterbank and window are the checkpoint's own buffers. Dither is
-  training-only and is not applied.
-
-## How it works
-
-### Why one window
-
-In a Core AI bundle the activation arena is sized per compiled shape and allocated for every function in the bundle.
-A ladder of input-length buckets (the usual way to handle variable-length audio) therefore costs the sum of all its
-shapes: 768 MB to over 1.1 GB measured for seven buckets. This port compiles exactly one shape, a 512-frame (5.12 s)
-window, and handles longer audio on the host.
-
-### Why a naive window is wrong, and the fix
-
-TitaNet has three reductions over the whole time axis:
-
-1. **five SqueezeExcite gates**: each block scales its channels by `sigmoid(W2 relu(W1 mean_t(x)))` over the entire
-   utterance;
-2. **the pooling mean / std** of the encoder output;
-3. **the attention softmax over time** in attentive statistics pooling.
-
-Computing these per window gives the wrong function: chunk-local SqueezeExcite alone drops the cosine to about 0.36.
-The graph here makes all three reductions *injectable* (taken as inputs) and *reportable* (partial sums returned as
-outputs), so the host can rebuild them exactly:
-
-| Pass | Calls | Rebuilds |
-|---|---|---|
-| 1–5 | `scan` per window, gate sums fed back as `s0..s4` | the SqueezeExcite fixed point: block *j*'s mean depends only on gates < *j*, so sweep *k* makes gate *k−1* exact and five sweeps make all five exact |
-| 6 | `scan` per window | pooling mean / std from running sums `x_sum`, `x_sqsum` |
-| 7 | `scan` per window, with the pooling stats | the attention softmax, merged across windows by running maximum (`lmax`, `den`, `ax`, `axx`) |
-| — | `head` once | the 192-d embedding from the attentive mean and std |
-
-Every convolution is stride 1 with "same" padding and the stack's receptive field is 93 frames, so each window carries
-46 frames of real context on each side and keeps only its interior; the interiors tile the clip exactly once. A clip
-of *n* mel frames (10 ms each) uses 1 window if *n* ≤ 512, otherwise ⌈(*n* − 512) / 420⌉ + 1, and
-**7 × windows + 1** model calls. Host accumulation is float64, and host memory is O(channels), never O(frames).
-
-All five sweeps are needed: the gate residual falls to 6e-4 after two sweeps and *looks* converged while the
-embedding cosine is still 0.64. Cosine by number of sweeps: 0.066, 0.639, 0.993, 0.99996, 0.9999987.
-
-### Precision
-
-`wfp16`: weights stored as fp16 (half the bytes), all compute in fp32. A full-fp16 graph was rejected for long
-audio: its whole-utterance reductions sum thousands of frames in fp16, and the worst-case cosine fell to 0.72 on
-clips up to 65 s, although it looked fine (0.99998) on 4-second clips.
-
-### Interface
-
-`scan`: one window of the clip.
-
-| Input | Shape | Meaning |
-|---|---|---|
-| `mel` | [1, 80, 512] | the window's normalized log-mel, zero past the clip's end |
-| `valid` | [1, 1, 512] | 1 for frames inside the clip |
-| `keep` | [1, 1, 512] | 1 for the window's interior frames, whose statistics this call reports |
-| `n_inv` | [1, 1] | 1 / (valid frames in the whole clip) |
-| `s0`..`s3`, `s4` | [1, 1024] ×4, [1, 3072] | SqueezeExcite sums from the previous sweep (zeros on the first) |
-| `mean`, `std` | [1, 3072] each | pooling statistics for the attention pass (zeros and ones before they are known) |
-
-Outputs, all [1, C]: `se0`..`se4` (this window's SqueezeExcite contributions), `x_sum`, `x_sqsum`, `lmax`, `den`,
-`ax`, `axx` (C = 3072).
-
-`head`: `mu`, `sg` [1, 3072] → `emb` [1, 192].
-
-## License and attribution
-
-This is a derivative of [nvidia/speakerverification_en_titanet_large](https://huggingface.co/nvidia/speakerverification_en_titanet_large)
-by NVIDIA, released under [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/); this port is released under the
-same license. 
-The weights are NVIDIA's; no retraining or fine-tuning was done.
-
-```bibtex
-@inproceedings{koluguri2022titanet,
-  title     = {TitaNet: Neural Model for Speaker Representation with 1D Depth-wise Separable Convolutions and Global Context},
-  author    = {Koluguri, Nithin Rao and Park, Taejin and Ginsburg, Boris},
-  booktitle = {ICASSP 2022 - 2022 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
-  pages     = {8102--8106},
-  year      = {2022}
-}
-```

python/titanet_coreai.py

@@ -1,262 +0,0 @@
-"""TitaNet-Large on Core AI: 16 kHz mono audio in, NeMo's 192-d speaker embedding out. numpy only, no torch.
-
-    python titanet_coreai.py a.wav b.wav [--compute gpu|ane|cpu|default]
-
-    from titanet_coreai import TitaNet
-    tn = await TitaNet.load("path/to/TitaNet-Large-CoreAI")
-    emb = await tn.embed_samples(samples)        # float32 [N] at 16 kHz -> float32 [192]
-
-The bundle compiles ONE 512-frame (5.12 s) window. Utterances of any length are handled by sweeping that window and
-rebuilding TitaNet's three global reductions on the host, exactly:
-
-  * five SqueezeExcite gates: a triangular fixed point, made exact by five sweeps over the windows
-    (sweep k makes gate k-1 exact; fewer sweeps look converged but are not);
-  * the pooling mean / std of the encoder output: one pass of running sums;
-  * the attention softmax over time: one pass, combined across windows by running maximum.
-
-Each window carries 46 frames of real context on each side (the conv stack's receptive field is 93 frames) and only
-its interior is kept, so the interiors tile the utterance exactly once. Host sums are float64.
-"""
-from __future__ import annotations
-
-import argparse
-import asyncio
-import gc
-import json
-from pathlib import Path
-
-import numpy as np
-
-# ---- the mel front end: NeMo FilterbankFeatures, eval mode ------------------------------------------------------
-
-N_FFT, HOP, WIN, N_MELS = 512, 160, 400, 80
-PREEMPH = np.float32(0.97)
-LOG_GUARD = np.float32(2.0 ** -24)
-MEL_STD_EPS = np.float32(1e-5)
-
-
-class MelFrontend:
-    """samples float32 [N] (16 kHz) -> (mel float32 [80, N // 160 + 1], valid frames N // 160).
-
-    preemphasis 0.97; centred STFT (n_fft 512, hop 160, Hann(400) centred in 512), DFT summed in float64; power;
-    slaney mel [80, 257]; log(x + 2^-24); per-feature normalization over the valid frames (unbiased std + 1e-5).
-    The filterbank and window are the checkpoint's own buffers (frontend/*.f32). Dither is training-only.
-    """
-
-    def __init__(self, fb: np.ndarray, window: np.ndarray):
-        assert fb.shape == (N_MELS, N_FFT // 2 + 1) and window.shape == (WIN,)
-        self.fb = fb.astype(np.float64)
-        w = np.zeros(N_FFT, np.float64)
-        off = (N_FFT - WIN) // 2
-        w[off:off + WIN] = window.astype(np.float64)
-        self.window = w
-        k = np.arange(N_FFT // 2 + 1)[:, None]
-        j = np.arange(N_FFT)[None, :]
-        ang = 2.0 * np.pi * ((k * j) % N_FFT) / N_FFT      # the angle reduced exactly before the trig call
-        self.cos, self.sin = np.cos(ang), -np.sin(ang)
-
-    @classmethod
-    def load(cls, frontend_dir: Path) -> "MelFrontend":
-        fb = np.fromfile(frontend_dir / "mel_fb.f32", "<f4").reshape(N_MELS, N_FFT // 2 + 1)
-        return cls(fb, np.fromfile(frontend_dir / "mel_window.f32", "<f4"))
-
-    def __call__(self, x: np.ndarray) -> tuple[np.ndarray, int]:
-        x = np.asarray(x, np.float32)
-        n_valid = len(x) // HOP
-        if len(x) == 0:
-            return np.zeros((N_MELS, 1), np.float32), 0
-        y = np.empty_like(x)
-        y[0] = x[0]
-        y[1:] = x[1:] - PREEMPH * x[:-1]
-        padded = np.concatenate([np.zeros(N_FFT // 2, np.float32), y, np.zeros(N_FFT // 2, np.float32)])
-        n_frames = 1 + (len(padded) - N_FFT) // HOP
-        idx = np.arange(N_FFT)[None, :] + HOP * np.arange(n_frames)[:, None]
-        frames = padded[idx].astype(np.float64) * self.window            # [frames, 512]
-        re = (frames @ self.cos.T).astype(np.float32)
-        im = (frames @ self.sin.T).astype(np.float32)
-        mag = np.sqrt(re * re + im * im)
-        power = mag * mag
-        mel = (self.fb @ power.T.astype(np.float64)).astype(np.float32)  # [80, frames]
-        logmel = np.log(mel.astype(np.float64) + float(LOG_GUARD)).astype(np.float32)
-        return _normalize(logmel, n_valid), n_valid
-
-
-def _normalize(x: np.ndarray, n: int) -> np.ndarray:
-    out = np.zeros_like(x)
-    if n == 0:
-        return out
-    v = x[:, :n].astype(np.float64)
-    ref = x[:, 0].astype(np.float64)
-    centered = (v - ref[:, None]).astype(np.float32).astype(np.float64)
-    mean = (ref + centered.sum(1) / n).astype(np.float32)
-    dev = (v - mean[:, None].astype(np.float64)).astype(np.float32).astype(np.float64)
-    std = np.sqrt((dev * dev).sum(1) / (n - 1.0)).astype(np.float32) if n > 1 else np.zeros(x.shape[0], np.float32)
-    out[:, :n] = (x[:, :n] - mean[:, None]) / (std + MEL_STD_EPS)[:, None]
-    return out
-
-
-# ---- the windowed host ------------------------------------------------------------------------------------------
-
-C_OUT = 3072                                   # encoder output channels
-SE_CHANNELS = (1024, 1024, 1024, 1024, 3072)   # the five SqueezeExcite blocks
-STD_EPS = 1e-10
-SWEEPS = 5
-GC_EVERY = 32
-
-
-def windows(n: int, F: int, margin: int) -> list[tuple[int, int, int]]:
-    """[(start, keep_lo, keep_hi)] in frame coordinates: the kept interiors tile [0, n) exactly once."""
-    if n <= F:
-        return [(0, 0, n)]
-    step = F - 2 * margin
-    out, s = [], 0
-    while True:
-        end = s + F
-        out.append((s, 0 if s == 0 else s + margin, n if end >= n else end - margin))
-        if end >= n:
-            return out
-        s += step
-
-
-def options(name: str):
-    from coreai.runtime import ComputeUnitKind, SpecializationOptions
-    return {"default": SpecializationOptions.default(), "cpu": SpecializationOptions.cpu_only(),
-            "gpu": SpecializationOptions.from_preferred_compute_unit_kind(ComputeUnitKind.gpu()),
-            "ane": SpecializationOptions.from_preferred_compute_unit_kind(ComputeUnitKind.neural_engine())}[name]
-
-
-class TitaNet:
-    @classmethod
-    async def load(cls, repo: str | Path, compute: str = "gpu") -> "TitaNet":
-        from coreai.runtime import AIModel
-        self = cls()
-        repo = Path(repo)
-        rec = json.loads((repo / "export.json").read_text())
-        self.F = int(rec["shape"])
-        self.margin = int(rec["margin"])
-        self.mel = MelFrontend.load(repo / "frontend")
-        self.model = await AIModel.load(repo / rec["aimodel"], options(compute))
-        self.scan = self.model.load_function("scan")
-        self.head = self.model.load_function("head")
-        self.calls = 0
-        return self
-
-    async def embed_samples(self, samples: np.ndarray) -> np.ndarray:
-        """float32 [N] at 16 kHz, mono -> embedding float32 [192]."""
-        mel, n = self.mel(samples)
-        return await self.embed_mel(mel, n)
-
-    async def embed_mel(self, mel: np.ndarray, n: int) -> np.ndarray:
-        """mel [80, >= n] with the utterance's n valid frames first -> embedding float32 [192]."""
-        if n < 1:
-            raise ValueError("the clip is shorter than one 10 ms frame")
-        wins = windows(n, self.F, self.margin)
-        n_inv = 1.0 / n
-        zero = np.zeros(C_OUT, np.float32)
-        one = np.ones(C_OUT, np.float32)
-
-        sums = [np.zeros(c, np.float64) for c in SE_CHANNELS]
-        for _ in range(SWEEPS):
-            new = [np.zeros(c, np.float64) for c in SE_CHANNELS]
-            for w in wins:
-                o = await self._scan(mel, n, w, n_inv, sums, zero, one)
-                for j in range(5):
-                    new[j] += o[f"se{j}"]
-            sums = new
-
-        sx = np.zeros(C_OUT)
-        sxx = np.zeros(C_OUT)
-        for w in wins:
-            o = await self._scan(mel, n, w, n_inv, sums, zero, one)
-            sx += o["x_sum"]
-            sxx += o["x_sqsum"]
-        pmean = sx / n
-        pstd = np.sqrt(np.maximum(sxx / n - pmean * pmean, STD_EPS))
-
-        mx = None
-        den, ax, axx = np.zeros(C_OUT), np.zeros(C_OUT), np.zeros(C_OUT)
-        for w in wins:
-            o = await self._scan(mel, n, w, n_inv, sums, pmean.astype(np.float32), pstd.astype(np.float32))
-            lmax = o["lmax"]
-            if mx is None:
-                mx, scale, f = lmax, np.zeros(C_OUT), np.ones(C_OUT)
-            else:
-                m_new = np.maximum(mx, lmax)
-                scale, f, mx = np.exp(mx - m_new), np.exp(lmax - m_new), m_new
-            den = den * scale + o["den"] * f
-            ax = ax * scale + o["ax"] * f
-            axx = axx * scale + o["axx"] * f
-        mu = ax / den
-        sg = np.sqrt(np.maximum(axx / den - mu * mu, STD_EPS))
-
-        out = await self.head({"mu": _nd(mu[None]), "sg": _nd(sg[None])})
-        self.calls += 1
-        return out["emb"].numpy().astype(np.float32)[0]
-
-    async def _scan(self, mel, n, w, n_inv, sums, pmean, pstd):
-        s, lo, hi = w
-        F = self.F
-        take = max(0, min(F, n - s))
-        mw = np.zeros((1, N_MELS, F), np.float32)
-        mw[0, :, :take] = mel[:, s:s + take]
-        vw = np.zeros((1, 1, F), np.float32)
-        vw[0, 0, :take] = 1
-        kw = np.zeros((1, 1, F), np.float32)
-        kw[0, 0, lo - s:hi - s] = 1
-        feeds = {"mel": _nd(mw), "valid": _nd(vw), "keep": _nd(kw), "n_inv": _nd(np.array([[n_inv]])),
-                 "mean": _nd(pmean[None]), "std": _nd(pstd[None])}
-        for j in range(5):
-            feeds[f"s{j}"] = _nd(sums[j][None])
-        out = await self.scan(feeds)
-        self.calls += 1
-        res = {k: v.numpy().astype(np.float64)[0] for k, v in out.items()}
-        # The Python runtime returns NDArray storage to its pool only on collection; collect regularly or a long
-        # utterance (hundreds of calls) can exhaust it. Swift hosts are not affected.
-        del out, feeds
-        if self.calls % GC_EVERY == 0:
-            gc.collect()
-        return res
-
-
-def _nd(a):
-    from coreai.runtime import NDArray
-    return NDArray(np.ascontiguousarray(a, dtype=np.float32))
-
-
-def cosine(a, b) -> float:
-    a, b = np.asarray(a, np.float64), np.asarray(b, np.float64)
-    return float(a @ b / np.sqrt((a @ a) * (b @ b)))
-
-
-def score(a, b) -> float:
-    """NeMo's verification score, (cos + 1) / 2; the same speaker at >= 0.7."""
-    return (cosine(a, b) + 1.0) / 2.0
-
-
-def read_wav(path: str | Path) -> np.ndarray:
-    import soundfile as sf
-    x, sr = sf.read(str(path), dtype="float32")
-    if x.ndim > 1:
-        x = x.mean(axis=1)
-    if sr != 16000:
-        raise ValueError(f"{path}: {sr} Hz; resample to 16 kHz first (the model was trained on 16 kHz)")
-    return x
-
-
-async def _main() -> None:
-    ap = argparse.ArgumentParser(description="Compare two recordings with TitaNet-Large on Core AI.")
-    ap.add_argument("a")
-    ap.add_argument("b")
-    ap.add_argument("--repo", default=str(Path(__file__).resolve().parent.parent))
-    ap.add_argument("--compute", default="gpu", choices=["gpu", "ane", "cpu", "default"])
-    ap.add_argument("--threshold", type=float, default=0.7)
-    args = ap.parse_args()
-    tn = await TitaNet.load(args.repo, args.compute)
-    ea = await tn.embed_samples(read_wav(args.a))
-    eb = await tn.embed_samples(read_wav(args.b))
-    sc = score(ea, eb)
-    print(f"score {sc:.4f} (cos {2 * sc - 1:.4f}): {'same speaker' if sc >= args.threshold else 'different speakers'}")
-
-
-if __name__ == "__main__":
-    asyncio.run(_main())

swift/Host.swift

@@ -1,331 +0,0 @@
-// Host — one loaded titanet.aimodel and the seven-pass windowed scan that rebuilds TitaNet's three global reductions
-// (five SqueezeExcite gates, pooling mean/std, attention softmax) exactly, from one 512-frame window swept over an
-// utterance of any length. python/titanet_coreai.py is the same algorithm in Python. Host accumulation is Double.
-
-import CoreAI
-import Foundation
-
-enum TitaNetError: Error, CustomStringConvertible {
-    case contract(String)
-    case audio(String)
-
-    var description: String {
-        switch self {
-        case .contract(let s): return s
-        case .audio(let s): return s
-        }
-    }
-}
-
-/// The fields of export.json the host needs.
-struct ExportRecord: Decodable, Sendable {
-    struct Signature: Decodable, Sendable { var inputs: [String]; var outputs: [String] }
-    var shape: Int
-    var margin: Int?
-    var entrypoints: [String]
-    var compute_dtype: String
-    var seconds_of_audio: Double?
-    var arm: String?
-    var signature: [String: Signature]?
-}
-
-/// [(start, keep_lo, keep_hi)] in global frame coordinates: interiors tile [0, n) exactly once; each window carries a 46-frame margin of real context.
-func windows(_ n: Int, _ F: Int, _ margin: Int) throws -> [(s: Int, lo: Int, hi: Int)] {
-    if n <= F { return [(0, 0, n)] }
-    let step = F - 2 * margin
-    guard step > 0 else { throw TitaNetError.contract("window \(F) is too small for a \(margin)-frame margin on each side") }
-    var out: [(Int, Int, Int)] = []
-    var s = 0
-    while true {
-        let end = s + F
-        out.append((s, s == 0 ? 0 : s + margin, end >= n ? n : end - margin))
-        if end >= n { return out }
-        s += step
-    }
-}
-
-final class Host {
-    static let stdEps = 1e-10
-    let record: ExportRecord
-    let F: Int
-    let margin: Int
-    let nMels: Int
-    let cOut: Int
-    private let model: AIModel
-    private let scan: InferenceFunction?
-    private let head: InferenceFunction?
-    private let once: InferenceFunction?
-    private let scanIn: [String: NDArrayDescriptor]
-    private let headIn: [String: NDArrayDescriptor]
-    private let onceIn: [String: NDArrayDescriptor]
-    private let seSizes: [Int]
-    private let scanOutputs: [String]
-
-    init(graph: URL, record: ExportRecord, options: SpecializationOptions) async throws {
-        // Everything is computed into locals first: a nested function or closure that touched `self` here would
-        // capture it before all of its members were initialized, which Swift 6 refuses.
-        let F = record.shape
-        let m = try await AIModel(contentsOf: graph, options: options)
-        let names = Set(m.functionNames)
-        let hasScan = record.entrypoints.contains("scan") && names.contains("scan")
-        let hasOnce = record.entrypoints.contains("once") && names.contains("once")
-        guard hasScan || hasOnce else {
-            throw TitaNetError.contract("\(graph.lastPathComponent): neither scan nor once; functions \(names.sorted())")
-        }
-        let scanD = hasScan ? try Host.descriptors(m, "scan") : [:]
-        let onceD = hasOnce ? try Host.descriptors(m, "once") : [:]
-        let headD = hasScan ? try Host.descriptors(m, "head") : [:]
-
-        guard let melD = scanD["mel"] ?? onceD["mel"], melD.shape.count == 3, melD.shape[2] == F else {
-            throw TitaNetError.contract("mel input is \((scanD["mel"] ?? onceD["mel"])?.shape.description ?? "missing"), "
-                + "expected [1, mels, \(F)]")
-        }
-        var c = 0
-        var se: [Int] = []
-        if hasScan {
-            guard let mean = scanD["mean"], mean.shape.count == 2 else { throw TitaNetError.contract("scan.mean is missing") }
-            c = mean.shape[1]
-            for j in 0..<5 {
-                guard let d = scanD["s\(j)"], d.shape.count == 2 else { throw TitaNetError.contract("scan.s\(j) is missing") }
-                se.append(d.shape[1])
-            }
-        }
-
-        self.record = record
-        self.F = F
-        self.margin = record.margin ?? 46
-        self.model = m
-        // the names `scan` returns, as export.json's signature records them
-        self.scanOutputs = record.signature?["scan"]?.outputs
-            ?? ["se0", "se1", "se2", "se3", "se4", "x_sum", "x_sqsum", "lmax", "den", "ax", "axx"]
-        self.scanIn = scanD
-        self.onceIn = onceD
-        self.headIn = headD
-        self.scan = hasScan ? try Host.load(m, "scan") : nil
-        self.head = hasScan ? try Host.load(m, "head") : nil
-        self.once = hasOnce ? try Host.load(m, "once") : nil
-        self.nMels = melD.shape[1]
-        self.cOut = c
-        self.seSizes = se
-    }
-
-    /// Every NDArray input of `name`, by name, as the graph itself declares it (shape and scalar type).
-    private static func descriptors(_ model: AIModel, _ name: String) throws -> [String: NDArrayDescriptor] {
-        guard let md = model.functionDescriptor(for: name) else { throw TitaNetError.contract("\(name): no function descriptor") }
-        var out: [String: NDArrayDescriptor] = [:]
-        for i in md.inputNames {
-            guard let d = ND.descriptor(md.inputDescriptor(of: i)) else {
-                throw TitaNetError.contract("\(name).\(i) is not an NDArray input")
-            }
-            out[i] = d
-        }
-        return out
-    }
-
-    private static func load(_ model: AIModel, _ name: String) throws -> InferenceFunction {
-        guard let fn = try model.loadFunction(named: name) else { throw TitaNetError.contract("\(name) did not load") }
-        return fn
-    }
-
-    /// mel: [nMels * n] feature-major with the utterance's n valid frames first. emb [192] is returned unchecked.
-    func embed(mel: [Float], n: Int, progress: @MainActor @Sendable @escaping (String) -> Void) async throws
-        -> (emb: [Double], calls: Int, windows: Int) {
-        guard n >= 1 else { throw TitaNetError.contract("no valid mel frame") }
-        if n <= F, let once {
-            let (mw, vw, _) = window(mel, n: n, s: 0, keep: (0, n))
-            var inputs: [String: NDArray] = [:]
-            inputs["mel"] = nd(mw, onceIn["mel"]!)
-            inputs["valid"] = nd(vw, onceIn["valid"]!)
-            var o = try await once.run(inputs: inputs)
-            guard let e = o.remove("emb")?.ndArray else { throw TitaNetError.contract("once: no emb output") }
-            return (ND.doubles(e), 1, 1)
-        }
-        guard let scan, let head else { throw TitaNetError.contract("\(n) frames need the scan path, which this bundle lacks") }
-        let wins = try windows(n, F, margin)
-        let nInv = 1.0 / Double(n)
-        var calls = 0
-        var sums = seSizes.map { [Double](repeating: 0, count: $0) }
-        let zeroMean = [Double](repeating: 0, count: cOut)
-        let unitStd = [Double](repeating: 1, count: cOut)
-
-        // 1. the SqueezeExcite gate fixed point: five sweeps, the sums fed back as s0..s4
-        for sweep in 0..<5 {
-            await progress("Gate sweep \(sweep + 1) of 5")
-            var new = seSizes.map { [Double](repeating: 0, count: $0) }
-            for w in wins {
-                let o = try await call(scan, mel: mel, n: n, w: w, nInv: nInv, sums: sums, mean: zeroMean, std: unitStd)
-                calls += 1
-                for j in 0..<5 {
-                    guard let se = o["se\(j)"] else { throw TitaNetError.contract("scan: no se\(j) output") }
-                    for k in 0..<min(new[j].count, se.count) { new[j][k] += se[k] }
-                }
-            }
-            sums = new
-        }
-
-        // 2. the pooling mean / std of the encoder output
-        await progress("Pooling statistics")
-        var sx = [Double](repeating: 0, count: cOut)
-        var sxx = [Double](repeating: 0, count: cOut)
-        for w in wins {
-            let o = try await call(scan, mel: mel, n: n, w: w, nInv: nInv, sums: sums, mean: zeroMean, std: unitStd)
-            calls += 1
-            guard let a = o["x_sum"], let b = o["x_sqsum"] else { throw TitaNetError.contract("scan: no x_sum / x_sqsum") }
-            for k in 0..<cOut { sx[k] += a[k]; sxx[k] += b[k] }
-        }
-        var pmean = [Double](repeating: 0, count: cOut)
-        var pstd = [Double](repeating: 0, count: cOut)
-        for k in 0..<cOut {
-            pmean[k] = sx[k] / Double(n)
-            pstd[k] = (max(sxx[k] / Double(n) - pmean[k] * pmean[k], Host.stdEps)).squareRoot()
-        }
-
-        // 3. the attention softmax over time, combined across windows by running maximum
-        await progress("Attentive pooling")
-        var mx: [Double]? = nil
-        var den = [Double](repeating: 0, count: cOut)
-        var ax = [Double](repeating: 0, count: cOut)
-        var axx = [Double](repeating: 0, count: cOut)
-        for w in wins {
-            let o = try await call(scan, mel: mel, n: n, w: w, nInv: nInv, sums: sums, mean: pmean, std: pstd)
-            calls += 1
-            guard let lmax = o["lmax"], let d = o["den"], let a = o["ax"], let aa = o["axx"] else {
-                throw TitaNetError.contract("scan: no lmax / den / ax / axx")
-            }
-            var scale = [Double](repeating: 0, count: cOut)
-            var f = [Double](repeating: 1, count: cOut)
-            if let m = mx {
-                var mNew = [Double](repeating: 0, count: cOut)
-                for k in 0..<cOut {
-                    mNew[k] = max(m[k], lmax[k])
-                    scale[k] = exp(m[k] - mNew[k])
-                    f[k] = exp(lmax[k] - mNew[k])
-                }
-                mx = mNew
-            } else {
-                mx = lmax
-            }
-            for k in 0..<cOut {
-                den[k] = den[k] * scale[k] + d[k] * f[k]
-                ax[k] = ax[k] * scale[k] + a[k] * f[k]
-                axx[k] = axx[k] * scale[k] + aa[k] * f[k]
-            }
-        }
-        var mu = [Double](repeating: 0, count: cOut)
-        var sg = [Double](repeating: 0, count: cOut)
-        for k in 0..<cOut {
-            let q = den[k] == 0 ? 0 : ax[k] / den[k]
-            mu[k] = q
-            let v = den[k] == 0 ? Host.stdEps : axx[k] / den[k] - q * q
-            sg[k] = max(v, Host.stdEps).squareRoot()
-        }
-
-        await progress("Embedding head")
-        var inputs: [String: NDArray] = [:]
-        inputs["mu"] = nd(mu.map { Float($0) }, headIn["mu"]!)
-        inputs["sg"] = nd(sg.map { Float($0) }, headIn["sg"]!)
-        var o = try await head.run(inputs: inputs)
-        calls += 1
-        guard let e = o.remove("emb")?.ndArray else { throw TitaNetError.contract("head: no emb output") }
-        return (ND.doubles(e), calls, wins.count)
-    }
-
-    /// One `scan` call with its eleven inputs.
-    private func call(_ scan: InferenceFunction, mel: [Float], n: Int, w: (s: Int, lo: Int, hi: Int), nInv: Double,
-                      sums: [[Double]], mean: [Double], std: [Double]) async throws -> [String: [Double]] {
-        let (mw, vw, kw) = window(mel, n: n, s: w.s, keep: (w.lo, w.hi))
-        var inputs: [String: NDArray] = [:]
-        inputs["mel"] = nd(mw, scanIn["mel"]!)
-        inputs["valid"] = nd(vw, scanIn["valid"]!)
-        inputs["keep"] = nd(kw, scanIn["keep"]!)
-        inputs["n_inv"] = nd([Float(nInv)], scanIn["n_inv"]!)
-        inputs["mean"] = nd(mean.map { Float($0) }, scanIn["mean"]!)
-        inputs["std"] = nd(std.map { Float($0) }, scanIn["std"]!)
-        for j in 0..<5 { inputs["s\(j)"] = nd(sums[j].map { Float($0) }, scanIn["s\(j)"]!) }
-        var out = try await scan.run(inputs: inputs)
-        var r: [String: [Double]] = [:]
-        for name in scanOutputs {
-            guard let a = out.remove(name)?.ndArray else { continue }
-            r[name] = ND.doubles(a)
-        }
-        return r
-    }
-
-    /// mel [nMels, n] -> (mel_w [1, nMels, F], valid_w [1, 1, F], keep_w [1, 1, F]).
-    private func window(_ mel: [Float], n: Int, s: Int, keep: (Int, Int)) -> ([Float], [Float], [Float]) {
-        var mw = [Float](repeating: 0, count: nMels * F)
-        let take = max(0, min(F, n - s))
-        if take > 0 {
-            for c in 0..<nMels {
-                let src = c * n + s
-                for f in 0..<take { mw[c * F + f] = mel[src + f] }
-            }
-        }
-        var vw = [Float](repeating: 0, count: F)
-        for f in 0..<take { vw[f] = 1 }
-        var kw = [Float](repeating: 0, count: F)
-        let lo = max(0, keep.0 - s), hi = min(F, keep.1 - s)
-        if hi > lo { for f in lo..<hi { kw[f] = 1 } }
-        return (mw, vw, kw)
-    }
-
-    /// Input dtype comes from the graph's own descriptor, which export.json `compute_dtype` set.
-    private func nd(_ v: [Float], _ d: NDArrayDescriptor) -> NDArray {
-        d.scalarType == .float16 ? ND.make(v.map { Float16($0) }, d) : ND.make(v, d)
-    }
-}
-
-// MARK: - NDArray plumbing
-
-enum ND {
-    static func descriptor(_ value: InferenceValue.Descriptor?) -> NDArrayDescriptor? {
-        guard case .ndArray(let d) = value else { return nil }
-        return d
-    }
-
-    /// A new array for `descriptor`, filled row-major from `values`.
-    static func make<T: BitwiseCopyable>(_ values: [T], _ descriptor: NDArrayDescriptor) -> NDArray {
-        var array = NDArray(descriptor: descriptor)
-        var view = array.mutableView(as: T.self)
-        view.copyElements(fromContentsOf: values)
-        return array
-    }
-
-    /// Row-major copy of an array's scalars, honoring its strides (in elements).
-    static func read<T: BitwiseCopyable>(_ array: NDArray, as type: T.Type) -> [T] {
-        let shape = array.shape
-        let count = shape.reduce(1, *)
-        return array.view(as: T.self).withUnsafePointer { ptr, _, strides in
-            var expected = 1
-            var contiguous = true
-            for d in stride(from: shape.count - 1, through: 0, by: -1) {
-                if shape[d] > 1 && strides[d] != expected {
-                    contiguous = false
-                    break
-                }
-                expected *= shape[d]
-            }
-            if contiguous { return Array(UnsafeBufferPointer(start: ptr, count: count)) }
-            var out = [T]()
-            out.reserveCapacity(count)
-            var index = [Int](repeating: 0, count: shape.count)
-            for _ in 0..<count {
-                var offset = 0
-                for d in 0..<shape.count { offset += index[d] * strides[d] }
-                out.append(ptr[offset])
-                var d = shape.count - 1
-                while d >= 0 {
-                    index[d] += 1
-                    if index[d] < shape[d] { break }
-                    index[d] = 0
-                    d -= 1
-                }
-            }
-            return out
-        }
-    }
-
-    static func doubles(_ a: NDArray) -> [Double] {
-        a.scalarType == .float16 ? read(a, as: Float16.self).map { Double($0) } : read(a, as: Float.self).map { Double($0) }
-    }
-}

swift/MelFrontend.swift

@@ -1,112 +0,0 @@
-// MelFrontend — NeMo's FilterbankFeatures (eval mode) for one utterance, the front end TitaNet-Large was trained on.
-// Needs frontend/mel_fb.f32 (slaney filterbank [80, 257]) and frontend/mel_window.f32 (Hann(400), periodic=False),
-// both the checkpoint's own buffers. python/titanet_coreai.py implements the same steps in numpy.
-//
-//   samples Float [N] (16 kHz) -> mel Float [80, N / 160 + 1] row-major (feature-major), valid frames n = N / 160
-//   1 preemphasis  y[0] = x[0], y[i] = x[i] - 0.97 x[i-1]                        (Float)
-//   2 STFT         centred, 256 zeros each side, Hann(400, periodic=false) placed at offset 56 of 512; the DFT summed
-//                  in Double (vDSP_mmulD over an exact (k j mod 512) cos / -sin basis); re / im rounded to Float
-//   3 power        sqrt(re^2 + im^2) then squared, in Float                     (NeMo: magnitude, then pow(2))
-//   4 mel          filterbank [80, 257] x power, summed in Double, rounded to Float
-//   5 log          log(mel + 2^-24) in Double, rounded to Float
-//   6 normalize    per feature over the n valid frames: reference-centred mean, unbiased std + 1e-5 (Float), frames
-//                  >= n set to 0
-
-import Accelerate
-import Foundation
-
-final class MelFrontend: @unchecked Sendable {
-    static let nFFT = 512, hop = 160, win = 400, nMels = 80, bins = 257
-    static let preemph: Float = 0.97
-    static let logGuard: Double = Double(Float(pow(2.0, -24.0)))
-    static let stdEps: Float = 1e-5
-
-    private let window: [Double]      // [512], the 400 taps centred
-    private let basis: [Double]       // [512, 514]: column k = cos(2 pi k j / 512), column 257 + k = -sin(...)
-    private let fb: [Double]          // [80, 257]
-
-    init(filterbank: [Float], window w: [Float]) {
-        precondition(filterbank.count == Self.nMels * Self.bins && w.count == Self.win)
-        var win = [Double](repeating: 0, count: Self.nFFT)
-        let off = (Self.nFFT - Self.win) / 2
-        for i in 0..<Self.win { win[off + i] = Double(w[i]) }
-        window = win
-        var b = [Double](repeating: 0, count: Self.nFFT * 2 * Self.bins)
-        for j in 0..<Self.nFFT {
-            for k in 0..<Self.bins {
-                let ang = 2.0 * Double.pi * Double((k * j) % Self.nFFT) / Double(Self.nFFT)
-                b[j * 2 * Self.bins + k] = cos(ang)
-                b[j * 2 * Self.bins + Self.bins + k] = -sin(ang)
-            }
-        }
-        basis = b
-        fb = filterbank.map(Double.init)
-    }
-
-    /// The normalized log-mel of `samples`: (mel [80 * frames] feature-major, frames, valid frames).
-    func callAsFunction(_ x: [Float]) -> (mel: [Float], frames: Int, valid: Int) {
-        let n = x.count
-        let valid = n / Self.hop
-        guard n > 0 else { return ([Float](repeating: 0, count: Self.nMels), 1, 0) }
-        // 1 preemphasis
-        var y = [Float](repeating: 0, count: n)
-        y[0] = x[0]
-        for i in 1..<n { y[i] = x[i] - Self.preemph * x[i - 1] }
-        // 2 framing of the centred, zero-padded signal
-        let pad = Self.nFFT / 2
-        let total = n + 2 * pad
-        let frames = 1 + (total - Self.nFFT) / Self.hop
-        var framed = [Double](repeating: 0, count: frames * Self.nFFT)
-        for f in 0..<frames {
-            let start = f * Self.hop - pad
-            for j in 0..<Self.nFFT {
-                let s = start + j
-                if s >= 0 && s < n { framed[f * Self.nFFT + j] = Double(y[s]) * window[j] }
-            }
-        }
-        var spec = [Double](repeating: 0, count: frames * 2 * Self.bins)
-        vDSP_mmulD(framed, 1, basis, 1, &spec, 1, vDSP_Length(frames), vDSP_Length(2 * Self.bins), vDSP_Length(Self.nFFT))
-        // 3 power, Float, stored [257, frames] in Double for the mel product
-        var power = [Double](repeating: 0, count: Self.bins * frames)
-        for f in 0..<frames {
-            for k in 0..<Self.bins {
-                let re = Float(spec[f * 2 * Self.bins + k]), im = Float(spec[f * 2 * Self.bins + Self.bins + k])
-                let mag = (re * re + im * im).squareRoot()
-                power[k * frames + f] = Double(mag * mag)
-            }
-        }
-        // 4 mel, 5 log
-        var mel64 = [Double](repeating: 0, count: Self.nMels * frames)
-        vDSP_mmulD(fb, 1, power, 1, &mel64, 1, vDSP_Length(Self.nMels), vDSP_Length(frames), vDSP_Length(Self.bins))
-        var mel = [Float](repeating: 0, count: Self.nMels * frames)
-        for i in 0..<mel.count {
-            mel[i] = Float(log(Double(Float(mel64[i])) + Self.logGuard))
-        }
-        // 6 normalize
-        Self.normalize(&mel, frames: frames, valid: valid)
-        return (mel, frames, valid)
-    }
-
-    /// normalize_batch(per_feature) for one utterance (model/host_mel.normalize).
-    static func normalize(_ x: inout [Float], frames: Int, valid n: Int) {
-        for c in 0..<nMels {
-            let row = c * frames
-            if n == 0 {
-                for f in 0..<frames { x[row + f] = 0 }
-                continue
-            }
-            let ref = Double(x[row])
-            var sum = 0.0
-            for f in 0..<n { sum += Double(Float(Double(x[row + f]) - ref)) }
-            let mean = Float(ref + sum / Double(n))
-            var ss = 0.0
-            for f in 0..<n {
-                let d = Double(Float(Double(x[row + f]) - Double(mean)))
-                ss += d * d
-            }
-            let std: Float = (n > 1 ? Float((ss / (Double(n) - 1.0)).squareRoot()) : 0) + stdEps
-            for f in 0..<n { x[row + f] = (x[row + f] - mean) / std }
-            for f in n..<frames { x[row + f] = 0 }
-        }
-    }
-}

swift/SpeakerEngine.swift

@@ -1,157 +0,0 @@
-// SpeakerEngine — 16 kHz mono samples in, the 192-d TitaNet embedding out. Owns the model (Host) and the mel front
-// end, off the main actor; every load and embed runs one at a time, in order. Looks for titanet.aimodel, export.json,
-// mel_fb.f32 and mel_window.f32 in the app bundle (Bundle.main); add them to your target's resources.
-
-import CoreAI
-import Foundation
-
-enum ComputeUnit: String, CaseIterable, Identifiable, Sendable {
-    case auto = "default", gpu, ane, cpu
-
-    var id: String { rawValue }
-
-    var label: String {
-        switch self {
-        case .auto: return "Auto"
-        case .gpu: return "GPU"
-        case .ane: return "Neural Engine"
-        case .cpu: return "CPU"
-        }
-    }
-
-    var short: String { self == .ane ? "ANE" : label }
-
-    /// Core AI specialization options for each choice
-    var options: SpecializationOptions {
-        switch self {
-        case .cpu: return .cpuOnly
-        case .gpu: return SpecializationOptions(preferredComputeUnitKind: .gpu)
-        case .ane: return SpecializationOptions(preferredComputeUnitKind: .neuralEngine)
-        case .auto: return .default
-        }
-    }
-}
-
-struct EngineInfo: Sendable, Equatable {
-    var window: Int                 // F, mel frames per scan call
-    var windowSeconds: Double
-    var margin: Int
-    var mels: Int
-    var entrypoints: [String]
-    var arm: String
-    var architecture: String
-    var compute: ComputeUnit
-    var loadSeconds: Double
-}
-
-struct Embedding: Sendable, Codable, Equatable {
-    var vector: [Float]
-    var frames: Int                 // valid mel frames (10 ms each)
-    var windows: Int
-    var calls: Int
-    var featureSeconds: Double      // the mel front end
-    var modelSeconds: Double        // scan sweeps + head
-}
-
-actor SpeakerEngine {
-    static let sampleRate = 16000
-
-    private var host: Host?
-    private var mel: MelFrontend?
-    private var tail: Task<Void, Never>?
-
-    func load(_ unit: ComputeUnit) async throws -> EngineInfo {
-        try await serially { try await self.loadNow(unit) }
-    }
-
-    func embed(_ samples: [Float], progress: @MainActor @Sendable @escaping (String) -> Void) async throws -> Embedding {
-        try await serially { try await self.embedNow(samples, progress: progress) }
-    }
-
-    private func serially<T: Sendable>(_ body: @Sendable @escaping () async throws -> T) async throws -> T {
-        let previous = tail
-        let job = Task { await previous?.value; return try await body() }
-        tail = Task { _ = try? await job.value }
-        return try await job.value
-    }
-
-    private func loadNow(_ unit: ComputeUnit) async throws -> EngineInfo {
-        host = nil      // release the old specialization before building the next
-        let res = Bundle.main
-        guard let graph = res.url(forResource: "titanet", withExtension: "aimodel"),
-              let exportURL = res.url(forResource: "export", withExtension: "json") else {
-            throw TitaNetError.contract("titanet.aimodel / export.json are missing from the app bundle")
-        }
-        let record = try JSONDecoder().decode(ExportRecord.self, from: Data(contentsOf: exportURL))
-        if mel == nil {
-            let fb = try Self.floats("mel_fb", count: MelFrontend.nMels * MelFrontend.bins)
-            let w = try Self.floats("mel_window", count: MelFrontend.win)
-            mel = MelFrontend(filterbank: fb, window: w)
-        }
-        let t0 = ContinuousClock.now
-        let h = try await Host(graph: graph, record: record, options: unit.options)
-        guard h.nMels == MelFrontend.nMels else {
-            throw TitaNetError.contract("the bundle takes \(h.nMels) mels, the front end makes \(MelFrontend.nMels)")
-        }
-        host = h
-        return EngineInfo(window: h.F, windowSeconds: Double(h.F * MelFrontend.hop) / Double(Self.sampleRate),
-                          margin: h.margin, mels: h.nMels, entrypoints: record.entrypoints, arm: record.arm ?? "—",
-                          architecture: AIModel.deviceArchitectureName, compute: unit, loadSeconds: seconds(since: t0))
-    }
-
-    private func embedNow(_ samples: [Float], progress: @MainActor @Sendable @escaping (String) -> Void) async throws -> Embedding {
-        guard let host, let mel else { throw TitaNetError.contract("the model is not loaded") }
-        await progress("Extracting log-mel features")
-        let t0 = ContinuousClock.now
-        let (m, frames, n) = mel(samples)
-        guard n >= 1 else { throw TitaNetError.audio("The clip is too short to embed.") }
-        // repack the n valid frames into a tight [80, n] buffer: the window slicer's row stride is n
-        var packed = [Float](repeating: 0, count: MelFrontend.nMels * n)
-        for c in 0..<MelFrontend.nMels {
-            let src = c * frames, dst = c * n
-            for t in 0..<n { packed[dst + t] = m[src + t] }
-        }
-        let featureSeconds = seconds(since: t0)
-        let t1 = ContinuousClock.now
-        let r = try await host.embed(mel: packed, n: n, progress: progress)
-        let vector = r.emb.map { Float($0) }
-        guard vector.allSatisfy(\.isFinite) else { throw TitaNetError.contract("the embedding is not finite") }
-        return Embedding(vector: vector, frames: n, windows: r.windows, calls: r.calls,
-                         featureSeconds: featureSeconds, modelSeconds: seconds(since: t1))
-    }
-
-    private static func floats(_ name: String, count: Int) throws -> [Float] {
-        guard let url = Bundle.main.url(forResource: name, withExtension: "f32") else {
-            throw TitaNetError.contract("\(name).f32 is missing from the app bundle")
-        }
-        let d = try Data(contentsOf: url)
-        guard d.count == 4 * count else { throw TitaNetError.contract("\(name).f32: \(d.count) bytes, expected \(4 * count)") }
-        return d.withUnsafeBytes { raw in
-            (0..<count).map { Float(bitPattern: UInt32(littleEndian: raw.loadUnaligned(fromByteOffset: 4 * $0, as: UInt32.self))) }
-        }
-    }
-}
-
-/// NeMo's speaker-verification score (verify_speakers): (cos + 1) / 2 on the raw embeddings, same speaker at >= 0.7.
-enum Scoring {
-    static let threshold = 0.7
-
-    static func cosine(_ a: [Float], _ b: [Float]) -> Double {
-        var ab = 0.0, aa = 0.0, bb = 0.0
-        for i in 0..<min(a.count, b.count) {
-            let x = Double(a[i]), y = Double(b[i])
-            ab += x * y
-            aa += x * x
-            bb += y * y
-        }
-        let d = (aa * bb).squareRoot()
-        return d == 0 ? 0 : ab / d
-    }
-
-    static func score(_ a: [Float], _ b: [Float]) -> Double { (cosine(a, b) + 1) / 2 }
-}
-
-func seconds(since t: ContinuousClock.Instant) -> Double {
-    let d = ContinuousClock.now - t
-    return Double(d.components.seconds) + Double(d.components.attoseconds) * 1e-18
-}