Add files using upload-large-folder tool

.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,24 @@
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+(CC BY-NC-SA 4.0)
+
+The PyAra dataset (https://www.kaggle.com/datasets/alep079/pyara) is distributed
+under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+license. This repository hosts the PyAra audio repackaged in the canonical Arena
+parquet format, under the same CC BY-NC-SA 4.0 license.
+
+You are free to:
+  Share — copy and redistribute the material in any medium or format
+  Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+  Attribution   — You must give appropriate credit, provide a link to the
+                  license, and indicate if changes were made.
+  NonCommercial — You may not use the material for commercial purposes.
+  ShareAlike    — If you remix, transform, or build upon the material, you must
+                  distribute your contributions under the same license as the
+                  original.
+
+No additional restrictions — You may not apply legal terms or technological
+measures that legally restrict others from doing anything the license permits.
+
+Full legal text: https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode

README.md

@@ -0,0 +1,98 @@
+---
+license: cc-by-nc-sa-4.0
+language: [ru]
+pretty_name: "PyAra — Russian Audio Deepfake Detection"
+task_categories: [audio-classification]
+size_categories: [100K<n<1M]
+configs:
+  - config_name: default
+    data_files:
+      - {split: test, path: "data/test-*.parquet"}
+tags:
+  - anti-spoofing
+  - audio-deepfake-detection
+  - speech
+  - benchmark
+  - arena-ready
+  - russian
+arxiv: []
+---
+
+# PyAra — Russian Audio Deepfake Detection
+
+Benchmark-ready packaging of **PyAra**, a Russian-language audio anti-spoofing
+dataset (source: https://www.kaggle.com/datasets/alep079/pyara).
+
+## Overview
+
+Binary classification: **bonafide** (genuine Russian human recordings) vs.
+**spoof** (synthetic / converted speech). The spoof side is produced by **five**
+generation algorithms (`alg_1` … `alg_5`). Label is the top-level source
+directory (`Real/` → bonafide, `Fake/` → spoof), per the `fake` column of
+`final_dataset.tsv`.
+
+## License & redistribution
+
+Released under the **Creative Commons Attribution-NonCommercial-ShareAlike 4.0
+International (CC BY-NC-SA 4.0)** license. Redistribution and adaptation are
+permitted for **non-commercial** use with attribution and ShareAlike; this
+packaging is itself CC BY-NC-SA 4.0. See `LICENSE.txt`. Audio is the original
+16 kHz mono WAV, embedded bit-exactly (no re-encode — a full decode probe of all
+clips passed cleanly).
+
+## Schema
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `path` | `string` | source-relative path, e.g. `Fake/alg_1_0.wav`, unique |
+| `audio` | `Audio(16000)` | 16 kHz mono WAV |
+| `label` | `ClassLabel` | `"bonafide"` (0) / `"spoof"` (1) |
+| `notes` | `string` | JSON: `utterance_id`, `algorithm`, `gender`, `age`, `length` |
+
+`notes` example:
+```json
+{"utterance_id": "alg_1_0", "algorithm": "alg_1", "gender": "male", "age": "twenties", "length": "5.55"}
+```
+
+`utterance_id` is the source filename stem (`real_12713`, `alg_1_0`) — unique
+across the whole set.
+
+## Quick Start
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("SpeechAntiSpoofingBenchmarks/PyAra", split="test")
+print(ds[0])
+```
+
+## Stats
+
+| Stat | Value |
+|------|-------|
+| Total trials | 201,778 |
+| Bonafide (real) | 73,583 |
+| Spoof | 128,195 |
+| Spoof algorithms | alg_1 (46,505), alg_2 (10,065), alg_3 (11,165), alg_4 (25,412), alg_5 (35,048) |
+| Language | Russian |
+| Sample rate | 16 kHz mono |
+
+## Source provenance
+
+- Dataset: PyAra, https://www.kaggle.com/datasets/alep079/pyara
+- No associated academic paper.
+
+## Evaluation
+
+For evaluation instructions and submission format, see [`submissions/README.md`](submissions/README.md).
+
+## Citation
+
+```
+PyAra — Russian Audio Deepfake Detection dataset.
+https://www.kaggle.com/datasets/alep079/pyara
+```
+
+## Maintainer
+
+Contact: k.n.borodin@mtuci.ru

build_parquet.py

@@ -0,0 +1,280 @@
+"""Parquet build for the PyAra (Russian audio deepfake) HF dataset repo.
+
+PyAra (https://www.kaggle.com/datasets/alep079/pyara) — a Russian-language
+anti-spoofing set. Source layout:
+  Real/<stem>.wav   (fake=0) -> bonafide  (73,583)
+  Fake/<stem>.wav   (fake=1) -> spoof     (128,195, 5 TTS/VC algorithms alg_1..alg_5)
+  final_dataset.tsv : path, sentence, age, gender, fake, algorithm, length
+
+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 PCM_16 WAV, every
+clip >= 3.0 s. Records are processed sorted by utterance_id for stable sharding
+and near-sequential HDD reads.
+
+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 csv
+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/final_dataset")
+META_PATH = SRC_ROOT / "final_dataset.tsv"
+PARQUET_DIR = REPO_ROOT / "data"
+NUM_SHARDS = 100
+EXPECTED_ROWS = 201778
+EXPECTED_BONAFIDE = 73583
+EXPECTED_SPOOF = 128195
+TARGET_SR = 16000
+WORKERS = int(os.environ.get("PYARA_BUILD_WORKERS", "64"))
+
+FEATURES = Features(
+    {
+        "path": Value("string"),
+        "audio": Audio(sampling_rate=16000),
+        "label": ClassLabel(names=["bonafide", "spoof"]),
+        "notes": Value("string"),
+    }
+)
+
+
+def parse_metadata():
+    """Parse final_dataset.tsv -> records. Columns:
+    path, sentence, age, gender, fake, algorithm, length."""
+    records = []
+    seen = set()
+    with open(META_PATH, encoding="utf-8") as fh:
+        reader = csv.DictReader(fh, delimiter="\t")
+        for row in reader:
+            rel = row["path"].strip()
+            if not rel:
+                continue
+            stem = Path(rel).stem
+            if stem in seen:
+                raise ValueError(f"Duplicate utterance_id stem: {stem}")
+            seen.add(stem)
+            is_spoof = row["fake"].strip() == "1"
+            records.append(
+                {
+                    "uid": stem,
+                    "relpath": rel,
+                    "abspath": str(SRC_ROOT / rel),
+                    "label": "spoof" if is_spoof else "bonafide",
+                    "algorithm": (row.get("algorithm") or "").strip() or ("bonafide" if not is_spoof else ""),
+                    "gender": (row.get("gender") or "").strip(),
+                    "age": (row.get("age") or "").strip(),
+                    "length": (row.get("length") or "").strip(),
+                }
+            )
+    return records
+
+
+def build_notes(rec):
+    return json.dumps(
+        {
+            "utterance_id": rec["uid"],
+            "algorithm": rec["algorithm"],
+            "gender": rec["gender"],
+            "age": rec["age"],
+            "length": rec["length"],
+        }
+    )
+
+
+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=32):
+            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"Reading metadata from {META_PATH}")
+    records = parse_metadata()
+    print(f"Parsed {len(records)} rows")
+    if not sample_mode:
+        assert len(records) == EXPECTED_ROWS, f"Expected {EXPECTED_ROWS}, got {len(records)}"
+
+    check = records if not sample_mode else records[: max(limit * 4, limit)]
+    missing = [r["uid"] for r in check if not Path(r["abspath"]).exists()]
+    assert not missing, f"{len(missing)} wav files missing, e.g. {missing[:5]}"
+
+    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:63a101960b7be7fd40cd43ada7ba2dd4a1b1083fa3eb03eef346ba3cca2ece37
+size 1087602

data/test-00000-of-00100.parquet

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

data/test-00001-of-00100.parquet

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

data/test-00002-of-00100.parquet

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

data/test-00003-of-00100.parquet

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

data/test-00010-of-00100.parquet

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

data/test-00011-of-00100.parquet

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

data/test-00012-of-00100.parquet

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

data/test-00015-of-00100.parquet

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

data/test-00017-of-00100.parquet

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

data/test-00018-of-00100.parquet

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

data/test-00023-of-00100.parquet

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

data/test-00025-of-00100.parquet

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

data/test-00041-of-00100.parquet

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

data/test-00043-of-00100.parquet

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

data/test-00044-of-00100.parquet

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

data/test-00047-of-00100.parquet

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

data/test-00053-of-00100.parquet

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

data/test-00059-of-00100.parquet

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

data/test-00061-of-00100.parquet

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

data/test-00064-of-00100.parquet

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

data/test-00066-of-00100.parquet

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

data/test-00074-of-00100.parquet

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

data/test-00077-of-00100.parquet

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

data/test-00078-of-00100.parquet

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

data/test-00079-of-00100.parquet

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

data/test-00081-of-00100.parquet

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

data/test-00082-of-00100.parquet

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

data/test-00083-of-00100.parquet

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

data/test-00084-of-00100.parquet

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

data/test-00085-of-00100.parquet

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

data/test-00086-of-00100.parquet

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

data/test-00087-of-00100.parquet

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

data/test-00088-of-00100.parquet

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

data/test-00089-of-00100.parquet

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

data/test-00090-of-00100.parquet

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

data/test-00091-of-00100.parquet

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

data/test-00092-of-00100.parquet

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

data/test-00094-of-00100.parquet

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

data/test-00097-of-00100.parquet

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

data/test-00098-of-00100.parquet

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

data/test-00099-of-00100.parquet

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

eval.yaml

@@ -0,0 +1,26 @@
+name: PyAra
+description: >
+  PyAra — Russian-language audio anti-spoofing dataset
+  (https://www.kaggle.com/datasets/alep079/pyara). Binary classification:
+  bonafide (genuine Russian recordings) vs. spoof (synthetic/converted speech
+  from 5 algorithms alg_1..alg_5). EER over the full set (201,778 utterances:
+  73,583 bonafide / 128,195 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: ""