"""Pair features for the AMLC 2026 matcher (Stage B). build_idf_tables(s1_norm) -> {country: idf dicts} build_features(cands, s1_norm, pool_norm, idf_tables, ...) -> pd.DataFrame ``cands`` is the blocking output (src/blocking.py): s1_id, cand_id, country, src, sim_name, sim_nameaddr, sim_addr, sim_word, from_reverse [, f_*, rank_*]. ``s1_norm`` / ``pool_norm`` are the normalised record tables (ROOT/norm/*.parquet; pool = S2 and S3 concatenated) as a pyarrow Table, polars or pandas DataFrame. Output: one row per (deduplicated) candidate pair, in input order, with key columns ``s1_id, cand_id`` (Arrow strings), ``s1_row, pool_row`` (int32 row numbers in the two tables) followed by the numeric features (float32) and ``country`` (pandas category, categories = the values present in the data; never a fixed list). ``feature_columns(df)`` lists the model inputs. Missing-value convention: three-state features are 1 / 0 / -1 (agree / disagree / missing); similarity features are -1 when either side is empty; blocking sims NaN -> -1. Blocking ranks (when present) and the competition margins of single-candidate groups stay NaN. Execution model: the normalised tables are packed into ONE Python ``bytes`` object per table (one record per row: fields joined by \\x1e, list items by \\x1f) plus an int64 offset array. Worker processes are forked after packing, so they share those two buffers copy-on-write without touching per-row Python objects (a list-of-str representation of the 10M-row pool would be duplicated page by page in every worker by refcount writes). Each task decodes only the rows it needs. The per-pair loop is plain Python around rapidfuzz calls. Competition features need every candidate of an S1 record / pool record, so they are computed after the per-pair pass on the whole candidate table. With ``keep_s1`` (training on an S1 subsample) only the kept S1 records get the full feature pass; all other rows get a cheap base-score pass so the competition context (esp. how many S1 records compete for a pool record) is the one of the full candidate table. Throughput benchmark: python -m src.features --bench 200000 --workers 16 """ from __future__ import annotations import gc import math import multiprocessing as mp import os import sys import time import warnings from array import array import numpy as np import pandas as pd import pyarrow as pa import pyarrow.compute as pc import pyarrow.parquet as pq import polars as pl from rapidfuzz import fuzz from rapidfuzz.distance import JaroWinkler, Levenshtein warnings.filterwarnings("ignore", message=r".*fork.*") # polars at-fork warning: workers never call polars warnings.filterwarnings("ignore", message=r".*empty_as_null.*") __all__ = [ "PAIR_FEATURES", "KEY_COLUMNS", "NORM_COLUMNS", "load_norm", "build_idf_tables", "build_features", "feature_columns", "log", ] KEY_COLUMNS = ["s1_id", "cand_id", "s1_row", "pool_row"] # Columns read from ROOT/norm/*.parquet (missing ones are tolerated, see _FALLBACK). NORM_COLUMNS = [ "entity_id", "country", "name_core", "name_legal", "name_tokens", "name_spaceless", "name_alt_names", "name_is_domain_form", "name_has_indic_script", "name_full", "name_translit", "name_translit_tokens", "name_translit_unknown", "addr_tokens", "addr_tokens_translit", "addr_numbers", "addr_street_number", "addr_city", "addr_state", "addr_district", "addr_localities", "addr_street", ] _FALLBACK = {"name_translit": "name_core", "name_translit_tokens": "name_tokens", "addr_tokens_translit": "addr_tokens"} FS, LS = "\x1e", "\x1f" # field / list-item separators inside a packed record # (field, kind): s = string, l = list of strings, b = bool _S1_FIELDS = [("country", "s"), ("name_core", "s"), ("name_tokens", "l"), ("name_spaceless", "s"), ("name_full", "s"), ("name_legal", "s"), ("addr_tokens_translit", "l"), ("addr_numbers", "l"), ("addr_street_number", "s"), ("addr_city", "s"), ("addr_state", "s"), ("addr_district", "s"), ("addr_localities", "l"), ("addr_street", "s")] _POOL_FIELDS = [("country", "s"), ("name_translit", "s"), ("name_translit_tokens", "l"), ("name_spaceless", "s"), ("name_full", "s"), ("name_legal", "s"), ("addr_tokens_translit", "l"), ("addr_numbers", "l"), ("addr_street_number", "s"), ("addr_city", "s"), ("addr_state", "s"), ("addr_district", "s"), ("addr_localities", "l"), ("addr_street", "s"), ("name_alt_names", "l"), ("name_has_indic_script", "b")] _N_S1F, _N_POOLF = len(_S1_FIELDS), len(_POOL_FIELDS) PAIR_FEATURES = [ # name: S1 name_core vs pool name_translit (legal words dropped from transliterated Indic names) "n_ratio", "n_partial", "n_tsort", "n_tset", "n_wratio", "n_jw", "n_lev", "n_sp_ratio", # spaceless S1 core / full name vs pool spaceless (domain forms) "n_alt_best", # best ratio against the pool's former / trade names (f/k/a, dba), -1 none "n_jac", "n_idf_jac", "n_max_idf_shared", "n_shared", "n_ntok_s1", "n_ntok_pool", "n_ntok_delta", "n_legal3", "n_first_eq", "n_pfirst_in_s1", "n_s1first_in_pool", # address: S1 addr_tokens_translit vs pool addr_tokens_translit "a_jac", "a_idf_jac", "a_max_idf_shared", "a_tset", "a_stno3", "a_num_jac", "a_s1stno_in_pool", "a_city3", "a_loc_overlap", "a_city_in_pool", "a_state3", "a_district3", "a_pool_empty", "a_ntok_s1", "a_ntok_pool", "a_ntok_delta", "a_street_ratio", # cross (landmark / trade-name leakage) "x_s1name_paddr", "x_pname_s1addr", ] _N_PAIR = len(PAIR_FEATURES) _I_WRATIO, _I_ATSET = PAIR_FEATURES.index("n_wratio"), PAIR_FEATURES.index("a_tset") POOL_FLAG_FEATURES = ["p_is_domain", "p_has_indic", "p_translit_unknown"] CONTEXT_FEATURES = ["s1_name_freq", "s1_addr_freq", "pool_name_freq", "log_s1_name_freq", "log_s1_addr_freq", "log_pool_name_freq"] BLOCK_SIMS = ["sim_name", "sim_nameaddr", "sim_addr", "sim_word"] BLOCK_FLAGS = ["f_name", "f_nameaddr", "f_addr", "f_word"] # optional BLOCK_RANKS = ["rank_name", "rank_nameaddr", "rank_addr", "rank_word", "rank_rev"] # optional COMPETITION_FEATURES = [ "c_base", "c_s1_rank", "c_s1_gap", "c_s1_margin", "c_s1_n70", "c_s1_n", "c_p_n", "c_p_n_rel", "c_p_rank", "c_p_gap", "c_p_margin", ] BASE_HIGH = 70.0 # legal words that survive in transliterated Indic names (the lexicon maps the raw name) _LEGAL_STRIP = frozenset("private limited pvt ltd llp opc llc inc corp corporation incorporated".split()) _STATE_EQ = {"andhra pradesh": "telangana"} # the generator swaps these two freely _T0 = time.time() def log(msg: str) -> None: rss = "" try: import psutil rss = f" rss={psutil.Process().memory_info().rss / 1e9:.2f}GB" except Exception: # noqa: BLE001 pass print(f"[{time.time() - _T0:8.1f}s{rss}] {msg}", flush=True) # ---------------------------------------------------------------------------------------------- # Table helpers # ---------------------------------------------------------------------------------------------- def _to_arrow(t) -> pa.Table: if isinstance(t, pa.Table): return t if isinstance(t, pl.DataFrame): return t.to_arrow() if isinstance(t, pd.DataFrame): return pa.Table.from_pandas(t, preserve_index=False) raise TypeError(f"unsupported table type {type(t)}") def _to_polars(t) -> pl.DataFrame: if isinstance(t, pl.DataFrame): return t if isinstance(t, pa.Table): return pl.from_arrow(t) if isinstance(t, pd.DataFrame): return pl.from_pandas(t) raise TypeError(f"unsupported table type {type(t)}") def load_norm(paths, columns=None) -> pa.Table: """Read and concatenate normalised parquet tables (only the columns the matcher needs).""" if isinstance(paths, (str, os.PathLike)): paths = [paths] columns = columns or NORM_COLUMNS tabs = [] for p in paths: names = set(pq.ParquetFile(p).schema_arrow.names) tabs.append(pq.read_table(p, columns=[c for c in columns if c in names])) if len(tabs) == 1: return tabs[0] try: return pa.concat_tables(tabs, promote_options="permissive") # e.g. list vs list except TypeError: # pyarrow < 14 return pa.concat_tables(tabs, promote=True) def _col(t: pa.Table, name: str): if name in t.column_names: return t.column(name) alt = _FALLBACK.get(name) if alt and alt in t.column_names: return t.column(alt) return None def _join_list(c, sep: str): """list (also list from all-empty columns, large_list) -> large_string, joined.""" c = pc.cast(c, pa.list_(pa.large_string())) return pc.binary_join(c, pa.scalar(sep, pa.large_string())) def _str_col(t: pa.Table, name: str, kind: str) -> pa.ChunkedArray: """One packed-record field as a large_string column.""" n = t.num_rows c = _col(t, name) if c is None: return pa.chunked_array([pa.array([""] * n, pa.large_string())]) if n else pa.chunked_array([], pa.large_string()) if kind == "l": c = _join_list(c, LS) elif kind == "b": c = pc.cast(pc.fill_null(c, False), pa.string()) return pc.fill_null(pc.cast(c, pa.large_string()), "") def _pack(t: pa.Table, fields) -> tuple[bytes, np.ndarray]: """Pack rows into one utf-8 buffer; record i = data[off[i]:off[i+1]].""" if t.num_rows == 0: return b"", np.zeros(1, dtype=np.int64) cols = [_str_col(t, f, k) for f, k in fields] rec = pc.binary_join_element_wise(*cols, pa.scalar(FS, pa.large_string())) rec = pc.cast(rec, pa.large_string()) rec = rec.combine_chunks() if isinstance(rec, pa.ChunkedArray) else rec bufs = rec.buffers() off = np.frombuffer(bufs[1], dtype=np.int64)[rec.offset: rec.offset + len(rec) + 1].copy() data = bufs[2].to_pybytes() if bufs[2] is not None else b"" return data, off def _np_col(t: pa.Table, name: str, dtype, fill=0) -> np.ndarray: c = _col(t, name) if c is None: return np.full(t.num_rows, fill, dtype=dtype) return np.asarray(pc.fill_null(c, fill).to_numpy(zero_copy_only=False)).astype(dtype, copy=False) def _list_len(t: pa.Table, name: str) -> np.ndarray: c = _col(t, name) if c is None: return np.zeros(t.num_rows, dtype=np.int32) return np.asarray(pc.fill_null(pc.list_value_length(c), 0).to_numpy(zero_copy_only=False)).astype(np.int32) def _freq_within_country(t: pa.Table, key_expr_col: str, is_list: bool = False) -> np.ndarray: """Count of rows sharing (country, value) in table t, per row.""" c = _col(t, key_expr_col) if c is None or t.num_rows == 0: return np.ones(t.num_rows, dtype=np.int32) val = _join_list(c, " ") if is_list else pc.cast(c, pa.large_string()) df = pl.from_arrow(pa.table({"c": pc.fill_null(_col(t, "country"), ""), "v": pc.fill_null(val, "")})) return df.select(pl.len().over(["c", "v"]).cast(pl.Int32)).to_series().to_numpy() # ---------------------------------------------------------------------------------------------- # IDF # ---------------------------------------------------------------------------------------------- def build_idf_tables(s1_norm) -> dict: """{country: {'n', 'name', 'addr', 'name_default', 'addr_default'}} from the S1 table. idf(t) = ln((N+1)/(df+1)) + 1 with df = number of S1 records of the country containing t; unseen tokens get the maximum ln(N+1) + 1. Address items holding spaces are split. """ t = _to_arrow(s1_norm) addr = _col(t, "addr_tokens_translit") df = pl.from_arrow(pa.table({ "c": pc.fill_null(_col(t, "country"), ""), "nt": pc.cast(_col(t, "name_tokens"), pa.list_(pa.large_string())), "at": pc.fill_null(_join_list(addr, " "), "") if addr is not None else pa.array([""] * t.num_rows), })) n_by_c = dict(df.group_by("c").len().iter_rows()) name_df = (df.select("c", pl.col("nt").list.unique()).explode("nt").drop_nulls("nt") .filter(pl.col("nt") != "").group_by(["c", "nt"]).len()) addr_df = (df.select("c", pl.col("at").str.split(" ").list.unique()).explode("at").drop_nulls("at") .filter(pl.col("at") != "").group_by(["c", "at"]).len()) out = {} for c, n in n_by_c.items(): top = math.log(n + 1) + 1.0 nd = name_df.filter(pl.col("c") == c) ad = addr_df.filter(pl.col("c") == c) out[c] = { "n": int(n), "name": dict(zip(nd.get_column("nt").to_list(), (np.log((n + 1) / (nd.get_column("len").to_numpy() + 1.0)) + 1.0).tolist())), "addr": dict(zip(ad.get_column("at").to_list(), (np.log((n + 1) / (ad.get_column("len").to_numpy() + 1.0)) + 1.0).tolist())), "name_default": top, "addr_default": top, } return out _EMPTY_IDF = {"n": 0, "name": {}, "addr": {}, "name_default": 1.0, "addr_default": 1.0} # ---------------------------------------------------------------------------------------------- # Worker side # ---------------------------------------------------------------------------------------------- _G: dict = {} # set in the parent before forking; read-only in workers def _split(s: str) -> list: return s.split(LS) if s else [] def _parse_s1(rec: str, idf_tables: dict): f = rec.split(FS) if len(f) != _N_S1F: f = [""] * _N_S1F idf = idf_tables.get(f[0], _EMPTY_IDF) toks = _split(f[2]) tset = set(toks) wn, dn = idf["name"], idf["name_default"] nw = {t: wn.get(t, dn) for t in tset} atoks = f[6].replace(LS, " ").split() aset = set(atoks) wa, da = idf["addr"], idf["addr_default"] aw = {t: wa.get(t, da) for t in aset} return ( f[1], tset, nw, sum(nw.values()), f[3], f[4].replace(" ", ""), f[5], # 0-6 " ".join(atoks), aset, aw, sum(aw.values()), set(_split(f[7])), f[8], # 7-12 f[9], _STATE_EQ.get(f[10], f[10]), f[11], set(_split(f[12])), f[13], # 13-17 len(toks), len(atoks), toks[0] if toks else "", # 18-20 ) def _parse_pool(rec: str, idf_tables: dict): f = rec.split(FS) if len(f) != _N_POOLF: f = [""] * _N_POOLF idf = idf_tables.get(f[0], _EMPTY_IDF) toks = _split(f[2]) indic = f[15] == "true" if indic: kept = [t for t in toks if t not in _LEGAL_STRIP] if kept: toks = kept core = " ".join(toks) sp = core.replace(" ", "") else: core = f[1] sp = f[3] tset = set(toks) wn, dn = idf["name"], idf["name_default"] atoks = f[6].replace(LS, " ").split() aset = set(atoks) wa, da = idf["addr"], idf["addr_default"] return ( core, tset, sum(wn.get(t, dn) for t in tset), sp, f[5], # 0-4 " ".join(atoks), aset, sum(wa.get(t, da) for t in aset), set(_split(f[7])), f[8], # 5-9 f[9], _STATE_EQ.get(f[10], f[10]), f[11], set(_split(f[12])), f[13], # 10-14 len(toks), len(atoks), toks[0] if toks else "", _split(f[14]), # 15-18 ) _ratio, _partial, _tsort, _tset = fuzz.ratio, fuzz.partial_ratio, fuzz.token_sort_ratio, fuzz.token_set_ratio _wratio, _jw, _lev = fuzz.WRatio, JaroWinkler.normalized_similarity, Levenshtein.normalized_similarity _NAME_MISSING = (-1.0,) * 7 def _pair(a, b) -> tuple: (a_core, a_tset, a_nw, a_nws, a_sp, a_fsp, a_legal, a_astr, a_aset, a_aw, a_aws, a_nums, a_stno, a_city, a_state, a_dist, a_locs, a_street, a_ntok, a_antok, a_first) = a (b_core, b_tset, b_nws, b_sp, b_legal, b_astr, b_aset, b_aws, b_nums, b_stno, b_city, b_state, b_dist, b_locs, b_street, b_ntok, b_antok, b_first, b_alts) = b # ---- name if b_core and a_core: nm = (_ratio(a_core, b_core), _partial(a_core, b_core), _tsort(a_core, b_core), _tset(a_core, b_core), _wratio(a_core, b_core), _jw(a_core, b_core), _lev(a_core, b_core)) else: nm = _NAME_MISSING if b_sp: sp = _ratio(a_sp, b_sp) if a_fsp != a_sp: sp = max(sp, _ratio(a_fsp, b_sp)) else: sp = -1.0 alt = max(_ratio(a_core, x) for x in b_alts) if b_alts else -1.0 inter = a_tset & b_tset nsh = len(inter) nun = len(a_tset) + len(b_tset) - nsh if nsh: ws = [a_nw[t] for t in inter] iw, mx = sum(ws), max(ws) else: iw = mx = 0.0 den = a_nws + b_nws - iw # ---- address if a_astr and b_astr: ai = a_aset & b_aset if ai: ws = [a_aw[t] for t in ai] aiw, amx = sum(ws), max(ws) else: aiw = amx = 0.0 aden = a_aws + b_aws - aiw ajac = len(ai) / (len(a_aset) + len(b_aset) - len(ai)) aijac = aiw / aden if aden > 0 else -1.0 atset = _tset(a_astr, b_astr) else: ajac = aijac = amx = atset = -1.0 if a_nums and b_nums: nj = len(a_nums & b_nums) / len(a_nums | b_nums) else: nj = -1.0 return nm + ( sp, alt, nsh / nun if nun else -1.0, iw / den if den > 0 else -1.0, mx, nsh, a_ntok, b_ntok, b_ntok - a_ntok, (1 if a_legal == b_legal else 0) if (a_legal and b_legal) else -1, (1 if a_first == b_first else 0) if (a_first and b_first) else -1, (1 if b_first in a_tset else 0) if b_first else -1, (1 if a_first in b_tset else 0) if a_first else -1, ajac, aijac, amx, atset, (1 if a_stno == b_stno else 0) if (a_stno and b_stno) else -1, nj, (1 if a_stno in b_nums else 0) if (a_stno and b_nums) else -1, (1 if a_city == b_city else 0) if (a_city and b_city) else -1, (len(a_locs & b_locs) / len(a_locs) if b_astr else -1.0) if a_locs else -1.0, (1 if (" " + a_city + " ") in (" " + b_astr + " ") else 0) if (a_city and b_astr) else -1, (1 if a_state == b_state else 0) if (a_state and b_state) else -1, (1 if a_dist == b_dist else 0) if (a_dist and b_dist) else -1, 0 if b_astr else 1, a_antok, b_antok, b_antok - a_antok, _ratio(a_street, b_street) if (a_street and b_street) else -1.0, _partial(a_core, b_astr) if (a_core and b_astr) else -1.0, _partial(b_core, a_astr) if (b_core and a_astr) else -1.0, ) def _base(a, b) -> float: w = _wratio(a[0], b[0]) if (a[0] and b[0]) else 0.0 t = _tset(a[7], b[5]) if (a[7] and b[5]) else 0.0 return 0.5 * w + 0.5 * t def _decode_rows(data: bytes, off: np.ndarray, rows: np.ndarray, parse, idf_tables) -> list: starts = off[rows].tolist() ends = off[rows + 1].tolist() return [parse(data[s:e].decode("utf-8"), idf_tables) for s, e in zip(starts, ends)] def _task(args): """(mode, lo, hi) over the global row arrays of that mode -> (mode, lo, hi, result).""" mode, lo, hi = args g = _G r1 = g[f"r1_{mode}"][lo:hi] r2 = g[f"r2_{mode}"][lo:hi] was = gc.isenabled() gc.disable() try: idf = g["idf"] u1, inv1 = np.unique(r1, return_inverse=True) u2, inv2 = np.unique(r2, return_inverse=True) A = _decode_rows(g["s1_data"], g["s1_off"], u1, _parse_s1, idf) B = _decode_rows(g["pool_data"], g["pool_off"], u2, _parse_pool, idf) if mode == "full": out = array("f") ext = out.extend for i, j in zip(inv1.tolist(), inv2.tolist()): ext(_pair(A[i], B[j])) res = np.frombuffer(out, dtype=np.float32).reshape(-1, _N_PAIR) else: res = np.fromiter((_base(A[i], B[j]) for i, j in zip(inv1.tolist(), inv2.tolist())), dtype=np.float32, count=hi - lo) finally: if was: gc.enable() return mode, lo, hi, res def _run_tasks(tasks, n_jobs: int, on_result, total_rows: int, label: str, verbose: bool): t0 = time.time() done = 0 last = t0 if n_jobs <= 1 or len(tasks) <= 1: it = map(_task, tasks) pool = None else: ctx = mp.get_context("fork") gc.collect() gc.freeze() # keep the GC from writing to every shared object's header after fork pool = ctx.Pool(n_jobs) it = pool.imap_unordered(_task, tasks, chunksize=1) try: for mode, lo, hi, res in it: on_result(mode, lo, hi, res) done += hi - lo now = time.time() if verbose and (now - last > 30 or done == total_rows): rate = done / max(now - t0, 1e-9) eta = (total_rows - done) / rate if rate > 0 else float("nan") log(f" {label}: {done:,}/{total_rows:,} rows, {rate:,.0f} rows/s " f"({rate / max(n_jobs, 1):,.0f}/worker), eta {eta:.0f}s") last = now finally: if pool is not None: pool.close() pool.join() gc.unfreeze() return done / max(time.time() - t0, 1e-9) # ---------------------------------------------------------------------------------------------- # Competition features (vectorised) # ---------------------------------------------------------------------------------------------- def _group_stats(key: np.ndarray, base: np.ndarray): """Per-row stats of ``base`` within groups of ``key``: rank (1 = best, ties -> min), gap to the group best, margin to the best OTHER row (NaN for single-row groups), count >= BASE_HIGH, size.""" n = len(key) if n == 0: z = np.zeros(0, np.float32) return z, z, z, z, z order = np.lexsort((-base, key)) k = key[order] b = base[order].astype(np.float64) new_g = np.empty(n, dtype=bool) new_g[0] = True np.not_equal(k[1:], k[:-1], out=new_g[1:]) starts = np.flatnonzero(new_g) gid = np.cumsum(new_g) - 1 size = np.diff(np.append(starts, n)) idx = np.arange(n) pos = idx - starts[gid] new_v = new_g.copy() new_v[1:] |= b[1:] != b[:-1] first_of_val = np.maximum.accumulate(np.where(new_v, idx, 0)) rank = first_of_val - starts[gid] + 1 top1 = b[starts] second = np.where(size > 1, b[np.minimum(starts + 1, n - 1)], np.nan) best_other = np.where(pos == 0, second[gid], top1[gid]) margin = b - best_other gap = top1[gid] - b n_high = np.add.reduceat((b >= BASE_HIGH).astype(np.int64), starts) out = [] for v in (rank, gap, margin, n_high[gid], size[gid]): o = np.empty(n, dtype=np.float32) o[order] = v out.append(o) return tuple(out) # ---------------------------------------------------------------------------------------------- # Main entry # ---------------------------------------------------------------------------------------------- def feature_columns(df: pd.DataFrame) -> list: return [c for c in df.columns if c not in KEY_COLUMNS] def _arrow_series(arr, name: str) -> pd.Series: arr = pc.cast(arr, pa.large_string()) if isinstance(arr, pa.ChunkedArray): arr = arr.combine_chunks() return pd.Series(pd.arrays.ArrowExtensionArray(arr), name=name) def build_features(cands, s1_norm, pool_norm, idf_tables: dict, *, n_jobs: int | None = None, task_rows: int = 50_000, keep_s1=None, verbose: bool = True) -> pd.DataFrame: """Feature table for candidate pairs (see module docstring). keep_s1 : optional iterable of S1 ids; only their rows are featurised and returned, while the competition features still see every row of ``cands`` (cheap base-score pass). n_jobs : worker processes (fork); default os.cpu_count(); 1 = in-process. """ t_start = time.time() n_jobs = int(n_jobs or os.cpu_count() or 1) s1t, pt = _to_arrow(s1_norm), _to_arrow(pool_norm) c = _to_polars(cands) present = set(c.columns) need = ["s1_id", "cand_id"] + [x for x in ["country", "src"] + BLOCK_SIMS + ["from_reverse"] + BLOCK_FLAGS + BLOCK_RANKS if x in present] c = c.select(need) # ---- entity id -> row number (vectorised join; order restored by the row index) n1, n2 = s1t.num_rows, pt.num_rows m1 = pl.DataFrame({"s1_id": pl.from_arrow(pc.cast(s1t.column("entity_id"), pa.large_string())), "s1_row": pl.int_range(0, n1, eager=True, dtype=pl.Int32)}).unique("s1_id", keep="first") m2 = pl.DataFrame({"cand_id": pl.from_arrow(pc.cast(pt.column("entity_id"), pa.large_string())), "pool_row": pl.int_range(0, n2, eager=True, dtype=pl.Int32)}).unique("cand_id", keep="first") c = (c.with_columns(pl.col("s1_id").cast(pl.Utf8), pl.col("cand_id").cast(pl.Utf8)).with_row_index("_i") .join(m1, on="s1_id", how="left").join(m2, on="cand_id", how="left").sort("_i")) bad = c.filter(pl.col("s1_row").is_null() | pl.col("pool_row").is_null()).height if bad: print(f"WARNING: {bad:,} candidate rows reference ids missing from the normalised tables; dropped", file=sys.stderr) c = c.filter(pl.col("s1_row").is_not_null() & pl.col("pool_row").is_not_null()) n_before = c.height c = c.unique(subset=["s1_row", "pool_row"], keep="first", maintain_order=True).drop("_i") if c.height < n_before: print(f"WARNING: {n_before - c.height:,} duplicate (s1_id, cand_id) rows dropped", file=sys.stderr) del m1, m2 N = c.height r1_all = c.get_column("s1_row").to_numpy().astype(np.int64) r2_all = c.get_column("pool_row").to_numpy().astype(np.int64) if keep_s1 is not None: keep_ids = (keep_s1.cast(pl.Utf8) if isinstance(keep_s1, pl.Series) else pl.Series("k", [str(x) for x in keep_s1], dtype=pl.Utf8)) keep = c.get_column("s1_id").is_in(keep_ids).to_numpy() else: keep = np.ones(N, dtype=bool) kpos = np.flatnonzero(keep) bpos = np.flatnonzero(~keep) NK = len(kpos) if verbose: log(f"build_features: {N:,} candidate rows ({NK:,} featurised, {len(bpos):,} base-only), " f"S1 table {n1:,}, pool table {n2:,}, workers {n_jobs}") # ---- pack tables, parent-side vectors t = time.time() s1_data, s1_off = _pack(s1t, _S1_FIELDS) pool_data, pool_off = _pack(pt, _POOL_FIELDS) p_dom = _np_col(pt, "name_is_domain_form", np.float32, False) p_ind = _np_col(pt, "name_has_indic_script", np.float32, False) p_unk = _np_col(pt, "name_translit_unknown", np.float32, 0) s1_nf = _freq_within_country(s1t, "name_core") s1_af = _freq_within_country(s1t, "addr_tokens_translit", is_list=True) p_nf = _freq_within_country(pt, "name_translit") s1_ck = pc.fill_null(_col(s1t, "country"), "").to_numpy(zero_copy_only=False) if verbose: log(f" packed tables: S1 {len(s1_data) / 1e6:.0f} MB, pool {len(pool_data) / 1e6:.0f} MB ({time.time() - t:.1f}s)") # ---- per-pair pass (workers) _G.clear() _G.update(s1_data=s1_data, s1_off=s1_off, pool_data=pool_data, pool_off=pool_off, idf=idf_tables, r1_full=r1_all[kpos], r2_full=r2_all[kpos], r1_base=r1_all[bpos], r2_base=r2_all[bpos]) num_cols = (PAIR_FEATURES + POOL_FLAG_FEATURES + CONTEXT_FEATURES + BLOCK_SIMS + ["from_reverse"] + [x for x in BLOCK_FLAGS + BLOCK_RANKS if x in present] + ["is_s2"] + COMPETITION_FEATURES) M = np.empty((NK, len(num_cols)), dtype=np.float32) base = np.empty(N, dtype=np.float32) tasks = [("full", lo, min(lo + task_rows, NK)) for lo in range(0, NK, task_rows)] tasks += [("base", lo, min(lo + task_rows, len(bpos))) for lo in range(0, len(bpos), task_rows)] def on_result(mode, lo, hi, res): if mode == "full": M[lo:hi, :_N_PAIR] = res w = np.maximum(res[:, _I_WRATIO], 0) ts = np.maximum(res[:, _I_ATSET], 0) base[kpos[lo:hi]] = 0.5 * w + 0.5 * ts else: base[bpos[lo:hi]] = res t = time.time() try: rate = _run_tasks(tasks, n_jobs, on_result, N, "pair features", verbose) finally: _G.clear() del s1_data, pool_data if verbose: log(f" pair pass: {N:,} rows in {time.time() - t:.1f}s ({rate:,.0f} rows/s overall)") # ---- parent-side features for the kept rows t = time.time() r1k, r2k = r1_all[kpos], r2_all[kpos] j = _N_PAIR for arr in (p_dom, p_ind, p_unk): M[:, j] = arr[r2k] j += 1 f1, f2, f3 = s1_nf[r1k], s1_af[r1k], p_nf[r2k] for arr in (f1, f2, f3, np.log1p(f1), np.log1p(f2), np.log1p(f3)): M[:, j] = arr j += 1 ck = c.filter(pl.Series(keep)) if NK < N else c for s in BLOCK_SIMS: if s in present: M[:, j] = ck.get_column(s).cast(pl.Float32).fill_nan(None).fill_null(-1.0).to_numpy() else: M[:, j] = -1.0 j += 1 M[:, j] = (ck.get_column("from_reverse").cast(pl.Float32).fill_null(0.0).to_numpy() if "from_reverse" in present else 0.0) j += 1 for s in BLOCK_FLAGS: if s in present: M[:, j] = ck.get_column(s).cast(pl.Float32).fill_null(0.0).to_numpy() j += 1 for s in BLOCK_RANKS: if s in present: M[:, j] = ck.get_column(s).cast(pl.Float32).to_numpy() # null -> NaN (not retrieved) j += 1 if "src" in present: M[:, j] = (ck.get_column("src") == "S2").cast(pl.Float32).fill_null(0.0).to_numpy() else: M[:, j] = ck.get_column("cand_id").str.starts_with("S2-").cast(pl.Float32).to_numpy() j += 1 # ---- competition features over the whole candidate table s_rank, s_gap, s_margin, s_n70, s_n = _group_stats(r1_all, base) p_rank, p_gap, p_margin, _, p_n = _group_stats(r2_all, base) # pool-side count relative to the country mean (the S1/pool ratio differs between train and test) s1_country_code, _ = pd.factorize(s1_ck) cc = s1_country_code[r1_all] if len(s1_country_code) else np.zeros(N, dtype=np.int64) first_of_pool = np.zeros(N, dtype=bool) _, first_idx = np.unique(r2_all, return_index=True) first_of_pool[first_idx] = True ncc = int(cc.max()) + 1 if N else 1 sums = np.bincount(cc[first_of_pool], weights=p_n[first_of_pool], minlength=ncc) cnts = np.bincount(cc[first_of_pool], minlength=ncc) mean_pn = np.where(cnts > 0, sums / np.maximum(cnts, 1), 1.0) p_n_rel = p_n / mean_pn[cc] for arr in (base, s_rank, s_gap, s_margin, s_n70, s_n, p_n, p_n_rel, p_rank, p_gap, p_margin): M[:, j] = arr[kpos] if NK < N else arr j += 1 assert j == len(num_cols), (j, len(num_cols)) # ---- assemble df = pd.DataFrame(M, columns=num_cols, copy=False) if "country" in present: cser = ck.get_column("country").cast(pl.Utf8).fill_null("") else: cser = pl.Series("country", s1_ck[r1k].tolist(), dtype=pl.Utf8) cats = sorted(cser.unique().to_list()) codes = cser.cast(pl.Enum(cats)).to_physical().to_numpy().astype(np.int32) if NK else np.zeros(0, np.int32) df["country"] = pd.Categorical.from_codes(codes, categories=cats) df.insert(0, "pool_row", r2k.astype(np.int32)) df.insert(0, "s1_row", r1k.astype(np.int32)) df.insert(0, "cand_id", _arrow_series(ck.get_column("cand_id").to_arrow(), "cand_id")) df.insert(0, "s1_id", _arrow_series(ck.get_column("s1_id").to_arrow(), "s1_id")) if verbose: log(f" features assembled: {df.shape[0]:,} rows x {len(num_cols) + 1} features " f"({M.nbytes / 1e9:.2f} GB float32), parent-side {time.time() - t:.1f}s, " f"total {time.time() - t_start:.1f}s") return df # ---------------------------------------------------------------------------------------------- # Throughput benchmark on synthetic normalised records # ---------------------------------------------------------------------------------------------- def _bench(n_pairs: int, workers: int, seed: int = 0) -> None: import random from src.normalize import normalize_record rng = random.Random(seed) A = ["holloway", "prime", "westbrook", "summit", "riverside", "oakridge", "maple", "cedar", "liberty", "shree", "krishna", "ganesh", "balaji", "durga", "sai", "vishnu", "maruti", "surya"] B = ["dental", "pediatric", "seafood", "consulting", "logistics", "realty", "marketing", "traders", "textiles", "pharma", "constructions", "motors", "foods", "primary care"] C = ["group", "llc", "inc", "services", "center", "private limited", "pvt ltd", "llp"] ST = ["elm", "oak", "main", "mg", "station", "lake", "hill", "pine", "sunset", "banjara hills", "civil lines"] CITY = ["phoenix, az", "fort worth, tx", "high point, nc", "hyderabad, telangana", "pune, maharashtra", "bengaluru, karnataka", "new delhi, delhi"] def rec(i): name = f"{rng.choice(A)} {rng.choice(B)} {rng.choice(C)}" addr = f"{rng.randint(1, 9999)} {rng.choice(ST)} road, {rng.choice(['sector 4, ', ''])}{rng.choice(CITY)}" r = normalize_record(name, addr, rng.choice(["US", "India"])) r["entity_id"] = i r["name_translit"], r["name_translit_tokens"], r["name_translit_unknown"] = r["name_core"], r["name_tokens"], 0 r["addr_tokens_translit"] = r["addr_tokens"] return r n1 = max(1000, n_pairs // 40) n2 = max(4000, n_pairs // 8) s1 = pa.Table.from_pylist([rec(f"S1-{i}") for i in range(n1)]) pool = pa.Table.from_pylist([rec(f"S{2 + i % 2}-{i}") for i in range(n2)]) nr = np.random.default_rng(seed) a = np.sort(nr.integers(0, n1, n_pairs)) b = nr.integers(0, n2, n_pairs) cands = pl.DataFrame({"s1_id": s1.column("entity_id").to_numpy(zero_copy_only=False)[a], "cand_id": pool.column("entity_id").to_numpy(zero_copy_only=False)[b], "country": "US", "src": "S2", **{s: nr.random(n_pairs).astype(np.float32) for s in BLOCK_SIMS}, "from_reverse": nr.random(n_pairs) < 0.1}) idf = build_idf_tables(s1) t = time.time() df = build_features(cands, s1, pool, idf, n_jobs=workers, task_rows=20_000) dt = time.time() - t print(f"bench: {len(df):,} pairs x {len(feature_columns(df))} features in {dt:.1f}s -> " f"{len(df) / dt:,.0f} pairs/s with {workers} workers ({len(df) / dt / workers:,.0f}/worker)") if __name__ == "__main__": import argparse ap = argparse.ArgumentParser() ap.add_argument("--bench", type=int, default=200_000) ap.add_argument("--workers", type=int, default=os.cpu_count()) a = ap.parse_args() sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) _bench(a.bench, a.workers)