code/berx/retrieve.py

"""C. Multi-GPU top-K retrieval and the three-channel union.



WHY THIS IS WORTH GPU TIME. Measured ceilings on model-4's val, with a perfect decision layer:



    top-64 candidates (what ships)          0.9953

    top-100 candidates                      0.9964

    union of three retrievers' top-100      0.9976



The union is worth +0.0023 of headroom over what ships. That is larger than every decision-side

idea left on the list, and unlike them it cannot be had on CPU.



HOW THE GPUs ARE USED



  * Per country. Zero true pairs cross a country boundary in train, so a cross-country score

    is arithmetic that can only produce a false positive. Blocking by country cuts the work

    to sum(share^2) = 0.445 of the full matrix - a 2.2x saving before any other optimisation.

  * Resident pool. A 96 GB card holds an entire country's pool in fp16 (10.3M x 1024 x 2 =

    21 GB for the large channels, 7.9 GB for e5-small). When it fits, the pool is uploaded

    once and every query chunk reuses it, so the run is pure matmul with no PCIe traffic.

    `resident="auto"` measures free memory and decides.

  * Streaming fallback. When it does not fit, pool blocks are staged through a pinned host

    buffer on a second CUDA stream, double-buffered, so the copy for block i+1 overlaps the

    matmul for block i.

  * Query sharding. `--shard i --nshards n` splits the QUERY set, not the pool, so the two

    GPUs never need to exchange anything and a shard can be re-run alone after a failure.



SHARED-BOX MANNERS. This box has other users on it. Run it under `nice -n 19 ionice -c3` and

leave `--pblock` at the default; an earlier memmap-heavy job at load 37 made SSH unreachable

for everyone.

"""
from __future__ import annotations

import os
import time

import numpy as np


def _load(path: str) -> np.ndarray:
    """mmap a .npy. NOT np.memmap: a .npy carries a 128-byte header that np.memmap maps as

    data, which shifts every row and fails a reshape by exactly the header size in elements."""
    return np.load(path, mmap_mode="r")


def _free_bytes(dev: int) -> int:
    import torch
    free, _ = torch.cuda.mem_get_info(dev)
    return free


def topk_country(qmat: np.ndarray, pmat: np.ndarray, k: int, device: str,

                 qchunk: int = 4096, pblock: int = 262_144, resident: str = "auto",

                 log_every: int = 20):
    """Top-k over one country. Returns (idx[nq,k] int64, val[nq,k] float32).



    Embeddings are assumed L2-normalised, so the inner product is cosine. If they are not,

    normalise them before calling - silently normalising here would hide a mismatch between

    the matrix on disk and the model that produced it.

    """
    import torch

    torch.backends.cuda.matmul.allow_tf32 = True
    torch.backends.cudnn.allow_tf32 = True
    dev = torch.device(device)
    nq, d = qmat.shape
    npool = pmat.shape[0]
    k = min(k, npool)

    want = npool * d * 2
    if resident == "auto":
        use_resident = want < _free_bytes(dev.index or 0) * 0.55
    else:
        use_resident = resident == "yes"

    # The pool is ALWAYS walked in blocks, whichever mode is chosen. `resident` decides only
    # where a block is read from - a GPU-resident copy of the pool, or the host mmap. It does
    # not mean "one matmul over the whole pool": the score matrix for a 4,096-query chunk
    # against a 6M-row country pool would be 49 GiB on its own, dwarfing the embeddings.
    P_gpu = None
    if use_resident:
        P_gpu = torch.empty((npool, d), dtype=torch.float16, device=dev)
        for ps in range(0, npool, pblock):                         # staged upload, once
            pe = min(ps + pblock, npool)
            P_gpu[ps:pe] = torch.from_numpy(np.ascontiguousarray(pmat[ps:pe])).to(dev, torch.float16)
        print(f"    pool resident on {device}: {want/2**30:.1f} GiB")
    else:
        print(f"    pool streamed on {device} ({want/2**30:.1f} GiB vs free "
              f"{_free_bytes(dev.index or 0)/2**30:.1f} GiB), pblock={pblock:,}")

    blocks = [(ps, min(ps + pblock, npool)) for ps in range(0, npool, pblock)]
    best_i = torch.empty((nq, k), dtype=torch.int64, device=dev)
    best_v = torch.full((nq, k), -1e4, dtype=torch.float16, device=dev)
    copy_stream = torch.cuda.Stream(device=dev) if not use_resident else None
    main = torch.cuda.current_stream(dev)
    t0 = time.time()

    for ci, qs in enumerate(range(0, nq, qchunk)):
        qe = min(qs + qchunk, nq)
        Q = torch.from_numpy(np.ascontiguousarray(qmat[qs:qe])).to(dev, torch.float16)
        bi = torch.zeros((qe - qs, k), dtype=torch.int64, device=dev)
        bv = torch.full((qe - qs, k), -1e4, dtype=torch.float16, device=dev)

        staged = staged_off = staged_evt = None
        for bidx in range(len(blocks) + 1):
            nxt = nxt_off = nxt_evt = None
            if bidx < len(blocks):
                ps, pe = blocks[bidx]
                if use_resident:
                    nxt, nxt_off = P_gpu[ps:pe], ps
                else:
                    # Prefetch block bidx while block bidx-1 is still being multiplied.
                    with torch.cuda.stream(copy_stream):
                        host = torch.from_numpy(np.ascontiguousarray(pmat[ps:pe])).pin_memory()
                        nxt = host.to(dev, torch.float16, non_blocking=True)
                        nxt_evt = torch.cuda.Event()
                        nxt_evt.record(copy_stream)
                    nxt_off = ps
            if staged is not None:
                if staged_evt is not None:
                    main.wait_event(staged_evt)
                s = Q @ staged.T                                   # [qc, block] fp16
                v, i = torch.topk(s, min(k, s.shape[1]), dim=1)
                bv, bi = _merge(bv, bi, v, i + staged_off, k)
                del s
                if not use_resident:
                    del staged
            staged, staged_off, staged_evt = nxt, nxt_off, nxt_evt

        best_v[qs:qe], best_i[qs:qe] = bv, bi
        if log_every and ci % log_every == 0:
            done = qe / nq
            el = time.time() - t0
            print(f"    {qe:>9,}/{nq:,} ({done:6.1%})  {el:6.0f}s  "
                  f"eta {el/max(done, 1e-9) - el:6.0f}s", flush=True)

    del P_gpu
    torch.cuda.empty_cache()
    return best_i.cpu().numpy(), best_v.float().cpu().numpy()


def _merge(bv, bi, v, i, k):
    import torch
    cv = torch.cat([bv, v], dim=1)
    ci = torch.cat([bi, i], dim=1)
    nv, pos = torch.topk(cv, k, dim=1)
    return nv, torch.gather(ci, 1, pos)


def run_channel(qmat_path: str, pmat_path: str, q_country: np.ndarray, p_country: np.ndarray,

                k: int, device: str, shard: int = 0, nshards: int = 1,

                max_queries: int | None = None, **kw):
    """Retrieve top-k for one channel, one query shard, blocking by country.



    Returns a dict with flat arrays: q (global query row), c (global pool row), s (score),

    r (rank within the channel). Global rows, not per-country rows - a per-country index that

    escapes into a later stage is the kind of bug that produces a plausible wrong answer.

    """
    Q = _load(qmat_path)
    P = _load(pmat_path)
    assert Q.shape[1] == P.shape[1], f"dim mismatch {Q.shape} vs {P.shape}"
    assert len(q_country) == Q.shape[0], "query country vector does not match the matrix"
    assert len(p_country) == P.shape[0], "pool country vector does not match the matrix"

    qs_all, cs_all, ss_all, rs_all = [], [], [], []
    for country in sorted(set(q_country.tolist())):
        qrows = np.flatnonzero(q_country == country)
        qrows = qrows[shard::nshards]
        if max_queries:
            qrows = qrows[:max_queries]           # debug path only
        prows = np.flatnonzero(p_country == country)
        if len(qrows) == 0 or len(prows) == 0:
            continue
        print(f"  {country}: {len(qrows):,} queries x {len(prows):,} pool", flush=True)
        qm = np.ascontiguousarray(Q[qrows])
        pm = P[prows]
        idx, val = topk_country(qm, pm, k, device, **kw)
        n, kk = idx.shape
        qs_all.append(np.repeat(qrows, kk))
        cs_all.append(prows[idx.ravel()])
        ss_all.append(val.ravel())
        rs_all.append(np.tile(np.arange(kk, dtype=np.int16), n))

    if not qs_all:
        return {k_: np.array([]) for k_ in ("q", "c", "s", "r")}
    return {
        "q": np.concatenate(qs_all).astype(np.int32),
        "c": np.concatenate(cs_all).astype(np.int32),
        "s": np.concatenate(ss_all).astype(np.float32),
        "r": np.concatenate(rs_all).astype(np.int16),
    }


def union(frames: dict, rrf_k: int = 60):
    """Union per-channel results into one candidate table with per-channel evidence.



    `frames` maps channel name -> the dict from run_channel. The output keeps each channel's

    score and rank as separate columns, plus Reciprocal Rank Fusion. Keeping the per-channel

    columns matters: a pair found by all three is different evidence from a pair found by one,

    and collapsing to a single fused score throws that distinction away before the stacker

    ever sees it.

    """
    import pandas as pd

    out = None
    for name, f in frames.items():
        if len(f["q"]) == 0:
            continue
        d = pd.DataFrame({"q": f["q"], "c": f["c"],
                          f"s_{name}": f["s"], f"r_{name}": f["r"]})
        d = d.sort_values(f"s_{name}", ascending=False).drop_duplicates(["q", "c"])
        out = d if out is None else out.merge(d, on=["q", "c"], how="outer")

    if out is None:
        return None
    rrf = np.zeros(len(out), dtype=np.float32)
    nfound = np.zeros(len(out), dtype=np.int8)
    for name in frames:
        col = f"r_{name}"
        if col not in out:
            continue
        r = out[col].to_numpy()
        ok = ~np.isnan(r)
        rrf[ok] += 1.0 / (rrf_k + r[ok])
        nfound[ok] += 1
        out[col] = np.where(ok, r, 9999).astype(np.int16)
        out[f"s_{name}"] = out[f"s_{name}"].fillna(0.0).astype(np.float32)
    out["rrf"] = rrf
    out["n_channels"] = nfound
    return out.reset_index(drop=True)