scripts/train_span.py

#!/usr/bin/env python3
"""Fine-tune one span-extraction arm with in-training validation & best checkpoint saving.

Tracks Gate 2 criteria every epoch:
- over_deletion_rate < 1.0%
- lowest harmful_span_rate
Saves the best epoch checkpoint, preventing overfit degradation.

Usage:
  venv/bin/python train_span.py --model <hf-id> --out <dir> [--val <path>] [--epochs 4]
"""

import argparse
import json
import math
import os
import random
import sys
import time

import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset
from transformers import AutoConfig, AutoModelForTokenClassification, AutoTokenizer, get_linear_schedule_with_warmup

sys.path.insert(0, "/opt/vox/sandbox/scripts")
from span_common import (
    LABELS, MAX_LEN, decode_bio, encode_bio, load_jsonl, split_words, sweep_thresholds
)

THRESHOLDS = [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.97, 0.99, 0.995]


def set_seed(s: int):
    random.seed(s)
    np.random.seed(s)
    torch.manual_seed(s)
    torch.cuda.manual_seed_all(s)


class SpanDataset(Dataset):
    """Char spans -> word BIO -> first-subword label alignment."""

    def __init__(self, rows, tokenizer, max_len=MAX_LEN):
        self.ex = []
        self.truncated = 0
        for r in rows:
            words, _, _ = split_words(r["raw_text"])
            if not words:
                continue
            word_labels = encode_bio(r["raw_text"], [s["span"] for s in r.get("spans", [])])
            enc = tokenizer(words, is_split_into_words=True, truncation=True, max_length=max_len)
            wids = enc.word_ids()
            if wids is None or all(w is None for w in wids):
                raise RuntimeError(f"word_ids unavailable for {r[id]}: {words[:5]}")
            labels, prev = [], None
            for w in wids:
                if w is None:
                    labels.append(-100)
                elif w != prev:
                    labels.append(word_labels[w] if w < len(word_labels) else -100)
                else:
                    labels.append(-100)
                prev = w
            if len(wids) and wids[-1] is not None and len(enc["input_ids"]) >= max_len:
                self.truncated += 1
            self.ex.append((enc["input_ids"], enc["attention_mask"], labels, r["id"]))

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

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


def collate(batch, pad_id):
    n = max(len(b[0]) for b in batch)
    ids, mask, lab = [], [], []
    for input_ids, attn, labels, _ in batch:
        k = n - len(input_ids)
        ids.append(input_ids + [pad_id] * k)
        mask.append(attn + [0] * k)
        lab.append(labels + [-100] * k)
    return (
        torch.tensor(ids, dtype=torch.long),
        torch.tensor(mask, dtype=torch.long),
        torch.tensor(lab, dtype=torch.long),
    )


class LFMForTokenClassification(nn.Module):
    def __init__(self, model_name="LiquidAI/LFM2.5-Encoder-230M", num_labels=3):
        super().__init__()
        from transformers import AutoModelForMaskedLM
        self.config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
        mlm = AutoModelForMaskedLM.from_pretrained(model_name, trust_remote_code=True)
        self.lfm2 = mlm.lfm2
        self.classifier = nn.Linear(self.config.hidden_size, num_labels)
        self.num_labels = num_labels

    def forward(self, input_ids, attention_mask=None, labels=None):
        out = self.lfm2(input_ids=input_ids, attention_mask=attention_mask)
        seq = out.last_hidden_state
        logits = self.classifier(seq)
        loss = None
        if labels is not None:
            loss = nn.functional.cross_entropy(logits.view(-1, self.num_labels), labels.view(-1), ignore_index=-100)
        return type("Output", (), {"loss": loss, "logits": logits})()


@torch.no_grad()
def evaluate_val(val_rows, tok, model, device, max_len=MAX_LEN, batch_size=32):
    model.eval()
    probs = []
    order = sorted(range(len(val_rows)), key=lambda i: len(val_rows[i]["raw_text"]))
    out = [None] * len(val_rows)
    for b in range(0, len(order), batch_size):
        chunk = order[b:b + batch_size]
        encs, wids_all = [], []
        for i in chunk:
            words, _, _ = split_words(val_rows[i]["raw_text"])
            e = tok(words, is_split_into_words=True, truncation=True, max_length=max_len)
            encs.append(e)
            wids_all.append(e.word_ids())
        pad = tok.pad(encs, return_tensors="pt")
        pad = {k: v.to(device) for k, v in pad.items()}
        logits = model(**pad).logits.float()
        p = torch.softmax(logits, dim=-1).cpu().numpy()
        for j, i in enumerate(chunk):
            wids = wids_all[j]
            if wids is None:
                out[i] = ([], [])
                continue
            p_inspan = np.zeros(len(wids))
            p_begin = np.zeros(len(wids))
            for t, w in enumerate(wids):
                if w is None or t >= p.shape[1]:
                    continue
                pr = p[j][t]
                p_inspan[w] = max(0.0, 1.0 - pr[0])
                tot = pr[1] + pr[2]
                p_begin[w] = (pr[1] / tot) if tot > 1e-9 else 0.5
            out[i] = (p_inspan, p_begin)
    for t in THRESHOLDS:
        preds = [decode_bio(val_rows[i]["raw_text"], out[i][0], out[i][1], t) for i in range(len(val_rows))]
        probs.append((t, preds))
    res = sweep_thresholds(val_rows, dict(probs), THRESHOLDS)
    return res


def save_checkpoint(out_dir, model, tok, is_lfm=False):
    os.makedirs(out_dir, exist_ok=True)
    if is_lfm:
        model.lfm2.save_pretrained(out_dir)
        torch.save(model.classifier.state_dict(), os.path.join(out_dir, "classifier_head.pt"))
        tok.save_pretrained(out_dir)
        model.config.save_pretrained(out_dir)
    else:
        model.save_pretrained(out_dir)
        tok.save_pretrained(out_dir)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", required=True)
    ap.add_argument("--out", required=True)
    ap.add_argument("--train", default="/opt/vox/sandbox/corpus/pilot_v2_train.jsonl")
    ap.add_argument("--val", default="/opt/vox/sandbox/corpus/pilot_v2_val_adjudicated.jsonl")
    ap.add_argument("--seed", type=int, default=42)
    ap.add_argument("--epochs", type=int, default=4)
    ap.add_argument("--max-steps", type=int, default=None)
    ap.add_argument("--batch-size", type=int, default=16)
    ap.add_argument("--lr-encoder", type=float, default=3e-5)
    ap.add_argument("--lr-head", type=float, default=1e-3)
    ap.add_argument("--weight-decay", type=float, default=0.01)
    ap.add_argument("--warmup-ratio", type=float, default=0.1)
    ap.add_argument("--max-len", type=int, default=MAX_LEN)
    ap.add_argument("--threads", type=int, default=4)
    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
    ap.add_argument("--dtype", default="float32", choices=["float32", "bfloat16", "float16"])
    args = ap.parse_args()

    set_seed(args.seed)
    os.makedirs(args.out, exist_ok=True)
    t0 = time.time()

    is_lfm = "LiquidAI" in args.model or "lfm" in args.model.lower()
    tok = AutoTokenizer.from_pretrained(args.model, trust_remote_code=is_lfm)
    dt = {"float32": torch.float32, "bfloat16": torch.bfloat16, "float16": torch.float16}[args.dtype]

    if is_lfm:
        model = LFMForTokenClassification(args.model, num_labels=len(LABELS)).to(args.device)
    else:
        model = AutoModelForTokenClassification.from_pretrained(
            args.model, num_labels=len(LABELS),
            id2label={i: l for i, l in enumerate(LABELS)},
            label2id={l: i for i, l in enumerate(LABELS)},
            dtype=dt,
        ).to(args.device)

    train_rows = load_jsonl(args.train)
    val_rows = load_jsonl(args.val) if args.val and os.path.exists(args.val) else None

    ds = SpanDataset(train_rows, tok, args.max_len)
    pad_id = tok.pad_token_id if tok.pad_token_id is not None else 0
    dl = DataLoader(
        ds, batch_size=args.batch_size, shuffle=True, num_workers=args.threads,
        collate_fn=lambda b: collate(b, pad_id), drop_last=False,
    )

    def is_head(n):
        return "classifier" in n or "score" in n

    groups = [
        {"params": [p for n, p in model.named_parameters() if not is_head(n) and p.ndim > 1],
         "lr": args.lr_encoder, "weight_decay": args.weight_decay},
        {"params": [p for n, p in model.named_parameters() if not is_head(n) and p.ndim <= 1],
         "lr": args.lr_encoder, "weight_decay": 0.0},
        {"params": [p for n, p in model.named_parameters() if is_head(n)],
         "lr": args.lr_head, "weight_decay": 0.0},
    ]
    opt = torch.optim.AdamW(groups)

    total_steps = len(dl) * args.epochs
    if args.max_steps is not None and args.max_steps < total_steps:
        total_steps = args.max_steps
    sched = get_linear_schedule_with_warmup(opt, int(total_steps * args.warmup_ratio), total_steps)

    log = []
    step = 0
    best_harmful = 999.0
    best_epoch = -1
    best_res = None

    print(f"Starting training: {args.model} | {len(ds)} train rows | {args.epochs} epochs | total_steps={total_steps}")
    for ep in range(args.epochs):
        model.train()
        tot, ntok = 0.0, 0
        for ids, mask, lab in dl:
            ids, mask, lab = ids.to(args.device), mask.to(args.device), lab.to(args.device)
            out = model(input_ids=ids, attention_mask=mask, labels=lab)
            out.loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
            opt.step()
            sched.step()
            opt.zero_grad(set_to_none=True)
            k = int((lab != -100).sum())
            tot += float(out.loss.detach()) * k
            ntok += k
            step += 1
            if args.max_steps is not None and step >= args.max_steps:
                break

        train_loss = round(tot / max(ntok, 1), 5)
        rec = {
            "epoch": ep + 1, "train_loss": train_loss,
            "lr": sched.get_last_lr()[0], "elapsed_s": round(time.time() - t0, 1), "step": step
        }

        # Validation evaluation at every epoch
        if val_rows:
            v_res = evaluate_val(val_rows, tok, model, args.device, args.max_len)
            best_at_ep = v_res["best"]
            rec["val_em"] = best_at_ep["exact_match"]
            rec["val_overdel"] = best_at_ep["over_deletion_rate"]
            rec["val_harmful"] = best_at_ep["harmful_span_rate"]
            rec["val_f1"] = best_at_ep.get("span_word", {}).get("f1", 0.0)
            rec["val_thr"] = best_at_ep["threshold"]

            # Gate 2 selection: over_del < 1.0% AND minimal harmful_span_rate
            is_better = False
            if best_at_ep["over_deletion_rate"] <= 1.0:
                if best_at_ep["harmful_span_rate"] < best_harmful:
                    is_better = True
                elif best_at_ep["harmful_span_rate"] == best_harmful and best_at_ep["exact_match"] > (best_res["exact_match"] if best_res else 0):
                    is_better = True

            if is_better:
                best_harmful = best_at_ep["harmful_span_rate"]
                best_epoch = ep + 1
                best_res = best_at_ep
                save_checkpoint(args.out, model, tok, is_lfm=is_lfm)
                with open(os.path.join(args.out, "best_val_eval.json"), "w") as f:
                    json.dump({"epoch": best_epoch, "eval": v_res}, f, indent=2)
                rec["is_best"] = True

        log.append(rec)
        print(json.dumps(rec), flush=True)
        if args.max_steps is not None and step >= args.max_steps:
            print("Reached max_steps; stopping training early.")
            break

    # If no validation set was provided, save the final model
    if not val_rows or best_epoch == -1:
        save_checkpoint(args.out, model, tok, is_lfm=is_lfm)

    meta = {
        "base_model": args.model, "labels": LABELS, "seed": args.seed, "epochs": args.epochs,
        "batch_size": args.batch_size, "lr_encoder": args.lr_encoder, "lr_head": args.lr_head,
        "weight_decay": args.weight_decay, "warmup_ratio": args.warmup_ratio, "max_len": args.max_len,
        "dtype": args.dtype, "train_file": args.train, "n_train": len(ds),
        "best_epoch": best_epoch, "best_eval": best_res,
        "train_log": log, "wall_s": round(time.time() - t0, 1),
    }
    with open(os.path.join(args.out, "train_meta.json"), "w") as f:
        json.dump(meta, f, indent=2)
    print("FINISHED", args.out, f"Best Epoch: {best_epoch} (Harmful: {best_harmful}%)", flush=True)


if __name__ == "__main__":
    main()