"""TempBench retrieval-quality metrics: TRP and Chain Consistency Rate. Scores *your* retriever against TempBench's per-question gold subgraphs. You supply the evidence your system retrieved; this module supplies the metrics the paper reports, so numbers are comparable without re-implementing the definitions. Both metrics are answer-independent: they score the evidence, not the generated string. That is the point of the benchmark -- a system can produce the right answer from stale evidence, and end-task exact-match cannot see it. TRP (Temporal Retrieval Precision) per question: |retrieved triples that are in S* AND valid at t_query| / |retrieved triples| Macro-averaged over questions that retrieved anything. Undefined (and excluded) when a system returns nothing. CCR (Chain Consistency Rate) per question: 1 if every triple of S* was retrieved and time-valid, else 0. Averaged over all questions, including empty retrievals. A triple counts as time-valid when t_start <= t_query <= t_end. On a point-in-time KG (t_start == t_end, as in the released benchmark) that reduces to exact-year equality. TRP is a precision-at-k quantity against 1-3-triple gold chains, so its absolute scale is low by construction; read the gap between retrievers and the per-complexity profile, not the raw value. TRP and CCR are not redundant: at 3+-hop the reference retriever scores TRP 0.203 against CCR 0.014 -- partial gold evidence is routinely retrieved, the full chain almost never. Stdlib only. Python 3.9+. Usage ----- import json from tempbench_eval import score_question, aggregate rows = [] for line in open('benchmark/benchmark_labelled.jsonl', encoding='utf-8'): q = json.loads(line) if q['split'] != 'test': continue evidence = my_retriever(q['question'], q['t_query']) # your system rows.append(score_question(q, evidence)) print(aggregate(rows)) `evidence` is whatever your retriever returned, as an iterable of triples. Each may be a dict with keys s/r/o/t_start/t_end (label space, matching `benchmark_labelled.jsonl`), a dict with s_id/r_id/o_id (Wikidata id space, matching `benchmark.jsonl`), or a 5-tuple (s, r, o, t_start, t_end). Mixing spaces within one run will silently score zero, so pick one and stay in it -- `key='auto'` infers it from the first item. Restrict negative-dependent analysis to the functional subset: see `benchmark/functional_negatives.jsonl`, and read `v1.0.1-addendum.md` before evaluating -- interval questions leak their answer under the original prompt protocol. """ from collections import defaultdict __all__ = ['score_question', 'aggregate', 'as_triple'] _LABEL_KEYS = ('s', 'r', 'o') _ID_KEYS = ('s_id', 'r_id', 'o_id') def as_triple(item, key='auto'): """Normalise one retrieved item to (s, r, o, t_start, t_end). key: 'label' to match on surface labels, 'id' to match on Wikidata ids, 'auto' to use ids when the item carries them and labels otherwise. """ if isinstance(item, (tuple, list)): if len(item) != 5: raise ValueError('tuple evidence must be (s, r, o, t_start, t_end),' ' got %d fields' % len(item)) s, r, o, ts, te = item elif isinstance(item, dict): use_id = (key == 'id' or (key == 'auto' and all(k in item for k in _ID_KEYS))) ks = _ID_KEYS if use_id else _LABEL_KEYS missing = [k for k in ks if k not in item] if missing: raise KeyError('evidence dict is missing %s; it has %s' % (missing, sorted(item))) s, r, o = (item[k] for k in ks) ts, te = item.get('t_start'), item.get('t_end') if ts is None or te is None: raise KeyError('evidence dict needs t_start and t_end to be scored ' 'for temporal validity') else: raise TypeError('evidence items must be dicts or 5-tuples, got %r' % type(item).__name__) return (s, r, o, float(ts), float(te)) def score_question(question, evidence, key='auto'): """Score one question's retrieved evidence. Returns a per-question row. `question` is a record from benchmark_labelled.jsonl (or benchmark.jsonl). `evidence` is what your retriever returned for it, already truncated to your k -- TRP is a precision quantity, so this module does not truncate for you. """ retrieved = [as_triple(e, key) for e in evidence] tq = float(question['t_query']) gold = question['S_star'] use_id = (key == 'id' or (key == 'auto' and all(k in gold[0] for k in _ID_KEYS))) gk = _ID_KEYS if use_id else _LABEL_KEYS gold_ids = {tuple(g[k] for k in gk) for g in gold} hits = [t for t in retrieved if t[:3] in gold_ids and t[3] <= tq <= t[4]] covered = {t[:3] for t in hits} n_ret = len(retrieved) return { 'id': question.get('id'), 'complexity': question.get('complexity'), 'operator': question.get('operator_type'), 'n_ret': n_ret, 'hits': len(hits), 'n_gold': len(gold_ids), 'trp': (len(hits) / n_ret) if n_ret else None, 'ccr': 1 if (gold_ids and covered == gold_ids) else 0, } def _cell(rows): scored = [r for r in rows if r['n_ret'] > 0] trp = [r['trp'] for r in scored] return { 'n': len(rows), 'TRP': (sum(trp) / len(trp)) if trp else 0.0, 'CCR': (sum(r['ccr'] for r in rows) / len(rows)) if rows else 0.0, } def aggregate(rows, by=('complexity', 'operator')): """Corpus-level metrics, plus the per-slice breakdowns the paper reports. TRP is macro-averaged over questions that retrieved something; CCR is averaged over all of them. `coverage` is the fraction that retrieved anything -- report it, because a system that returns nothing on hard questions otherwise inflates its own TRP. """ if not rows: return {'n_questions': 0} scored = [r for r in rows if r['n_ret'] > 0] total_ret = sum(r['n_ret'] for r in rows) out = { 'n_questions': len(rows), 'coverage': len(scored) / len(rows), 'TRP_macro': (sum(r['trp'] for r in scored) / len(scored)) if scored else 0.0, 'TRP_micro': (sum(r['hits'] for r in rows) / total_ret) if total_ret else 0.0, 'CCR': sum(r['ccr'] for r in rows) / len(rows), } for field in by: buckets = defaultdict(list) for r in rows: buckets[r.get(field)].append(r) out['by_' + field] = {k: _cell(v) for k, v in sorted( buckets.items(), key=lambda kv: str(kv[0]))} return out if __name__ == '__main__': # Self-check on a synthetic question: a perfect retrieval, a stale-fact # retrieval, and an empty one. Needs no data files. q = { 'id': 'demo', 'complexity': '1hop', 'operator_type': 'point_in_time', 't_query': 1994.0, 'S_star': [{'s': 'A', 'r': 'rel', 'o': 'B', 't_start': 1994.0, 't_end': 1994.0}], } gold = {'s': 'A', 'r': 'rel', 'o': 'B', 't_start': 1994.0, 't_end': 1994.0} stale = dict(gold, t_start=1991.0, t_end=1991.0) noise = {'s': 'A', 'r': 'rel', 'o': 'C', 't_start': 1994.0, 't_end': 1994.0} perfect = score_question(q, [gold]) diluted = score_question(q, [gold, noise]) stale_only = score_question(q, [stale]) empty = score_question(q, []) assert (perfect['trp'], perfect['ccr']) == (1.0, 1) assert (diluted['trp'], diluted['ccr']) == (0.5, 1), diluted assert (stale_only['trp'], stale_only['ccr']) == (0.0, 0), stale_only assert empty['trp'] is None and empty['ccr'] == 0 agg = aggregate([perfect, diluted, stale_only, empty]) assert agg['coverage'] == 0.75, agg assert agg['CCR'] == 0.5, agg print('tempbench_eval self-check OK') print(' perfect ', perfect) print(' +1 distractor', diluted) print(' stale only ', stale_only) print(' aggregate ', {k: v for k, v in agg.items() if not k.startswith('by_')})