"""Discrepancy-aware self-play after SFT (SP-DocReader, arXiv 2610.11148). Each round: 1. The current model (the "opponent", frozen for the round) reads every training image greedily. 2. Reading Discrepancy Masking: a longest common subsequence over model tokens aligns the reading with the ground truth; the unmatched positions in each sequence are the ones still wrong. 3. The model is trained on those positions only, with their full original prefixes: Reading Discrepancy Loss softplus(beta * (delta(reading) - delta(truth))) delta(z) = sum of log p over z's unmatched tokens, minus the opponent's Focused Fidelity Loss lambda * NLL of the unmatched ground-truth tokens Pages the model already reads perfectly contribute nothing, so compute goes to the residual errors. The paper reports SFT + 3 rounds on 30k pages beating plain SFT on 120k pages (Qwen3-VL-4B). Paper settings: lambda 0.5, greedy readings, 1,024 new tokens, 3 rounds; beta is not stated (0.1 is SPIN's). python -m common.selfplay --model data/models/OvisOCR3 --adapter data/runs/ovisocr3-lora-r16 \ --train data/prepared/canonical/train.jsonl --output data/runs/ovisocr3-selfplay --rounds 3 Differences from the paper: the paper trains only a separate OCR-encoder module of DocVLM; here a LoRA adapter on the language model is trained, which works for any model in this toolkit. """ import argparse import math import random import time from pathlib import Path import torch from .vlm_utils import Codec, answer_logprobs, generate, load_policy, read_jsonl, write_jsonl, resolve_prompt def lcs_unmatched(ref, hyp): """Unmatched positions in ref and hyp after one longest-common-subsequence alignment. Walks from the start using suffix LCS lengths: equal tokens match; otherwise advance the index that keeps the longer suffix LCS, advancing the hypothesis index on ties (as in the paper). """ n, m = len(ref), len(hyp) suf = [[0] * (m + 1) for _ in range(n + 1)] for i in range(n - 1, -1, -1): row, nxt, ri = suf[i], suf[i + 1], ref[i] for j in range(m - 1, -1, -1): row[j] = nxt[j + 1] + 1 if ri == hyp[j] else max(nxt[j], row[j + 1]) i = j = 0 um_ref, um_hyp = [], [] while i < n and j < m: if ref[i] == hyp[j]: i += 1 j += 1 elif suf[i + 1][j] > suf[i][j + 1]: um_ref.append(i) i += 1 else: um_hyp.append(j) j += 1 um_ref += range(i, n) um_hyp += range(j, m) return um_ref, um_hyp @torch.no_grad() def collect(model, codec, rows, max_new, device): """Opponent readings, unmatched positions and the opponent's scores at those positions.""" model.eval() recs, perfect = [], 0 for r in rows: enc = codec.prompt_inputs(r, device) y = codec.answer_ids(r["text"]) yhat = generate(model, enc, max_new, codec.end_id)[0] ey, eh = lcs_unmatched(y, yhat) if not ey and not eh: perfect += 1 continue recs.append({"row": r, "y": y, "yhat": yhat, "ey": ey, "eh": eh, "s_y": float(answer_logprobs(model, enc, y, ey).sum()), "s_h": float(answer_logprobs(model, enc, yhat, eh).sum()) if eh else 0.0}) return recs, perfect def train_round(model, codec, recs, n_total, args, device): model.train() opt = torch.optim.AdamW([p for p in model.parameters() if p.requires_grad], lr=args.lr, weight_decay=0.0) steps = max(1, math.ceil(len(recs) / args.grad_accum)) sched = torch.optim.lr_scheduler.LambdaLR( opt, lambda s: min(1.0, (s + 1) / max(1, int(0.1 * steps))) * 0.5 * (1 + math.cos(math.pi * min(s, steps) / steps))) random.shuffle(recs) # Batch averaging uses every page, perfect ones included (they add no gradient), as in the paper. scale = len(recs) / max(1, n_total) log = [] for k, rec in enumerate(recs): enc = codec.prompt_inputs(rec["row"], device) s_y = answer_logprobs(model, enc, rec["y"], rec["ey"]).sum() s_h = answer_logprobs(model, enc, rec["yhat"], rec["eh"]).sum() if rec["eh"] else s_y.new_zeros(()) d_y, d_h = s_y - rec["s_y"], s_h - rec["s_h"] rdm = torch.nn.functional.softplus(args.beta * (d_h - d_y)) ffl = -s_y loss = (rdm + args.lam * ffl) * scale / args.grad_accum loss.backward() log.append((float(rdm), float(ffl))) if (k + 1) % args.grad_accum == 0 or k + 1 == len(recs): torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) opt.step() sched.step() opt.zero_grad(set_to_none=True) return log def main(argv=None): ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("--model", required=True) ap.add_argument("--adapter", help="SFT LoRA adapter to start from (recommended); otherwise a new LoRA") ap.add_argument("--lora", type=int, default=16) ap.add_argument("--train", required=True, help="canonical JSONL") ap.add_argument("--output", required=True) ap.add_argument("--limit", type=int, default=0) ap.add_argument("--rounds", type=int, default=3) ap.add_argument("--beta", type=float, default=0.1) ap.add_argument("--lam", type=float, default=0.5, help="Focused Fidelity Loss weight") ap.add_argument("--lr", type=float, default=5e-5) ap.add_argument("--grad-accum", type=int, default=4) ap.add_argument("--max-new", type=int, default=1024) ap.add_argument("--prompt", help="prompt for page records (default: the page prompt from data_prep); lines keep the line prompt") ap.add_argument("--prompt-file", help="read the page prompt from a file (e.g. a model's prompts/*.txt)") ap.add_argument("--max-pixels", type=int, default=1280 * 1280) ap.add_argument("--dtype", choices=["auto", "bf16", "fp16", "fp32"], default="auto") ap.add_argument("--gradient-checkpointing", action="store_true") ap.add_argument("--seed", type=int, default=0) a = ap.parse_args(argv) a.prompt = resolve_prompt(a.prompt, a.prompt_file) random.seed(a.seed) torch.manual_seed(a.seed) model, processor, dtype = load_policy(a.model, a.adapter, a.lora, a.dtype, a.gradient_checkpointing) device = next(model.parameters()).device codec = Codec(processor, a.prompt, a.max_pixels) rows = read_jsonl(a.train, a.limit) out = Path(a.output) history = [] for t in range(a.rounds): t0 = time.time() recs, perfect = collect(model, codec, rows, a.max_new, device) unmatched = sum(len(r["ey"]) for r in recs) print(f"round {t + 1}: {perfect}/{len(rows)} read perfectly, {unmatched} unmatched truth tokens", flush=True) if not recs: print("nothing left to correct; stopping") break log = train_round(model, codec, recs, len(rows), a, device) rdm = sum(x for x, _ in log) / len(log) ffl = sum(y for _, y in log) / len(log) history.append({"round": t + 1, "perfect": perfect, "pages": len(rows), "unmatched_truth_tokens": unmatched, "rdm_loss": rdm, "ffl_loss": ffl, "sec": round(time.time() - t0, 1)}) print(history[-1], flush=True) model.save_pretrained(out / f"round{t + 1}") processor.save_pretrained(out / f"round{t + 1}") write_jsonl(out / "history.jsonl", history) if torch.cuda.is_available(): print(f"peak GPU memory: {torch.cuda.max_memory_allocated() / 1e9:.2f} GB") if __name__ == "__main__": main()