Wrapper code (speech-spoof-bench)

.gitignore

@@ -0,0 +1,14 @@
+# Hardware-specific TensorRT artifacts — rebuild per GPU with:
+#   CUDA_DEVICE_ORDER=PCI_BUS_ID CUDA_VISIBLE_DEVICES=<gpu> python trt_<module>.py export
+*.plan
+.trt_timing_*.cache
+
+# Python
+__pycache__/
+*.py[cod]
+.pytest_cache/
+
+# Caches & logs
+.cache/
+*.log
+*.out

LICENSE.source

@@ -0,0 +1,23 @@
+Upstream: github.com/adipiz99/RawNetLite @ fcb0fe8d0f40146d110e322c00a0723ba27d5520 (code: RawNetLite.py, audio_preprocessor.py vendored as _net.py; weights: models/triple_cross_domain_focal_rawnet_lite.pt). Its LICENSE file, verbatim:
+
+MIT License
+
+Copyright (c) 2025 Andrea Di Pierno
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

_net.py

@@ -0,0 +1,82 @@
+"""Vendored from github.com/adipiz99/RawNetLite @ fcb0fe8d0f40146d110e322c00a0723ba27d5520 (MIT, (c) 2025 Andrea Di Pierno):
+RawNetLite.py (ResBlock, RawNetLite) and audio_preprocessor.py (preprocess_audio).
+
+Edits for the Arena wrapper:
+  1. RawNetLite.forward_logit = forward without the final torch.sigmoid (returns the fc2 pre-activation, the
+     spoof logit); forward() is kept verbatim (sigmoid(spoof logit) = P(fake)). Docstrings dropped.
+  2. prep_np = numpy port of preprocess_audio for an already-mono 16 kHz clip: divide by max |x| over the WHOLE clip,
+     then keep the first 48000 samples (3 s) / right zero-pad. No resampling (the Arena delivers 16 kHz =
+     the authors' target_sr). A silent/empty clip (max |x| = 0, where the source would give NaN) -> zeros.
+"""
+import numpy as np
+import torch
+import torch.nn as nn
+
+TARGET_SR = 16000
+TARGET_SAMPLES = 48000  # audio_preprocessor.py: target_sec=3.0 at 16 kHz (shorter than the Arena 4 s cap)
+
+
+def prep_np(wav, max_len=TARGET_SAMPLES):
+    wav = np.asarray(wav, dtype=np.float32).reshape(-1)
+    peak = np.abs(wav).max() if wav.size else 0.0
+    if peak > 0:
+        wav = wav / peak
+    out = np.zeros(max_len, dtype=np.float32)
+    n = min(wav.shape[0], max_len)
+    out[:n] = wav[:n]
+    return out
+
+
+class ResBlock(nn.Module):
+    def __init__(self, channels):
+        super(ResBlock, self).__init__()
+        self.conv1 = nn.Conv1d(channels, channels, kernel_size=3, padding=1)
+        self.bn1 = nn.BatchNorm1d(channels)
+        self.relu = nn.ReLU()
+        self.conv2 = nn.Conv1d(channels, channels, kernel_size=3, padding=1)
+        self.bn2 = nn.BatchNorm1d(channels)
+
+    def forward(self, x):
+        residual = x
+        x = self.relu(self.bn1(self.conv1(x)))
+        x = self.bn2(self.conv2(x))
+        return self.relu(x + residual)
+
+
+class RawNetLite(nn.Module):
+    def __init__(self):
+        super(RawNetLite, self).__init__()
+        self.conv_pre = nn.Conv1d(1, 64, kernel_size=3, stride=1, padding=1)
+        self.bn_pre = nn.BatchNorm1d(64)
+        self.relu = nn.ReLU()
+
+        self.resblock1 = ResBlock(64)
+        self.resblock2 = ResBlock(64)
+        self.resblock3 = ResBlock(64)
+
+        self.pool = nn.AdaptiveAvgPool1d(64)  # Sequence reduction for GRU
+
+        self.gru = nn.GRU(input_size=64, hidden_size=128, num_layers=1,
+                          batch_first=True, bidirectional=True)
+
+        self.fc1 = nn.Linear(128 * 2, 64)
+        self.fc2 = nn.Linear(64, 1)
+
+    def forward_logit(self, x):  # edit 1
+        # x: [B, 1, T]
+        x = self.relu(self.bn_pre(self.conv_pre(x)))     # [B, 64, T]
+        x = self.resblock1(x)
+        x = self.resblock2(x)
+        x = self.resblock3(x)
+        x = self.pool(x)                                 # [B, 64, 64]
+
+        x = x.transpose(1, 2)                            # [B, 64, 64] -> [B, seq, feat]
+        output, _ = self.gru(x)                          # [B, 64, 256]
+        x = output[:, -1, :]                             # Last step -> [B, 256]
+
+        x = self.fc1(x)                                  # [B, 64]
+        x = self.fc2(x)                                  # [B, 1]
+        return x
+
+    def forward(self, x):
+        return torch.sigmoid(self.forward_logit(x))

cmp_scores.py

@@ -0,0 +1,22 @@
+# cmp_scores.py A/scores.txt B/scores.txt -> n, Spearman, max |diff|
+import sys
+import numpy as np
+from scipy.stats import spearmanr
+
+
+def read(p):
+    d = {}
+    for line in open(p):
+        parts = line.split()
+        if len(parts) >= 2:
+            try:
+                d[parts[0]] = float(parts[-1])
+            except ValueError:
+                pass
+    return d
+
+
+a, b = read(sys.argv[1]), read(sys.argv[2])
+k = sorted(set(a) & set(b))
+x, y = np.array([a[i] for i in k]), np.array([b[i] for i in k])
+print(f"n={len(k)} spearman={spearmanr(x, y).correlation:.6f} max_abs_diff={np.max(np.abs(x - y)):.4g}")

implementation-notes.md

@@ -0,0 +1,58 @@
+# RawNetLite — implementation notes
+
+Plan: `speech-spoof-bench/docs/plans/2026-11-09-thirteen-model-batch-arena-submission.md` (model #13).
+
+## Source
+- github.com/adipiz99/RawNetLite @ `fcb0fe8d0f40146d110e322c00a0723ba27d5520` (MIT, `LICENSE.source`), clone in
+  `_ckpt_dl/gh__adipiz99__RawNetLite/`. Vendored into `_net.py`: `RawNetLite.py` (ResBlock, RawNetLite) and
+  `audio_preprocessor.py:preprocess_audio`. Read but not needed: tester.py, trainer.py, *_dataset.py, Mixed_dataset.py.
+- Checkpoint `models/triple_cross_domain_focal_rawnet_lite.pt` (963.8 KB, sha256
+  `6154d91f34f0a49d58e30bac602915f6b6853419419804be63b5274603891a9b`): plain state_dict, 61 tensors, loads with
+  `weights_only=True`. Symlinked here. (The repo also has rawnet_lite / cross_domain(_focal) / augmented_triple variants.)
+- Paper: arXiv 2504.20923 (Di Pierno, Guarnera, Allegra, Battiato; IJCNN 2025 VERIMEDIA workshop).
+
+## Wrapper (`rawnetlite.py:RawNetLite`, `_net.py`)
+- Preprocessing = `preprocess_audio` for 16 kHz mono input: `x / max|x|` over the whole clip, then first 48000 samples
+  (3 s, authors' fixed length; under the 4 s cap so kept), right zero-pad. Authors' target_sr is 16 kHz → no resampling
+  ever. Silent/empty clip: source divides by 0 (NaN) → wrapper feeds zeros.
+- Net input [B, 1, 48000] (DataLoader stacks the [1, 48000] tensors). Output: source applies sigmoid → P(fake)
+  (tester.py: probs > 0.5 = fake, EER with pos_label=1; label 0 = real, 1 = fake). Wrapper returns **−logit(fake)**
+  (fc2 output before the sigmoid, negated): identical ranking to 1 − P(fake), no saturation ties.
+- Strict load: `load_state_dict(strict=True)`, 0 missing / 0 unexpected, all 61 tensors used (no allow-list needed).
+  Params **240,769** trainable (+ BN running stats). FP32, TF32 off.
+
+## Parity / tests
+- `source_parity.py`: authors' `RawNetLite` (imported from the pinned clone) + `preprocess_audio` + tester.py's
+  `model(waveforms).squeeze()` per clip vs the wrapper batched, 16 J-SPAW_LA clips + a short and a long clip:
+  max |Δ P(fake)| 8.5e-8, max |Δ score| (vs −logit of the source P) 8.6e-7. Log: `logs_source_parity.txt`.
+- `test_rawnetlite.py`: peak-norm-then-crop, zero-pad, silent clip, sha256, strict load, params + eval,
+  sigmoid(forward_logit) == forward, batch == single (atol 1e-4), determinism, scale invariance. 9 passed.
+
+## Training data → trained_on
+- Paper Tables I–III: FakeOrReal 25,600 + 25,600 train; "AVSpoof2021" 6,400 real + 6,400 fake train (test: 22,616 /
+  25,000 disjoint); CodecFake 6,400 + 6,400 train (triple / augmented models only). The released checkpoint is the
+  triple-domain focal model (README).
+- "AVSpoof2021": README links asvspoof.org/index2021.html; the paper never names a track, describes it as containing
+  "replay attacks, TTS, and VC", and cites the ASVspoof 2019 overview (Todisco et al.) for it. ASVspoof 2021 only
+  released evaluation data, so the training clips come from 2021 eval → ASVspoof2021_LA **and** ASVspoof2021_DF marked
+  trained_on (track unknown). Note: their test real count 22,616 is one short of DF eval's 22,617 bona fide, but the
+  6,400 extra training reals rule out a DF-only pool — so the pool likely mixes tracks (PA too?). ASVspoof 2019 data
+  cannot be excluded (citation) but is not marked — maintainer decision.
+- CodecFake: README links roger-tseng/CodecFake (Wu et al., VCTK-based); the paper cites Xie et al.'s Codecfake
+  (arXiv 2405.04880, VCTK + AISHELL-3). Neither is the Arena's CD-ADD (Li et al., arXiv 2404.04904, LibriTTS-based codec
+  TTS; provenance `CD-ADD: {parts: [train, test]}`) → no CD-ADD overlap. FakeOrReal is not an Arena set.
+- Eval-subset EERs with this wrapper (`subset_eer.py 2000 <DS>`, shard 0, seed 0): ASVspoof2019_LA 13.82%,
+  ASVspoof2021_LA 20.24%, ASVspoof2021_DF 21.25% (paper AVSpoof2021 test: 19.96%).
+
+## Sanity (PyTorch, RTX 5060 Ti idx 3)
+- Full J-SPAW_LA (`run_pt.sh`, run at batch_size 64 before the sweep set it to 1; batch-invariant to ~1e-6): EER
+  **34.189%** (2397 trials, 0 skipped). Weak, as expected for this 0.24 M-param model; not inverted.
+
+## Batch sweep (`sweep.py`, 48000-sample input)
+| card | result | choice |
+|---|---|---|
+| RTX 5060 Ti (idx 3), 2026-11-09, run twice (idle-ish, then shared with the LaST-Net lane) | 238–240 utt/s @1; 165–200 utt/s @8–192 (best batched 200 @64); 256 OOM | `batch_size = 1` |
+| RTX 4070 Ti SUPER (idx 2) | not swept (not assigned) | same 1 |
+
+## TensorRT
+Not attempted (plan: no TRT for the 1 MB row).

meta.yaml

@@ -0,0 +1,47 @@
+system:
+  name: "RawNetLite"
+  slug: "rawnetlite"
+  description: >
+    RawNetLite (Di Pierno et al., IJCNN VERIMEDIA 2025): a lightweight end-to-end raw-waveform detector --
+    Conv1D(1->64) + BatchNorm + ReLU, three 1-D residual blocks (64 ch), adaptive average pooling to 64 steps,
+    a bidirectional GRU (128 per direction, last step), Linear(256,64) -> Linear(64,1). Released checkpoint
+    triple_cross_domain_focal_rawnet_lite.pt: trained with focal loss on a balanced mix of FakeOrReal,
+    "AVSpoof2021" (the authors' name for ASVspoof 2021) and CodecFake, no augmentation. Input as the authors'
+    audio_preprocessor.py: 16 kHz mono, peak-normalised (divide by max |x| of the whole clip), first 48000
+    samples (3 s, within the Arena 4 s cap), right zero-pad. score = -logit(fake) (the pre-sigmoid fc2 output
+    negated; the source's sigmoid(logit) is P(fake)). FP32 (TF32 off).
+  code: "https://github.com/adipiz99/RawNetLite/tree/fcb0fe8d0f40146d110e322c00a0723ba27d5520"
+  checkpoint: "https://huggingface.co/SpeechAntiSpoofingBenchmarks/RawNetLite/blob/7209f7f94f1c69bc0d2320e854914e0966b12bd4/triple_cross_domain_focal_rawnet_lite.pt"
+  params_millions: 0.240769  # counted from the loaded net (240,769 trainable; asserted in test_rawnetlite.py), 2026-11-09
+  paper:
+    arxiv_id: "2504.20923"
+    url: "https://arxiv.org/abs/2504.20923"
+    bibtex: |
+      @inproceedings{dipierno2025rawnetlite,
+        title     = {End-to-end Audio Deepfake Detection from RAW Waveforms: a RawNet-Based Approach with Cross-Dataset Evaluation},
+        author    = {Andrea Di Pierno and Luca Guarnera and Dario Allegra and Sebastiano Battiato},
+        booktitle = {International Joint Conference on Neural Networks (IJCNN) - VERIMEDIA Workshop},
+        year      = {2025}
+      }
+  trained_on:
+    - SpeechAntiSpoofingBenchmarks/ASVspoof2021_LA
+    - SpeechAntiSpoofingBenchmarks/ASVspoof2021_DF
+notes: >
+  RawNetLite = github.com/adipiz99/RawNetLite @ fcb0fe8d0f40146d110e322c00a0723ba27d5520 (MIT; RawNetLite.py and
+  audio_preprocessor.py vendored), checkpoint models/triple_cross_domain_focal_rawnet_lite.pt (sha256
+  6154d91f34f0a49d58e30bac602915f6b6853419419804be63b5274603891a9b; plain state_dict, 61 tensors, weights_only,
+  strict load, all used; re-hosted under MIT). Wrapper vs the authors' RawNetLite + preprocess_audio + tester.py
+  scoring on J-SPAW clips: max |d P(fake)| 8.5e-8. Deviations: score is -logit instead of the sigmoid output
+  (same ranking, avoids float saturation ties); a silent clip (source: division by zero -> NaN) is scored as
+  zeros; no resampling (authors' target is 16 kHz too). The authors' 3 s window is kept (shorter than the 4 s cap).
+  Training data (paper Tables I-III + README): FakeOrReal (25,600+25,600), "AVSpoof2021" 6,400+6,400 and
+  CodecFake 6,400+6,400 training clips. The paper never names the ASVspoof 2021 track and 2021 has no train
+  split (the training clips come from the released evaluation data), so both ASVspoof2021_LA and
+  ASVspoof2021_DF are marked trained_on (n/a*). Its citation for "AVSpoof2021" is the ASVspoof 2019 overview
+  paper and it mentions replay attacks, so ASVspoof 2019 LA/PA or 2021 PA data cannot be excluded either
+  (not marked). CodecFake is linked to roger-tseng/CodecFake (Wu et al., VCTK-based) in the README and cited as
+  Xie et al.'s Codecfake in the paper; neither is the Arena's CD-ADD (Li et al., LibriTTS-based), and FakeOrReal
+  is not an Arena set -> no further entries. Self-reported EER% (paper Table XII, this checkpoint): FoR 2.66 /
+  AVSpoof2021 19.96 / CodecFake 21.13 / triple-domain test 16.44. 2000-clip eval subsets with this wrapper:
+  ASVspoof2019_LA 13.82, ASVspoof2021_LA 20.24, ASVspoof2021_DF 21.25. J-SPAW_LA scored with this wrapper
+  (EER 34.19%).

rawnetlite.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import os
+
+import numpy as np
+import torch
+from speech_spoof_bench.model import AntiSpoofingModel
+
+from _net import TARGET_SAMPLES, RawNetLite as RawNetLiteNet, prep_np
+
+_DIR = os.path.dirname(os.path.abspath(__file__))
+# github.com/adipiz99/RawNetLite @ fcb0fe8d0f40146d110e322c00a0723ba27d5520, models/triple_cross_domain_focal_rawnet_lite.pt
+# sha256 6154d91f34f0a49d58e30bac602915f6b6853419419804be63b5274603891a9b -- plain state_dict (61 tensors), MIT
+_CKPT = os.path.join(_DIR, "triple_cross_domain_focal_rawnet_lite.pt")
+
+
+def load_state(path=_CKPT):
+    return torch.load(path, map_location="cpu", weights_only=True)
+
+
+def build_net(path=_CKPT):
+    net = RawNetLiteNet()
+    r = net.load_state_dict(load_state(path), strict=True)  # all 61 tensors used, 0 missing / 0 unexpected
+    assert not r.missing_keys and not r.unexpected_keys
+    return net
+
+
+class RawNetLite(AntiSpoofingModel):
+    name = "RawNetLite"
+    expected_sample_rate = 16000
+    batch_size = 1  # sweep 2026-11-09 (48000-sample input, RTX 5060 Ti idx 3): 238 utt/s @1, ~172-183 @8-192 (4070 not swept)
+
+    def load(self) -> None:
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        torch.backends.cudnn.allow_tf32 = False
+        torch.backends.cuda.matmul.allow_tf32 = False
+        self.net = build_net().to(self.device).eval()
+
+    @torch.no_grad()
+    def score_batch(self, audios, srs):
+        x = torch.from_numpy(np.stack([prep_np(a, TARGET_SAMPLES) for a in audios]))[:, None, :].to(self.device)
+        logit_fake = self.net.forward_logit(x)[:, 0].float()
+        # source: sigmoid(logit) = P(fake) (label 1 = fake); -logit is the same ranking without sigmoid saturation
+        return (-logit_fake).cpu().tolist()
+
+    def unload(self) -> None:
+        self.net = None
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()

source_parity.py

@@ -0,0 +1,42 @@
+# source_parity.py [SRC_DIR] -- authors' RawNetLite.RawNetLite + audio_preprocessor.preprocess_audio + tester.py scoring
+# (outputs = model(waveforms).squeeze() = P(fake)) vs this wrapper on 16 J-SPAW_LA clips (+ a short and a long clip).
+# Checkpoint loaded with weights_only=True instead of tester.py's plain torch.load. Compares -logit(P_fake) (wrapper
+# score) with -logit of the source's sigmoid output, and the source's P(fake) with sigmoid(-wrapper score).
+import io, os, sys
+import numpy as np, pyarrow.parquet as pq, soundfile as sf, torch
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+import rawnetlite as W
+src = sys.argv[1] if len(sys.argv) > 1 else os.path.join(HERE, "..", "_ckpt_dl", "gh__adipiz99__RawNetLite")
+sys.path.append(src)
+import RawNetLite as SRC  # noqa: E402  (pinned reviewed clone)
+from audio_preprocessor import preprocess_audio  # noqa: E402
+
+torch.backends.cudnn.allow_tf32 = False
+torch.backends.cuda.matmul.allow_tf32 = False
+dev = "cuda"
+ref = SRC.RawNetLite().to(dev)
+ref.load_state_dict(torch.load(W._CKPT, map_location="cpu", weights_only=True))
+ref.eval()
+m = W.RawNetLite(); m.load()
+
+d = os.path.join(HERE, "..", "J-SPAW_LA", "data")
+t = pq.read_table(os.path.join(d, "test-00000-of-00001.parquet"), columns=["audio"]).slice(0, 16).column("audio").to_pylist()
+auds = [sf.read(io.BytesIO(x["bytes"]), dtype="float32")[0] for x in t]
+auds.append(auds[0][:20000]); auds.append(np.concatenate([auds[1]] * 4))
+ours = np.array(m.score_batch(auds, [16000] * len(auds)))
+p_src = []
+with torch.no_grad():
+    for a in auds:
+        w = preprocess_audio(torch.from_numpy(a)[None, :], 16000)  # [1, 48000]
+        p_src.append(float(ref(w[None].to(dev)).squeeze()))  # DataLoader adds the batch dim -> [1, 1, 48000]
+p_src = np.array(p_src, dtype=np.float64)
+p_ours = 1.0 / (1.0 + np.exp(ours))  # sigmoid(logit_fake), logit_fake = -score
+print("lens", [len(a) for a in auds])
+print("ours score (-logit_fake)", np.round(ours, 4))
+print("source P(fake)          ", np.round(p_src, 5))
+print("max_abs_diff P(fake)", float(np.max(np.abs(p_ours - p_src))))
+ok = (p_src > 1e-6) & (p_src < 1 - 1e-6)
+print("max_abs_diff score where source P not saturated (n=%d)" % ok.sum(),
+      float(np.max(np.abs(ours[ok] - (-np.log(p_src[ok] / (1 - p_src[ok])))))) if ok.any() else "n/a")

subset_eer.py

@@ -0,0 +1,27 @@
+# subset_eer.py [N] [DATASET] -- quick EER on a fixed random eval subset (default ASVspoof2019_LA):
+# N rows sampled uniformly without replacement (seed 0) from shard 0. Cheap sanity vs the paper's ASV19 EER.
+import io, os, sys
+import numpy as np, pyarrow.parquet as pq, soundfile as sf
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+mod = __import__([m[:-3] for m in os.listdir(HERE) if m.startswith(("wst_graph_q8", "rawnetlite")) and m.endswith(".py") and not m.startswith("test_")][0])
+Cls = getattr(mod, [n for n in dir(mod) if n.startswith(("WSTGraphQ8", "RawNetLite")) and isinstance(getattr(mod, n), type) and hasattr(getattr(mod, n), "score_batch")][0])
+N = int(sys.argv[1]) if len(sys.argv) > 1 else 2000
+DS = sys.argv[2] if len(sys.argv) > 2 else "ASVspoof2019_LA"
+t = pq.read_table(os.path.join(HERE, "..", DS, "data", sorted(f for f in os.listdir(os.path.join(HERE, "..", DS, "data")) if f.startswith("test-"))[0]), columns=["audio", "label"])
+idx = np.sort(np.random.default_rng(0).choice(t.num_rows, N, replace=False))
+t = t.take(idx).to_pylist()
+m = Cls(); m.load()
+scores, labels = [], []
+B = 16
+for k in range(0, len(t), B):
+    rows = t[k:k + B]
+    scores += m.score_batch([sf.read(io.BytesIO(r["audio"]["bytes"]), dtype="float32")[0] for r in rows], [16000] * len(rows))
+    labels += [r["label"] for r in rows]
+s, y = np.array(scores), np.array(labels)
+bona, spoof = s[y == 0], s[y == 1]
+th = np.sort(s)
+frr = np.array([(bona < x).mean() for x in th]); far = np.array([(spoof >= x).mean() for x in th])
+i = np.argmin(np.abs(frr - far))
+print(f"{Cls.__name__} {DS} subset n={len(s)} bona={len(bona)} spoof={len(spoof)} EER~{100 * (frr[i] + far[i]) / 2:.3f}%")

sweep.py

@@ -0,0 +1,39 @@
+# sweep.py -- batch-size throughput sweep (48000-sample inputs = the model's fixed 3 s window)
+from __future__ import annotations
+import time
+from statistics import median
+import numpy as np
+import torch
+import rawnetlite as R
+
+_CUT = 48000
+
+
+def time_batch_sizes():
+    print("device", torch.cuda.get_device_name(), "| other GPU processes during the sweep make it unreliable (check nvidia-smi)")
+    m = R.RawNetLite(); m.load()
+    results = {}
+    for bs in [1, 8, 16, 32, 64, 96, 128, 192, 256]:
+        audios = [np.random.randn(_CUT).astype(np.float32) * 0.1 for _ in range(bs)]
+        srs = [16000] * bs
+        try:
+            m.score_batch(audios, srs); torch.cuda.synchronize()
+            reps = []
+            for _ in range(5):
+                torch.cuda.synchronize(); t0 = time.perf_counter()
+                m.score_batch(audios, srs)
+                torch.cuda.synchronize(); reps.append(time.perf_counter() - t0)
+            med = median(reps); results[bs] = bs / med
+            print(f"bs={bs:3d}  median={med*1000:8.3f} ms  utt/s={bs/med:8.2f}  peak_mem={torch.cuda.max_memory_allocated()/2**30:.2f} GiB")
+        except RuntimeError as e:  # TorchScript wraps CUDA OOM in a plain RuntimeError
+            if "out of memory" not in str(e):
+                raise
+            print(f"bs={bs:3d}  OOM"); torch.cuda.empty_cache()
+            break
+    m.unload()
+    best = max(results, key=results.get)
+    print(f"best batch_size = {best} (utt/s={results[best]:.2f})")
+
+
+if __name__ == "__main__":
+    time_batch_sizes()

test_rawnetlite.py

@@ -0,0 +1,78 @@
+import hashlib
+import io
+import os
+
+import numpy as np
+import pytest
+import torch
+
+import _net
+import rawnetlite as R
+
+SHA256 = "6154d91f34f0a49d58e30bac602915f6b6853419419804be63b5274603891a9b"
+N_PARAMS = 240_769  # trainable parameters (BN running stats / num_batches_tracked are buffers)
+
+
+def test_prep_peak_norm_then_prefix():
+    x = np.concatenate([np.full(48000, 0.1, np.float32), np.array([-0.5], np.float32), np.zeros(999, np.float32)])
+    out = _net.prep_np(x)  # peak over the WHOLE clip (0.5 lies beyond the 3 s crop)
+    assert out.shape == (48000,) and out.dtype == np.float32 and np.allclose(out, 0.2)
+
+
+def test_prep_short_right_zero_pad():
+    x = np.linspace(-0.25, 0.5, 1001, dtype=np.float32)
+    out = _net.prep_np(x)
+    assert np.allclose(out[:1001], x / 0.5) and not out[1001:].any() and abs(out.max() - 1.0) < 1e-7
+    assert not _net.prep_np(np.zeros(5000, np.float32)).any()  # silent clip -> zeros (source: NaN)
+    assert not _net.prep_np(np.zeros(0, np.float32)).any()
+
+
+def test_checkpoint_sha256():
+    assert hashlib.sha256(open(R._CKPT, "rb").read()).hexdigest() == SHA256
+
+
+def test_strict_load_all_tensors_used():
+    sd = R.load_state()
+    assert len(sd) == 61
+    net = _net.RawNetLite()
+    assert set(net.state_dict()) == set(sd)
+    r = net.load_state_dict(sd, strict=True)
+    assert not r.missing_keys and not r.unexpected_keys
+
+
+@pytest.fixture(scope="module")
+def model():
+    m = R.RawNetLite(); m.load()
+    yield m
+    m.unload()
+
+
+def test_eval_and_params(model):
+    assert not any(mod.training for mod in model.net.modules())
+    assert sum(p.numel() for p in model.net.parameters()) == N_PARAMS
+
+
+def test_logit_matches_source_sigmoid(model):
+    x = torch.randn(3, 1, 48000, device=model.device) * 0.3
+    with torch.no_grad():
+        assert torch.allclose(torch.sigmoid(model.net.forward_logit(x)), model.net(x), atol=1e-6)
+
+
+def test_shapes_and_batch_matches_single(model):
+    rng = np.random.default_rng(0)
+    a = [rng.standard_normal(n).astype(np.float32) * s for n, s in ((48000, 0.1), (20000, 0.5), (90000, 0.02), (3000, 0.3))]
+    batched = model.score_batch(a, [16000] * 4)
+    single = [model.score_batch([x], [16000])[0] for x in a]
+    assert len(batched) == 4 and all(np.isfinite(batched))
+    assert np.allclose(batched, single, atol=1e-4)
+
+
+def test_deterministic(model):
+    a = [np.random.randn(40000).astype(np.float32) * 0.1 for _ in range(3)]
+    assert model.score_batch(a, [16000] * 3) == model.score_batch(a, [16000] * 3)
+
+
+def test_scale_invariant(model):
+    x = np.random.default_rng(2).standard_normal(30000).astype(np.float32) * 0.1
+    s1, s2 = model.score_batch([x, 3 * x], [16000] * 2)
+    assert abs(s1 - s2) < 1e-4  # peak normalisation