| """Diagnose the false positives. 0.0041 of val loss, 24% of the total, undiagnosed by anyone. |
| |
| Every document in this project has attacked false NEGATIVES. FALSE_NEGATIVES_2026-09-27.md |
| s1 lists FP at 0.0041 and MODEL5_FALSE_NEGATIVE_FIXES.md s6 records it as "not diagnosed |
| yet [?]". It is now the largest unexamined bucket in the US/India half, and the arithmetic |
| says US/India must gain +0.0045 val for the leaderboard to reach 0.990 - so this bucket |
| alone is roughly the size of what is needed. |
| |
| THE QUESTION THAT DECIDES WHAT TO BUILD. A predicted pair (q, c) that is wrong is wrong in |
| one of three ways, and they need completely different fixes: |
| |
| A. c belongs to a DIFFERENT S1, and that S1 is also in our candidate table. |
| -> an arbitration / ranking failure. We had the right answer and chose the wrong one. |
| -> fixable with better global assignment. No new retrieval, no new scoring. |
| |
| B. c belongs to a different S1 that is NOT in our candidate table for c. |
| -> a retrieval failure wearing a false-positive costume: the true owner never competed. |
| -> fixable only by retrieving more. |
| |
| C. c belongs to NO S1 (a true distractor). |
| -> a scoring failure. 26.8% of addressed pool records are distractors, and 22.5% of |
| those deliberately reuse a real S1 name. |
| -> fixable only with a better scorer or better features. |
| |
| The split between A, B and C is the whole answer, and one pass over the labelled val split |
| settles it. Run: |
| |
| python scripts/20_fp_diag.py --bundle work/rescore/bundle.joblib |
| |
| With no bundle it fits a quick stacker on g_stack first, so it can run standalone. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import collections |
| import os |
| import sys |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) |
| from berx import evaluate as E |
| from berx import fuse as F |
| from berx import paths as P |
| from berx import structure as S |
|
|
| BASE = ["p1", "p1_rank", "p1_gap", "ce"] |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--bundle", default="") |
| ap.add_argument("--split", default="train") |
| ap.add_argument("--max-examples", type=int, default=12) |
| a = ap.parse_args() |
|
|
| df = pd.read_parquet(P.work("m4", "train.parquet")) |
| d = os.path.dirname(P.work("prep", a.split, "_")) |
| s1 = pd.read_parquet(os.path.join(d, "source1.parquet")) |
| pool = pd.read_parquet(os.path.join(d, "pool.parquet")) |
|
|
| |
| s1 = pd.concat([s1, S.name_key_columns(s1)], axis=1) |
| pool = pd.concat([pool, S.name_key_columns(pool)], axis=1) |
| pool["addr_empty"] = pool["business_address"].astype(str).str.strip() == "" |
| nf = S.name_features(df, s1, pool) |
| for c in S.NAME_FEATURES: |
| df[c] = nf[c].to_numpy() |
| feats = BASE + S.NAME_FEATURES |
|
|
| tr, va = df[df.grp == "stack"], df[df.grp == "val"].copy() |
| if a.bundle and os.path.exists(a.bundle): |
| import joblib |
| b = joblib.load(a.bundle) |
| feats = [f for f in b["feats"] if f in va.columns] |
| if len(feats) != len(b["feats"]): |
| print(" bundle wants features this table lacks; refitting instead") |
| b = F.fit_stacker(tr, BASE + S.NAME_FEATURES, label="y", group="q", n_folds=3) |
| else: |
| b = F.fit_stacker(tr, feats, label="y", group="q", n_folds=3) |
| va["p"] = F.apply_stacker(b, va) |
|
|
| t = np.load(P.work("m4", "truth.npz")) |
| ids = sorted(va["q"].unique().tolist()) |
| idset = set(ids) |
| truths = {q: set() for q in ids} |
| keep = np.isin(t["gt_q"], ids) |
| for q, c in zip(t["gt_q"][keep], t["gt_c"][keep]): |
| truths[int(q)].add(int(c)) |
|
|
| |
| owner = dict(zip(t["gt_c"].tolist(), t["gt_q"].tolist())) |
|
|
| best, _ = F.tune_decision(va, truths, ids) |
| pred = F.predict_sets(va, best["threshold"], all_q=np.asarray(ids), |
| method=best["method"], miss_mass=best["miss_mass"]) |
| m, _ = E.macro_f05(pred, truths, ids) |
| print(f"decision: {best['method']} F0.5 {m['f05']:.5f} " |
| f"P {m['precision']:.4f} R {m['recall']:.4f}\n") |
|
|
| fp = [(q, c) for q, cs in pred.items() for c in cs if c not in truths.get(q, ())] |
| n_pred = sum(len(v) for v in pred.values()) |
| print(f"predicted {n_pred:,} pairs, {len(fp):,} false positives " |
| f"({len(fp)/max(n_pred,1):.2%})\n") |
|
|
| |
| claim = collections.defaultdict(list) |
| for q, c, p in zip(va["q"].to_numpy(), va["c"].to_numpy(), va["p"].to_numpy()): |
| claim[int(c)].append((int(q), float(p))) |
|
|
| cat = collections.Counter() |
| rank_of_true = collections.Counter() |
| margins = [] |
| examples = {"A": [], "B": [], "C": []} |
| for q, c in fp: |
| o = owner.get(c) |
| if o is None: |
| cat["C distractor (belongs to no S1)"] += 1 |
| examples["C"].append((q, c, None)) |
| continue |
| competitors = claim.get(c, []) |
| has_true = any(qq == o for qq, _ in competitors) |
| if has_true: |
| cat["A true owner WAS in our table (we chose wrong)"] += 1 |
| ranked = sorted(competitors, key=lambda x: -x[1]) |
| pos = [i for i, (qq, _) in enumerate(ranked) if qq == o] |
| rank_of_true[min(pos[0], 5) if pos else 99] += 1 |
| pw = dict(competitors) |
| margins.append(pw[q] - pw[o]) |
| examples["A"].append((q, c, o)) |
| else: |
| cat["B true owner NOT in our table (retrieval miss)"] += 1 |
| examples["B"].append((q, c, o)) |
|
|
| print("=" * 74) |
| print("WHERE THE FALSE POSITIVES COME FROM") |
| print("=" * 74) |
| for k, v in cat.most_common(): |
| print(f" {k:<48} {v:>7,} {v/max(len(fp),1):6.1%}") |
|
|
| if rank_of_true: |
| print("\n For group A, where did the TRUE owner rank among competitors?") |
| tot = sum(rank_of_true.values()) |
| for r in sorted(rank_of_true): |
| lab = f"rank {r}" if r < 5 else ("rank 5+" if r < 99 else "not ranked") |
| print(f" {lab:<12} {rank_of_true[r]:>7,} {rank_of_true[r]/tot:6.1%}") |
| mg = np.array(margins) |
| print(f"\n Score margin by which the WRONG S1 beat the true owner:") |
| print(f" median {np.median(mg):.4f} p25 {np.percentile(mg,25):.4f} " |
| f"p75 {np.percentile(mg,75):.4f}") |
| print(f" within 0.05: {(mg < 0.05).mean():.1%} within 0.15: {(mg < 0.15).mean():.1%}") |
| print(" A small margin means the ordering is nearly right and a better") |
| print(" tie-break could flip it. A large one means the scorer is confident") |
| print(" and wrong, which needs features, not arbitration.") |
|
|
| print("\n" + "=" * 74) |
| print("WHAT THE FALSE POSITIVES LOOK LIKE") |
| print("=" * 74) |
| va_idx = {(int(q), int(c)): i for i, (q, c) in |
| enumerate(zip(va["q"].to_numpy(), va["c"].to_numpy()))} |
| ae = pool["addr_empty"].to_numpy() |
| ctry = s1["country"].to_numpy() |
| for grp in ("A", "B", "C"): |
| ex = examples[grp] |
| if not ex: |
| continue |
| qs = np.array([e[0] for e in ex]) |
| cs = np.array([e[1] for e in ex]) |
| print(f"\n group {grp}: {len(ex):,} empty-address {ae[cs].mean():.1%} " |
| f"by country {dict(collections.Counter(ctry[qs]).most_common())}") |
| for q, c, o in ex[:a.max_examples // 3]: |
| qn = s1['business_name'].iloc[q] |
| cn = pool['business_name'].iloc[c] |
| ca = pool['business_address'].iloc[c] |
| line = f" S1 {qn[:34]!r:38} -> {cn[:30]!r:34} | {str(ca)[:26]!r}" |
| if o is not None: |
| line += f" TRUE OWNER {s1['business_name'].iloc[o][:26]!r}" |
| print(line) |
|
|
| print("\n" + "=" * 74) |
| print("WHAT THIS MEANS") |
| print("=" * 74) |
| a_share = cat["A true owner WAS in our table (we chose wrong)"] / max(len(fp), 1) |
| b_share = cat["B true owner NOT in our table (retrieval miss)"] / max(len(fp), 1) |
| c_share = cat["C distractor (belongs to no S1)"] / max(len(fp), 1) |
| print(f" A {a_share:5.1%} fixable by better ASSIGNMENT (no new retrieval or scoring)") |
| print(f" B {b_share:5.1%} needs better RETRIEVAL for the true owner") |
| print(f" C {c_share:5.1%} needs a better SCORER or decoy features") |
| print(f"\n The 0.0041 of val loss splits roughly " |
| f"{0.0041*a_share:.4f} / {0.0041*b_share:.4f} / {0.0041*c_share:.4f}.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
