Datasets:
Tasks:
Text Classification
Formats:
parquet
Sub-tasks:
multi-label-classification
Size:
10K - 100K
License:
| #!/usr/bin/env python3 | |
| """Score a model's answers on the `decisions` config of JS/TS Code Review Decisions. | |
| Predictions are JSONL, one object per case: {"id": "<case id>", "answers": {...}, "latency_ms": <optional number>}. | |
| `answers` is the map a System One API returns for the case's `questions`: a noul answer carries "noul" (the | |
| probability of yes); choice and score answers carry "probabilities" over the question's options or level indexes. | |
| Full distributions are required; a case with a missing question is an error. | |
| uv run --no-project --with pyarrow==26.0.0 --with numpy==2.5.4 \ | |
| python3 score_decisions.py PREDICTIONS.jsonl [--split test] [--json OUT.json] | |
| python3 score_decisions.py --reference prior|uniform [--split test] | |
| Prints the leaderboard columns and a per-question table. Read the scored-vs-cases line and the off-menu mass | |
| before any score: cases without a prediction are left out, not scored as wrong. | |
| """ | |
| import argparse | |
| import json | |
| import sys | |
| from collections import Counter | |
| from pathlib import Path | |
| import numpy as np | |
| import pyarrow.parquet as pq | |
| HERE = Path(__file__).resolve().parent | |
| SPLITS = ("train", "validation", "test") | |
| FLAW_NOULS = 10 # the first 10 questions are the flaw nouls that macro F1 averages over | |
| PROBABILITY_FLOOR = 1e-6 | |
| ECE_BINS = 15 | |
| BOOTSTRAP_RESAMPLES = 500 | |
| SEED = 0 | |
| def load_split(data: Path, split: str) -> tuple[list[dict], dict]: | |
| table = pq.read_table(data / "decisions" / f"{split}.parquet", columns=["id", "task_slug", "questions", "gold"]) | |
| rows = table.to_pylist() | |
| schemas = {row["questions"] for row in rows} | |
| if len(schemas) != 1: | |
| sys.exit(f"{split} rows carry {len(schemas)} different question schemas") | |
| return rows, json.loads(schemas.pop()) | |
| def options_of(question: dict) -> list[str]: | |
| if question["type"] == "noul": | |
| return ["true", "false"] | |
| if question["type"] == "choice": | |
| return list(question["criteria"]) | |
| return [str(i) for i in range(len(question["criteria"]))] | |
| def distribution(answer: dict, question: dict, options: list[str]) -> tuple[np.ndarray, float]: | |
| """Probability over `options` in order, plus the mass the answer put on options that are not on the menu.""" | |
| if question["type"] == "noul": | |
| p = float(answer["noul"]) | |
| return np.array([p, 1 - p]), 0.0 | |
| probabilities = {str(k): float(v) for k, v in answer["probabilities"].items()} | |
| off_menu = sum(v for k, v in probabilities.items() if k not in options) | |
| return np.array([probabilities.get(o, 0.0) for o in options]), off_menu | |
| def reference_answers(data: Path, kind: str, questions: dict) -> dict: | |
| """The same answer for every case: train label frequencies (prior) or equal probabilities (uniform).""" | |
| answers = {} | |
| if kind == "uniform": | |
| for name, question in questions.items(): | |
| options = options_of(question) | |
| if question["type"] == "noul": | |
| answers[name] = {"type": "noul", "noul": 0.5} | |
| else: | |
| answers[name] = {"type": question["type"], "probabilities": {o: 1 / len(options) for o in options}} | |
| return answers | |
| columns = [f"{name}__label" for name in questions] | |
| train = pq.read_table(data / "decisions" / "train.parquet", columns=columns).to_pylist() | |
| for name, question in questions.items(): | |
| counts = Counter(row[f"{name}__label"] for row in train) | |
| total = sum(counts.values()) | |
| if question["type"] == "noul": | |
| answers[name] = {"type": "noul", "noul": counts["true"] / total} | |
| else: | |
| answers[name] = {"type": question["type"], | |
| "probabilities": {o: counts[o] / total for o in options_of(question)}} | |
| return answers | |
| def expected_calibration_error(confidence: np.ndarray, outcome: np.ndarray) -> float: | |
| edges = np.linspace(0, 1, ECE_BINS + 1) | |
| bins = np.clip(np.digitize(confidence, edges[1:-1]), 0, ECE_BINS - 1) | |
| error = 0.0 | |
| for b in range(ECE_BINS): | |
| members = bins == b | |
| if members.any(): | |
| error += members.mean() * abs(confidence[members].mean() - outcome[members].mean()) | |
| return float(error) | |
| def f1(pred: np.ndarray, truth: np.ndarray) -> float: | |
| tp = int((pred & truth).sum()) | |
| fp = int((pred & ~truth).sum()) | |
| fn = int((~pred & truth).sum()) | |
| return 2 * tp / (2 * tp + fp + fn) if tp + fp + fn else 0.0 | |
| class Scored: | |
| """Per-case, per-question arrays for one split, aligned with the cases that have predictions.""" | |
| def __init__(self, rows: list[dict], questions: dict, predictions: dict[str, dict]): | |
| self.names = list(questions) | |
| self.types = [questions[n]["type"] for n in self.names] | |
| self.cases = [row for row in rows if row["id"] in predictions] | |
| self.tasks = np.array([row["task_slug"] for row in self.cases]) | |
| self.clean = np.array([json.loads(row["gold"])["primary_flaw"]["label"] == "none" for row in self.cases]) | |
| n, q = len(self.cases), len(self.names) | |
| self.correct = np.zeros((n, q), bool) | |
| self.log_loss = np.zeros((n, q)) | |
| self.brier = np.zeros((n, q)) | |
| self.confidence = np.zeros((n, q)) # p(true) for nouls, max probability otherwise | |
| self.outcome = np.zeros((n, q)) # the gold truth for nouls, correctness otherwise | |
| self.positives = np.zeros((n, q), bool) # noul gold | |
| self.predicted_true = np.zeros((n, q), bool) | |
| self.level_error = np.zeros(n) # score questions: |expected level - gold level|, last score question | |
| self.off_menu = 0.0 | |
| self.mass_missing = 0.0 | |
| latencies = [predictions[row["id"]].get("latency_ms") for row in self.cases] | |
| self.latency_ms = np.array(latencies, float) if all(v is not None for v in latencies) else None | |
| for i, row in enumerate(self.cases): | |
| gold = json.loads(row["gold"]) | |
| answers = predictions[row["id"]]["answers"] | |
| for j, name in enumerate(self.names): | |
| if name not in answers: | |
| sys.exit(f"case {row['id']} has no answer for {name}") | |
| question = questions[name] | |
| options = options_of(question) | |
| p, off_menu = distribution(answers[name], question, options) | |
| self.off_menu += off_menu | |
| self.mass_missing += max(0.0, 1 - p.sum() - off_menu) | |
| target = options.index(gold[name]["label"]) | |
| onehot = np.zeros(len(options)) | |
| onehot[target] = 1 | |
| self.log_loss[i, j] = -np.log(max(p[target], PROBABILITY_FLOOR)) | |
| if question["type"] == "noul": | |
| self.predicted_true[i, j] = p[0] >= 0.5 | |
| self.positives[i, j] = target == 0 | |
| self.correct[i, j] = self.predicted_true[i, j] == self.positives[i, j] | |
| self.brier[i, j] = (p[0] - onehot[0]) ** 2 | |
| self.confidence[i, j], self.outcome[i, j] = p[0], onehot[0] | |
| else: | |
| self.correct[i, j] = int(p.argmax()) == target | |
| self.brier[i, j] = float(((p - onehot) ** 2).sum()) | |
| self.confidence[i, j], self.outcome[i, j] = p.max(), self.correct[i, j] | |
| if question["type"] == "score": | |
| self.level_error[i] = abs(float(p @ np.arange(len(options))) - target) | |
| decisions = n * q | |
| self.off_menu /= decisions | |
| self.mass_missing /= decisions | |
| def headline(self, rows: np.ndarray | None = None) -> dict: | |
| rows = np.arange(len(self.cases)) if rows is None else rows | |
| flags = range(FLAW_NOULS) | |
| return { | |
| "macro_f1_at_0_5": float(np.mean([f1(self.predicted_true[rows, j], self.positives[rows, j]) for j in flags])), | |
| "accuracy": float(self.correct[rows].mean()), | |
| "log_loss": float(self.log_loss[rows].mean()), | |
| "brier": float(self.brier[rows].mean()), | |
| } | |
| def bootstrap(self) -> dict[str, list[float]]: | |
| rng = np.random.default_rng(SEED) | |
| _, codes = np.unique(self.tasks, return_inverse=True) | |
| members = [np.flatnonzero(codes == g) for g in range(codes.max() + 1)] | |
| draws: dict[str, list[float]] = {} | |
| for _ in range(BOOTSTRAP_RESAMPLES): | |
| rows = np.concatenate([members[g] for g in rng.integers(0, len(members), len(members))]) | |
| for key, value in self.headline(rows).items(): | |
| draws.setdefault(key, []).append(value) | |
| return {k: [float(x) for x in np.percentile(v, [2.5, 97.5])] for k, v in draws.items()} | |
| def per_question(self) -> dict: | |
| out = {} | |
| for j, name in enumerate(self.names): | |
| entry = { | |
| "type": self.types[j], | |
| "accuracy": float(self.correct[:, j].mean()), | |
| "log_loss": float(self.log_loss[:, j].mean()), | |
| "brier": float(self.brier[:, j].mean()), | |
| "ece": expected_calibration_error(self.confidence[:, j], self.outcome[:, j]), | |
| } | |
| if self.types[j] == "noul": | |
| entry["positives"] = int(self.positives[:, j].sum()) | |
| entry["f1_at_0_5"] = f1(self.predicted_true[:, j], self.positives[:, j]) | |
| if self.types[j] == "score": | |
| entry["level_mae"] = float(self.level_error.mean()) | |
| out[name] = entry | |
| return out | |
| def report(self, total_cases: int) -> dict: | |
| per_question = self.per_question() | |
| by_type = {t: float(self.correct[:, [j for j, u in enumerate(self.types) if u == t]].mean()) | |
| for t in dict.fromkeys(self.types)} | |
| has_flaw = self.names.index("has_flaw") | |
| result = { | |
| "cases_in_split": total_cases, | |
| "cases_scored": len(self.cases), | |
| "decisions_scored": int(self.correct.size), | |
| "off_menu_mass": self.off_menu, | |
| "mass_missing": self.mass_missing, | |
| **self.headline(), | |
| "ece": float(np.mean([q["ece"] for q in per_question.values()])), | |
| "ci95": self.bootstrap(), | |
| "accuracy_by_type": by_type, | |
| "clean_cases_judged_clean": float((~self.predicted_true[self.clean, has_flaw]).mean()), | |
| "p50_latency_ms": float(np.median(self.latency_ms)) if self.latency_ms is not None else None, | |
| "per_question": per_question, | |
| } | |
| return result | |
| def markdown(result: dict) -> str: | |
| def interval(key: str) -> str: | |
| low, high = result["ci95"][key] | |
| return f"{result[key]:.3f} ({low:.3f} to {high:.3f})" | |
| latency = f"{result['p50_latency_ms']:.1f} ms" if result["p50_latency_ms"] is not None else "not reported" | |
| lines = [ | |
| f"scored {result['cases_scored']}/{result['cases_in_split']} cases, {result['decisions_scored']:,} decisions; " | |
| f"off-menu mass {result['off_menu_mass']:.4f}; missing mass {result['mass_missing']:.4f}", | |
| "", | |
| "| Macro F1 at 0.5 | Accuracy | Log loss | Brier | ECE | p50 latency |", | |
| "|---:|---:|---:|---:|---:|---:|", | |
| f"| {interval('macro_f1_at_0_5')} | {interval('accuracy')} | {interval('log_loss')} | {interval('brier')} | " | |
| f"{result['ece']:.3f} | {latency} |", | |
| "", | |
| "Accuracy by type: " + ", ".join(f"{t} {v:.3f}" for t, v in result["accuracy_by_type"].items()) | |
| + f"; clean cases judged clean {result['clean_cases_judged_clean']:.3f}", | |
| "", | |
| "| Question | Type | Positives | Accuracy | F1 at 0.5 | Log loss | Brier | ECE |", | |
| "|---|---|---:|---:|---:|---:|---:|---:|", | |
| ] | |
| for name, q in result["per_question"].items(): | |
| positives = str(q["positives"]) if "positives" in q else "" | |
| f1_cell = f"{q['f1_at_0_5']:.3f}" if "f1_at_0_5" in q else "" | |
| lines.append(f"| `{name}` | {q['type']} | {positives} | {q['accuracy']:.3f} | {f1_cell} | {q['log_loss']:.3f} | " | |
| f"{q['brier']:.3f} | {q['ece']:.3f} |") | |
| return "\n".join(lines) | |
| def main() -> None: | |
| parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) | |
| parser.add_argument("predictions", nargs="?", type=Path) | |
| parser.add_argument("--reference", choices=("prior", "uniform")) | |
| parser.add_argument("--split", default="test", choices=SPLITS) | |
| parser.add_argument("--data", type=Path, default=HERE, help="dataset folder holding decisions/*.parquet") | |
| parser.add_argument("--json", type=Path, help="write the full result here") | |
| args = parser.parse_args() | |
| if (args.predictions is None) == (args.reference is None): | |
| parser.error("give a predictions file or --reference, not both") | |
| rows, questions = load_split(args.data, args.split) | |
| if args.reference: | |
| answers = reference_answers(args.data, args.reference, questions) | |
| predictions = {row["id"]: {"answers": answers} for row in rows} | |
| else: | |
| with args.predictions.open() as handle: | |
| predictions = {} | |
| for line in handle: | |
| if line.strip(): | |
| entry = json.loads(line) | |
| predictions[entry["id"]] = entry | |
| ids = {row["id"] for row in rows} | |
| unknown = sorted(set(predictions) - ids) | |
| if unknown: | |
| print(f"ignoring {len(unknown)} predictions for ids not in {args.split}, e.g. {unknown[0]}", file=sys.stderr) | |
| if not ids & set(predictions): | |
| sys.exit(f"no prediction matches a case id in {args.split}") | |
| result = Scored(rows, questions, predictions).report(len(rows)) | |
| result["split"] = args.split | |
| result["source"] = f"reference:{args.reference}" if args.reference else str(args.predictions) | |
| print(markdown(result)) | |
| if args.json: | |
| args.json.write_text(json.dumps(result, indent=1) + "\n") | |
| if __name__ == "__main__": | |
| main() | |