AnimeScore release

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,88 @@
+---
+language:
+- ja
+license: mit
+tags:
+- audio
+- speech
+- preference
+- anime
+library_name: transformers
+pipeline_tag: audio-classification
+---
+
+# AnimeScore
+
+Try the interactive demo: [AnimeScore Demo Space](https://huggingface.co/spaces/spellbrush/animescore-demo).
+
+A learned scorer for anime-like speech style. 
+Given an audio clip, it returns a scalar score; higher is more anime-like. 
+
+This is the official Huggingface model repository for the paper "[AnimeScore: A Preference-Based Dataset and Framework for Evaluating Anime-Like Speech Style](https://arxiv.org/abs/2603.11482)".
+
+For more details, please visit our [GitHub Repository](https://github.com/sizigi/animescore).
+
+## Checkpoint
+
+We release the HuBERT-based model, which achieved the best performance among the backbones we evaluated (pairwise accuracy 82.4%, AUC 0.908).
+
+| File | Size | Notes |
+|---|---:|---|
+| `model.safetensors` | ~9 MB | Released head weights |
+| `config.json` | — | Model config |
+| `modeling_animescore.py` | — | Custom modeling code (loaded via `trust_remote_code=True`) |
+
+## How to use
+
+```bash
+pip install -r requirements.txt
+```
+
+```python
+import torch, torchaudio
+from transformers import AutoModel
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model = AutoModel.from_pretrained(
+    "spellbrush/animescore",
+    trust_remote_code=True,
+).eval().to(device)
+
+wav, sr = torchaudio.load("sample.wav")
+if wav.size(0) > 1:
+    wav = wav.mean(0, keepdim=True)         # mono
+if sr != 16000:
+    wav = torchaudio.functional.resample(wav, sr, 16000)
+
+with torch.no_grad():
+    s = model.score(wav.to(device)).item()
+print(f"AnimeScore: {s:.3f}")
+```
+
+Pairwise probability:
+
+```python
+sa = model.score(wav_a.to(device))
+sb = model.score(wav_b.to(device))
+p_a_gt_b = torch.sigmoid(sa - sb).item()
+```
+
+CLI: `python example_inference.py --ckpt . --wav sample.wav`
+
+or deploy this directory as a HuggingFace Space (SDK = `gradio`).
+
+## Citation
+
+```bibtex
+@inproceedings{park2026animescore,
+  title     = {AnimeScore: A Preference-Based Dataset and Framework for
+               Evaluating Anime-Like Speech Style},
+  author    = {Park, Joonyong and Li, Jerry},
+  booktitle = {Interspeech},
+  year      = {2026}
+}
+```
+
+## License
+
+MIT License.

app.py

@@ -0,0 +1,81 @@
+"""Gradio demo for AnimeScore: audio in -> anime-likeness score out."""
+
+import sys
+from pathlib import Path
+
+import gradio as gr
+import torch
+import torchaudio
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+
+from modeling_animescore import AnimeScoreConfig, AnimeScoreRankNet
+from safetensors.torch import load_file
+
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+def _build_model() -> AnimeScoreRankNet:
+    cfg = AnimeScoreConfig.from_json_file(str(HERE / "config.json"))
+    model = AnimeScoreRankNet(cfg).to(DEVICE).eval()
+    sd = load_file(str(HERE / "model.safetensors"))
+    missing, unexpected = model.load_state_dict(sd, strict=False)
+    if [m for m in missing if not m.startswith("ssl.")]:
+        raise RuntimeError(f"unexpected missing head keys: {missing}")
+    if unexpected:
+        raise RuntimeError(f"unexpected keys in safetensors: {unexpected}")
+    return model
+
+
+MODEL = _build_model()
+TARGET_SR = MODEL.config.target_sr
+
+
+def _read_audio(path: str):
+    """Load audio to a [channels, frames] float32 tensor and its sample rate.
+
+    Uses soundfile (self-contained libsndfile) first so the demo does not depend
+    on torchaudio's optional torchcodec/ffmpeg backend; falls back to
+    torchaudio.load for the rare format libsndfile cannot decode.
+    """
+    try:
+        import soundfile as sf
+        data, sr = sf.read(path, dtype="float32", always_2d=True)  # [frames, ch]
+        return torch.from_numpy(data.T).contiguous(), sr
+    except Exception:
+        wav, sr = torchaudio.load(path)
+        return wav.to(torch.float32), sr
+
+
+def _load_wav_to_tensor(path: str) -> torch.Tensor:
+    wav, sr = _read_audio(path)
+    if wav.size(0) > 1:
+        wav = wav.mean(0, keepdim=True)
+    if sr != TARGET_SR:
+        wav = torchaudio.functional.resample(wav, sr, TARGET_SR)
+    return wav.to(DEVICE)
+
+
+def predict(audio):
+    if audio is None:
+        return "—"
+    wav = _load_wav_to_tensor(audio)
+    with torch.no_grad():
+        score = MODEL.score(wav).item()
+    return f"{score:.4f}"
+
+
+with gr.Blocks(title="AnimeScore") as demo:
+    gr.Markdown("# AnimeScore\n\nScore a speech clip for anime-likeness. Higher = more anime-like.")
+    audio_in = gr.Audio(sources=["upload", "microphone"], type="filepath", label="Audio")
+    run = gr.Button("Score", variant="primary")
+    score_out = gr.Textbox(label="AnimeScore", interactive=False)
+
+    run.click(predict, inputs=audio_in, outputs=score_out)
+    audio_in.change(predict, inputs=audio_in, outputs=score_out)
+
+
+if __name__ == "__main__":
+    demo.queue().launch()

config.json

@@ -0,0 +1,17 @@
+{
+  "model_type": "animescore_ranknet",
+  "architectures": ["AnimeScoreRankNet"],
+  "auto_map": {
+    "AutoConfig": "modeling_animescore.AnimeScoreConfig",
+    "AutoModel": "modeling_animescore.AnimeScoreRankNet"
+  },
+  "ssl_backbone": "facebook/hubert-base-ls960",
+  "ssl_feat_dim": 768,
+  "use_layer_mixing_last_k": 4,
+  "lstm_hidden": 256,
+  "lstm_layers": 1,
+  "mlp_hidden": 256,
+  "dropout": 0.1,
+  "target_sr": 16000,
+  "torch_dtype": "float32"
+}

example_inference.py

@@ -0,0 +1,99 @@
+"""Minimal inference example for the AnimeScore release.
+
+Loads the model from a local directory (or HuggingFace Hub) and scores
+either a single wav or a directory of wavs.
+
+Usage:
+    # single wav
+    python example_inference.py --ckpt . --wav path/to/audio.wav
+
+    # batch over a directory
+    python example_inference.py --ckpt . --dir path/to/wavs --csv out.csv
+
+    # pairwise probability A > B
+    python example_inference.py --ckpt . --pair a.wav b.wav
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+import torch
+import torchaudio
+from transformers import AutoModel
+
+
+def _read_audio(path: str):
+    """Load audio to a [channels, frames] float32 tensor and its sample rate.
+
+    Prefers soundfile (self-contained libsndfile) so this does not depend on
+    torchaudio's optional torchcodec/ffmpeg backend; falls back to
+    torchaudio.load for the rare format libsndfile cannot decode.
+    """
+    try:
+        import soundfile as sf
+        data, sr = sf.read(path, dtype="float32", always_2d=True)  # [frames, ch]
+        return torch.from_numpy(data.T).contiguous(), sr
+    except Exception:
+        wav, sr = torchaudio.load(path)
+        return wav.to(torch.float32), sr
+
+
+def load_wav(path: str, target_sr: int = 16000) -> torch.Tensor:
+    wav, sr = _read_audio(path)
+    if wav.size(0) > 1:
+        wav = wav.mean(dim=0, keepdim=True)
+    if sr != target_sr:
+        wav = torchaudio.functional.resample(wav, sr, target_sr)
+    return wav.squeeze(0)
+
+
+def score_paths(model, paths, device):
+    scores = []
+    for p in paths:
+        wav = load_wav(p, model.config.target_sr).unsqueeze(0).to(device)
+        s = model.score(wav).item()
+        scores.append(s)
+    return scores
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", required=True, help="HF repo id or local directory")
+    ap.add_argument("--wav", help="single wav path")
+    ap.add_argument("--dir", help="directory of wavs to score")
+    ap.add_argument("--pair", nargs=2, metavar=("A", "B"), help="two wavs for pairwise prob")
+    ap.add_argument("--csv", default="", help="optional output CSV when using --dir")
+    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    args = ap.parse_args()
+
+    model = AutoModel.from_pretrained(args.ckpt, trust_remote_code=True).eval().to(args.device)
+
+    if args.wav:
+        s = score_paths(model, [args.wav], args.device)[0]
+        print(f"{args.wav}\tanimescore={s:.4f}")
+
+    if args.dir:
+        paths = sorted(str(p) for p in Path(args.dir).glob("*.wav"))
+        scores = score_paths(model, paths, args.device)
+        if args.csv:
+            with open(args.csv, "w") as f:
+                f.write("path,animescore\n")
+                for p, s in zip(paths, scores):
+                    f.write(f"{p},{s:.6f}\n")
+            print(f"wrote {len(paths)} rows to {args.csv}")
+        else:
+            for p, s in zip(paths, scores):
+                print(f"{p}\t{s:.4f}")
+
+    if args.pair:
+        a, b = args.pair
+        sa, sb = score_paths(model, [a, b], args.device)
+        p_a_gt_b = torch.sigmoid(torch.tensor(sa - sb)).item()
+        print(f"score({a}) = {sa:.4f}")
+        print(f"score({b}) = {sb:.4f}")
+        print(f"P({os.path.basename(a)} > {os.path.basename(b)}) = {p_a_gt_b:.4f}")
+
+
+if __name__ == "__main__":
+    main()

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3450c34915c68572e38de15594ab35944ce73bf9cd100a89e392298ec1cf2af7
+size 8936708

modeling_animescore.py

@@ -0,0 +1,234 @@
+"""
+AnimeScore RankNet — HuggingFace-compatible release.
+
+Architecture:
+  audio (16 kHz mono)
+    -> frozen SSL encoder (HuBERT-base, last 4 hidden states)
+    -> softmax-weighted layer mix
+    -> BiLSTM(256, 1 layer)
+    -> mean pool over time
+    -> MLP (LayerNorm -> Linear 512->256 -> GELU -> Linear 256->1)
+    -> scalar anime-likeness score s(x)
+
+Pairwise interpretation:
+  P(a is more anime-like than b) = sigmoid(s_a - s_b)
+
+The SSL encoder is loaded from the HuggingFace Hub at model-init time
+(`config.ssl_backbone`, default `facebook/hubert-base-ls960`) and is NOT
+included in the released weights. The released safetensors contains only
+the trainable head: layer mixer + BiLSTM + MLP (~9 MB).
+
+Reference paper:
+  Joonyong Park and Jerry Li, "AnimeScore: A Preference-Based Dataset and
+  Framework for Evaluating Anime-Like Speech Style," Interspeech 2026.
+"""
+
+import os
+from typing import List, Optional
+
+import torch
+import torch.nn as nn
+from huggingface_hub import hf_hub_download
+from safetensors.torch import load_file
+from transformers import AutoModel, PretrainedConfig, PreTrainedModel
+
+
+class AnimeScoreConfig(PretrainedConfig):
+    model_type = "animescore_ranknet"
+
+    def __init__(
+        self,
+        ssl_backbone: str = "facebook/hubert-base-ls960",
+        ssl_feat_dim: int = 768,
+        use_layer_mixing_last_k: int = 4,
+        lstm_hidden: int = 256,
+        lstm_layers: int = 1,
+        mlp_hidden: int = 256,
+        dropout: float = 0.1,
+        target_sr: int = 16000,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.ssl_backbone = ssl_backbone
+        self.ssl_feat_dim = ssl_feat_dim
+        self.use_layer_mixing_last_k = int(use_layer_mixing_last_k)
+        self.lstm_hidden = int(lstm_hidden)
+        self.lstm_layers = int(lstm_layers)
+        self.mlp_hidden = int(mlp_hidden)
+        self.dropout = float(dropout)
+        self.target_sr = int(target_sr)
+
+
+class LayerMixing(nn.Module):
+    def __init__(self, n_layers: int):
+        super().__init__()
+        self.alpha = nn.Parameter(torch.zeros(n_layers))
+
+    def forward(self, hidden_states: List[torch.Tensor]) -> torch.Tensor:
+        w = torch.softmax(self.alpha, dim=0)
+        out = w[0] * hidden_states[0]
+        for i in range(1, len(hidden_states)):
+            out = out + w[i] * hidden_states[i]
+        return out
+
+
+class AnimeScoreRankNet(PreTrainedModel):
+    config_class = AnimeScoreConfig
+    main_input_name = "input_values"
+
+    def __init__(self, config: AnimeScoreConfig):
+        super().__init__(config)
+        self.ssl = AutoModel.from_pretrained(config.ssl_backbone)
+        self.ssl.config.output_hidden_states = True
+        for p in self.ssl.parameters():
+            p.requires_grad = False
+
+        if config.use_layer_mixing_last_k > 1:
+            self.layer_mixer = LayerMixing(config.use_layer_mixing_last_k)
+        else:
+            self.layer_mixer = None
+
+        self.bilstm = nn.LSTM(
+            input_size=config.ssl_feat_dim,
+            hidden_size=config.lstm_hidden,
+            num_layers=config.lstm_layers,
+            batch_first=True,
+            bidirectional=True,
+        )
+
+        out_dim = 2 * config.lstm_hidden
+        self.mlp = nn.Sequential(
+            nn.LayerNorm(out_dim),
+            nn.Dropout(config.dropout),
+            nn.Linear(out_dim, config.mlp_hidden),
+            nn.GELU(),
+            nn.Dropout(config.dropout),
+            nn.Linear(config.mlp_hidden, 1),
+        )
+
+    def _extract_feats(self, wav_16k: torch.Tensor) -> torch.Tensor:
+        out = self.ssl(input_values=wav_16k, output_hidden_states=True)
+        if self.layer_mixer is not None and out.hidden_states is not None:
+            last_k = out.hidden_states[-self.config.use_layer_mixing_last_k:]
+            return self.layer_mixer(list(last_k))
+        return out.last_hidden_state
+
+    @torch.no_grad()
+    def score(self, wav_16k: torch.Tensor) -> torch.Tensor:
+        """Return scalar anime-likeness score per waveform.
+
+        Args:
+            wav_16k: float32 tensor of shape [B, T], 16 kHz mono, values in [-1, 1].
+
+        Returns:
+            Tensor of shape [B] with raw RankNet scores.
+            Pairwise prob: P(a > b) = sigmoid(score(a) - score(b)).
+        """
+        feats = self._extract_feats(wav_16k)
+        z, _ = self.bilstm(feats)
+        zbar = z.mean(dim=1)
+        return self.mlp(zbar).squeeze(-1)
+
+    def forward(
+        self,
+        input_values: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+    ):
+        feats = self._extract_feats(input_values)
+        z, _ = self.bilstm(feats)
+        zbar = z.mean(dim=1)
+        s = self.mlp(zbar).squeeze(-1)
+        return {"score": s}
+
+    # ------------------------------------------------------------------
+    # Custom loader.
+    #
+    # The released checkpoint holds ONLY the trainable head (layer mixer +
+    # BiLSTM + MLP, ~9 MB). The frozen SSL backbone (HuBERT-base) is restored
+    # from its own Hub repo inside __init__.
+    #
+    # We override `from_pretrained` so the canonical one-liner
+    #     AutoModel.from_pretrained("spellbrush/animescore", trust_remote_code=True)
+    # works in a single call: build the full model on a real device (loading the
+    # real pretrained HuBERT in __init__), then overlay the head weights with
+    # strict=False. This intentionally bypasses transformers' meta-device
+    # fast-init, which would otherwise (a) crash on transformers>=5 — the
+    # backbone is itself loaded via from_pretrained inside __init__ — and
+    # (b) silently re-initialize the frozen backbone with random weights on
+    # transformers 4.x, yielding NaN/garbage scores.
+    # ------------------------------------------------------------------
+    _HEAD_WEIGHT_NAMES = ("model.safetensors", "pytorch_model.safetensors")
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):
+        config = kwargs.pop("config", None)
+        torch_dtype = kwargs.pop("torch_dtype", None)
+        # Hub-resolution kwargs we honor; everything else transformers/AutoModel
+        # may pass (device_map, low_cpu_mem_usage, attn_implementation, ...) is
+        # intentionally ignored — this loader runs eagerly on a real device.
+        hub_keys = (
+            "cache_dir", "force_download", "resume_download", "proxies",
+            "local_files_only", "token", "use_auth_token", "revision",
+            "subfolder", "trust_remote_code",
+        )
+        hub_kwargs = {k: kwargs[k] for k in hub_keys if k in kwargs}
+
+        if config is None:
+            config, _ = AnimeScoreConfig.from_pretrained(
+                pretrained_model_name_or_path,
+                return_unused_kwargs=True,
+                **hub_kwargs,
+            )
+
+        # Build the full model on CPU; __init__ loads the real pretrained HuBERT.
+        model = cls(config, *model_args)
+
+        # Locate and overlay the head weights.
+        weights_path = cls._resolve_head_weights(
+            str(pretrained_model_name_or_path), hub_kwargs
+        )
+        state_dict = load_file(weights_path)
+        missing, unexpected = model.load_state_dict(state_dict, strict=False)
+        head_missing = [m for m in missing if not m.startswith("ssl.")]
+        if head_missing:
+            raise RuntimeError(f"missing head keys after load: {head_missing}")
+        if unexpected:
+            raise RuntimeError(f"unexpected keys in checkpoint: {unexpected}")
+
+        if isinstance(torch_dtype, torch.dtype):
+            model = model.to(torch_dtype)
+        return model.eval()
+
+    @classmethod
+    def _resolve_head_weights(cls, path, hub_kwargs):
+        if os.path.isfile(path):
+            return path
+        if os.path.isdir(path):
+            for name in cls._HEAD_WEIGHT_NAMES:
+                candidate = os.path.join(path, name)
+                if os.path.isfile(candidate):
+                    return candidate
+            raise OSError(
+                f"None of {cls._HEAD_WEIGHT_NAMES} found in directory '{path}'."
+            )
+        # Treat `path` as a Hub repo id and download the head weights.
+        token = hub_kwargs.get("token", hub_kwargs.get("use_auth_token"))
+        dl_kwargs = {
+            k: hub_kwargs[k]
+            for k in ("cache_dir", "force_download", "proxies",
+                      "local_files_only", "revision", "subfolder")
+            if k in hub_kwargs
+        }
+        last_err = None
+        for name in cls._HEAD_WEIGHT_NAMES:
+            try:
+                return hf_hub_download(repo_id=path, filename=name, token=token, **dl_kwargs)
+            except Exception as err:  # fall through to the next candidate name
+                last_err = err
+        raise OSError(
+            f"Could not fetch head weights {cls._HEAD_WEIGHT_NAMES} from '{path}': {last_err}"
+        )
+
+
+AnimeScoreConfig.register_for_auto_class("AutoConfig")
+AnimeScoreRankNet.register_for_auto_class("AutoModel")

requirements.txt

@@ -0,0 +1,6 @@
+torch>=2.0
+transformers>=4.40
+torchaudio>=2.0
+safetensors>=0.4
+soundfile>=0.12
+gradio>=4.0

sanity_test.py

@@ -0,0 +1,86 @@
+"""Sanity check for the AnimeScore HuBERT release.
+
+What it verifies:
+  1. modeling_animescore.AnimeScoreRankNet can be built from config.json.
+  2. model.safetensors loads with zero missing/unexpected non-SSL keys.
+  3. A forward pass on a 3-second random waveform runs and returns a finite scalar.
+  4. (Optional) If --wav is given, prints the AnimeScore for that file.
+
+Usage:
+  python sanity_test.py
+  python sanity_test.py --wav path/to/clip.wav
+"""
+
+import argparse
+import math
+import os
+import sys
+
+import torch
+from safetensors.torch import load_file
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--wav", help="Optional: score this wav file as a real-data check.")
+    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    args = ap.parse_args()
+
+    here = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0, here)
+
+    from modeling_animescore import AnimeScoreConfig, AnimeScoreRankNet
+
+    print("[1/4] Building model from config.json...")
+    cfg_path = os.path.join(here, "config.json")
+    if not os.path.exists(cfg_path):
+        raise FileNotFoundError(cfg_path)
+    cfg = AnimeScoreConfig.from_json_file(cfg_path)
+    model = AnimeScoreRankNet(cfg).to(args.device).eval()
+    print(f"      backbone = {cfg.ssl_backbone}")
+    n_head = sum(p.numel() for n, p in model.named_parameters() if not n.startswith("ssl."))
+    n_ssl = sum(p.numel() for n, p in model.named_parameters() if n.startswith("ssl."))
+    print(f"      ssl = {n_ssl/1e6:.2f} M, head = {n_head/1e6:.2f} M")
+
+    print("[2/4] Loading head weights from model.safetensors...")
+    sd = load_file(os.path.join(here, "model.safetensors"))
+    missing, unexpected = model.load_state_dict(sd, strict=False)
+    head_missing = [m for m in missing if not m.startswith("ssl.")]
+    if head_missing:
+        raise RuntimeError(f"head keys missing after load: {head_missing}")
+    if unexpected:
+        raise RuntimeError(f"unexpected keys in safetensors: {unexpected}")
+    print(f"      loaded {len(sd)} head tensors, 0 missing, 0 unexpected.")
+
+    print("[3/4] Forward pass on 3 s of random audio...")
+    wav = torch.randn(1, 16000 * 3).to(args.device)
+    with torch.no_grad():
+        s = model.score(wav).item()
+    if not math.isfinite(s):
+        raise RuntimeError(f"non-finite score: {s}")
+    print(f"      score = {s:+.4f}  (random audio; value is uninformative, just non-NaN check)")
+
+    if args.wav:
+        print(f"[4/4] Scoring real audio: {args.wav}")
+        import torchaudio
+        try:
+            import soundfile as sf
+            data, sr = sf.read(args.wav, dtype="float32", always_2d=True)
+            wav = torch.from_numpy(data.T).contiguous()
+        except Exception:
+            wav, sr = torchaudio.load(args.wav)
+        if wav.size(0) > 1:
+            wav = wav.mean(0, keepdim=True)
+        if sr != cfg.target_sr:
+            wav = torchaudio.functional.resample(wav, sr, cfg.target_sr)
+        with torch.no_grad():
+            s = model.score(wav.to(args.device)).item()
+        print(f"      AnimeScore({os.path.basename(args.wav)}) = {s:+.4f}")
+    else:
+        print("[4/4] (skipped) Pass --wav to score a real audio file.")
+
+    print("\nAll sanity checks passed.")
+
+
+if __name__ == "__main__":
+    main()