"""Shared fixtures and metrics for the audio-text retrieval harness. Protocol (v1, pinned): * Query sets come from HF datasets whose audio is embedded in the parquet, so nothing is downloaded from YouTube, Kaggle, or Zenodo. * One "clip" is a unique row-group id. Its captions are the distinct caption strings that appear for that id. * Text-to-audio (T2A): every caption is a query; the only relevant item is its own clip. Standard single-positive AP. * Audio-to-text (A2T): every clip is a query; all captions of that clip are relevant. R@k counts a hit if any relevant caption lands in the top k. * Similarity is cosine on L2-normalized embeddings. """ from __future__ import annotations import json import time from pathlib import Path import numpy as np DATASETS = { # repo, split, glob of only the shards for that split, id/text/audio columns. # The glob matters: loading the repo by split name still fetches every split's # shards (11 GB for AudioCaps), while these globs pull only the eval shards. "clotho": { "repo": "CLAPv2/Clotho", "split": "test", "files": "data/test/*.parquet", "id_col": "index", "text_col": "text", "audio_col": "audio", "captions_per_clip": 1, }, "audiocaps": { "repo": "CLAPv2/audiocaps", "split": "test", "files": "data/test/*.parquet", "id_col": "index", "text_col": "text", "audio_col": "audio", "captions_per_clip": 1, }, # Same audio as clotho5 but only the first reference, so the effect of caption # multiplicity can be separated from the effect of the audio itself. "clotho1": { "repo": "gijs/clotho", "split": "test", "files": None, "id_col": "file_name", "caption_cols": ["caption_1"], "audio_col": "audio", "captions_per_clip": 1, }, # The five references joined into one string, matching what CLAPv2/Clotho ships. # Same audio and same words as clotho5, so it isolates text length from audio. "clotho5cat": { "repo": "gijs/clotho", "split": "test", "files": None, "id_col": "file_name", "caption_cols": ["caption_1", "caption_2", "caption_3", "caption_4", "caption_5"], "join_captions": " ", "audio_col": "audio", "captions_per_clip": 1, }, # Five references per clip on the same audio as clotho1: this is the fixture # that puts the harness on the published protocol and exercises multi-positive AP. "clotho5": { "repo": "gijs/clotho", "split": "test", "files": None, # parquet native; load by split name "id_col": "file_name", "caption_cols": ["caption_1", "caption_2", "caption_3", "caption_4", "caption_5"], "audio_col": "audio", "captions_per_clip": 5, }, } SAMPLE_RATE = 48_000 # CLAP feature extractor expects 48 kHz def load_rows(name: str, limit: int | None = None, revision: str | None = None): from datasets import load_dataset from datasets import Audio spec = DATASETS[name] if spec.get("files"): # Pull only the shards for this split, then treat them as one split. ds = load_dataset(spec["repo"], data_files=spec["files"], split="train", revision=revision) else: ds = load_dataset(spec["repo"], split=spec["split"], revision=revision) # Keep audio as raw encoded bytes and decode with soundfile below. datasets>=3 # wants torchcodec for its own decoder, and the torchcodec wheel tracks a newer # CUDA runtime than the cu128 image provides. ds = ds.cast_column(spec["audio_col"], Audio(decode=False)) if limit: ds = ds.select(range(min(limit, len(ds)))) return ds, spec def _clip_key(row, spec) -> str: """Identity of a clip is its audio, not its row id. CLAPv2/audiocaps repeats one clip across caption rows and its `index` column is a shard label, not a clip id, so grouping on it collapses the whole split into one clip. Hash the encoded audio instead. """ import hashlib audio = row.get(spec["audio_col"]) if isinstance(audio, dict) and audio.get("bytes"): return "clip_" + hashlib.sha1(audio["bytes"]).hexdigest()[:16] if isinstance(audio, dict) and audio.get("path"): return "clip_" + hashlib.sha1(str(audio["path"]).encode()).hexdigest()[:16] return str(row[spec["id_col"]]) def group_clips(ds, spec) -> list[dict]: """Collapse rows into unique clips, first-seen order. Two fixture shapes are supported: * caption_cols present -> one row per clip carrying N caption columns (clotho5: caption_1..caption_5), so every clip keeps all references; * text_col -> one caption per row, collapsed by clip identity. """ audio_col = spec["audio_col"] caption_cols = spec.get("caption_cols") text_col = spec.get("text_col") order: list[str] = [] clips: dict[str, dict] = {} for row in ds: cid = _clip_key(row, spec) if cid not in clips: clips[cid] = {"clip_id": cid, "captions": [], "audio": row[audio_col]} order.append(cid) if caption_cols: texts = [(row.get(c) or "").strip() for c in caption_cols] if spec.get("join_captions"): # one caption built from all references, the CLAPv2 convention joined = spec["join_captions"].join(t for t in texts if t) texts = [joined] else: texts = [(row.get(text_col) or "").strip()] for text in texts: if text and text not in clips[cid]["captions"]: clips[cid]["captions"].append(text) return [clips[c] for c in order if clips[c]["captions"]] def fixture_summary(clips: list[dict]) -> dict: """Counts plus a stable hash, so a v2 run can be compared to the fixture spec.""" import hashlib h = hashlib.sha1() for c in clips: h.update(("|".join([c["clip_id"], *c["captions"]])).encode()) h.update(b"\x00") caps = [len(c["captions"]) for c in clips] return { "clips": len(clips), "captions": int(sum(caps)), "min_captions_per_clip": int(min(caps)) if caps else 0, "max_captions_per_clip": int(max(caps)) if caps else 0, "fixture_sha": h.hexdigest()[:16], } def to_mono_48k(audio, orig_sr: int) -> np.ndarray: """audio: {'bytes','path'} (decode=False), {'array','sampling_rate'}, or np array.""" import io import librosa import soundfile as sf if isinstance(audio, dict) and audio.get("bytes"): arr, orig_sr = sf.read(io.BytesIO(audio["bytes"]), dtype="float32", always_2d=False) arr = np.asarray(arr, dtype=np.float32) elif isinstance(audio, dict): arr = np.asarray(audio["array"], dtype=np.float32) orig_sr = int(audio.get("sampling_rate", orig_sr)) else: arr = np.asarray(audio, dtype=np.float32) if arr.ndim > 1: arr = arr.mean(axis=1) if orig_sr != SAMPLE_RATE: arr = librosa.resample(arr, orig_sr=orig_sr, target_sr=SAMPLE_RATE) return np.ascontiguousarray(arr, dtype=np.float32) def l2norm(x: np.ndarray) -> np.ndarray: n = np.linalg.norm(x, axis=-1, keepdims=True) return x / np.clip(n, 1e-12, None) def retrieval_metrics(sim: np.ndarray, relevance: list[set[int]], ks=(1, 5, 10), per_query: bool = False, clusters: list[int] | None = None) -> dict: """sim: (n_query, n_target), higher is better. relevance: per-query target indices. With per_query=True the result also carries the two arrays a bootstrap needs: the 1-based rank of the first relevant item for every query, and the AP of every query. R@k and MRR are recoverable from the ranks, mAP from the APs. """ n_query = sim.shape[0] # stable sort so ties break by target index rather than by memory order ranks = np.argsort(-sim, axis=1, kind="stable") out = {} for k in ks: hits = 0 for i in range(n_query): top = ranks[i, :k] if any(int(j) in relevance[i] for j in top): hits += 1 out[f"r@{k}"] = hits / n_query if n_query else 0.0 aps: list[float] = [] first_ranks: list[int] = [] for i in range(n_query): rel = relevance[i] if not rel: continue found = 0 prec_sum = 0.0 first = 0 for pos, j in enumerate(ranks[i], start=1): if int(j) in rel: found += 1 if first == 0: first = pos prec_sum += found / pos if found == len(rel): break aps.append(prec_sum / len(rel)) first_ranks.append(first if first else len(ranks[i]) + 1) out["map"] = float(np.mean(aps)) if aps else 0.0 out["n_queries"] = n_query if per_query: out["first_hit_rank"] = first_ranks out["ap"] = aps # Queries inside one clip are not independent (five captions describe the # same audio), so a bootstrap has to resample clips, not queries. out["cluster"] = list(clusters) if clusters is not None else list(range(n_query)) return out def build_problem(clips: list[dict], audio_emb: np.ndarray, text_emb: np.ndarray, per_query: bool = False): """Return (t2a_metrics, a2t_metrics) from per-clip and per-caption embeddings.""" clip_index = {c["clip_id"]: i for i, c in enumerate(clips)} cap_owner: list[int] = [] for i, c in enumerate(clips): cap_owner.extend([i] * len(c["captions"])) assert len(cap_owner) == text_emb.shape[0], (len(cap_owner), text_emb.shape) a = l2norm(audio_emb) t = l2norm(text_emb) # T2A: each caption queries for its own clip sim_t2a = t @ a.T rel_t2a = [{owner} for owner in cap_owner] t2a = retrieval_metrics(sim_t2a, rel_t2a, per_query=per_query, clusters=cap_owner) # A2T: each clip queries for any of its captions sim_a2t = a @ t.T rel_a2t = [set(j for j, o in enumerate(cap_owner) if o == i) for i in range(len(clips))] a2t = retrieval_metrics(sim_a2t, rel_a2t, per_query=per_query) return t2a, a2t, clip_index def write_result(path: Path, payload: dict) -> None: path.parent.mkdir(parents=True, exist_ok=True) # newline="\n" keeps artifacts byte-identical across platforms; the default # would emit CRLF on Windows and break byte-level review of the release. path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8", newline="\n") print(f"[harness] wrote {path}") def now() -> str: return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())