scripts/og2baseline.py

"""k-mer (Markov) baselines: bits per base of order-0..7 models fitted on train, scored out of sample.

  python og2baseline.py [--root .] [--fit train] [--eval heldout valid] [--alpha 0.5] [--workers 8]

Fit: the train split's 8-mer counts (stats/train_kmer8.npz from og2stats.py; case folded, k-mers with N or crossing a
window boundary excluded) give, for each order k, P(b | previous k bases) = (c(ctx, b) + alpha) / (c(ctx) + 4 alpha).
Score: on each evaluation split, every position i of every window whose target and 7 previous bases are A/C/G/T (the
same positions for every order, so orders are comparable; these are exactly the targets kept by the loss mask, minus
the first 7 of each window). Reports bits/base overall and per subset, plus the best order, and the in-sample value on
train for reference (lower than out of sample: the model has seen those counts).
Writes stats/baseline.json. A trained model's masked bits/base on heldout should be compared with the best order.
"""

from __future__ import annotations

import argparse
import json
from collections import defaultdict
from concurrent.futures import ProcessPoolExecutor
from pathlib import Path

import numpy as np

K = 8
ORDERS = list(range(K))


def tables(k8: np.ndarray, alpha: float) -> dict[int, np.ndarray]:
    """log2 P(b | ctx) for each order: [4**k, 4] arrays."""
    t = k8.reshape([4] * K).astype(np.float64)
    out = {}
    for k in ORDERS:
        c = t.sum(axis=tuple(range(k + 1, K))) if k + 1 < K else t  # (k+1)-mer counts
        c = c.reshape(4**k, 4)
        out[k] = np.log2((c + alpha) / (c.sum(1, keepdims=True) + 4 * alpha))
    return out


_T: dict[int, np.ndarray] = {}


def _init(tabs: dict[int, np.ndarray]) -> None:
    _T.update(tabs)


def score_shard(npy: str, ids: list[int] | None) -> dict:
    """Summed -log2 P per order and position count for one shard."""
    base = Path(npy).with_suffix("")
    arr = np.load(npy, mmap_mode="r")
    rows = [json.loads(line) for line in base.with_suffix(".jsonl").read_text().splitlines()]
    if ids is not None:
        rows = [rows[i] for i in ids]
    bits = np.zeros(K)
    n = 0
    for r in rows:
        b = (np.asarray(arr[r["offset"]: r["offset"] + r["len"]]) & 7).astype(np.int64)
        L = len(b)
        if L <= K - 1:
            continue
        bad = np.concatenate([[0], np.cumsum(b >= 4)])
        pos = np.arange(K - 1, L)  # target positions with 7 previous bases
        ok = (bad[pos + 1] - bad[pos - (K - 1)]) == 0  # context + target all A/C/G/T
        pos = pos[ok]
        if len(pos) == 0:
            continue
        tgt = b[pos]
        ctx = np.zeros(len(pos), dtype=np.int64)
        for k in ORDERS:  # ctx = code of the k bases before the target (grows one base per order)
            if k > 0:
                ctx = ctx + b[pos - k] * 4 ** (k - 1)
            bits[k] -= _T[k][ctx, tgt].sum()
        n += len(pos)
    return {"subset": base.parent.name, "bits": bits.tolist(), "n": n}


def evaluate(root: Path, split: str, tabs: dict, workers: int) -> dict:
    sel_path = root / split / "selected.json"
    sel = json.loads(sel_path.read_text())["shards"] if sel_path.exists() else None
    jobs = [(str(p), None if sel is None else sel.get(str(p.with_suffix("").relative_to(root)), []))
            for p in sorted((root / split).glob("*/*.npy"))]
    agg: dict[str, list] = defaultdict(lambda: [np.zeros(K), 0])
    with ProcessPoolExecutor(workers, initializer=_init, initargs=(tabs,)) as ex:
        for res in ex.map(score_shard, *zip(*jobs), chunksize=4):
            g = agg[res["subset"]]
            g[0] += np.array(res["bits"])
            g[1] += res["n"]
    tot_bits = sum((g[0] for g in agg.values()), np.zeros(K))
    tot_n = sum(g[1] for g in agg.values())

    def row(bits, n):
        bpb = {str(k): round(float(bits[k] / max(n, 1)), 5) for k in ORDERS}
        best = min(ORDERS, key=lambda k: bpb[str(k)])
        return {"positions": int(n), "bits_per_base": bpb, "best_order": best, "best": bpb[str(best)]}

    return {"overall": row(tot_bits, tot_n),
            "subsets": {k: row(g[0], g[1]) for k, g in sorted(agg.items(), key=lambda kv: -kv[1][1])}}


def main(argv: list[str] | None = None) -> None:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--root", type=Path, default=Path("."))
    ap.add_argument("--fit", default="train")
    ap.add_argument("--eval", nargs="+", default=["heldout", "valid", "train"])
    ap.add_argument("--alpha", type=float, default=0.5)
    ap.add_argument("--workers", type=int, default=8)
    a = ap.parse_args(argv)
    k8 = np.load(a.root / "stats" / f"{a.fit}_kmer8.npz")["overall"]
    tabs = tables(k8, a.alpha)
    out = {"fit": a.fit, "alpha": a.alpha, "orders": ORDERS, "splits": {}}
    for split in a.eval:
        if (a.root / split).exists():
            out["splits"][split] = r = evaluate(a.root, split, tabs, a.workers)
            o = r["overall"]
            print(f"{split}: " + " ".join(f"k{k}={v:.4f}" for k, v in o["bits_per_base"].items())
                  + f"  best k{o['best_order']} {o['best']:.4f} ({o['positions']:,} positions)")
    (a.root / "stats" / "baseline.json").write_text(json.dumps(out, indent=1))


if __name__ == "__main__":
    main()