| """Track 1. Add the new features to model-4's existing scores, gate on a clean val, ship.
|
|
|
| # measure (fit on g_stack, read g_val)
|
| python scripts/11_rescore.py --mode train
|
| # apply, only if the gate passed
|
| python scripts/11_rescore.py --mode test --bundle work/rescore/bundle.joblib
|
|
|
| WHAT IS BEING TESTED. model-4 has no feature for "how many S1 share this candidate's name".
|
| On its own stack, among empty-address candidates whose name_core equals the S1's:
|
|
|
| unique among the country's S1 mean p 0.714 actual match rate 0.982
|
| shared by 3 or more S1 mean p 0.280 actual 0.170
|
|
|
| The model under-predicts the first group by 0.27 and over-predicts the third. Per coarse
|
| group its calibration is perfect, so nothing short of conditioning on the competitor count
|
| reveals it. These features supply exactly that count, plus the address-equivalence signal for
|
| France, and the stacker is refit on top of model-4's own p1 and cross-encoder score.
|
|
|
| THE ABLATION IS THE POINT. Four nested feature sets are fitted and read on g_val, so the gain
|
| from each block is separable and a block that does nothing is visible rather than absorbed.
|
|
|
| THE GATE. Ship only if the full set beats the baseline set by at least --min-gain on g_val.
|
| Both numbers come from the same stacker on the same split, so the comparison is like for like
|
| even if this stacker is not tuned as finely as model-4's own.
|
| """
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import json
|
| import os
|
| import sys
|
| import time
|
|
|
| import joblib
|
| 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 france_geo as G
|
| 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"]
|
| M4 = os.environ.get("BERX_M4", "/scratch/user4/dai/model-4/work")
|
|
|
|
|
| def prep_dir(split: str) -> str:
|
| return os.path.dirname(P.work("prep", split, "_"))
|
|
|
|
|
| def add_all(df: pd.DataFrame, split: str, use_geo: bool = True):
|
| """Attach structure and geo features. `split` selects which source files to read."""
|
| d = prep_dir(split)
|
| s1 = pd.read_parquet(os.path.join(d, "source1.parquet"))
|
| pool = pd.read_parquet(os.path.join(d, "pool.parquet"))
|
|
|
|
|
| t0 = time.time()
|
| print(f" name_core / name_ns over {len(s1):,} S1 and {len(pool):,} pool rows ...",
|
| flush=True)
|
| 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()
|
| print(f" name-sharing features: {time.time()-t0:.0f}s", flush=True)
|
|
|
| t0 = time.time()
|
| print(f" building name index over {len(s1):,} S1 rows ...", flush=True)
|
| ni = S.build_name_index(s1)
|
| df = S.add_features(df, s1["business_name"].to_numpy(), s1["country"].to_numpy(),
|
| pool["business_name"].to_numpy(), pool["business_address"].to_numpy(),
|
| pool["country"].to_numpy(), ni["count"], pcol="ce")
|
| print(f" structure features: {time.time()-t0:.0f}s")
|
| feats = list(BASE) + S.NAME_FEATURES + S.FEATURE_NAMES
|
|
|
| gpath = P.work("geo", f"equiv_{split}.json")
|
| if use_geo and os.path.exists(gpath):
|
| t0 = time.time()
|
| tables = json.load(open(gpath, encoding="utf-8"))
|
| matchers = {c: G.GeoMatcher(t) for c, t in tables.items()}
|
| qcn = s1["country"].to_numpy()
|
| qi, ci = df["q"].to_numpy(), df["c"].to_numpy()
|
|
|
| uq, uc = np.unique(qi), np.unique(ci)
|
| qa, pa = s1["business_address"].to_numpy(), pool["business_address"].to_numpy()
|
| qp = {int(i): G.parse_address(qa[i]) for i in uq}
|
| pp = {int(i): G.parse_address(pa[i]) for i in uc}
|
| blank = {k: 0.0 for k in G.FEATURE_NAMES}
|
| cols = {k: np.zeros(len(df), np.float32) for k in G.FEATURE_NAMES}
|
| stepj = max(1, len(df) // 10)
|
| for j in range(len(df)):
|
| if j % stepj == 0 and j:
|
| print(f" geo {j:>12,}/{len(df):,} ({j/len(df):5.1%})", flush=True)
|
| m = matchers.get(qcn[qi[j]])
|
| r = m.features_pre(qp[int(qi[j])], pp[int(ci[j])]) if m is not None else blank
|
| for k in G.FEATURE_NAMES:
|
| cols[k][j] = r[k]
|
| for k in G.FEATURE_NAMES:
|
| df[k] = cols[k]
|
| feats += G.FEATURE_NAMES
|
| print(f" geo features: {time.time()-t0:.0f}s")
|
| elif use_geo:
|
| print(f" no geo table at {gpath}; continuing without it")
|
| return df, feats
|
|
|
|
|
| def truths_for(qs, gt_q, gt_c):
|
| keep = np.isin(gt_q, qs)
|
| out = {int(q): set() for q in qs}
|
| for q, c in zip(gt_q[keep], gt_c[keep]):
|
| out[int(q)].add(int(c))
|
| return out
|
|
|
|
|
| def evaluate_block(tr, va, feats, truths, ids, name, n_folds=3):
|
| b = F.fit_stacker(tr, feats, label="y", group="q", n_folds=n_folds)
|
| va = va.copy()
|
| va["p"] = F.apply_stacker(b, va)
|
|
|
|
|
|
|
| best, f_thr = 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" {name:<26} {len(feats):>3} feats {best['method']:<9} "
|
| f"F0.5 {best['f05']:.5f} (flat thr {f_thr:.5f}) "
|
| f"P {m['precision']:.4f} R {m['recall']:.4f}")
|
| b["threshold"] = best["threshold"]
|
| b["method"] = best["method"]
|
| b["miss_mass"] = best["miss_mass"]
|
| return b, best["f05"]
|
|
|
|
|
| def main():
|
| ap = argparse.ArgumentParser()
|
| ap.add_argument("--mode", required=True, choices=["train", "test"])
|
| ap.add_argument("--bundle", default="")
|
| ap.add_argument("--min-gain", type=float, default=0.0015,
|
| help="required g_val gain of the full set over the baseline set")
|
| ap.add_argument("--no-geo", action="store_true")
|
| ap.add_argument("--out", default="")
|
| a = ap.parse_args()
|
|
|
| if a.mode == "train":
|
| df = pd.read_parquet(P.work("m4", "train.parquet"))
|
| df, feats = add_all(df, "train", use_geo=not a.no_geo)
|
| tr = df[df.grp == "stack"]
|
| va = df[df.grp == "val"]
|
| t = np.load(P.work("m4", "truth.npz"))
|
| ids = sorted(set(va["q"].unique().tolist()))
|
| truths = truths_for(np.array(ids), t["gt_q"], t["gt_c"])
|
| nt = np.mean([len(v) for v in truths.values()])
|
| print(f"\nfit on {len(tr):,} stack rows / {tr.q.nunique():,} S1")
|
| print(f"read on {len(va):,} val rows / {len(ids):,} S1, mean true matches {nt:.2f}\n")
|
|
|
|
|
|
|
|
|
| blocks = [
|
| ("baseline (model-4 cols)", BASE),
|
| ("+ 6 name-sharing [measured]", BASE + S.NAME_FEATURES),
|
| ("+ my structure", BASE + S.NAME_FEATURES
|
| + [f for f in S.FEATURE_NAMES if f in df.columns]),
|
| ("+ geo", feats),
|
| ]
|
| results = []
|
| for name, fs in blocks:
|
| fs = [f for f in fs if f in df.columns]
|
| results.append((name, *evaluate_block(tr, va, fs, truths, ids, name)))
|
|
|
| base_f05 = results[0][2]
|
| best_name, best_b, best_f05 = max(results, key=lambda r: r[2])
|
| gain = best_f05 - base_f05
|
| print(f"\n baseline {base_f05:.5f} -> best '{best_name}' {best_f05:.5f} "
|
| f"({gain:+.5f})")
|
| print(f" model-4's own val F0.5 for reference: 0.98298")
|
|
|
| p = a.bundle or P.work("rescore", "bundle.joblib")
|
| joblib.dump(best_b, p)
|
| json.dump({"base": base_f05, "best": best_f05, "gain": gain,
|
| "threshold": best_b["threshold"], "block": best_name,
|
| "pass": bool(gain >= a.min_gain)},
|
| open(P.work("rescore", "gate.json"), "w"), indent=1)
|
|
|
| if gain >= a.min_gain:
|
| print(f"\n GATE A PASS ({gain:+.5f} >= {a.min_gain}). Run --mode test.")
|
| else:
|
| print(f"\n GATE A FAIL ({gain:+.5f} < {a.min_gain}).")
|
| print(" The global information is already in model-4's scores. Do not ship this;")
|
| print(" keep the existing submission and put the time into retrieval instead.")
|
| sys.exit(3)
|
| return
|
|
|
| assert a.bundle, "--mode test needs --bundle"
|
| b = joblib.load(a.bundle)
|
| df = pd.read_parquet(P.work("m4", "test.parquet"))
|
| df, _ = add_all(df, "test", use_geo=not a.no_geo)
|
| missing = [f for f in b["feats"] if f not in df.columns]
|
| assert not missing, f"test table is missing features the bundle needs: {missing}"
|
| df["p"] = F.apply_stacker(b, df)
|
|
|
| d = prep_dir("test")
|
| s1 = pd.read_parquet(os.path.join(d, "source1.parquet"))
|
| pool = pd.read_parquet(os.path.join(d, "pool.parquet"))
|
| pred = F.predict_sets(df, b["threshold"], all_q=np.arange(len(s1)),
|
| method=b.get("method", "threshold"),
|
| miss_mass=b.get("miss_mass", 0.0))
|
|
|
| out = a.out or P.work("output_v2", "matching_results.tsv")
|
| os.makedirs(os.path.dirname(out), exist_ok=True)
|
| qid, pid = s1["entity_id"].to_numpy(), pool["entity_id"].to_numpy()
|
| with open(out, "w", encoding="utf-8", newline="") as fh:
|
| fh.write("source1_entity_id\tmatched_entity_ids\n")
|
| for i in range(len(qid)):
|
| fh.write(f"{qid[i]}\t{','.join(pid[c] for c in pred.get(i, []))}\n")
|
| npred = sum(len(v) for v in pred.values())
|
| nempty = sum(1 for v in pred.values() if not v)
|
| print(f"\nwrote {out}")
|
| print(f" {len(qid):,} S1 rows {npred:,} pairs {nempty:,} empty ({nempty/len(qid):.2%})")
|
| print(f" rule {b.get('method','threshold')} threshold {b['threshold']:.3f} "
|
| f"miss_mass {b.get('miss_mass',0.0)}")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
