code/scripts/13_ename.py

"""Fix 2: name-only retrieval over address-less pool records, by character TF-IDF.



Reproduced exactly from MODEL5_FALSE_NEGATIVE_FIXES.md s4.2, which is the version that was

measured. Of 16,332 true copies model-4 never retrieved, 7,628 have an empty address, and

this channel recovers them:



    k = 5    3,386 of 7,628 (44%)    2.6% of the channel's candidates are true copies

    k = 10   4,259 (56%)             1.4%

    k = 20   4,906 (64%)             -



k = 5 is the recommendation and the default here: 5 extra candidates per S1, about 8.7M test

pairs, and the precision of the channel falls off fast beyond it.



WHY CHARACTER TF-IDF AND NOT THE DENSE ENCODER. I first built this channel with e5-small

embeddings, which was a guess. This recipe is the one with a measured recovery rate attached,

it needs no GPU at all, and character 3-grams are the right tool for the failure being

targeted: typos and spacing damage on a short name with no address to fall back on.



THE TRAP THIS CHANNEL WALKS INTO (s4.4). These candidates are address-less records that the

other retrievers rank low. Under reciprocal-rank fusion with one channel voting they land

below rank 64 and get cut - so fusing them normally throws away the entire point. They must

enter the candidate set as a GUARANTEED UNION after the cut. 12_new_pairs.py gives this

channel priority 0 for exactly that reason.



Address-only retrieval is deliberately NOT implemented: measured at 6-12% recovery, about

+0.0002 val, for 10-50 candidates per S1. It was rejected on the evidence.

"""
from __future__ import annotations

import argparse
import os
import sys
import time

import numpy as np
import pandas as pd

# Pin BLAS before numpy/scipy import, so each forked worker stays single-threaded.
for _v in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS",
           "NUMEXPR_NUM_THREADS"):
    os.environ.setdefault(_v, "1")

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from berx import paths as P  # noqa: E402


_G: dict = {}          # set in the parent, inherited by forked workers


def _block(args):
    """One query chunk, run in a forked worker.



    Q and D are inherited through fork rather than pickled. A country's TF-IDF matrices are

    hundreds of MB and pickling them per task would cost more than the multiply.

    """
    s, e, k = args
    Q, DT = _G["Q"], _G["DT"]
    sim = (Q[s:e] @ DT).toarray()
    kk = min(k, sim.shape[1])
    part = np.argpartition(-sim, kk - 1, axis=1)[:, :kk]
    rows = np.arange(e - s)[:, None]
    sv = sim[rows, part]
    order = np.argsort(-sv, axis=1)
    return s, e, part[rows, order].astype(np.int32), sv[rows, order].astype(np.float32)


def topk_sparse(Q, D, k: int, chunk: int = 4096, workers: int = 0):
    """Top-k cosine per query row, over a pool of processes.



    Both matrices are L2-normalised TF-IDF, so the inner product IS the cosine.



    WHY PARALLEL. Serially this is one core of the 96 on the box: France measured at about

    4 minutes, and the work scales with queries x documents, so India is 8.5x France and the

    whole channel projects to roughly an hour - on the critical path to the Colab lanes, for

    a step that is embarrassingly parallel over query chunks.



    Each worker is pinned to a single BLAS thread. Without that, N workers each spawn their

    own thread pool on a 96-core box and spend their time fighting each other for cache.

    """
    import multiprocessing as mp

    n = Q.shape[0]
    idx = np.zeros((n, k), dtype=np.int32)
    val = np.zeros((n, k), dtype=np.float32)
    _G["Q"], _G["DT"] = Q, D.T.tocsc()
    tasks = [(s, min(s + chunk, n), k) for s in range(0, n, chunk)]

    if workers <= 0:
        # Leave headroom: this box is shared and has been made unusable before by a job that
        # took every core.
        workers = max(1, min(16, (os.cpu_count() or 8) // 4, len(tasks)))
    t0 = time.time()
    pool = None
    if workers == 1:
        results = map(_block, tasks)
    else:
        # fork, so Q and DT are inherited rather than pickled per task. Windows has no fork;
        # this runs on Linux, but falling back keeps the file testable anywhere.
        try:
            ctx = mp.get_context("fork")
        except ValueError:
            print("      no fork on this platform; running serially", flush=True)
            ctx = None
        if ctx is None:
            workers = 1
            results = map(_block, tasks)
            pool = None
        else:
            pool = ctx.Pool(workers)
            results = pool.imap_unordered(_block, tasks, chunksize=1)

    done = 0
    for s, e, bi, bv in results:
        kk = bi.shape[1]
        idx[s:e, :kk] = bi
        val[s:e, :kk] = bv
        done += e - s
        if done % (chunk * 20) < chunk:
            el = time.time() - t0
            f = done / n
            print(f"      {done:>9,}/{n:,} ({f:5.1%})  {workers}w  "
                  f"eta {el/max(f,1e-9)-el:6.0f}s", flush=True)
    if pool is not None:
        pool.close()
        pool.join()
    _G.clear()
    return idx, val


def _self_test():
    """Prove the parallel path returns exactly what the serial path returns.



    Run through the real entry point, not an imported copy: multiprocessing resolves the

    worker function by module name, so a module loaded under a synthetic name fails to

    pickle even though production is fine.

    """
    from scipy import sparse
    D = sparse.random(3000, 150, density=0.1, format="csr", random_state=1, dtype=np.float32)
    Q = sparse.random(2000, 150, density=0.1, format="csr", random_state=2, dtype=np.float32)
    i1, v1 = topk_sparse(Q, D, 5, chunk=128, workers=1)
    i8, v8 = topk_sparse(Q, D, 5, chunk=128, workers=8)
    assert np.allclose(v1, v8), "parallel scores differ from serial"
    assert (i1 == i8).all(), "parallel indices differ from serial"
    print(f"self-test PASS: 8 workers match serial exactly on {Q.shape[0]:,} queries")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--split", default="test")
    ap.add_argument("--k", type=int, default=5)
    ap.add_argument("--chunk", type=int, default=4096)
    ap.add_argument("--workers", type=int, default=0, help="0 = auto (capped, shared box)")
    ap.add_argument("--self-test", action="store_true",
                    help="check the parallel path against the serial one, then exit")
    a = ap.parse_args()

    if a.self_test:
        _self_test()
        return

    from sklearn.feature_extraction.text import TfidfVectorizer

    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"))
    empty = (pool["business_address"].astype(str).str.strip() == "").to_numpy()
    print(f"{a.split}: {len(s1):,} S1, {len(pool):,} pool, "
          f"{int(empty.sum()):,} address-less ({empty.mean():.2%})")

    qs, cs, ss, rs = [], [], [], []
    for country in sorted(set(s1["country"])):
        qrows = np.flatnonzero((s1["country"] == country).to_numpy())
        drows = np.flatnonzero(empty & (pool["country"] == country).to_numpy())
        if len(qrows) == 0 or len(drows) == 0:
            print(f"  {country}: nothing to do")
            continue
        print(f"  {country}: {len(qrows):,} queries x {len(drows):,} address-less docs",
              flush=True)
        docs = pool["business_name"].astype(str).to_numpy()[drows]
        qtxt = s1["business_name"].astype(str).to_numpy()[qrows]
        # Fitted on the DOCUMENTS, as measured - the idf weighting should describe the
        # address-less pool, not the S1 table.
        vec = TfidfVectorizer(analyzer="char_wb", ngram_range=(3, 3), sublinear_tf=True)
        t0 = time.time()
        D = vec.fit_transform(docs)
        Q = vec.transform(qtxt)
        print(f"    tfidf {D.shape[1]:,} features in {time.time()-t0:.0f}s", flush=True)
        idx, val = topk_sparse(Q, D, a.k, a.chunk, a.workers)
        kk = idx.shape[1]
        qs.append(np.repeat(qrows, kk))
        cs.append(drows[idx.ravel()])
        ss.append(val.ravel())
        rs.append(np.tile(np.arange(kk, dtype=np.int16), len(qrows)))

    assert qs, "no country produced candidates"
    out = pd.DataFrame({
        "q": np.concatenate(qs).astype(np.int32),
        "c": np.concatenate(cs).astype(np.int32),
        "s": np.concatenate(ss).astype(np.float32),
        "r": np.concatenate(rs).astype(np.int16),
    })
    out = out[out["s"] > 0]                       # a zero score means no shared 3-gram at all
    p = P.work("retr", f"{a.split}_ename_s0of1.parquet")
    out.to_parquet(p, index=False)
    print(f"\nwrote {p}  {len(out):,} pairs  "
          f"({len(out)/len(s1):.2f} per S1)")


if __name__ == "__main__":
    main()