code/berx/fuse.py

"""Merge shards, retrain the stacker on the new features, decide, arbitrate.

THE DECISION RULE AND WHY IT IS THE SHAPE IT IS

The metric is macro F0.5 over S1 entities, and for one entity with T true matches and k
predicted, of which TP are right:

    F0.5 = 1.25 * TP / (0.25 * T + k)

FP = k - TP and FN = T - TP cancel the TP terms in the denominator, which is why only TP, T
and k survive. Writing D = 0.25*T + k, adding one more pair is worth it exactly when its
TP:FP odds beat TP/(D - TP). At the shipped operating point that is 3.76:1. It approaches 4:1
only in the limit TP -> T, k -> T, so quoting a flat 4:1 sets the bar too high and discards
pairs that were worth taking.

ONE OWNER PER RECORD. A pool record belongs to exactly one S1. Enforcing it globally is free
precision. The tie-break is deliberate: sort by candidate id, then descending probability,
then S1 id ascending, and keep the first. The last key makes the result deterministic; without
it two runs with identical scores could emit different files.
"""
from __future__ import annotations

import numpy as np
import pandas as pd


# --------------------------------------------------------------------------- stacking

def fit_stacker(df: pd.DataFrame, feats: list[str], label: str = "y",
                group: str = "component", n_folds: int = 5, seed: int = 42,
                params: dict | None = None):
    """Cross-fitted LightGBM + isotonic calibration.

    Folds are grouped by `component` - the connected components of the label graph - not by
    S1 row. Two S1 entities that share a true target must not land on opposite sides of a
    fold, or the model sees the answer to one through the other.
    """
    import lightgbm as lgb
    from sklearn.isotonic import IsotonicRegression

    p = dict(objective="binary", learning_rate=0.05, num_leaves=63, min_data_in_leaf=200,
             feature_fraction=0.8, bagging_fraction=0.8, bagging_freq=1, verbosity=-1,
             num_threads=max(1, (len(feats) // 4) or 4))
    p.update(params or {})

    g = df[group].to_numpy() if group in df else df.index.to_numpy()
    uniq = np.unique(g)
    rng = np.random.default_rng(seed)
    fold_of = dict(zip(uniq, rng.integers(0, n_folds, len(uniq))))
    fold = np.array([fold_of[x] for x in g])

    X, y = df[feats].to_numpy(np.float32), df[label].to_numpy(np.int8)
    oof = np.zeros(len(df), dtype=np.float32)
    models = []
    for f in range(n_folds):
        tr, va = fold != f, fold == f
        if va.sum() == 0:
            continue
        m = lgb.train(p, lgb.Dataset(X[tr], label=y[tr]), num_boost_round=600)
        oof[va] = m.predict(X[va])
        models.append(m)

    iso = IsotonicRegression(out_of_bounds="clip").fit(oof, y)
    return {"models": models, "iso": iso, "feats": feats, "oof": oof}


def apply_stacker(bundle, df: pd.DataFrame) -> np.ndarray:
    X = df[bundle["feats"]].to_numpy(np.float32)
    raw = np.mean([m.predict(X) for m in bundle["models"]], axis=0)
    return bundle["iso"].predict(raw).astype(np.float32)


# --------------------------------------------------------------------------- decision

def resolve_conflicts(df: pd.DataFrame, prob_col: str = "p", qcol: str = "q",
                      ccol: str = "c") -> pd.DataFrame:
    """Global one-owner arbitration. Keeps the best-scoring S1 for each pool record."""
    d = df.sort_values([ccol, prob_col, qcol], ascending=[True, False, True], kind="mergesort")
    return d[~d.duplicated(subset=ccol, keep="first")]


def predict_sets(df: pd.DataFrame, threshold: float, qcol: str = "q", ccol: str = "c",
                 pcol: str = "p", arbitrate: bool = True,
                 all_q: np.ndarray | None = None, method: str = "threshold",
                 miss_mass: float = 0.0) -> dict:
    """Select, arbitrate, and return {q: [c, ...]} including empty predictions.

    `method` is "threshold" (flat cut) or "ef05" (expected-F0.5 per entity, see above).

    Entities with no accepted pair MUST appear with an empty list. A singleton scores 1.0 for
    a correct empty prediction and 0.0 for any prediction at all, so dropping such entities
    from the output is not a neutral omission - it changes the macro average.
    """
    if method == "ef05":
        sel = expected_f05_select(df, qcol, ccol, pcol, miss_mass)
    else:
        sel = df[df[pcol] >= threshold]
    if arbitrate:
        sel = resolve_conflicts(sel, pcol, qcol, ccol)
    out = {int(q): [int(x) for x in g[ccol]] for q, g in sel.groupby(qcol, sort=False)}
    if all_q is not None:
        for q in all_q:
            out.setdefault(int(q), [])
    return out


def expected_f05_select(df: pd.DataFrame, qcol: str = "q", ccol: str = "c", pcol: str = "p",
                        miss_mass: float = 0.0) -> pd.DataFrame:
    """Per entity, keep the top-k that maximises EXPECTED F0.5. Returns the kept rows.

    WHY NOT A FLAT THRESHOLD. The metric is per entity, and the value of one more pair
    depends on how many that entity already has. With D = 0.25*T + k, an extra pair pays
    only when its odds beat TP/(D - TP) - 3.76:1 at the shipped operating point. An entity
    with one confident match and an entity with six have different bars, and a single global
    threshold gives them the same one. model-4 drops 99.8% of its rejected true copies by
    this rule, so comparing a flat threshold against it measures the rule, not the features.

    THE APPROXIMATION. With probabilities sorted descending,
        E[TP@k] = sum of the top k          E[T] = sum of all p, plus miss_mass
        E[F0.5@k] ~ 1.25 * E[TP@k] / (0.25 * E[T] + k)
    and k=0 scores P(no true match at all) = prod(1 - p_i), which is what lets a singleton be
    predicted empty and score 1.0 rather than 0.0.

    This is the plug-in approximation, not the exact Poisson-binomial dynamic program. That
    is deliberate: the exact version was measured at -0.00089 against this one, because the
    extra precision buys nothing while the miss_mass term remains an estimate.

    `miss_mass` is the expected number of true matches that retrieval never produced. Leaving
    it at 0 tells the rule every true match is on the table, which makes it too eager to stop
    early; it should be set from measured retrieval recall.
    """
    d = df.sort_values([qcol, pcol], ascending=[True, False], kind="mergesort")
    q = d[qcol].to_numpy()
    p = d[pcol].to_numpy(dtype=np.float64)
    n = len(d)
    if n == 0:
        return d

    new = np.empty(n, dtype=bool)
    new[0] = True
    np.not_equal(q[1:], q[:-1], out=new[1:])
    gid = np.cumsum(new) - 1
    starts = np.flatnonzero(new)
    sizes = np.diff(np.append(starts, n))

    csum = np.cumsum(p)
    base = np.append(0.0, csum[starts[1:] - 1]) if len(starts) > 1 else np.array([0.0])
    e_tp = csum - base[gid]                                   # E[TP] at k = rank+1
    group_sum = e_tp[starts + sizes - 1][gid]
    k = (np.arange(n) - starts[gid] + 1).astype(np.float64)
    score = 1.25 * e_tp / (0.25 * (group_sum + miss_mass) + k)

    # k = 0 competes: prod(1 - p) over the group, via a log-sum to stay stable.
    lg = np.log1p(-np.clip(p, 0.0, 1.0 - 1e-12))
    lcum = np.cumsum(lg)
    lbase = np.append(0.0, lcum[starts[1:] - 1]) if len(starts) > 1 else np.array([0.0])
    ltot = (lcum - lbase[gid])[starts + sizes - 1]
    score0 = np.exp(ltot)

    keep = np.zeros(n, dtype=bool)
    for g in range(len(starts)):
        s, sz = starts[g], sizes[g]
        seg = score[s:s + sz]
        bi = int(np.argmax(seg))
        if seg[bi] >= score0[g]:
            keep[s:s + bi + 1] = True                          # take the top bi+1
    return d[keep]


def tune_threshold(df: pd.DataFrame, truths: dict, ids, lo: float = 0.30, hi: float = 0.90,
                   steps: int = 25, **kw):
    """Sweep the threshold and return (best_threshold, best_f05, the full curve).

    Sweep on a clean split. The shipped 0.70 was tuned on a cache drawn with the wrong RNG,
    so it is a threshold selected partly on data the model had seen.
    """
    from .evaluate import macro_f05

    curve = []
    for t in np.linspace(lo, hi, steps):
        pred = predict_sets(df, float(t), all_q=np.asarray(ids), **kw)
        m, _ = macro_f05(pred, truths, ids)
        curve.append((float(t), m["f05"], m["precision"], m["recall"]))
    best = max(curve, key=lambda r: r[1])
    return best[0], best[1], curve


def tune_decision(df: pd.DataFrame, truths: dict, ids, miss_masses=(0.0, 0.2, 0.4, 0.6),
                  **kw):
    """Pick the better of the two decision rules on this split, and report both.

    Both are reported because a gate that only prints the winner hides whether a gain came
    from the features or from swapping the rule underneath them.
    """
    from .evaluate import macro_f05

    thr, f_thr, _ = tune_threshold(df, truths, ids, **kw)
    best = {"method": "threshold", "threshold": thr, "f05": f_thr, "miss_mass": 0.0}
    for mm in miss_masses:
        pred = predict_sets(df, 0.0, all_q=np.asarray(ids), method="ef05", miss_mass=mm, **kw)
        m, _ = macro_f05(pred, truths, ids)
        if m["f05"] > best["f05"]:
            best = {"method": "ef05", "threshold": 0.0, "f05": m["f05"], "miss_mass": mm}
    return best, f_thr


# --------------------------------------------------------------------------- shards

def merge_shards(paths: list[str], on=("q", "c"), score_col: str = "ce") -> pd.DataFrame:
    """Concatenate scored shards and verify that together they cover the work exactly once.

    The assert is the point. Four lanes writing four files is four chances to lose one, and a
    missing shard does not raise - it produces a submission with a plausible score that is
    quietly missing a fifth of its candidates.
    """
    parts = [pd.read_parquet(p) for p in paths]
    out = pd.concat(parts, ignore_index=True)
    before = len(out)
    out = out.drop_duplicates(list(on))
    if len(out) != before:
        print(f"  WARNING: {before - len(out):,} duplicate pairs across shards "
              f"(overlapping shard ranges?)")
    assert out[score_col].notna().all(), f"{int(out[score_col].isna().sum()):,} unscored pairs"
    return out.reset_index(drop=True)


def split_shards(df: pd.DataFrame, n: int) -> list[pd.DataFrame]:
    """Split work into n contiguous shards of roughly equal TOKEN cost, not equal row count.

    Cross-encoder cost scales with sequence length, and empty-address records are much shorter
    than the rest. Splitting by row count hands the lane that happens to draw the long records
    a job that takes half again as long as its neighbours.
    """
    if n <= 1 or len(df) == 0:
        return [df.reset_index(drop=True)]
    cost = (df["len_a"] + df["len_b"]).to_numpy() if "len_a" in df else np.ones(len(df))
    cum = np.cumsum(cost)
    edges = np.searchsorted(cum, np.linspace(0, cum[-1], n + 1)[1:-1])
    bounds = [0, *edges.tolist(), len(df)]
    # iloc, not np.split: np.split on a DataFrame returns bare ndarrays and loses the columns
    return [df.iloc[bounds[i]:bounds[i + 1]].reset_index(drop=True) for i in range(n)]