| """Final step. Merge every lane, add the new features, decide, write the submission. |
| |
| THIS RUNS ON ONE MACHINE AND MUST SEE EVERY SHARD. The competitive features and the one-owner |
| arbitration are both global: a record's competitor count is wrong if a fifth of the candidate |
| table is missing, and arbitration cannot resolve a conflict it cannot see. Running this per |
| lane and concatenating the outputs produces a file that looks fine and is wrong. |
| |
| In --mode train it fits the stacker and reports val F0.5 with an ablation, so the gain from |
| each new feature block is visible separately. In --mode test it applies a saved bundle. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import glob |
| import json |
| import os |
| import sys |
|
|
| 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 ce_score as CE |
| 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_FEATS = ["rrf", "n_channels", "s_e5_small", "s_e5_large", "s_bge_m3", |
| "r_e5_small", "r_e5_large", "r_bge_m3", "ce", "ce2", "ce_blend"] |
|
|
|
|
| def build(split: str, args) -> pd.DataFrame: |
| prep = os.path.dirname(P.work("prep", split, "_")) |
| s1 = pd.read_parquet(os.path.join(prep, "source1.parquet")) |
| pool = pd.read_parquet(os.path.join(prep, "pool.parquet")) |
|
|
| cand = pd.read_parquet(P.work("cand", f"{split}_union.parquet")) |
| print(f"union candidates: {len(cand):,}") |
|
|
| for col, pat in (("ce", args.ce_glob), ("ce2", args.ce2_glob)): |
| files = sorted(glob.glob(pat)) if pat else [] |
| if not files: |
| print(f" {col}: no files matched {pat!r}") |
| cand[col] = np.nan |
| continue |
| sc = F.merge_shards(files, score_col=col) |
| print(f" {col}: {len(sc):,} scored pairs from {len(files)} file(s)") |
| cand = cand.merge(sc[["q", "c", col]], on=["q", "c"], how="left") |
|
|
| if cand["ce"].isna().any(): |
| n = int(cand["ce"].isna().sum()) |
| print(f" WARNING: {n:,} union pairs ({n/len(cand):.2%}) have no primary CE score. " |
| f"A lane is missing or its shard range did not cover them.") |
| |
| if cand["ce2"].notna().any(): |
| m = cand["ce"].notna() & cand["ce2"].notna() |
| cand["ce_blend"] = cand["ce"].fillna(0).to_numpy(np.float32) |
| cand.loc[m, "ce_blend"] = CE.blend(cand.loc[m, "ce"].to_numpy(np.float32), |
| cand.loc[m, "ce2"].to_numpy(np.float32), |
| mode=args.blend_mode) |
| else: |
| cand["ce_blend"] = cand["ce"] |
| cand[["ce", "ce2", "ce_blend"]] = cand[["ce", "ce2", "ce_blend"]].fillna(0.0) |
|
|
| feats = list(BASE_FEATS) |
|
|
| if not args.no_structure: |
| print("adding structure / competitive features ...") |
| ni = S.build_name_index(s1) |
| cand = S.add_features( |
| cand, 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_blend") |
| feats += S.FEATURE_NAMES |
|
|
| gpath = P.work("geo", f"equiv_{split}.json") |
| if not args.no_geo and os.path.exists(gpath): |
| print("adding administrative-equivalence features ...") |
| tables = json.load(open(gpath, encoding="utf-8")) |
| matchers = {c: G.GeoMatcher(t) for c, t in tables.items()} |
| qcn = s1["country"].to_numpy() |
| |
| qp = G.parse_many(s1["business_address"].to_numpy()) |
| pp = G.parse_many(pool["business_address"].to_numpy()) |
| blank = {k: 0.0 for k in G.FEATURE_NAMES} |
| qi, ci = cand["q"].to_numpy(), cand["c"].to_numpy() |
| cols = {k: np.zeros(len(cand), np.float32) for k in G.FEATURE_NAMES} |
| for j in range(len(cand)): |
| m = matchers.get(qcn[qi[j]]) |
| r = m.features_pre(qp[qi[j]], pp[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: |
| cand[k] = cols[k] |
| feats += G.FEATURE_NAMES |
| elif not args.no_geo: |
| print(f" no geo table at {gpath}; skipping (run 02_france_geo.py first)") |
|
|
| return cand, feats, s1 |
|
|
|
|
| def attach_labels(cand: pd.DataFrame, split: str, s1: pd.DataFrame): |
| prep = os.path.dirname(P.work("prep", split, "_")) |
| pool = pd.read_parquet(os.path.join(prep, "pool.parquet")) |
| gtp = P.ground_truth(split) |
| gt = (pd.read_csv(gtp, sep="\t", dtype=str, keep_default_na=False, na_filter=False) |
| if gtp.endswith(".tsv") else pd.read_parquet(gtp)) |
| prow = {e: i for i, e in enumerate(pool["entity_id"])} |
| qrow = {e: i for i, e in enumerate(s1["entity_id"])} |
| truths = {} |
| for q, m in zip(gt["source1_entity_id"], gt["matched_entity_ids"]): |
| if q in qrow: |
| truths[qrow[q]] = {prow[x] for x in str(m).split(",") if x in prow} |
| y = np.fromiter((1 if c in truths.get(q, ()) else 0 |
| for q, c in zip(cand["q"], cand["c"])), np.int8, len(cand)) |
| cand["y"] = y |
| return truths |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--split", default="test") |
| ap.add_argument("--mode", default="test", choices=["train", "test"]) |
| ap.add_argument("--ce-glob", default="") |
| ap.add_argument("--ce2-glob", default="") |
| ap.add_argument("--blend-mode", default="rank", choices=["rank", "p"]) |
| ap.add_argument("--bundle", default="") |
| ap.add_argument("--threshold", type=float, default=-1.0, help="-1 = tune (train mode)") |
| ap.add_argument("--no-structure", action="store_true") |
| ap.add_argument("--no-geo", action="store_true") |
| ap.add_argument("--out", default="") |
| a = ap.parse_args() |
|
|
| cand, feats, s1 = build(a.split, a) |
| feats = [f for f in feats if f in cand.columns] |
|
|
| if a.mode == "train": |
| truths = attach_labels(cand, a.split, s1) |
| ids = sorted(truths) |
| cand["component"] = cand["q"] |
| print("\nablation (each block added to the one above):") |
| blocks = [("ce only", ["ce"]), |
| ("+ retrieval union", [f for f in BASE_FEATS if f in cand.columns]), |
| ("+ structure", [f for f in BASE_FEATS + S.FEATURE_NAMES if f in cand.columns]), |
| ("+ geo", feats)] |
| best = None |
| for name, fs in blocks: |
| if not fs: |
| continue |
| b = F.fit_stacker(cand, fs) |
| cand["p"] = F.apply_stacker(b, cand) |
| thr, f05, _ = F.tune_threshold(cand, truths, ids) |
| print(f" {name:<22} {len(fs):>3} feats thr {thr:.3f} F0.5 {f05:.5f}") |
| best = (b, thr, f05) |
| bundle, thr, f05 = best |
| bundle["threshold"] = thr |
| p = a.bundle or P.work("bundle", f"{a.split}_v2.joblib") |
| joblib.dump(bundle, p) |
| print(f"\nwrote {p} val F0.5 {f05:.5f} at threshold {thr:.3f}") |
| return |
|
|
| assert a.bundle, "--bundle is required in test mode" |
| bundle = joblib.load(a.bundle) |
| cand["p"] = F.apply_stacker(bundle, cand) |
| thr = a.threshold if a.threshold >= 0 else bundle["threshold"] |
| all_q = np.arange(len(s1)) |
| pred = F.predict_sets(cand, thr, all_q=all_q) |
|
|
| prep = os.path.dirname(P.work("prep", a.split, "_")) |
| pool = pd.read_parquet(os.path.join(prep, "pool.parquet")) |
| pid = pool["entity_id"].to_numpy() |
| qid = s1["entity_id"].to_numpy() |
| out = a.out or P.work("output_v2", "matching_results.tsv") |
| os.makedirs(os.path.dirname(out), exist_ok=True) |
| 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"wrote {out}") |
| print(f" {len(qid):,} S1 rows {npred:,} pairs {nempty:,} empty ({nempty/len(qid):.2%})") |
| print(f" threshold {thr:.3f}") |
| print(" run the official validator next: python utils/validate_submission.py " |
| f"{out} --check-ids") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
