Add TRP/CCR scorers and a quickstart; state train-split, template and point-in-time scope

MANIFEST.json

@@ -79,6 +79,11 @@
     "bytes": 15074,
     "why": "Wikidata QID/PID -> human-readable label resolution"
   },
+  {
+    "path": "code/tempbench_eval.py",
+    "bytes": 8213,
+    "why": "TRP / CCR scorers -- evaluate your own retriever without the reference implementation"
+  },
   {
     "path": "annotation/pilot_low_confidence.jsonl",
     "bytes": 63043,
@@ -141,7 +146,7 @@
   },
   {
     "path": "v1.0.1-addendum.md",
-    "bytes": 5252,
+    "bytes": 9334,
     "why": "known issues + evaluation protocol; the interval-leak fix the paper cites"
   }
 ]

README.md

@@ -49,6 +49,91 @@ answers are years and a same-`(s,r,o)`-other-time variant is ill-defined.
 **Per-question flags ship in `benchmark/functional_negatives.jsonl`** — restrict
 negative-dependent evaluation to the functional subset.
 
+## Quickstart
+
+Three steps, standard library only, no install. Scoring your own retriever
+against TempBench does **not** require the reference system.
+
+**1. Load.** Each line of `benchmark/benchmark_labelled.jsonl` is one question
+carrying its gold subgraph `S*` and its two typed negatives:
+
+```python
+import json
+
+test = [json.loads(l) for l in open('benchmark/benchmark_labelled.jsonl',
+                                    encoding='utf-8')]
+test = [q for q in test if q['split'] == 'test']          # 1,743 questions
+
+q = test[0]
+q['question']    # 'In 1994, what was ... ?'
+q['t_query']     # 1994.0  -- the time the question is asked about
+q['S_star']      # [{'s':..., 'r':..., 'o':..., 't_start':..., 't_end':...}, ...]
+q['S_dist']      # same (s,r), wrong object
+q['S_stale']     # same (s,r,o), wrong time
+```
+
+**2. Retrieve** with your own system. Return an iterable of triples per
+question — dicts with `s`/`r`/`o`/`t_start`/`t_end`, or 5-tuples in that order.
+Truncate to your own `k`; TRP is a precision quantity and is not truncated for
+you.
+
+**3. Score** with `code/tempbench_eval.py`:
+
+```python
+from tempbench_eval import score_question, aggregate
+
+rows = [score_question(q, my_retriever(q['question'], q['t_query']))
+        for q in test]
+print(aggregate(rows))
+# {'n_questions': 1743, 'coverage': ..., 'TRP_macro': ..., 'CCR': ...,
+#  'by_complexity': {...}, 'by_operator': {...}}
+```
+
+`python code/tempbench_eval.py` runs a self-check on synthetic data and needs
+no files.
+
+### What the two metrics mean
+
+Both are **answer-independent** — they score retrieved evidence, not the
+generated string, which is the whole point of the resource. A system can emit
+the right answer from a stale fact, and exact-match cannot see it.
+
+- **TRP** — of the triples you retrieved, the fraction that are in `S*` *and*
+  valid at `t_query`. Macro-averaged over questions that retrieved anything.
+- **CCR** — 1 if you retrieved *every* triple of `S*`, all time-valid; else 0.
+  Averaged over all questions, empty retrievals included.
+
+A triple is time-valid when `t_start <= t_query <= t_end`. TRP scores against
+1–3-triple gold chains, so its absolute value is low by construction: read the
+gap between systems and the per-complexity profile, not the raw number. The two
+are not redundant — the reference retriever scores TRP 0.203 against CCR 0.014
+at 3+-hop, meaning partial evidence arrives routinely and the full chain almost
+never.
+
+Always report `coverage` alongside them. A system that returns nothing on hard
+questions inflates its own TRP, since undefined TRP is excluded rather than
+scored zero.
+
+### The one trap
+
+**Restrict negative-dependent analysis to the functional subset.** Not every
+question's negatives genuinely differ from its gold. Scoring the stale subgraph
+directly on the 1-hop test slice returns TRP 0.141 — which looks like a
+time-aware retriever leaking, and is not:
+
+```python
+flags = {json.loads(l)['id']: json.loads(l)
+         for l in open('benchmark/functional_negatives.jsonl', encoding='utf-8')}
+sub = [q for q in test if flags[q['id']]['stale_functional']]
+```
+
+Restricted to functional negatives, the same measurement returns **TRP 0.000 /
+CCR 0.000**, as the construction implies. The 0.141 was entirely
+non-functional negatives.
+
+Read `v1.0.1-addendum.md` before evaluating: interval questions leak their
+answer under the original prompt protocol.
+
 ## Contents
 
 | path | what |
@@ -58,6 +143,7 @@ negative-dependent evaluation to the functional subset.
 | `benchmark/functional_negatives.jsonl` | per-question functional-negative flags |
 | `benchmark/labels.tsv`, `ids.txt` | Wikidata label dump and id list |
 | `code/` | the **deterministic construction pipeline** — indexer, 6-stage benchmark builder, label resolver, and the design-decisions document. Stdlib only; `python build_benchmark.py --smoke_test` verifies it |
+| `code/tempbench_eval.py` | **the TRP and CCR scorers** — score your own retriever without re-implementing the definitions. Stdlib only; `python tempbench_eval.py` self-checks |
 | `annotation/` | the annotation protocol (EN governing, IT translation) and validation-sample provenance |
 | `annotation/pilot_low_confidence.jsonl` | per-question **low-confidence flags** for the 500-question IAA pilot: 452 consensus, 48 flagged, with which judgment was disputed |
 | `baselines/` | reference-baseline evaluation outputs (see below) |
@@ -93,6 +179,59 @@ corrected protocol are in `v1.0.1-addendum.md`.
 **Naturalness ratings are not reliable between annotators** and should not be used
 as a quality signal; see the paper's Human Validation section.
 
+**Only the test split is human-validated.** Validation covers the 500-question
+pilot plus a 120-item blind round (116 scored) drawn from the test split. The
+6,096-question training split carries automatically generated labels that no
+human has checked. This is defensible for the benchmark's intended use — every
+number in the paper is computed on test, and none of the reference baselines
+trains on the released split — but if you fine-tune on `train`, you are training
+on unaudited labels. Treat the pipeline's construction guarantees, not human
+review, as what backs that split.
+
+**Question surface forms come from nine templates** — three for point-in-time,
+two each for before/after, interval and sequence — parameterised over anchor
+entity, relation chain and reference year. Linguistic diversity is therefore
+low by construction, and TempBench measures temporal *retrieval*, not robustness
+to paraphrase. Do not read a score here as evidence about natural-language
+variation. (Full template inventory and parameters in
+`code/benchmark-design-decisions.md`.)
+
+**The source KG is point-in-time, so `valid_at` reduces to exact-year
+equality.** `tkgl-smallpedia` carries discrete-timestamp facts
+(`t_start == t_end`), which means the composability operator ⊕ is exercised here
+in its degenerate case: checking that each hop is valid at the query year. The
+operator is defined for interval facts and admits chains that a plain interval
+intersection rejects, but **the released benchmark does not test that generality**
+— a validity-window TKG (YAGO3, ICEWS) would. Treat results here as evidence
+about time-valid retrieval on point-in-time graphs, and not yet as evidence
+about general temporal-chain reasoning.
+
+## Open questions this release does not answer
+
+Stated plainly, because they bound what a number on TempBench means.
+
+**Whether the benchmark discriminates across retriever families is not yet
+established.** Every system evaluated in the paper is a variant of one
+BFS + BM25 retriever — the same graph-traversal family used to *construct* `S*`
+by shortest-path retrieval under temporal constraints. High CCR may therefore
+partly reflect that methodological alignment rather than retrieval quality, and
+no heterogeneous system has been run: no dense retriever, no published
+temporal-RAG system, no parametric-LLM baseline.
+
+This is the most important open question about the resource, and it is
+squarely future work. The metrics ship here (`code/tempbench_eval.py`)
+specifically so that anyone can run a system from a different family and
+report TRP/CCR without going through the reference implementation — which is
+the cheapest path to settling it. Results from an unrelated architecture are
+more informative about the benchmark than anything the reference retriever can
+produce, and contributions are welcome.
+
+**A validity-window edition (v2).** Extending construction to interval-fact TKGs
+would exercise ⊕ in its general form and test whether the retrieval findings
+survive outside exact-year matching. When porting, check the source data's
+closed-interval convention against `valid_at`'s semantics first — the two do not
+always agree.
+
 ## Provenance and licence
 
 Built from `tkgl-smallpedia` in [TGB 2.0](https://arxiv.org/abs/2406.09639)

code/tempbench_eval.py

@@ -0,0 +1,204 @@
+"""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_')})