Add DFADD test split (canonical parquet)

.gitattributes

@@ -1,60 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro 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
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds 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
+*.tar.gz 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
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+.pytest_cache/
+*.pyc
+_clean_flac/

LICENSE.txt

@@ -0,0 +1,31 @@
+MIT License
+
+DFADD (The Diffusion and Flow-Matching Based Audio Deepfake Dataset) is released
+under the MIT License by its authors (arXiv:2409.08731). This repository hosts the
+DFADD test (eval) split repackaged in the canonical Arena parquet format.
+
+Copyright (c) 2024 The DFADD authors
+
+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.
+
+---
+
+Underlying speech: the CSTR VCTK Corpus, distributed under the Creative Commons
+Attribution 4.0 International (CC BY 4.0) license. Attribute both the DFADD
+authors and the VCTK Corpus when using this dataset.

README.md

@@ -0,0 +1,113 @@
+---
+license: mit
+language: [en]
+pretty_name: "DFADD — Diffusion and Flow-Matching Based Audio Deepfake Dataset"
+task_categories: [audio-classification]
+size_categories: [1K<n<10K]
+configs:
+  - config_name: default
+    data_files:
+      - {split: test, path: "data/test-*.parquet"}
+tags:
+  - anti-spoofing
+  - audio-deepfake-detection
+  - speech
+  - benchmark
+  - arena-ready
+  - diffusion
+  - flow-matching
+arxiv: ["2409.08731"]
+---
+
+# DFADD — Diffusion and Flow-Matching Based Audio Deepfake Dataset
+
+Benchmark-ready packaging of the **DFADD** **test (eval) split** (*DFADD: The
+Diffusion and Flow-Matching Based Audio Deepfake Dataset*, arXiv 2409.08731), a
+VCTK-derived dataset targeting the newest generation of high-quality TTS
+spoofing built on **diffusion** and **flow-matching** synthesizers.
+
+## Overview
+
+Binary classification: **bonafide** (genuine VCTK recordings) vs. **spoof**
+(text-to-speech generated from VCTK speakers). Label is the top-level source
+directory. The spoof side spans **five** modern TTS systems:
+
+| Generator | Family | Spoof clips (test) |
+|-----------|--------|--------------------|
+| Grad-TTS | diffusion | 600 |
+| Matcha-TTS | flow-matching | 600 |
+| NaturalSpeech 2 | latent diffusion | 600 |
+| PFlow-TTS | flow-matching | 600 |
+| StyleTTS 2 | diffusion (style) | 600 |
+
+The bonafide side is the genuine VCTK audio held out for the test split (755 clips).
+
+## License & redistribution
+
+Released under the **MIT License** (per the upstream DFADD release). Redistribution
+is permitted with attribution; see `LICENSE.txt`. The underlying speech derives from
+the **VCTK Corpus** (CC BY 4.0) — attribute both DFADD and VCTK. Audio is the
+original 16 kHz mono FLAC/WAV, embedded bit-exactly (no re-encode — a full decode
+probe of all test clips passed cleanly).
+
+## Schema
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `path` | `string` | source-relative path, e.g. `DATASET_GradTTS/test/p227_001_GradTTS.flac`, unique |
+| `audio` | `Audio(16000)` | 16 kHz mono |
+| `label` | `ClassLabel` | `"bonafide"` (0) / `"spoof"` (1) |
+| `notes` | `string` | JSON: `utterance_id`, `generator`, `speaker`, `attack` |
+
+`notes` example:
+```json
+{"utterance_id": "gradtts__p227_001_GradTTS", "generator": "gradtts", "speaker": "p227", "attack": "gradtts"}
+```
+
+`utterance_id` is `<generator>__<filename-stem>` — the bare stem repeats across
+generators (the same VCTK texts are synthesized), so the generator prefix is what
+makes ids unique. Bonafide ids use the `vctk__` prefix.
+
+## Quick Start
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("SpeechAntiSpoofingBenchmarks/DFADD", split="test")
+print(ds[0])
+```
+
+## Stats
+
+| Stat | Value |
+|------|-------|
+| Total trials | 3,755 |
+| Bonafide (VCTK) | 755 |
+| Spoof (TTS) | 3,000 |
+| Generators | Grad-TTS, Matcha-TTS, NaturalSpeech 2, PFlow-TTS, StyleTTS 2 (600 each) |
+| Sample rate | 16 kHz mono |
+
+## Source provenance
+
+- Paper: *DFADD: The Diffusion and Flow-Matching Based Audio Deepfake Dataset*,
+  arXiv 2409.08731 (https://arxiv.org/abs/2409.08731).
+- Underlying speech: the **VCTK Corpus** (CC BY 4.0).
+
+## Evaluation
+
+For evaluation instructions and submission format, see [`submissions/README.md`](submissions/README.md).
+
+## Citation
+
+```bibtex
+@article{du2024dfadd,
+  title   = {{DFADD: The Diffusion and Flow-Matching Based Audio Deepfake Dataset}},
+  author  = {Du, Jiawei and others},
+  journal = {arXiv preprint arXiv:2409.08731},
+  year    = {2024},
+}
+```
+
+## Maintainer
+
+Contact: k.n.borodin@mtuci.ru

build_parquet.py

@@ -0,0 +1,280 @@
+"""Parquet build for the DFADD (eval / test split) HF dataset repo.
+
+DFADD ("The Diffusion and Flow-Matching Based Audio Deepfake Dataset", arXiv
+2409.08731) packaged for the Arena. Only the **test** split is used (eval-only).
+
+Label is the top-level source directory:
+  DATASET_VCTK_BONAFIDE/test/*.wav            -> bonafide (755, VCTK)
+  DATASET_<GEN>/test/*.{flac,wav}             -> spoof    (600 each, 5 generators)
+    GradTTS, MatchaTTS, NaturalSpeech2, PflowTTS, StyleTTS2
+
+A full decode probe of all clips runs first; 0 failures -> CLEAN raw-byte embed
+(no decode/re-encode). All source audio is already 16 kHz mono. Records are
+processed sorted by utterance_id for stable sharding.
+
+Sample mode (--limit N): first N rows into a single shard, skipping full-count
+asserts -- used for the fast offline validate-dataset pass.
+"""
+
+import argparse
+import io
+import json
+import os
+import tempfile
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+
+import datasets  # noqa: E402
+import pyarrow.parquet as pq  # noqa: E402
+import soundfile as sf  # noqa: E402
+from datasets import Audio, ClassLabel, Dataset, Features, Value  # noqa: E402
+from tqdm.auto import tqdm  # noqa: E402
+
+try:
+    datasets.disable_progress_bars()
+except AttributeError:
+    from datasets.utils.logging import disable_progress_bar
+
+    disable_progress_bar()
+
+REPO_ROOT = Path(__file__).resolve().parent
+SRC_ROOT = Path("/home/kirill/mnt/users_4tb/datasets/dfadd")
+PARQUET_DIR = REPO_ROOT / "data"
+NUM_SHARDS = 2
+EXPECTED_ROWS = 3755
+EXPECTED_BONAFIDE = 755
+EXPECTED_SPOOF = 3000
+TARGET_SR = 16000
+WORKERS = int(os.environ.get("DFADD_BUILD_WORKERS", "32"))
+
+# source dir -> (label, generator)
+GENERATORS = {
+    "DATASET_VCTK_BONAFIDE": ("bonafide", "vctk"),
+    "DATASET_GradTTS": ("spoof", "gradtts"),
+    "DATASET_MatchaTTS": ("spoof", "matchatts"),
+    "DATASET_NaturalSpeech2": ("spoof", "naturalspeech2"),
+    "DATASET_PflowTTS": ("spoof", "pflowtts"),
+    "DATASET_StyleTTS2": ("spoof", "styletts2"),
+}
+
+FEATURES = Features(
+    {
+        "path": Value("string"),
+        "audio": Audio(sampling_rate=16000),
+        "label": ClassLabel(names=["bonafide", "spoof"]),
+        "notes": Value("string"),
+    }
+)
+
+
+def build_catalogue():
+    """Enumerate test-split audio across all generator dirs -> records."""
+    records = []
+    for src_dir, (label, gen) in GENERATORS.items():
+        test_dir = SRC_ROOT / src_dir / "test"
+        if not test_dir.is_dir():
+            raise FileNotFoundError(test_dir)
+        for f in test_dir.iterdir():
+            if not f.is_file() or f.suffix.lower() not in (".wav", ".flac"):
+                continue
+            stem = f.stem
+            uid = f"{gen}__{stem}"
+            speaker = stem.split("_")[0]
+            records.append(
+                {
+                    "uid": uid,
+                    "abspath": str(f),
+                    "relpath": f"{src_dir}/test/{f.name}",
+                    "label": label,
+                    "generator": gen,
+                    "speaker": speaker,
+                    "attack": "bonafide" if label == "bonafide" else gen,
+                }
+            )
+    return records
+
+
+def build_notes(rec):
+    return json.dumps(
+        {
+            "utterance_id": rec["uid"],
+            "generator": rec["generator"],
+            "speaker": rec["speaker"],
+            "attack": rec["attack"],
+        }
+    )
+
+
+def _probe_one(abspath):
+    try:
+        data, _ = sf.read(abspath)
+        if data.shape[0] == 0:
+            return f"{abspath}: empty"
+        return None
+    except Exception as e:  # noqa: BLE001
+        return f"{abspath}: {str(e).splitlines()[0][:100]}"
+
+
+def probe_decodability(records):
+    paths = [r["abspath"] for r in records]
+    failures = []
+    with ProcessPoolExecutor(max_workers=WORKERS) as ex:
+        for err in ex.map(_probe_one, paths, chunksize=16):
+            if err:
+                failures.append(err)
+    print(f"Probe: {len(failures)}/{len(paths)} clips failed soundfile decode")
+    if failures:
+        for f in failures[:10]:
+            print(f"  {f}")
+        raise RuntimeError(
+            "Source audio no longer cleanly decodable; the CLEAN raw-embed path "
+            "is unsafe. Re-introduce a re-encode stage (see ASVspoof2021_LA)."
+        )
+
+
+def _clip_duration(abspath):
+    info = sf.info(abspath)
+    return info.frames / info.samplerate
+
+
+def _ensure_long_first_row(records):
+    for i in range(len(records)):
+        if _clip_duration(records[i]["abspath"]) >= 1.0:
+            if i != 0:
+                records[0], records[i] = records[i], records[0]
+            return
+    raise RuntimeError("No clip with duration >= 1.0s found")
+
+
+def _build_shard(task):
+    shard_index, rows, num_shards = task
+    shard_name = f"test-{shard_index:05d}-of-{num_shards:05d}.parquet"
+    final = PARQUET_DIR / shard_name
+    if final.exists() and final.stat().st_size > 0:
+        return (shard_index, len(rows), "skipped")
+
+    def row_gen():
+        for rec in rows:
+            yield {
+                "path": rec["relpath"],
+                "audio": {
+                    "bytes": Path(rec["abspath"]).read_bytes(),
+                    "path": rec["relpath"],
+                },
+                "label": rec["label"],
+                "notes": build_notes(rec),
+            }
+
+    with tempfile.TemporaryDirectory() as cache:
+        ds = Dataset.from_generator(row_gen, features=FEATURES, cache_dir=cache)
+        tmp = PARQUET_DIR / f".{shard_name}.tmp"
+        ds.to_parquet(str(tmp))
+        os.replace(tmp, final)
+    return (shard_index, len(rows), "built")
+
+
+def _partition(records, num_shards):
+    n = len(records)
+    per = (n + num_shards - 1) // num_shards
+    out = []
+    for i in range(num_shards):
+        chunk = records[i * per : (i + 1) * per]
+        if chunk:
+            out.append(chunk)
+    return out
+
+
+def build():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--limit", type=int, default=None)
+    args = parser.parse_args()
+    limit = args.limit
+    sample_mode = limit is not None
+
+    print(f"Building catalogue from {SRC_ROOT}")
+    records = build_catalogue()
+    print(f"Catalogued {len(records)} clips")
+    if not sample_mode:
+        assert len(records) == EXPECTED_ROWS, f"Expected {EXPECTED_ROWS}, got {len(records)}"
+
+    records.sort(key=lambda r: r["uid"])
+    _ensure_long_first_row(records)
+    probe_decodability(records)
+
+    if sample_mode:
+        records = records[:limit]
+        num_shards = 1
+        print(f"SAMPLE MODE: {len(records)} rows -> 1 shard")
+    else:
+        num_shards = NUM_SHARDS
+
+    bona = sum(1 for r in records if r["label"] == "bonafide")
+    spoof = sum(1 for r in records if r["label"] == "spoof")
+    print(f"  bonafide={bona} spoof={spoof} total={len(records)}")
+
+    PARQUET_DIR.mkdir(parents=True, exist_ok=True)
+    keep_suffix = f"-of-{num_shards:05d}.parquet"
+    for stale in PARQUET_DIR.glob("test-*.parquet"):
+        if not stale.name.endswith(keep_suffix):
+            print(f"Removing stale shard {stale.name}")
+            stale.unlink()
+    shards = _partition(records, num_shards)
+    tasks = [(i, rows, num_shards) for i, rows in enumerate(shards)]
+    stage_workers = min(WORKERS, len(tasks))
+    print(f"Building {len(tasks)} shard(s) with {stage_workers} workers...")
+    built = skipped = 0
+    with ProcessPoolExecutor(max_workers=stage_workers) as ex:
+        for idx, n, status in tqdm(
+            ex.map(_build_shard, tasks), total=len(tasks), desc="shards", unit="shard"
+        ):
+            if status == "built":
+                built += 1
+            elif status == "skipped":
+                skipped += 1
+    print(f"Done: {built} built, {skipped} skipped")
+
+    _verify(num_shards, sample_mode)
+    print("All verifications passed!")
+
+    if not sample_mode:
+        from speech_spoof_bench import labels
+
+        out = labels.emit_labels(REPO_ROOT)
+        print(f"Wrote {out}")
+
+
+def _verify(num_shards, sample_mode):
+    shards = sorted(PARQUET_DIR.glob("test-*.parquet"))
+    total = sum(pq.read_metadata(str(f)).num_rows for f in shards)
+    uid_set, path_set, bona, spoof = set(), set(), 0, 0
+    for f in shards:
+        t = pq.read_table(str(f), columns=["path", "label", "notes"])
+        for p, lab, n in zip(
+            t.column("path").to_pylist(),
+            t.column("label").to_pylist(),
+            t.column("notes").to_pylist(),
+        ):
+            path_set.add(p)
+            uid_set.add(json.loads(n)["utterance_id"])
+            if lab == 0:
+                bona += 1
+            elif lab == 1:
+                spoof += 1
+    assert len(uid_set) == total, "Duplicate utterance_ids"
+    assert len(path_set) == total, "Duplicate paths"
+    if not sample_mode:
+        assert total == EXPECTED_ROWS, f"{total} != {EXPECTED_ROWS}"
+        assert bona == EXPECTED_BONAFIDE, f"bonafide {bona} != {EXPECTED_BONAFIDE}"
+        assert spoof == EXPECTED_SPOOF, f"spoof {spoof} != {EXPECTED_SPOOF}"
+    t0 = pq.read_table(str(shards[0]))
+    assert set(t0.column_names) == {"path", "audio", "label", "notes"}, t0.column_names
+    audio0 = t0.column("audio")[0].as_py()
+    data, sr = sf.read(io.BytesIO(audio0["bytes"]))
+    dur = len(data) / sr
+    assert sr == 16000, f"row0 sr {sr} != 16000"
+    assert dur >= 1.0, f"row0 dur {dur:.2f}s < 1.0s"
+    print(f"  verify: {total} rows, row0 {sr}Hz {dur:.2f}s decodable OK")
+
+
+if __name__ == "__main__":
+    build()

data/labels.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9fe0632779a9383b2af82ba38a04c5e361b02c53a115cea9e36bd0d5b059bd71
+size 23172

data/test-00000-of-00002.parquet

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

data/test-00001-of-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:801892a37dbc6b0af6838676e5ead70dbe77f3c02cad7df10b087211b54a5c67
+size 238579890

eval.yaml

@@ -0,0 +1,27 @@
+name: DFADD
+description: >
+  DFADD (The Diffusion and Flow-Matching Based Audio Deepfake Dataset, arXiv
+  2409.08731) — VCTK-derived anti-spoofing set targeting modern diffusion /
+  flow-matching TTS. Eval (test) split only. Binary classification: bonafide
+  (genuine VCTK) vs. spoof (Grad-TTS / Matcha-TTS / NaturalSpeech 2 / PFlow-TTS
+  / StyleTTS 2). EER over the full test set (3,755 utterances: 755 bonafide /
+  3,000 spoof).
+evaluation_framework: inspect-ai
+
+tasks:
+  - id: antispoofing_eval
+    config: default
+    split: test
+
+    field_spec:
+      input: audio
+      target: label
+
+    solvers:
+      - name: speech_spoof_bench_solver
+
+    scorers:
+      - name: speech_spoof_scorer
+
+    metrics:
+      - eer_percent

submissions/README.md

@@ -0,0 +1,81 @@
+# Benchmark Submissions
+
+To submit a result, you'll upload two files (no git clone required):
+
+1. **`scores.txt`** to **your own HF model repo** under `.eval_results/SpeechAntiSpoofingBenchmarks/ASVspoof2019_LA/scores.txt`.
+2. **`<your-slug>.yaml`** as a pull request to **this dataset repo** under `submissions/<your-slug>.yaml`.
+
+The YAML in this repo carries a pinned URL pointing at your `scores.txt`, plus its sha256. Scores files do not live in this repo.
+
+## Submitter workflow
+
+### 1. Generate `scores.txt` locally
+
+```bash
+speech-spoof-bench run \
+  --model-module <your_package>:<YourModelClass> \
+  --datasets SpeechAntiSpoofingBenchmarks/ASVspoof2019_LA
+```
+
+Output: `results/ASVspoof2019_LA/scores.txt` (one line per utterance, `<utterance_id> <score>`, higher = more bonafide).
+
+### 2. Upload `scores.txt` to your model repo
+
+```bash
+huggingface-cli upload <your-owner>/<your-model-repo> \
+  results/ASVspoof2019_LA/scores.txt \
+  .eval_results/SpeechAntiSpoofingBenchmarks/ASVspoof2019_LA/scores.txt \
+  --repo-type=model \
+  --commit-message="Add ASVspoof2019_LA scores"
+```
+
+**Note the commit sha** the CLI prints — you'll need it in the next step.
+
+### 3. Fill in the submission YAML
+
+Copy `results_template.yaml` to `<your-slug>.yaml` and fill in every field. The two most important fields:
+
+- `artifact.scores_url`: the **pinned** URL to your uploaded scores file. Use the commit sha from step 2, not `main`:
+  ```
+  https://huggingface.co/<your-owner>/<your-model-repo>/resolve/<commit-sha-from-step-2>/.eval_results/SpeechAntiSpoofingBenchmarks/ASVspoof2019_LA/scores.txt
+  ```
+  URLs with `/resolve/main/` are rejected because they're mutable.
+- `artifact.scores_sha256`: `sha256sum results/ASVspoof2019_LA/scores.txt | awk '{print $1}'`.
+
+Leave the `reproduction:` block empty — the maintainer fills it in at merge time.
+
+### 4. Open the PR via HF CLI
+
+```bash
+huggingface-cli upload \
+  SpeechAntiSpoofingBenchmarks/ASVspoof2019_LA \
+  <your-slug>.yaml submissions/<your-slug>.yaml \
+  --repo-type=dataset \
+  --create-pr \
+  --commit-message="Add <your-slug> submission"
+```
+
+The CLI prints a PR URL. That's it.
+
+### 5. Wait for maintainer reproduction
+
+A maintainer runs `speech-spoof-bench reproduce --scoring <PR-branch>`, which:
+- Fetches `scores_url`.
+- Verifies the sha256 against `artifact.scores_sha256`.
+- Recomputes EER from the file.
+- Compares to your claimed `scores.eer_percent` (must match within 1e-6).
+
+If it passes, the maintainer fills in `reproduction:` and merges. If it fails, you get a comment on the PR explaining why.
+
+## Verification levels
+
+| Level | What the maintainer checks | Cost |
+|---|---|---|
+| `scoring` (default) | sha + recomputed EER from your `scores.txt`. | Seconds. |
+| `inference` (optional, follow-up) | Re-runs your checkpoint end-to-end and regenerates `scores.txt`. Must match within 0.05% EER. | Expensive. |
+
+Submissions without a `reproduction:` block never appear in the arena.
+
+## What about git clone + push?
+
+You can do it that way too, but for a single 2 KB YAML it's massively heavier. The HF CLI path is the documented one.

submissions/results_template.yaml

@@ -0,0 +1,44 @@
+schema_version: 4
+
+system:
+  name: ""
+  slug: ""
+  description: ""
+  code: ""
+  checkpoint: ""
+  paper:
+    arxiv_id: ""
+    url: ""
+    bibtex: |
+      @article{...}
+
+dataset:
+  id: SpeechAntiSpoofingBenchmarks/ASVspoof2019_LA
+  revision: ""
+  split: test
+
+scores:
+  eer_percent: 0.0
+  n_trials: 71237
+  n_skipped: 0
+
+artifact:
+  # Must be pinned by commit sha. Pattern:
+  #   https://huggingface.co/<owner>/<repo>/resolve/<commit-sha>/.eval_results/SpeechAntiSpoofingBenchmarks/ASVspoof2019_LA/scores.txt
+  scores_url: ""
+  scores_sha256: ""
+  bench_version: ""
+
+# Leave this block empty — the maintainer fills it in at merge.
+reproduction:
+  reproduced_by: ""
+  reproduced_at: ""
+  reproduced_bench_version: ""
+  match: ""
+
+submitter:
+  hf_username: ""
+  contact: ""
+
+submitted_at: ""
+notes: ""