| """End-to-end smoke test for the matching stage: src.features, src.train_matcher, src.predict. |
| |
| Run with `python tests/test_matcher_smoke.py` (or pytest). Builds a tiny synthetic world with the |
| hard cases from docs/dataset_findings.md (Indic-script vendor name resolved by transliteration, a |
| domain-form name, a former-name 'f/k/a' form, a chain = two S1 records with the same name and |
| different addresses, singletons, orphans, a missed true match, an S1 id without any candidate), |
| normalises it with src.normalize exactly like scripts/preprocess_normalize.py, fabricates a |
| blocking-style candidate parquet and then: |
| * build_features: in-process == forked workers; keep_s1 subset == the same rows of a full run; |
| spot checks on the hard cases; competition counts; |
| * train_matcher: k-fold core function + leave-one-country-out through the CLI; |
| * predict: train countries + an unseen third country (France); matching_results.tsv and |
| candidate_pairs.tsv checked structurally and with student_resource/utils/validate_submission.py. |
| Everything stays in a temp dir of a few hundred KB. |
| """ |
| import json |
| import os |
| import random |
| import shutil |
| import subprocess |
| import sys |
| import tempfile |
| import unicodedata |
| import re |
| from pathlib import Path |
|
|
| import numpy as np |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| sys.path.insert(0, str(ROOT)) |
|
|
| from src.normalize import normalize_record |
|
|
| VALIDATOR = ROOT.parents[1] / "student_resource" / "utils" / "validate_submission.py" |
| INDIC = re.compile(r"[ऀ-]") |
| NAME_LEX = {"श्री": "shree", "गणेश": "ganesh", "ट्रेडर्स": "traders", "प्राइवेट": "private", "लिमिटेड": "limited", |
| "कृष्णा": "krishna", "मोटर्स": "motors", "बालाजी": "balaji", "फूड्स": "foods"} |
| ADDR_LEX = {} |
|
|
| US_A = ["Holloway", "Prime", "Westbrook", "Summit", "Riverside", "Oakridge", "Maple", "Cedar", "Liberty", "Pioneer", |
| "Harbor", "Evergreen", "Golden", "Granite", "Falcon", "Keystone", "Bluebird", "Ironwood", "Sterling"] |
| US_B = ["Dental", "Pediatric", "Seafood", "Consulting", "Logistics", "Realty", "Bakery", "Auto", "Learning", "Fitness"] |
| US_C = ["Group", "LLC", "Inc", "Services", "Center", "Co"] |
| US_ST = ["Elm", "Oak", "Westchester", "Montebello", "Ellis", "Fawn", "Lake", "Hill", "Pine", "Cedar", "Sunset"] |
| US_TY = [("Street", "St"), ("Road", "Rd"), ("Drive", "Dr"), ("Avenue", "Ave"), ("Court", "Ct")] |
| US_CITY = [("High Point", "NC", "North Carolina"), ("Phoenix", "AZ", "Arizona"), ("Tahlequah", "OK", "Oklahoma"), |
| ("Fort Worth", "TX", "Texas"), ("Morganton", "NC", "North Carolina")] |
| IN_A = ["Shree", "Aditya", "Krishna", "Ganesh", "Lakshmi", "Balaji", "Durga", "Sai", "Om", "Vishnu", "Maruti", "Surya"] |
| IN_B = ["Marketing", "Properties", "Traders", "Enterprises", "Textiles", "Pharma", "Constructions", "Motors", "Foods"] |
| IN_C = ["Private Limited", "LLP", "Pvt Ltd", "Limited"] |
| IN_LOC = ["Gulmohar Colony", "Subhash Nagar", "MG Road", "Civil Lines", "Banjara Hills", "Salt Lake"] |
| IN_CITY = [("Bhopal", "Madhya Pradesh", "MP"), ("New Delhi", "Delhi", "DL"), ("Bengaluru", "Karnataka", "KA"), |
| ("Hyderabad", "Telangana", "TG"), ("Pune", "Maharashtra", "MH")] |
| FR_A = ["Boulangerie", "Atelier", "Maison", "Cabinet", "Garage", "Pharmacie", "Librairie", "Brasserie"] |
| FR_B = ["Dupont", "Martin", "Lefevre", "Moreau", "Bernard", "Petit", "Rousseau", "Fontaine"] |
| FR_C = ["SARL", "SAS", "EURL", "SA"] |
| FR_ST = ["de la Paix", "Victor Hugo", "des Lilas", "Pasteur", "du Moulin", "Jean Jaures"] |
| FR_CITY = [("Lille", "Hauts-de-France", "Nord"), ("Bordeaux", "Nouvelle-Aquitaine", "Gironde"), |
| ("Nantes", "Pays de la Loire", "Loire-Atlantique")] |
|
|
|
|
| |
| |
| |
| def _typo(s, rng): |
| if len(s) < 6: |
| return s |
| i = rng.randrange(1, len(s) - 2) |
| return s[:i] + s[i + 1] + s[i] + s[i + 2:] |
|
|
|
|
| def _entity(country, rng): |
| if country == "US": |
| city, ab, full = rng.choice(US_CITY) |
| ty, tya = rng.choice(US_TY) |
| st, num = rng.choice(US_ST), rng.randint(10, 9999) |
| name = f"{rng.choice(US_A)} {rng.choice(US_B)} {rng.choice(US_C)}" |
| return name, (num, st, ty, tya, city, ab, full) |
| if country == "India": |
| city, st, code = rng.choice(IN_CITY) |
| name = f"{rng.choice(IN_A)} {rng.choice(IN_B)} {rng.choice(IN_C)}" |
| return name, (rng.randint(1, 999), rng.randint(1, 99), rng.choice(IN_LOC), city, st, code) |
| city, reg, dep = rng.choice(FR_CITY) |
| name = f"{rng.choice(FR_A)} {rng.choice(FR_B)} {rng.choice(FR_C)}" |
| return name, (rng.randint(1, 200), rng.choice(FR_ST), city, reg, dep) |
|
|
|
|
| def _s1_addr(country, a): |
| if country == "US": |
| num, st, ty, tya, city, ab, full = a |
| return f"{num} {st} {ty}, {city}, {full}" |
| if country == "India": |
| n1, n2, loc, city, st, code = a |
| return f"{n1}/{n2}, {loc}, {city}, {st}" |
| num, st, city, reg, dep = a |
| return f"{num} rue {st}, {city}, {reg}" |
|
|
|
|
| def _vendor_addr(country, a, rng): |
| r = rng.random() |
| if r < 0.06: |
| return "" |
| if country == "US": |
| num, st, ty, tya, city, ab, full = a |
| if rng.random() < 0.1: |
| num = num + 2 |
| s = f"{num} {st.upper()} {tya.upper()}, {city.upper()}, {ab}" if rng.random() < 0.5 else f"{num} {st} {tya}, {city}" |
| return s |
| if country == "India": |
| n1, n2, loc, city, st, code = a |
| return rng.choice([f"H.No {n1}/{n2}, {loc}, {city}, {code}", f"{n1}/{n2}, {city}, {st}", f"{loc}, {city}"]) |
| num, st, city, reg, dep = a |
| return rng.choice([f"{num} R. {st}, {city.upper()}, {dep}", f"{num} rue {st}, {city}"]) |
|
|
|
|
| def _vendor_name(name, rng): |
| r = rng.random() |
| if r < 0.3: |
| return name |
| if r < 0.5: |
| return " ".join(name.split()[:-1]) or name |
| if r < 0.65: |
| return name.upper() |
| if r < 0.8: |
| return _typo(name, rng) |
| return name + " Services" |
|
|
|
|
| def make_world(seed, countries, n_per_country, tag): |
| """-> s1 rows, pool rows (raw), gt {s1: [ids]}, special {name: (s1_id, [vendor ids])}.""" |
| rng = random.Random(seed) |
| s1, pool, gt, special = [], [], {}, {} |
| nid = [0] |
|
|
| def new_id(prefix): |
| nid[0] += 1 |
| return f"{prefix}-{tag}{nid[0]:05d}" |
|
|
| def add_vendor(country, name, addr): |
| vid = new_id(rng.choice(["S2", "S3"])) |
| pool.append((vid, name, addr, country)) |
| return vid |
|
|
| for country in countries: |
| for i in range(n_per_country): |
| name, a = _entity(country, rng) |
| sid = new_id("S1") |
| s1.append((sid, name, _s1_addr(country, a), country)) |
| k = rng.choices([0, 1, 2, 3, 4], weights=[1, 2, 3, 3, 2])[0] |
| gt[sid] = [add_vendor(country, _vendor_name(name, rng), _vendor_addr(country, a, rng)) for _ in range(k)] |
| for _ in range(n_per_country // 3): |
| name, a = _entity(country, rng) |
| add_vendor(country, _vendor_name(name, rng), _vendor_addr(country, a, rng)) |
| if "India" in countries: |
| sid = new_id("S1") |
| s1.append((sid, "Shree Ganesh Traders Private Limited", "12/4, Banjara Hills, Hyderabad, Telangana", "India")) |
| v1 = add_vendor("India", "श्री गणेश ट्रेडर्स प्राइवेट लिमिटेड", "12/4, Banjara Hills, Hyderabad, Andhra Pradesh") |
| v2 = add_vendor("India", "Shree Ganesh Traders Pvt Ltd", "12/4, Hyderabad, TG") |
| gt[sid] = [v1, v2] |
| special["indic"] = (sid, [v1, v2]) |
| if "US" in countries: |
| sid = new_id("S1") |
| s1.append((sid, "Dutta International School", "740 Montebello Drive, Phoenix, Arizona", "US")) |
| v = add_vendor("US", "duttainternationalschool.com", "740 MONTEBELLO DR, PHOENIX, AZ") |
| gt[sid] = [v] |
| special["domain"] = (sid, [v]) |
| sid = new_id("S1") |
| s1.append((sid, "Big Seafood LLC", "1200 Elm Street, Fort Worth, Texas", "US")) |
| v = add_vendor("US", "Belovera Sys f/k/a Big Seafood LLC", "1200 Elm St, Fort Worth, TX") |
| gt[sid] = [v] |
| special["former"] = (sid, [v]) |
| chain = [] |
| for num, st, city, ab, full in [(15, "Ellis", "High Point", "NC", "North Carolina"), |
| (3315, "Fawn", "Tahlequah", "OK", "Oklahoma")]: |
| sid = new_id("S1") |
| s1.append((sid, "Primary Care Group", f"{num} {st} Road, {city}, {full}", "US")) |
| vs = [add_vendor("US", "Primary Care Group", f"{num} {st} Rd, {city}, {ab}"), |
| add_vendor("US", "PRIMARY CARE GROUP LLC", f"{num} {st.upper()} ROAD, {city.upper()}")] |
| gt[sid] = vs |
| chain.append((sid, vs)) |
| special["chain"] = chain |
| sid = new_id("S1") |
| s1.append((sid, "Keystone Realty Inc", "88 Lake Court, Morganton, North Carolina", "US")) |
| add_vendor("US", "Keystone Realty Group", "4512 Pine Ave, Phoenix, AZ") |
| gt[sid] = [] |
| special["singleton"] = (sid, []) |
| rng.shuffle(pool) |
| return s1, pool, gt, special |
|
|
|
|
| def _translit_tokens(raw): |
| out, unk = [], 0 |
| for t in raw.split(): |
| if INDIC.search(t): |
| m = NAME_LEX.get(t) or NAME_LEX.get(t.strip(".,()")) |
| if m: |
| out.append(m) |
| else: |
| unk += 1 |
| out.append(t) |
| else: |
| t2 = unicodedata.normalize("NFKD", t) |
| t2 = "".join(c for c in t2 if not unicodedata.combining(c)).lower() |
| t2 = re.sub(r"[^a-z0-9]+", " ", t2).strip() |
| if t2: |
| out.extend(t2.split()) |
| return out, unk |
|
|
|
|
| def norm_table(rows): |
| """Same record layout as scripts/preprocess_normalize.py.""" |
| out = [] |
| for eid, n, a, c in rows: |
| r = normalize_record(n, a, c) |
| if r["name_has_indic_script"]: |
| toks, unk = _translit_tokens(n) |
| else: |
| toks, unk = r["name_tokens"], 0 |
| r["name_translit_tokens"], r["name_translit_unknown"] = toks, unk |
| r["name_translit"] = " ".join(toks) |
| r["addr_tokens_translit"] = [ADDR_LEX.get(t, t) for t in r["addr_tokens"]] |
| r["entity_id"], r["raw_name"], r["raw_address"] = eid, n, a |
| r.pop("addr_postal", None) |
| out.append(r) |
| return pa.Table.from_pylist(out) |
|
|
|
|
| def _jac(a, b): |
| a, b = set(a.lower().split()), set(b.lower().split()) |
| return len(a & b) / len(a | b) if (a or b) else 0.0 |
|
|
|
|
| def make_cands(s1, pool, gt, seed, per_s1=10, drop_true=0.04, no_cand_s1=()): |
| """Blocking-like candidate table: true matches (a few dropped) + most similar same-country vendors.""" |
| rng = random.Random(seed) |
| by_c = {} |
| for v in pool: |
| by_c.setdefault(v[3], []).append(v) |
| rows = [] |
| for sid, n, a, c in s1: |
| if sid in no_cand_s1: |
| continue |
| true = set(gt.get(sid, [])) |
| scored = sorted(by_c.get(c, []), key=lambda v: -(_jac(n, v[1]) + 0.5 * _jac(a, v[2]))) |
| chosen = [v for v in scored if v[0] in true and rng.random() > drop_true] |
| for v in scored: |
| if len(chosen) >= per_s1: |
| break |
| if v[0] not in true and v not in chosen: |
| chosen.append(v) |
| for r, v in enumerate(chosen): |
| sn, sa = _jac(n, v[1]), _jac(a, v[2]) |
| rev = rng.random() < 0.15 |
| rows.append({"s1_id": sid, "cand_id": v[0], "country": c, "src": v[0][:2], |
| "sim_name": np.float32(sn), "sim_nameaddr": np.float32(0.5 * (sn + sa)), |
| "sim_addr": np.float32(sa) if v[2] else np.float32("nan"), |
| "sim_word": np.float32(0.5 * (sn + sa)), "f_name": True, "f_nameaddr": r < 6, |
| "f_addr": bool(v[2]), "f_word": r < 8, "from_reverse": rev, |
| "rank_name": r, "rank_nameaddr": r if r < 6 else None, "rank_addr": None, |
| "rank_word": r if r < 8 else None, "rank_rev": 0 if rev else None}) |
| tab = pa.Table.from_pylist(rows) |
| return tab.cast(pa.schema([(f.name, pa.int16() if f.name.startswith("rank_") else f.type) for f in tab.schema])) |
|
|
|
|
| def write_tsv(path, rows, header=("entity_id", "business_name", "business_address", "country")): |
| with open(path, "w", encoding="utf-8") as fh: |
| fh.write("\t".join(header) + "\n") |
| for r in rows: |
| fh.write("\t".join(r) + "\n") |
|
|
|
|
| def build_dataset(d: Path): |
| s1, pool, gt, special = make_world(7, ["US", "India"], 45, "a") |
| t1, tpool, tgt, tspecial = make_world(11, ["US", "India", "France"], 18, "t") |
| norm = d / "norm" |
| norm.mkdir(parents=True, exist_ok=True) |
| pq.write_table(norm_table(s1), norm / "s1.parquet") |
| pq.write_table(norm_table([v for v in pool if v[0].startswith("S2")]), norm / "s2.parquet") |
| pq.write_table(norm_table([v for v in pool if v[0].startswith("S3")]), norm / "s3.parquet") |
| pq.write_table(norm_table(t1), norm / "t1.parquet") |
| pq.write_table(norm_table([v for v in tpool if v[0].startswith("S2")]), norm / "t2.parquet") |
| pq.write_table(norm_table([v for v in tpool if v[0].startswith("S3")]), norm / "t3.parquet") |
| no_cand = {s1[3][0]} |
| pq.write_table(make_cands(s1, pool, gt, 1, no_cand_s1=no_cand), d / "cands_train.parquet") |
| pq.write_table(make_cands(t1, tpool, tgt, 2, no_cand_s1={t1[0][0]}), d / "cands_test.parquet") |
| pq.write_table(pa.table({"a": [s for s, v in gt.items() for _ in v], "b": [x for v in gt.values() for x in v]}), |
| d / "pairs.parquet") |
| pq.write_table(pa.table({"source1_entity_id": list(gt), "matched_entity_ids": [",".join(v) for v in gt.values()]}), |
| d / "gt.parquet") |
| |
| names = {r[0]: r[1] for r in s1 + pool} |
| addrs = {r[0]: r[2] for r in pool} |
| au = [{"a": s, "b": v, "indic_name": bool(INDIC.search(names[v])), "domain_form": ".com" in names[v], |
| "former_form": "f/k/a" in names[v], "addr_empty": addrs[v] == "", "name_j": _jac(names[s], names[v])} |
| for s, vs in gt.items() for v in vs] |
| pq.write_table(pa.Table.from_pylist(au), d / "pair_audit.parquet") |
| test_dir = d / "dataset_test" |
| test_dir.mkdir(exist_ok=True) |
| write_tsv(test_dir / "test_source1.tsv", t1) |
| write_tsv(test_dir / "test_source2.tsv", [v for v in tpool if v[0].startswith("S2")]) |
| write_tsv(test_dir / "test_source3.tsv", [v for v in tpool if v[0].startswith("S3")]) |
| return {"s1": s1, "pool": pool, "gt": gt, "special": special, "t1": t1, "tpool": tpool, "tgt": tgt, |
| "no_cand": no_cand, "test_dir": test_dir} |
|
|
|
|
| |
| |
| |
| def _row(df, s1_id, cand_id): |
| m = (df["s1_id"].astype(str) == s1_id) & (df["cand_id"].astype(str) == cand_id) |
| assert m.sum() == 1, (s1_id, cand_id, int(m.sum())) |
| return df[m].iloc[0] |
|
|
|
|
| def check_features(d: Path, W: dict): |
| import polars as pl |
| from src.features import PAIR_FEATURES, build_features, build_idf_tables, feature_columns, load_norm |
|
|
| s1t = load_norm(d / "norm" / "s1.parquet") |
| pt = load_norm([d / "norm" / "s2.parquet", d / "norm" / "s3.parquet"]) |
| cands = pl.read_parquet(d / "cands_train.parquet") |
| idf = build_idf_tables(s1t) |
| assert set(idf) == {"us", "india"}, idf.keys() |
| f1 = build_features(cands, s1t, pt, idf, n_jobs=1, verbose=False) |
| f2 = build_features(cands.to_pandas(), s1t, pt, idf, n_jobs=2, task_rows=97, verbose=False) |
| cols = feature_columns(f1) |
| assert len(f1) == cands.height and cols == feature_columns(f2) |
| a1 = f1[[c for c in cols if c != "country"]].to_numpy(np.float64) |
| a2 = f2[[c for c in cols if c != "country"]].to_numpy(np.float64) |
| assert np.allclose(a1, a2, equal_nan=True), "forked workers differ from in-process" |
| assert (f1["country"].astype(str) == f2["country"].astype(str)).all() |
| assert str(f1["country"].dtype) == "category" and sorted(f1["country"].cat.categories) == ["India", "US"] |
| assert not np.isnan(f1[PAIR_FEATURES].to_numpy()).any(), "pair features must not be NaN" |
| assert list(f1["s1_id"].astype(str)) == cands.get_column("s1_id").to_list() |
|
|
| sp = W["special"] |
| sid, (v1, v2) = sp["indic"][0], sp["indic"][1] |
| r = _row(f1, sid, v1) |
| assert r.p_has_indic == 1 and r.n_jac == 1.0 and r.n_ratio == 100 and r.n_legal3 == 1, r[PAIR_FEATURES[:20]] |
| assert r.a_state3 == 1 |
| sid, (v,) = sp["domain"] |
| r = _row(f1, sid, v) |
| assert r.p_is_domain == 1 and r.n_sp_ratio == 100 and r.a_stno3 == 1, r |
| sid, (v,) = sp["former"] |
| r = _row(f1, sid, v) |
| assert r.n_alt_best == 100 and r.n_ratio == 100 |
| (sa, va), (sb, vb) = sp["chain"] |
| own, other = _row(f1, sa, va[0]), _row(f1, sa, vb[0]) |
| assert own.n_ratio == other.n_ratio == 100 and own.a_tset > other.a_tset and own.a_stno3 == 1 and other.a_stno3 == 0 |
| assert own.c_p_n >= 2 and own.s1_name_freq == 2 |
| |
| g = f1.groupby(f1["s1_id"].astype(str)) |
| assert (g["c_s1_n"].transform("first").to_numpy() == g["c_s1_n"].transform("size").to_numpy()).all() |
| assert (f1["c_s1_rank"] >= 1).all() and (f1["c_s1_gap"] >= 0).all() |
| assert (g["c_s1_rank"].transform("min") == 1).all() |
| gp = f1.groupby(f1["cand_id"].astype(str)) |
| assert (gp["c_p_n"].transform("first").to_numpy() == gp["c_p_n"].transform("size").to_numpy()).all() |
| |
| keep = sorted(set(cands.get_column("s1_id").to_list()))[::3] |
| f3 = build_features(cands, s1t, pt, idf, n_jobs=2, task_rows=50, keep_s1=keep, verbose=False) |
| sub = f1[f1["s1_id"].astype(str).isin(keep)].reset_index(drop=True) |
| assert len(f3) == len(sub) > 0 |
| assert np.allclose(sub[[c for c in cols if c != "country"]].to_numpy(np.float64), |
| f3[[c for c in cols if c != "country"]].to_numpy(np.float64), equal_nan=True) |
| print(f"features OK: {len(f1)} rows x {len(cols)} features") |
|
|
|
|
| def check_train(d: Path, W: dict): |
| from src import train_matcher |
|
|
| folds_file = d / "artifacts" / "folds.parquet" |
| common = ["--cands", str(d / "cands_train.parquet"), "--norm-dir", str(d / "norm"), "--pairs", str(d / "pairs.parquet"), |
| "--gt", str(d / "gt.parquet"), "--workers", "2", "--task-rows", "200", "--lr", "0.1", "--leaves", "15", |
| "--min-data-in-leaf", "5", "--rounds", "300", "--early-stop", "30", "--log-period", "0", |
| "--inner-val-frac", "0.2", "--folds", "3", "--folds-file", str(folds_file), |
| "--pair-audit", str(d / "pair_audit.parquet")] |
| out = d / "model_kfold" |
| m = train_matcher.run(train_matcher.build_parser().parse_args(common + ["--out-dir", str(out), "--neg-ratio", "4"])) |
| for fn in ["model_fold0.txt", "model_fold2.txt", "calibrator.pkl", "features.json", "metrics.json", |
| "importance.csv", "oof.parquet", "folds.parquet"]: |
| assert (out / fn).exists(), fn |
| assert folds_file.exists() |
| folds = pq.read_table(folds_file).to_pydict() |
| assert sorted(folds["s1_id"]) == sorted(W["gt"]) and set(folds["fold"]) == {0, 1, 2} |
| assert m["headline"] == "kfold_oof" |
| ev = m["results"]["kfold_oof"] |
| assert m["universe_mode"] == "all" and m["n_eval_s1"] == len(W["gt"]) == ev["n_s1"], (m["universe_mode"], m["n_eval_s1"]) |
| assert ev["n_s1_with_cands"] == len(W["gt"]) - len(W["no_cand"]) |
| assert 0.0 <= ev["macro_f05"] <= 1.0 and ev["blocking_pair_recall"] < 1.0 |
| assert ev["macro_f05"] > 0.6, ev["macro_f05"] |
| assert 0.0 < ev["expected_f05_mean_all"] <= 1.0 and ev["threshold_oof"] in [float(x) for x in ev["threshold_sweep"]] |
| assert ev["pair_cal"]["auc"] > 0.9 |
| cats = {r["category"]: r for r in ev["noise"]} |
| assert cats["indic_script"]["pairs"] >= 1 and cats["domain_form"]["pairs"] >= 1 and cats["former_name"]["pairs"] >= 1 |
| assert {r["slice"] for r in ev["breakdown"] if r["dimension"] == "true_count"} >= {"0", "1", "2"} |
| assert {r["slice"] for r in ev["breakdown"] if r["dimension"] == "group"} == {"us", "india"} |
| meta = json.loads((out / "features.json").read_text()) |
| assert meta["models"] == ["model_fold0.txt", "model_fold1.txt", "model_fold2.txt"] and "country" in meta["features"] |
| print(f"train k-fold OK: macro F0.5 {ev['macro_f05']:.4f} (expected {ev['expected_f05_mean_all']:.4f}), " |
| f"AUC {ev['pair_cal']['auc']:.4f}") |
|
|
| |
| out2 = d / "model_loco" |
| cmd = [sys.executable, "-m", "src.train_matcher"] + common + ["--out-dir", str(out2), "--holdout-country", "India", |
| "--max-s1", "80"] |
| p = subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True) |
| assert p.returncode == 0, p.stdout[-3000:] + p.stderr[-3000:] |
| assert "folds: reused" in p.stdout |
| m2 = json.loads((out2 / "metrics.json").read_text()) |
| assert m2["headline"] == "loco:india" and m2["n_eval_s1"] == 80 |
| r2 = m2["results"] |
| assert set(r2) == {"loco:india", "loco:india/train_oof", "loco:india/oracle_calibration"} |
| n_india = sum(1 for k in r2["loco:india/train_oof"]["breakdown"] if k["dimension"] == "group" and k["slice"] == "india") |
| assert n_india == 0 and all(b["slice"] == "india" for b in r2["loco:india"]["breakdown"] if b["dimension"] == "group") |
| assert pq.read_table(out2 / "folds.parquet").to_pydict() == folds |
| assert len(json.loads((out2 / "features.json").read_text())["models"]) == 3 |
| print(f"train holdout India OK: macro F0.5 {r2['loco:india']['macro_f05']:.4f} " |
| f"(oracle calibration {r2['loco:india/oracle_calibration']['macro_f05']:.4f})") |
| return out |
|
|
|
|
| def check_predict(d: Path, W: dict, model_dir: Path): |
| from src import predict |
|
|
| out = d / "output" |
| argv = ["--cands", str(d / "cands_test.parquet"), "--norm-dir", str(d / "norm"), "--model-dir", str(model_dir), |
| "--s1", str(d / "norm" / "t1.parquet"), "--out-dir", str(out), "--workers", "2", "--task-rows", "100", |
| "--save-probs"] |
| if VALIDATOR.exists(): |
| argv += ["--validator", str(VALIDATOR), "--test-dir", str(W["test_dir"])] |
| rc = predict.main(argv) |
| assert rc == 0, "predict / validator failed" |
| s1_ids = [r[0] for r in W["t1"]] |
| lines = (out / "matching_results.tsv").read_text(encoding="utf-8").split("\n") |
| assert lines[0] == "source1_entity_id\tmatched_entity_ids" and lines[-1] == "" |
| rows = [ln.split("\t") for ln in lines[1:-1]] |
| assert [r[0] for r in rows] == s1_ids and all(len(r) == 2 for r in rows) |
| cl = (out / "candidate_pairs.tsv").read_text(encoding="utf-8").split("\n") |
| assert cl[0] == "source1_entity_id\tcandidate_entity_ids" |
| cand = {r.split("\t")[0]: set(x for x in r.split("\t")[1].split(",") if x) for r in cl[1:] if r} |
| assert list(cand) == s1_ids |
| seen = set() |
| n_match = 0 |
| for sid, lst in rows: |
| ids = [x for x in lst.split(",") if x] |
| assert len(ids) == len(set(ids)) and all(x[:3] in ("S2-", "S3-") for x in ids) |
| assert set(ids) <= cand[sid], sid |
| assert not (set(ids) & seen), "one-parent rule violated" |
| seen |= set(ids) |
| n_match += bool(ids) |
| assert cand[W["t1"][0][0]] == set() and rows[0][1] == "" |
| france = [r for r, s in zip(rows, W["t1"]) if s[3] == "France"] |
| assert france and sum(bool(r[1]) for r in france) > 0, "unseen country must still get matches" |
| summ = json.loads((out / "predict_summary.json").read_text()) |
| assert summ["validator_rc"] in (None, 0) |
| |
| from src.metric import macro_f05, read_id_list_tsv |
|
|
| pred = read_id_list_tsv(out / "matching_results.tsv") |
| tr = {k: set(v) for k, v in W["tgt"].items()} |
| fr = {k: v for k, v in tr.items() if any(s[0] == k and s[3] == "France" for s in W["t1"])} |
| print(f"predict OK: {len(rows)} rows, {n_match} non-empty; synthetic test macro F0.5 {macro_f05(pred, tr):.4f} " |
| f"(France {macro_f05(pred, fr):.4f}); validator rc {summ['validator_rc']}") |
|
|
|
|
| def test_matcher_smoke(): |
| d = Path(tempfile.mkdtemp(prefix="matcher_smoke_")) |
| try: |
| W = build_dataset(d) |
| check_features(d, W) |
| model_dir = check_train(d, W) |
| check_predict(d, W, model_dir) |
| finally: |
| if os.environ.get("KEEP_SMOKE_DIR"): |
| print(f"kept {d}") |
| else: |
| shutil.rmtree(d, ignore_errors=True) |
|
|
|
|
| if __name__ == "__main__": |
| test_matcher_smoke() |
| print("PASS test_matcher_smoke") |
|
|
