| """Macro F0.5 exactly as `ps.pdf` defines it. |
| |
| Per S1 entity: |
| F0.5 = (1.25 * P * R) / (0.25 * P + R) |
| macro-averaged over ALL S1 entities. A singleton (no true match) scores 1.0 for a correct |
| empty prediction and 0.0 for any prediction. |
| |
| Substituting P = TP/k and R = TP/T collapses this to the identity the whole project relies on: |
| |
| F0.5 = 1.25 * TP / (0.25 * T + k) |
| |
| because FP = k - TP and FN = T - TP cancel the TP contributions in the denominator. This is |
| exact, not an approximation. |
| |
| THE BREAK-EVEN EXCHANGE RATE, derived from that identity. With D = 0.25T + k, adding one |
| prediction |
| * gains 1.25 (D - TP) / (D (D+1)) if it is a true positive |
| * loses 1.25 TP / (D (D+1)) if it is a false positive |
| so an extra pair is worth taking only when its TP:FP ratio beats |
| |
| TP / (D - TP) |
| |
| This is an OPERATING-POINT-DEPENDENT number, not a universal constant. In the idealised limit |
| TP -> T and k -> T (so D = 1.25T) it tends to T / 0.25T = 4. At the shipped operating point it |
| is lower: measured mean T = 3.449, mean k = 3.316, mean TP = 3.300 over 20,000 validation |
| entities gives D = 4.178 and a break-even of 3.300 / 0.878 = ~3.8:1. |
| |
| Any batch of pairs added to the prediction set must be better than roughly 3.8-4 true |
| for every 1 false - about 80% precision - or macro F0.5 falls. |
| |
| (An earlier version of this analysis asserted "exactly 4:1". That is only the limiting value; |
| the self-test below checks the formula itself rather than the round number.) |
| |
| Measured on validation, the best band below our threshold offered 1.90:1 (386 TP / 203 FP), |
| and the next best 1.54:1. Both are far under the break-even either way, which is why lowering |
| the threshold could not buy recall, and why any new candidate source has to clear ~80% |
| precision to be worth including at all. |
| """ |
| from __future__ import annotations |
|
|
| import numpy as np |
|
|
|
|
| def entity_f05(pred: set, truth: set) -> float: |
| """F0.5 for one S1 entity. `pred` and `truth` are sets of S2/S3 identifiers.""" |
| k, t = len(pred), len(truth) |
| if t == 0: |
| return 1.0 if k == 0 else 0.0 |
| if k == 0: |
| return 0.0 |
| tp = len(pred & truth) |
| if tp == 0: |
| return 0.0 |
| return 1.25 * tp / (0.25 * t + k) |
|
|
|
|
| def macro_f05(preds: dict, truths: dict, ids): |
| """Macro F0.5 over `ids`. |
| |
| preds : {entity -> iterable of predicted targets} (missing == predicted empty) |
| truths : {entity -> iterable of true targets} (missing == true singleton) |
| ids : the entity list to average over - MUST be every S1 entity being scored, not |
| just the ones with predictions, or singletons silently vanish from the average. |
| |
| Returns (summary_dict, per_entity_array). |
| """ |
| per = np.empty(len(ids), np.float64) |
| tp_sum = k_sum = t_sum = 0 |
| for i, q in enumerate(ids): |
| p = preds.get(q) or () |
| t = truths.get(q) or () |
| p = p if isinstance(p, set) else set(p) |
| t = t if isinstance(t, set) else set(t) |
| per[i] = entity_f05(p, t) |
| tp_sum += len(p & t) |
| k_sum += len(p) |
| t_sum += len(t) |
| return { |
| "f05": float(per.mean()) if len(per) else 0.0, |
| "precision": (tp_sum / k_sum) if k_sum else 0.0, |
| "recall": (tp_sum / t_sum) if t_sum else 0.0, |
| "n": len(ids), |
| "tp": tp_sum, "k": k_sum, "t": t_sum, |
| "pred_per_entity": (k_sum / len(ids)) if len(ids) else 0.0, |
| }, per |
|
|
|
|
| def entity_scores(preds: dict, truths: dict, ids): |
| return macro_f05(preds, truths, ids)[1] |
|
|
|
|
| def slice_report(preds: dict, truths: dict, ids, by: dict, label="slice"): |
| """Macro F0.5 broken out by an arbitrary per-entity key (country, singleton flag, ...). |
| |
| Model-1's contribution to the project was that slice-level reporting is where the real |
| failures show up: the shipped run scored us 0.9832 / india 0.9806 on validation while |
| France - which has no labels at all - came out at an implied 0.946. |
| """ |
| groups: dict = {} |
| for q in ids: |
| groups.setdefault(by.get(q, "?"), []).append(q) |
| rows = [] |
| for key in sorted(groups, key=str): |
| g = groups[key] |
| m, _ = macro_f05(preds, truths, g) |
| rows.append({label: key, "n": len(g), "f05": m["f05"], |
| "precision": m["precision"], "recall": m["recall"], |
| "pred_per_entity": m["pred_per_entity"]}) |
| return rows |
|
|
|
|
| def oracle_f05(candidates: dict, truths: dict, ids): |
| """Best macro F0.5 reachable from a candidate set: predict truth AND candidates, and |
| predict empty for genuine singletons. |
| |
| THE CEILING THAT MATTERS. Measured on the shipped candidates this was 0.9942 against a |
| shipped 0.9821 - so the scorer lost 0.0121 and blocking lost 0.0058. Model-5 s25 is right |
| that you must never optimise the decision layer while this number is the bottleneck. |
| |
| Note the distinction Model-5 s33 rule 9 insists on: this is NOT pair recall. Pair recall |
| on the same candidates was 0.9824, which is a different and much less useful number. |
| """ |
| preds = {} |
| for q in ids: |
| hit = set(candidates.get(q) or ()) & set(truths.get(q) or ()) |
| if hit: |
| preds[q] = hit |
| return macro_f05(preds, truths, ids) |
|
|
|
|
| def pair_recall(candidates: dict, truths: dict, ids): |
| """Fraction of true pairs present in the candidate set, plus per-entity coverage rates.""" |
| got = tot = 0 |
| all_present = 0 |
| n_nonsing = 0 |
| for q in ids: |
| t = set(truths.get(q) or ()) |
| if not t: |
| continue |
| n_nonsing += 1 |
| c = set(candidates.get(q) or ()) |
| h = len(t & c) |
| got += h |
| tot += len(t) |
| if h == len(t): |
| all_present += 1 |
| return { |
| "pair_recall": got / tot if tot else 0.0, |
| "true_pairs": tot, |
| "retrieved": got, |
| "all_match_rate": all_present / n_nonsing if n_nonsing else 0.0, |
| } |
|
|
|
|
| |
| def _selftest(): |
| """ps.pdf's worked example: one true positive, three true matches, one prediction.""" |
| got = entity_f05({"a"}, {"a", "b", "c"}) |
| assert abs(got - 0.7142857) < 1e-6, got |
| assert entity_f05(set(), set()) == 1.0 |
| assert entity_f05({"a"}, set()) == 0.0 |
| assert entity_f05(set(), {"a"}) == 0.0 |
| assert entity_f05({"a"}, {"a"}) == 1.0 |
| assert abs(entity_f05({"a", "x"}, {"a"}) - 1.25 / 2.25) < 1e-9 |
|
|
| |
| |
| def brute_ratio(T, TP, k): |
| D = 0.25 * T + k |
| base = 1.25 * TP / D |
| gain = 1.25 * (TP + 1) / (0.25 * T + k + 1) - base |
| loss = base - 1.25 * TP / (0.25 * T + k + 1) |
| return gain, loss, loss / gain, TP / (D - TP) |
|
|
| for T, TP, k in [(4, 3, 3), (10, 9, 9), (100, 99, 99), (4, 2, 2), (8, 7, 8)]: |
| gain, loss, emp, formula = brute_ratio(T, TP, k) |
| assert gain > 0 and loss > 0 |
| assert abs(emp - formula) < 1e-9, (T, TP, k, emp, formula) |
|
|
| |
| lim = [brute_ratio(T, T - 1, T - 1)[3] for T in (4, 40, 400, 4000)] |
| assert lim[-1] > 3.9 and lim[0] < lim[-1] < 4.0, lim |
|
|
| |
| n = 20000 |
| T, k, TP = 68983 / n, 66324 / n, 66009 / n |
| D = 0.25 * T + k |
| shipped = TP / (D - TP) |
| assert 3.6 < shipped < 3.9, shipped |
| print(f"evaluate.py self-test OK (ps.pdf example = 0.714286; " |
| f"break-even formula verified; shipped operating point = {shipped:.2f}:1, " |
| f"limit -> 4:1)") |
|
|
|
|
| if __name__ == "__main__": |
| _selftest() |
|
|
