training/turn-load/scripts/decide/rerank/train_rerank.py

#!/usr/bin/env python3
"""Fine-tune the Painted Wolf Decide head on reranking candidates.

Reads the candidate dumps lycaon/cmd/decide-rerank writes (one row per pair,
every candidate the site offered with its lexical score and target flag) and
trains the head, scorer, and type embedding of a Laya checkpoint on the
engine's own relevance question: the exact rubric pw-decide serves, read from
scripts/decide/rank-rubric.json so training and serving never drift.

Labels come from the site's own structure, on the rubric's 0..4 scale:

  4  the target unit
  2  another unit in the target's file
  1  a lexical neighbour: top-ranked by the site, another file
  0  a random candidate from the rest

The encoder stays frozen and runs per batch every epoch, so memory is bounded
by the batch size rather than the corpus; run one training job per host. The
head file records the backbone it was trained over, which the engine checks
before loading it (see scripts/decide/headfile.py).

Usage:
  train_rerank.py --dump rows.jsonl [--dump more.jsonl ...] --out .task/decide/heads/code-rank.safetensors
                  [--model convaiinnovations/laya-multilingual] [--epochs 6] [--val-fraction 0.1]
"""

import argparse
import json
import os
import random
import sys
import time
from pathlib import Path

import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset

import laya
from laya.common import QTYPES, build_sequence, collate_items

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
import headfile  # noqa: E402

# The rubric the engine serves (scripts/decide/rank-rubric.json, compiled into pw-decide).
with open(Path(__file__).resolve().parents[1] / "rank-rubric.json", encoding="utf-8") as _fh:
    _RUBRIC_FILE = json.load(_fh)
RUBRIC = {"instructions": _RUBRIC_FILE["instructions"], "criteria": list(_RUBRIC_FILE["levels"])}
NEIGHBOURS_PER_ROW = 2
RANDOMS_PER_ROW = 2


def read_jsonl(path):
    with open(path, encoding="utf-8") as fh:
        for line in fh:
            line = line.strip()
            if line:
                yield json.loads(line)


def state_text(task, candidate):
    """Exactly what the daemon encodes for one rank candidate."""
    return "Task: %s\n\nCandidate:\n%s" % (task, candidate)


def labelled_examples(rows, rng):
    """(task, text, level) triples from one dump, with the site's own labels."""
    out = []
    for row in rows:
        cands = row["candidates"]
        target = next((c for c in cands if c.get("target")), None)
        if target is None or len(cands) < 2:
            continue
        task = row["task"]
        if all("label" in c for c in cands):
            # Synthetic site rows carry explicit rubric levels.
            picked = [c for c in cands if c["label"] > 0]
            zeros = [c for c in cands if c["label"] == 0]
            rng.shuffle(zeros)
            for c in picked + zeros[:RANDOMS_PER_ROW]:
                out.append((task, c["text"], int(c["label"])))
            continue
        out.append((task, target["text"], 4))
        same_file = [c for c in cands if not c.get("target") and c.get("file") == row["file"]]
        for c in same_file[:1]:
            out.append((task, c["text"], 2))
        others = [c for c in cands if not c.get("target") and c.get("file") != row["file"]]
        by_lexical = sorted(others, key=lambda c: -c["lexical"])
        for c in by_lexical[:NEIGHBOURS_PER_ROW]:
            out.append((task, c["text"], 1))
        rest = by_lexical[NEIGHBOURS_PER_ROW:]
        rng.shuffle(rest)
        for c in rest[:RANDOMS_PER_ROW]:
            out.append((task, c["text"], 0))
    return out


class Tokenized(Dataset):
    """Token ids only. Encoder states are computed per batch and discarded, so
    memory is bounded by the batch, not the corpus."""

    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)

    def __getitem__(self, i):
        return self.items[i]


def tokenize(tok, examples, max_len):
    q = {"t": "score", "ins": RUBRIC["instructions"], "crit": list(RUBRIC["criteria"])}
    items = []
    for task, text, level in examples:
        ids, markers = build_sequence(tok, state_text(task, text), q, max_len=max_len)
        items.append({"ids": ids, "markers": markers, "qtype": QTYPES["score"], "label": level})
    return items


def collate_with(pad_id):
    def collate(batch):
        b = collate_items([[it] for it in batch], pad_id)
        b["label"] = torch.tensor([it["label"] for it in batch])
        return b

    return collate


def encode(model, b, device):
    """Frozen encoder forward for one batch; nothing is kept afterwards."""
    with torch.no_grad():
        return model.encoder(input_ids=b["input_ids"].to(device), attention_mask=b["attention_mask"].to(device)).last_hidden_state


def forward_head(model, h, att, mpos, mmask, qtype):
    d = h.size(-1)
    h = h + model.type_emb(qtype)[:, None, :]
    if model.head is not None:
        pad = ~att.bool()
        for layer in model.head.layers:
            h = layer(h, src_key_padding_mask=pad)
    m = torch.gather(h, 1, mpos.clamp(min=0)[:, :, None].expand(-1, -1, d))
    logits = model.scorer(m).squeeze(-1).float()
    return logits.masked_fill(~mmask, -1e4)


def evaluate(model, loader, device):
    model.eval()
    loss_sum, n, correct, mae = 0.0, 0, 0, 0.0
    with torch.no_grad():
        for b in loader:
            h = encode(model, b, device)
            logits = forward_head(model, h, b["attention_mask"].to(device), b["marker_pos"].to(device), b["marker_mask"].to(device), b["qtype"].to(device))
            labels = b["label"].to(device)
            loss_sum += F.cross_entropy(logits, labels).item() * len(labels)
            n += len(labels)
            correct += (logits.argmax(-1) == labels).sum().item()
            expected = (F.softmax(logits, -1) * torch.arange(logits.size(-1), device=device)).sum(-1)
            mae += (expected - labels.float()).abs().sum().item()
    return loss_sum / max(n, 1), correct / max(n, 1), mae / max(n, 1)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dump", action="append", default=[], help="candidate dump JSONL; repeatable")
    ap.add_argument("--out", required=True)
    ap.add_argument("--model", default=os.environ.get("LYCAON_DECIDE_MODEL_ID", "convaiinnovations/laya-multilingual"))
    ap.add_argument("--label", default="code-rank")
    ap.add_argument("--epochs", type=int, default=6)
    ap.add_argument("--batch-size", type=int, default=32)
    ap.add_argument("--lr", type=float, default=3e-4)
    ap.add_argument("--val-fraction", type=float, default=0.1)
    ap.add_argument("--max-rows", type=int, default=0)
    ap.add_argument("--seed", type=int, default=7)
    args = ap.parse_args()

    if not args.dump:
        ap.error("give at least one --dump")
    out = Path(args.out)
    lock = headfile.claim(out)  # noqa: F841 - held until the process exits, before any expensive work
    rng = random.Random(args.seed)
    torch.manual_seed(args.seed)
    rows = []
    for path in args.dump:
        rows.extend(read_jsonl(path))
    rng.shuffle(rows)
    if args.max_rows:
        rows = rows[: args.max_rows]
    split = int(len(rows) * (1 - args.val_fraction))
    train_ex = labelled_examples(rows[:split], rng)
    val_ex = labelled_examples(rows[split:], rng)
    print(f"rows {len(rows)}: {len(train_ex)} train examples, {len(val_ex)} validation examples", file=sys.stderr)

    device = "mps" if torch.backends.mps.is_available() else ("cuda" if torch.cuda.is_available() else "cpu")
    agent = laya.load(args.model, device=device)
    # The engine encodes at the checkpoint's full context; training at another length
    # teaches the head on candidates cut where the engine never cuts them.
    max_len = int(agent.cfg.get("max_len", 512))
    model = agent.model
    model.eval()
    collate = collate_with(agent.tok.pad_token_id)
    train_items = tokenize(agent.tok, train_ex, max_len)
    val_items = tokenize(agent.tok, val_ex, max_len)
    train_loader = DataLoader(Tokenized(train_items), batch_size=args.batch_size, shuffle=True, collate_fn=collate)
    val_loader = DataLoader(Tokenized(val_items), batch_size=args.batch_size, shuffle=False, collate_fn=collate)

    params = list(model.head.parameters()) + list(model.scorer.parameters()) + list(model.type_emb.parameters())
    opt = torch.optim.AdamW(params, lr=args.lr, weight_decay=0.01)
    loss, acc, mae = evaluate(model, val_loader, device)
    print(f"base: val loss {loss:.4f} acc {acc:.3f} mae {mae:.3f}", file=sys.stderr)
    best = float("inf")
    out.parent.mkdir(parents=True, exist_ok=True)
    for epoch in range(1, args.epochs + 1):
        model.train()
        model.encoder.eval()
        t0 = time.time()
        for b in train_loader:
            opt.zero_grad()
            h = encode(model, b, device)
            logits = forward_head(model, h, b["attention_mask"].to(device), b["marker_pos"].to(device), b["marker_mask"].to(device), b["qtype"].to(device))
            F.cross_entropy(logits, b["label"].to(device)).backward()
            opt.step()
        loss, acc, mae = evaluate(model, val_loader, device)
        print(f"epoch {epoch}: val loss {loss:.4f} acc {acc:.3f} mae {mae:.3f} ({time.time() - t0:.0f}s)", file=sys.stderr)
        if loss < best:
            best = loss
            headfile.save(out, model, args.label, args.model, {
                "max_len": max_len, "val_loss": loss, "val_acc": acc, "val_mae": mae, "train_examples": len(train_ex),
            })
            print(f"  saved {out}", file=sys.stderr)


if __name__ == "__main__":
    main()