Datasets:
File size: 5,416 Bytes
d49e060 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 | """Score parsing and aggregation.
The headline metric is IF_Score: ``product(hard_pass) x mean(soft_scores)``. A
single failed hard constraint zeroes the instance; soft constraints average into
a 0-1 multiplier. Instances with no soft constraints use a multiplier of 1.0, so
they score 1.0 or 0.0.
"""
from __future__ import annotations
import json
import re
from collections import Counter, defaultdict
from typing import Any
SCORES = (0.0, 0.5, 1.0)
def parse_quality_score(response: str) -> float | None:
"""Parse a 0 / 0.5 / 1 quality verdict. Returns None if unparseable."""
text = (response or "").strip()
if text.startswith("[") and text.endswith("]"):
text = text[1:-1].strip()
if not re.fullmatch(r"(?:0(?:\.0+)?|0\.50*|1(?:\.0+)?)", text):
return None
return float(text)
def parse_soft_constraint_scores(
response: str, constraint_ids: list[str]
) -> dict[str, dict[str, Any]]:
"""Parse the soft-constraint Judge's JSON verdict, keyed by constraint id."""
unscored = {cid: {"score": None} for cid in constraint_ids}
if not response:
return unscored
data = None
try:
data = json.loads(response.strip())
except json.JSONDecodeError:
# The Judge sometimes wraps the object in prose or a code fence.
match = re.search(r"\{[\s\S]*\}", response)
if match:
try:
data = json.loads(match.group(0))
except json.JSONDecodeError:
pass
if not isinstance(data, dict):
return unscored
results: dict[str, dict[str, Any]] = {}
for cid in constraint_ids:
entry = data.get(cid)
if isinstance(entry, dict):
try:
score = float(entry.get("score"))
except (TypeError, ValueError):
score = None
if score in (0, 0.5, 1):
results[cid] = {"score": score, "note": entry.get("note", "")}
continue
results[cid] = {"score": None}
return results
def compute_if_score(
hard_results: dict[str, Any], soft_results: dict[str, Any]
) -> float:
hard_pass = 1.0
for result in hard_results.values():
if not result.get("is_valid", True):
hard_pass = 0.0
break
soft_values = [r["score"] for r in soft_results.values() if r.get("score") is not None]
soft_mean = sum(soft_values) / len(soft_values) if soft_values else 1.0
return hard_pass * soft_mean
def _score_key(score: float) -> str:
return "0" if score == 0 else "0.5" if score == 0.5 else "1"
def aggregate_group(rows: list[dict[str, Any]]) -> dict[str, Any]:
total = len(rows)
covered = sum(row["prediction_status"] == "present" for row in rows)
if_scores = [float(row["if_score"]) for row in rows]
quality = [row["quality_score"] for row in rows if row["quality_score"] is not None]
return {
"total": total,
"prediction_coverage": covered,
"prediction_coverage_rate": covered / total if total else 0.0,
"if_score": sum(if_scores) / total if total else 0.0,
"translation_quality": sum(quality) / len(quality) if quality else None,
"quality_scored": len(quality),
"quality_distribution": {
_score_key(s): sum(1 for q in quality if q == s) for s in SCORES
},
}
def aggregate_constraints(rows: list[dict[str, Any]]) -> dict[str, Any]:
"""Per-constraint pass rate (hard) or mean score (soft)."""
hard: dict[str, Counter] = defaultdict(Counter)
soft: dict[str, list[float]] = defaultdict(list)
for row in rows:
for cid, result in row["hard_constraint_results"].items():
hard[cid]["total"] += 1
if result.get("is_valid", True):
hard[cid]["pass"] += 1
for cid, result in row["soft_constraint_results"].items():
if result.get("score") is not None:
soft[cid].append(float(result["score"]))
out: dict[str, Any] = {}
for cid, counts in sorted(hard.items()):
total = counts["total"]
out[cid] = {
"type": "hard",
"total": total,
"pass": counts["pass"],
"pass_rate": counts["pass"] / total if total else None,
}
for cid, scores in sorted(soft.items()):
out[cid] = {
"type": "soft",
"total": len(scores),
"mean_score": sum(scores) / len(scores) if scores else None,
"score_distribution": {
_score_key(s): sum(1 for v in scores if v == s) for s in SCORES
},
}
return out
def compute_summary(rows: list[dict[str, Any]]) -> dict[str, Any]:
summary = aggregate_group(rows)
summary["by_constraint"] = aggregate_constraints(rows)
grouped: dict[str, dict[str, list[dict[str, Any]]]] = {
"scenario": defaultdict(list),
"domain": defaultdict(list),
"language_pair": defaultdict(list),
}
for row in rows:
grouped["scenario"][row["scenario"]].append(row)
grouped["domain"][row["domain"]].append(row)
grouped["language_pair"][f"{row['source_lang']}-{row['target_lang']}"].append(row)
summary["breakdowns"] = {
dimension: {key: aggregate_group(group) for key, group in sorted(groups.items())}
for dimension, groups in grouped.items()
}
return summary
|