| |
| """Score model predictions for Tibetan FormatEval. |
| |
| Prediction JSONL schemas: |
| |
| MCQA: |
| {"id": "tfe-0001", "prediction": "B"} |
| {"id": "tfe-0001", "prediction_index": 1} |
| |
| Open short answer: |
| {"id": "tfe-0001", "prediction": "..."} |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import math |
| import random |
| import re |
| import unicodedata |
| from collections import Counter |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| LETTER_TO_INDEX = {chr(ord("A") + i): i for i in range(10)} |
| TIBETAN_DIGITS = str.maketrans("༠༡༢༣༤༥༦༧༨༩", "0123456789") |
|
|
|
|
| def read_jsonl(path: Path) -> list[dict[str, Any]]: |
| rows = [] |
| with path.open("r", encoding="utf-8") as f: |
| for line in f: |
| if line.strip(): |
| rows.append(json.loads(line)) |
| return rows |
|
|
|
|
| def normalize_text(text: str) -> str: |
| text = unicodedata.normalize("NFKC", text) |
| text = text.translate(TIBETAN_DIGITS) |
| text = re.sub(r"[\s\"'`.,;:!?，。；：！？་།༎\[\](){}<>]+", "", text) |
| return text.lower() |
|
|
|
|
| def parse_mcqa_prediction(value: Any, num_choices: int) -> int | None: |
| if isinstance(value, int): |
| return value if 0 <= value < num_choices else None |
| if value is None: |
| return None |
| text = str(value).strip().translate(TIBETAN_DIGITS) |
| if not text: |
| return None |
| upper = text.upper() |
|
|
| |
| patterns = [ |
| r"(?:ANSWER|OPTION|CHOICE)\s*(?:IS|:)?\s*([A-J])\b", |
| r"(?:答案|选项)\s*(?:是|为|:)?\s*([A-J])\b", |
| r"\b([A-J])\b", |
| ] |
| for pattern in patterns: |
| match = re.search(pattern, upper) |
| if match: |
| idx = LETTER_TO_INDEX[match.group(1)] |
| if idx < num_choices: |
| return idx |
|
|
| number_match = re.search(r"\b([1-9]|10)\b", upper) |
| if number_match: |
| idx = int(number_match.group(1)) - 1 |
| if 0 <= idx < num_choices: |
| return idx |
| return None |
|
|
|
|
| def bootstrap_ci(values: list[int], seed: int = 42, n_boot: int = 2000) -> tuple[float, float]: |
| if not values: |
| return (math.nan, math.nan) |
| rng = random.Random(seed) |
| n = len(values) |
| means = [] |
| for _ in range(n_boot): |
| means.append(sum(values[rng.randrange(n)] for _ in range(n)) / n) |
| means.sort() |
| return means[int(0.025 * n_boot)], means[int(0.975 * n_boot)] |
|
|
|
|
| def score_mcqa(gold_rows: list[dict[str, Any]], pred_rows: list[dict[str, Any]], chance: float) -> dict[str, Any]: |
| preds = {row["id"]: row for row in pred_rows} |
| per_item = [] |
| missing = 0 |
| unparsable = 0 |
| pred_pos = Counter() |
|
|
| for gold in gold_rows: |
| pred = preds.get(gold["id"]) |
| if pred is None: |
| missing += 1 |
| pred_idx = None |
| elif "prediction_index" in pred: |
| pred_idx = parse_mcqa_prediction(pred.get("prediction_index"), len(gold["choices"])) |
| else: |
| pred_idx = parse_mcqa_prediction(pred.get("prediction"), len(gold["choices"])) |
|
|
| if pred_idx is None: |
| unparsable += 1 |
| correct = 0 |
| else: |
| pred_pos[pred_idx] += 1 |
| correct = int(pred_idx == gold["answer"]) |
|
|
| per_item.append( |
| { |
| "id": gold["id"], |
| "correct": correct, |
| "prediction_index": pred_idx, |
| "answer": gold["answer"], |
| "source_dataset": gold.get("source_dataset"), |
| "source_subject": gold.get("source_subject"), |
| } |
| ) |
|
|
| values = [row["correct"] for row in per_item] |
| acc = sum(values) / len(values) if values else math.nan |
| ci_low, ci_high = bootstrap_ci(values) |
| chance_norm = (acc - chance) / (1 - chance) |
| return { |
| "n": len(values), |
| "accuracy": acc, |
| "ci95": [ci_low, ci_high], |
| "chance": chance, |
| "chance_normalized_accuracy": chance_norm, |
| "missing": missing, |
| "unparsable": unparsable, |
| "prediction_position_distribution": {str(k): pred_pos[k] for k in sorted(pred_pos)}, |
| "per_item": per_item, |
| } |
|
|
|
|
| def score_open(gold_rows: list[dict[str, Any]], pred_rows: list[dict[str, Any]]) -> dict[str, Any]: |
| preds = {row["id"]: row for row in pred_rows} |
| per_item = [] |
| missing = 0 |
| not_attempted = 0 |
| abstain_patterns = re.compile(r"(i don't know|unknown|not sure|cannot answer|不知道|无法回答)", re.I) |
|
|
| for gold in gold_rows: |
| pred = preds.get(gold["id"]) |
| aliases = gold.get("aliases") or [gold["answer_text"]] |
| if pred is None: |
| missing += 1 |
| pred_text = "" |
| else: |
| pred_text = str(pred.get("prediction", "")) |
|
|
| normalized_pred = normalize_text(pred_text) |
| normalized_aliases = [normalize_text(str(alias)) for alias in aliases] |
| attempted = bool(normalized_pred) and not abstain_patterns.search(pred_text) |
| if not attempted: |
| not_attempted += 1 |
| correct = int(attempted and any(alias and alias in normalized_pred for alias in normalized_aliases)) |
| per_item.append( |
| { |
| "id": gold["id"], |
| "correct": correct, |
| "attempted": int(attempted), |
| "prediction": pred_text, |
| "answer_text": gold["answer_text"], |
| "source_dataset": gold.get("source_dataset"), |
| "source_subject": gold.get("source_subject"), |
| } |
| ) |
|
|
| values = [row["correct"] for row in per_item] |
| attempts = [row["attempted"] for row in per_item] |
| acc = sum(values) / len(values) if values else math.nan |
| attempted_rate = sum(attempts) / len(attempts) if attempts else math.nan |
| ci_low, ci_high = bootstrap_ci(values) |
| return { |
| "n": len(values), |
| "accuracy": acc, |
| "ci95": [ci_low, ci_high], |
| "attempted_rate": attempted_rate, |
| "not_attempted_rate": 1 - attempted_rate, |
| "missing": missing, |
| "not_attempted": not_attempted, |
| "per_item": per_item, |
| } |
|
|
|
|
| def aggregate_by_dataset(per_item: list[dict[str, Any]]) -> dict[str, Any]: |
| groups: dict[str, list[int]] = {} |
| for row in per_item: |
| groups.setdefault(row.get("source_dataset", "unknown"), []).append(row["correct"]) |
| return { |
| key: {"n": len(vals), "accuracy": sum(vals) / len(vals)} |
| for key, vals in sorted(groups.items()) |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--gold", type=Path, required=True) |
| parser.add_argument("--predictions", type=Path, required=True) |
| parser.add_argument("--task", choices=["mcqa4", "mcqa10", "open"], required=True) |
| parser.add_argument("--output", type=Path, required=True) |
| args = parser.parse_args() |
|
|
| gold = read_jsonl(args.gold) |
| preds = read_jsonl(args.predictions) |
| if args.task == "mcqa4": |
| result = score_mcqa(gold, preds, chance=0.25) |
| elif args.task == "mcqa10": |
| result = score_mcqa(gold, preds, chance=0.10) |
| else: |
| result = score_open(gold, preds) |
|
|
| per_item = result.pop("per_item") |
| result["by_source_dataset"] = aggregate_by_dataset(per_item) |
|
|
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| args.output.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") |
| per_item_path = args.output.with_suffix(".per_item.jsonl") |
| with per_item_path.open("w", encoding="utf-8") as f: |
| for row in per_item: |
| f.write(json.dumps(row, ensure_ascii=False) + "\n") |
| print(json.dumps(result, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
