| """VeriSpoof-Bench metrics (standalone: numpy only). Same definitions as the VeriSpoof research code |
| (spoofllm/evaluate.py, spoofllm/grounded_eval.py, spoofllm/reasoning_eval.py, scripts/eval_faith_heldout.py). |
| |
| closed / binary tasks EER (%) on a score (authenticity: higher = spoof; pair tasks: higher = same) and accuracy of |
| the arg-max option; per-group accuracies; macro-F1 for generator ID |
| ad_reasoning parser of the reasoning lines; decision accuracy, localization kind accuracy, span IoU on |
| partial spoofs, observation accuracy (bandwidth, low band, SNR within 10 dB, level within 5 dB, |
| clipping, digital silence), channel classes, consistency; optional token-level F1 / EER |
| (0.16 s grid) and localization-score EER; faithfulness rates from intervention decisions |
| sv_reasoning parser; verdict accuracy, verdict EER on a decision score, attribute-comparison accuracy, |
| accuracy per stratum (SAME, REVERSAL, DIFF_ATTR) and per profile support |
| """ |
| import re |
|
|
| import numpy as np |
|
|
| |
| def eer(scores, labels): |
| """Equal error rate (%). scores: higher = more positive; labels: 1 positive, 0 negative.""" |
| scores, labels = np.asarray(scores, float), np.asarray(labels, int) |
| order = np.argsort(-scores, kind="mergesort") |
| labels = labels[order] |
| p, n = labels.sum(), len(labels) - labels.sum() |
| tp, fp = np.cumsum(labels), np.cumsum(1 - labels) |
| fnr = np.concatenate([[1.0], 1 - tp / p]) |
| fpr = np.concatenate([[0.0], fp / n]) |
| i = np.argmin(np.abs(fnr - fpr)) |
| return float(100 * (fnr[i] + fpr[i]) / 2) |
|
|
|
|
| def _r(m): |
| return {k: (round(v, 4) if isinstance(v, float) else v) for k, v in m.items()} |
|
|
|
|
| def macro_f1(y, p): |
| f = [] |
| for c in np.unique(y): |
| tp = np.sum((p == c) & (y == c)) |
| prec, rec = tp / max(1, np.sum(p == c)), tp / max(1, np.sum(y == c)) |
| f.append(0.0 if tp == 0 else 2 * prec * rec / (prec + rec)) |
| return float(np.mean(f)) |
|
|
|
|
| PAIR_TASKS = {"same_generator", "same_acoustic_model", "same_vocoder"} |
| HARD = {"SG-DS": 1, "DG-SS": 0} |
|
|
|
|
| |
| def direct_metrics(items, S): |
| """items: list of item dicts (task, options, label_index, meta dict); S: (N, K) candidate scores aligned with |
| `options` (-inf where an item has fewer options). For authenticity / pair tasks a (N,) score may be given |
| instead (higher = spoof / same); accuracy then uses the threshold 0.""" |
| task = items[0]["task"] |
| y = np.array([it["label_index"] for it in items]) |
| S = np.asarray(S, float) |
| if S.ndim == 1: |
| if task == "authenticity": |
| sp = items[0]["options"].index("spoof") |
| S2 = np.zeros((len(S), 2)) |
| S2[:, sp] = S |
| S = S2 |
| else: |
| S = np.stack([S, np.zeros_like(S)], 1) |
| pred = S.argmax(1) |
| m = {"n": len(items), "acc": float(np.mean(pred == y))} |
| meta = [it["meta"] for it in items] |
| if task == "authenticity": |
| sp = items[0]["options"].index("spoof") |
| m["eer"] = eer(S[:, sp] - S[:, 1 - sp], y == sp) |
| elif task in PAIR_TASKS: |
| s, pos = S[:, 0] - S[:, 1], y == 0 |
| m["eer"] = eer(s, pos) |
| group = [x.get("quadrant") or x.get("combo") or x.get("stratum") for x in meta] |
| for g in sorted({g for g in group if g}): |
| k = np.array([x == g for x in group]) |
| m[f"acc_{g}"] = float(np.mean(pred[k] == y[k])) |
| hard = np.array([HARD.get(x.get("quadrant"), -1) >= 0 for x in meta]) |
| if hard.any() and 0 < pos[hard].sum() < hard.sum(): |
| m["eer_hard"] = eer(s[hard], pos[hard]) |
| for lr in ("SL", "DL"): |
| k = np.array([x.get("lang_rel") == lr for x in meta]) |
| if k.any() and (~k).any() and 0 < pos[k].sum() < k.sum(): |
| m[f"eer_{lr}"] = eer(s[k], pos[k]) |
| elif task == "recording_condition": |
| for a in ("noise", "reverb", "codec"): |
| sel = np.array([x.get("attr") == a for x in meta]) |
| if sel.any(): |
| m[f"acc_{a}"] = float(np.mean(pred[sel] == y[sel])) |
| elif task == "generator_id": |
| m["macro_f1"] = macro_f1(y, pred) |
| m["chance"] = float(np.mean([1 / len(it["options"]) for it in items])) |
| k = np.array([bool(x.get("speaker_known")) for x in meta]) |
| if k.any() and (~k).any(): |
| m["acc_speaker_known"], m["acc_speaker_unknown"] = float(np.mean((pred == y)[k])), float(np.mean((pred == y)[~k])) |
| return _r(m) |
|
|
|
|
| |
| NOISE_TEXT = {"clean": "no audible noise", "mild": "mild noise", "moderate": "moderate noise", |
| "severe": "severe noise", "extreme": "extreme noise"} |
| REVERB_TEXT = {"minimal": "no noticeable reverberation", "slight": "slight reverberation", |
| "moderate": "moderate reverberation", "heavy": "heavy reverberation", |
| "extreme": "extreme reverberation"} |
| CODEC_TEXT = {"none": "no codec compression", "mp3": "MP3 compression", "aac": "AAC compression", |
| "opus": "Opus compression", "narrowband": "narrowband telephone coding", |
| "neural": "neural-codec compression", "wideband": "wideband telephone coding", |
| "cascade": "MP3 and neural-codec compression in cascade"} |
| PROC_TEXT = {"trimmed": "its edge silence has been trimmed", "digital silence added": "digital silence has been added " |
| "at the edges", "low-level noise added": "low-level noise has been added at the edges", |
| "clipped": "it has been amplified and clipped", "high-pass": "it has been high-pass filtered", |
| "band-pass": "it has been band-pass filtered"} |
| AD_FIELDS = ("OBSERVATIONS", "CHANNEL_STATUS", "LOCALIZATION", "SOURCE_PROFILE", "DECISION") |
|
|
|
|
| def parse_ad(text): |
| """Grounded detection reasoning text -> checkable fields.""" |
| f = dict.fromkeys(AD_FIELDS, "") |
| for line in (text or "").split("\n"): |
| for k in AD_FIELDS: |
| if line.startswith(k + ":"): |
| f[k] = line[len(k) + 1:].strip() |
| o, c, lo, d = f["OBSERVATIONS"], f["CHANNEL_STATUS"], f["LOCALIZATION"], f["DECISION"] |
| r = {} |
| r["bw"] = "narrow" if o.startswith("Narrowband") else "reduced" if o.startswith("Reduced") else \ |
| "full" if o.startswith("Full") else None |
| r["low"] = "almost no energy below 300 Hz" in o if o else None |
| m = re.search(r"SNR about (\d+) dB", o) |
| r["snr"] = 45 if "very clean" in o else int(m.group(1)) if m else None |
| m = re.search(r"level about (-?\d+) dBFS", o) |
| r["level"] = int(m.group(1)) if m else None |
| r["clip"] = True if "audible clipping" in o else False if "no clipping" in o else None |
| m = re.search(r"digital silence at the (start and end|start|end)", o) |
| r["dsil"] = m.group(1) if m else ("none" if o else None) |
| for k, table in (("noise", NOISE_TEXT), ("reverb", REVERB_TEXT), ("codec", CODEC_TEXT)): |
| r[k] = next((cls for cls, txt in sorted(table.items(), key=lambda kv: -len(kv[1])) if txt in c), None) |
| r["proc"] = sorted(cls for cls, txt in PROC_TEXT.items() if txt in c) |
| r["loc"] = "none" if "No synthesized segment" in lo else "whole" if "whole recording is synthesized" in lo else \ |
| "partial" if "Synthesized speech at" in lo else None |
| r["spans"] = [[float(a), float(b)] for a, b in re.findall(r"(\d+\.\d+)-(\d+\.\d+) s", lo)] |
| r["decision"] = "bonafide" if d.startswith("The recording is bona fide") else \ |
| "spoof" if d.startswith("The recording is a spoof") else None |
| return r |
|
|
|
|
| def time_iou(a, b, step=0.01): |
| if not a and not b: |
| return 1.0 |
| hi = max([y for _, y in a + b] + [0.0]) + step |
| t = np.arange(0, hi, step) |
| ma = np.zeros_like(t, bool) |
| mb = np.zeros_like(t, bool) |
| for x, y in a: |
| ma |= (t >= x) & (t < y) |
| for x, y in b: |
| mb |= (t >= x) & (t < y) |
| u = (ma | mb).sum() |
| return float((ma & mb).sum() / u) if u else 1.0 |
|
|
|
|
| def ad_metrics(items, texts, loc_scores=None, flip_scores=None, token_scores=None): |
| """items: dicts with `reference` (gold text), `ref_label` (bonafide / spoof), `ref_kind` (bonafide / spoof / |
| partial), `ref_spans` (window-time spans of the heard synthesized speech) and `has_proc`; texts: the model's |
| reasoning. Optional per item: loc_scores = log p(" No synthesized segment is found.") after the model's own |
| "LOCALIZATION:" prefix (-> eer_loc); flip_scores = (logp bona fide, logp spoof) decision candidates after the |
| opposite localization (-> flip_rate); token_scores = per-token synthesized scores on the 0.16 s grid, compared with |
| `ref_token_labels` (> 0 = synthesized; use logits or probability - 0.5).""" |
| P_ = [parse_ad(t) for t in texts] |
| G = [parse_ad(it["reference"]) for it in items] |
| y = np.array([it["ref_label"] == "spoof" for it in items]) |
| m = {"n": len(items), "n_bona": int((~y).sum()), "parse_ok": float(np.mean([p["decision"] is not None for p in P_]))} |
| pred = np.array([p["decision"] == "spoof" for p in P_]) |
| m["decision_acc"] = float(np.mean(pred == y)) |
| if loc_scores is not None and 0 < y.sum() < len(y): |
| m["eer_loc"] = eer(-np.asarray(loc_scores, float), y) |
| m["loc_kind_acc"] = float(np.mean([p["loc"] == it["ref_kind"].replace("bonafide", "none").replace("spoof", "whole") |
| for p, it in zip(P_, items)])) |
| part = [k for k, it in enumerate(items) if it["ref_kind"] == "partial"] |
| if part: |
| m["loc_partial_any"] = float(np.mean([bool(P_[k]["spans"]) or P_[k]["loc"] == "whole" for k in part])) |
| m["loc_partial_iou"] = float(np.mean([time_iou([[0.0, 8.0]] if P_[k]["loc"] == "whole" else P_[k]["spans"], |
| [list(s) for s in items[k]["ref_spans"]]) for k in part])) |
| for k in ("bw", "low", "clip", "dsil"): |
| ok = [p[k] == g[k] for p, g in zip(P_, G) if g[k] is not None] |
| m[f"obs_{k}"] = float(np.mean(ok)) if ok else None |
| for k, tol in (("snr", 10), ("level", 5)): |
| ok = [p[k] is not None and abs(p[k] - g[k]) <= tol for p, g in zip(P_, G) if g[k] is not None] |
| m[f"obs_{k}_within_{tol}"] = float(np.mean(ok)) if ok else None |
| for k in ("noise", "reverb", "codec"): |
| ok = [p[k] == g[k] for p, g in zip(P_, G) if g[k] is not None] |
| if ok: |
| m[f"ch_{k}"] = float(np.mean(ok)) |
| pk = [p["proc"] == g["proc"] for p, g, it in zip(P_, G, items) if it.get("has_proc")] |
| if pk: |
| m["ch_proc_exact"] = float(np.mean(pk)) |
| m["consistency"] = float(np.mean([(p["loc"] == "none") == (p["decision"] == "bonafide") for p in P_ |
| if p["loc"] and p["decision"]])) |
| if flip_scores is not None: |
| f = np.asarray(flip_scores, float) |
| said_none = np.array(["No synthesized segment" in t for t in texts]) |
| m["flip_rate"] = float(np.where(said_none, f[:, 1] > f[:, 0], f[:, 0] > f[:, 1]).mean()) |
| if token_scores is not None: |
| lab = np.concatenate([np.asarray(it["ref_token_labels"]) for it in items]) |
| s = np.concatenate([np.asarray(z, float) for z in token_scores]) |
| k = lab >= 0 |
| lab, s = lab[k], s[k] |
| if 0 < lab.sum() < len(lab): |
| p = s > 0 |
| tp, fp, fn = (p & (lab == 1)).sum(), (p & (lab == 0)).sum(), (~p & (lab == 1)).sum() |
| m["tok_f1"] = float(2 * tp / max(1, 2 * tp + fp + fn)) |
| m["tok_eer"] = eer(s, lab) |
| return _r(m) |
|
|
|
|
| |
| DECISION_PREFIX = "DECISION: The recording is" |
| DECISION = {"bonafide": " bona fide: it is genuine human speech.", |
| "spoof": " a spoof: it is synthetic or converted speech.", |
| "partial": " a spoof: synthetic segments are embedded in genuine speech."} |
| FLIP = {True: "LOCALIZATION: The whole recording is synthesized.\nSOURCE_PROFILE: The generation method cannot be " |
| "determined.\n", |
| False: "LOCALIZATION: No synthesized segment is found.\n"} |
| PARA = {True: "LOCALIZATION: Every part of this recording was produced by a speech synthesizer.\n" |
| "SOURCE_PROFILE: The generation method cannot be determined.\n", |
| False: "LOCALIZATION: All of the speech is genuine; no part of it was produced by a synthesizer.\n"} |
| SPAN = ("LOCALIZATION: Synthesized speech at 1.60-2.40 s; the rest is genuine speech.\n" |
| "SOURCE_PROFILE: The generation method cannot be determined.\n") |
| CHANNEL = "CHANNEL_STATUS: The recording has heavy background noise, strong reverberation and MP3 compression.\n" |
| OBSERVE = "OBSERVATIONS: Narrowband (telephone) bandwidth; SNR about 5 dB; speech level about -35 dBFS; audible clipping.\n" |
| FAITH_FORMS = { |
| "flip": "follow: LOCALIZATION replaced by the opposite (the edit form used in VeriSpoof training)", |
| "paraphrase": "follow: opposite LOCALIZATION in a paraphrased (held-out) wording", |
| "span": "follow: a 'No synthesized segment' LOCALIZATION replaced by one partial span (held-out)", |
| "channel": "keep: CHANNEL_STATUS replaced by heavy noise, reverberation and MP3 compression (held-out)", |
| "observe": "keep: OBSERVATIONS replaced by contradicting measurements (held-out)", |
| } |
|
|
|
|
| def intervene(text, form): |
| """Model's own reasoning text -> (edited prefix ending with "DECISION: The recording is", expected decision |
| "spoof" / "bonafide") or None when the form does not apply. The model is then asked to continue the prefix; its |
| decision (bona fide vs spoof, partial spoof counting as spoof) is compared with the expected one.""" |
| if form == "flip": |
| head = text[:text.index("LOCALIZATION:")] if "LOCALIZATION:" in text else text.rstrip() + "\n" |
| none = "No synthesized segment" in text |
| return head + FLIP[none] + DECISION_PREFIX, ("spoof" if none else "bonafide") |
| L = [l for l in text.split("\n") if l.strip()] |
| loc = next((l for l in L if l.startswith("LOCALIZATION:")), None) |
| if loc is None: |
| return None |
| none = "No synthesized segment" in loc |
| k = L.index(loc) |
| head, rest = L[:k], [l for l in L[k + 1:] if not l.startswith("DECISION")] |
| if form == "paraphrase": |
| return "\n".join(head) + "\n" + PARA[none] + DECISION_PREFIX, ("spoof" if none else "bonafide") |
| if form == "span": |
| return ("\n".join(head) + "\n" + SPAN + DECISION_PREFIX, "spoof") if none else None |
| if form == "channel": |
| head = [l for l in head if not l.startswith("CHANNEL_STATUS")] |
| ins = 1 if head and head[0].startswith("OBSERVATIONS") else 0 |
| head = head[:ins] + [CHANNEL.strip()] + head[ins:] |
| elif form == "observe": |
| head = [OBSERVE.strip()] + [l for l in head if not l.startswith("OBSERVATIONS")] |
| else: |
| raise ValueError(form) |
| return "\n".join(head + [loc] + rest) + "\n" + DECISION_PREFIX, ("bonafide" if none else "spoof") |
|
|
|
|
| def faith_rate(expected, decided): |
| """Share of intervened items whose decision equals the expected one (follow forms: the edited localization; |
| keep forms: the model's own localization).""" |
| e, d = np.asarray(expected), np.asarray(decided) |
| return float(np.mean(e == d)) if len(e) else None |
|
|
|
|
| |
| SV_ATTRS = ("method", "acoustic", "waveform") |
| ATTR_NAME = {"method": "Generation method", "acoustic": "Acoustic modelling", "waveform": "Waveform generation"} |
| SUMMARY = {"supportive": "Across the source profile, all attributes are similar.", |
| "mixed": "Across the source profile, the attributes are mixed.", |
| "conflicting": "Across the source profile, the attributes conflict."} |
| VERDICT = {True: "Taken together, the recordings come from the same generation system.", |
| False: "Taken together, the recordings come from different generation systems."} |
|
|
|
|
| def parse_channel(text): |
| line = next((l for l in (text or "").split("\n") if l.startswith("CHANNEL_STATUS:")), None) |
| if line is None: |
| return None |
| parts = line.split("; the second recording has ") |
| out = [] |
| for part in parts[:2]: |
| c = {} |
| for k, table in (("noise", NOISE_TEXT), ("reverb", REVERB_TEXT), ("codec", CODEC_TEXT)): |
| hits = [v for v, t in table.items() if t in part] |
| c[k] = max(hits, key=lambda v: len(table[v])) if hits else None |
| out.append(c) |
| return out if len(out) == 2 else None |
|
|
|
|
| def parse_sv(text): |
| text = text or "" |
| out = {k: (True if f"{ATTR_NAME[k]} is similar" in text else False if f"{ATTR_NAME[k]} differs" in text |
| else None) for k in SV_ATTRS} |
| out["support"] = next((lv for lv, t in SUMMARY.items() if t in text), None) |
| out["decision"] = True if VERDICT[True] in text else False if VERDICT[False] in text else None |
| out["channel"] = parse_channel(text) |
| out["fingerprint"] = True if "FINGERPRINT: The latent source-fingerprint cues show strong similarity" in text else \ |
| False if "FINGERPRINT: The latent source-fingerprint cues show clear differences" in text else None |
| out["complete"] = text.startswith(("PROFILE_COMPATIBILITY:", "CHANNEL_STATUS:", "FINGERPRINT:")) and \ |
| "\nDECISION:" in text and all(out[k] is not None for k in (*SV_ATTRS, "support", "decision")) |
| return out |
|
|
|
|
| def sv_metrics(items, texts, decision_scores=None, decided=None): |
| """items: dicts with `reference` (gold text), `labels` dict (same_generator), meta (stratum, support); |
| texts: the model's reasoning; decision_scores: per item, higher = same system (VeriSpoof: log p(same verdict) - |
| log p(different verdict) after its own analysis) -> verdict EER. Without scores the EER is computed on the parsed |
| verdict (1 / 0; unparsed = 0.5), which is coarser. `decided` overrides the parsed verdict (True / False / None).""" |
| P = [parse_sv(t) for t in texts] |
| if decided is not None: |
| for p, d in zip(P, decided): |
| p["decision"] = d |
| G = [parse_sv(it["reference"]) for it in items] |
| y = np.array([it["labels"]["same_generator"] for it in items]) |
|
|
| def acc(idx): |
| idx = list(idx) |
| return float(np.mean([P[i]["decision"] == y[i] for i in idx])) if idx else None |
|
|
| if decision_scores is None: |
| decision_scores = [0.5 if p["decision"] is None else float(p["decision"]) for p in P] |
| m = {"n": len(items), "parse_rate": float(np.mean([p["complete"] for p in P])), |
| "verdict_acc": acc(range(len(items))), "eer_decision": eer(decision_scores, y)} |
| for k in (*SV_ATTRS, "support"): |
| m[f"{k}_acc"] = float(np.mean([p[k] == g[k] for p, g in zip(P, G)])) |
| m["gold_complete"] = float(np.mean([g["complete"] for g in G])) |
| for st in ("SAME", "REVERSAL", "DIFF_ATTR"): |
| m[f"acc_{st}"] = acc(i for i, it in enumerate(items) if it["meta"]["stratum"] == st) |
| for lv in ("supportive", "mixed", "conflicting"): |
| idx = [i for i, it in enumerate(items) if it["meta"]["support"] == lv] |
| if idx: |
| m[f"acc_{lv}"] = acc(idx) |
| rev = [i for i, it in enumerate(items) if it["meta"]["stratum"] == "REVERSAL"] |
| if rev: |
| m["reversal_said_supportive"] = float(np.mean([P[i]["support"] == "supportive" for i in rev])) |
| m["unparsed_decision"] = int(sum(p["decision"] is None for p in P)) |
| fp = [i for i, p in enumerate(P) if p["fingerprint"] is not None] |
| if fp: |
| m["fingerprint_consistency"] = float(np.mean([P[i]["decision"] == P[i]["fingerprint"] for i in fp])) |
| ch = [i for i, g in enumerate(G) if g["channel"]] |
| if ch: |
| for k in ("noise", "reverb", "codec"): |
| m[f"channel_{k}_acc"] = float(np.mean([P[i]["channel"] is not None and P[i]["channel"][j][k] == G[i]["channel"][j][k] |
| for i in ch for j in (0, 1)])) |
| return _r(m) |
|
|
