Datasets:

Jyo-K
/

PopTurk

"""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)

	"""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)