Download code/common/train_monitor.py from aziz9788/OvisOCR3-Arabic-workdir: direct link, hf CLI and curl.
- Browser
- Download file 7.28 kB
-
https://huggingface.co/datasets/aziz9788/OvisOCR3-Arabic-workdir/resolve/main/code/common/train_monitor.py
- Command line
-
hf download hf://datasets/aziz9788/OvisOCR3-Arabic-workdir/code/common/train_monitor.py
-
curl -L -o train_monitor.py https://huggingface.co/datasets/aziz9788/OvisOCR3-Arabic-workdir/resolve/main/code/common/train_monitor.py
7.28 kB
| """Read a training run's telemetry and show trends, per-language / per-source breakdowns and alerts. | |
| Reads <run>/metrics.jsonl (per sample, from common.vlm_sft), steps.jsonl (optimizer steps: grad norm, lr), | |
| probes.jsonl (held-out pages read with generation during training) and data_report.json. | |
| python -m common.train_monitor data/runs/x/adapter # tables + alerts | |
| python -m common.train_monitor data/runs/x/adapter --plot # also curves.png (needs matplotlib) | |
| Alerts (each one is a real signal, not a guess): | |
| forgetting share of tokens the start model got right that the model now gets wrong ('broken') > 2%, | |
| or 3x its first-window value | |
| drift KL to the start model rising for 3 windows in a row, or above 0.05 | |
| collapse prediction entropy down by more than half from the first window | |
| instability a gradient norm above 5x the median | |
| probe a held-out page read worse than at step 0 (CER +0.01), a loop, or the token limit hit | |
| """ | |
| import argparse | |
| import json | |
| import statistics as st | |
| from collections import defaultdict | |
| from pathlib import Path | |
| def read(p): | |
| p = Path(p) | |
| return [json.loads(l) for l in open(p, encoding="utf-8") if l.strip()] if p.exists() else [] | |
| def mean(rows, k): | |
| v = [r[k] for r in rows if isinstance(r.get(k), (int, float))] | |
| return sum(v) / len(v) if v else float("nan") | |
| COLS = [("loss", "{:.3f}"), ("ce", "{:.3f}"), ("kl", "{:.4f}"), ("acc", "{:.3f}"), ("ref_acc", "{:.3f}"), | |
| ("focus_share", "{:.1%}"), ("fixed", "{:.1%}"), ("broken", "{:.2%}"), ("entropy", "{:.3f}"), ("sec", "{:.2f}")] | |
| def fmt(rows): | |
| out = [] | |
| for k, f in COLS: | |
| m = mean(rows, k) | |
| out.append("-" if m != m else f.format(m)) | |
| return out | |
| def table(title, groups): | |
| print(f"\n== {title}") | |
| print(f"{'':22s}" + "".join(f"{k:>13s}" for k, _ in COLS) + f"{'n':>6s}") | |
| for name, rows in groups: | |
| print(f"{name:22s}" + "".join(f"{v:>13s}" for v in fmt(rows)) + f"{len(rows):>6d}") | |
| def windows(rows, n): | |
| return [rows[i:i + n] for i in range(0, len(rows), n) if rows[i:i + n]] | |
| def alerts(rows, steps, probes, win): | |
| out = [] | |
| ws = windows(rows, win) | |
| if len(ws) >= 2 and any("broken" in r for r in rows): | |
| b0, b = mean(ws[0], "broken"), mean(ws[-1], "broken") | |
| if b > 0.02 or (b0 > 0 and b > 3 * b0 and b > 0.005): | |
| out.append(f"forgetting: broken {b:.2%} in the last window (first window {b0:.2%})") | |
| kls = [mean(w, "kl") for w in ws] | |
| if kls[-1] > 0.05 or (len(kls) >= 4 and kls[-4] < kls[-3] < kls[-2] < kls[-1]): | |
| out.append(f"drift: KL to the start model {kls[-1]:.4f} (trend {', '.join(f'{x:.4f}' for x in kls[-4:])})") | |
| if len(ws) >= 2: | |
| h0, h = mean(ws[0], "entropy"), mean(ws[-1], "entropy") | |
| if h0 == h0 and h < 0.5 * h0: | |
| out.append(f"collapse: prediction entropy {h:.3f} vs {h0:.3f} at the start") | |
| g = [s["grad_norm"] for s in steps if isinstance(s.get("grad_norm"), (int, float))] | |
| if len(g) >= 10: | |
| med = st.median(g) | |
| spikes = [s["step"] for s in steps if isinstance(s.get("grad_norm"), (int, float)) and s["grad_norm"] > 5 * med] | |
| if spikes: | |
| out.append(f"instability: gradient norm > 5x median ({med:.2f}) at steps {spikes[:10]}") | |
| by = defaultdict(dict) | |
| for p in probes: | |
| by[p["id"]][p["step"]] = p | |
| for pid, seq in by.items(): | |
| s0, last = min(seq), max(seq) | |
| a, b = seq[s0], seq[last] | |
| tag = b.get("tag") or pid[:24] | |
| if b["cer"] > a["cer"] + 0.01: | |
| out.append(f"probe {tag}: CER {a['cer']:.3f} -> {b['cer']:.3f} (step {s0} -> {last})") | |
| if b.get("loop") or b.get("hit_limit"): | |
| out.append(f"probe {tag}: loop / token limit at step {last}") | |
| return out | |
| def main(argv=None): | |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) | |
| ap.add_argument("run", help="the --output folder of common.vlm_sft") | |
| ap.add_argument("--window", type=int, default=100, help="samples per row of the trend table") | |
| ap.add_argument("--plot", action="store_true") | |
| a = ap.parse_args(argv) | |
| run = Path(a.run) | |
| rows, steps, probes = read(run / "metrics.jsonl"), read(run / "steps.jsonl"), read(run / "probes.jsonl") | |
| rep = run / "data_report.json" | |
| if rep.exists(): | |
| print("== data\n" + rep.read_text(encoding="utf-8")) | |
| if not rows: | |
| print("no metrics yet") | |
| return | |
| table(f"trend ({a.window} samples per row)", | |
| [(f"samples {i * a.window}-{i * a.window + len(w) - 1} s{w[-1]['step']}", w) | |
| for i, w in enumerate(windows(rows, a.window))]) | |
| last = rows[-max(a.window, len(rows) // 5):] | |
| table("by language (last window)", [(lg, [r for r in last if r.get("language") == lg]) | |
| for lg in sorted({r.get("language") for r in last})]) | |
| srcs = sorted({r.get("source") for r in last}) | |
| table("by source (last window)", [(str(s)[-22:], [r for r in last if r.get("source") == s]) for s in srcs]) | |
| lu = [(r["step"], r["lora_update_norm"]) for r in rows if "lora_update_norm" in r] | |
| if lu: | |
| print("\n== LoRA update norm |dW| by step: " + ", ".join(f"s{s}:{v:.4f}" for s, v in lu[-10:])) | |
| if steps: | |
| g = [s.get("grad_norm") for s in steps if isinstance(s.get("grad_norm"), (int, float))] | |
| if g: | |
| print(f"== gradient norm: median {st.median(g):.2f}, last {g[-1]:.2f}, max {max(g):.2f} " | |
| f"over {len(g)} logged steps; lr now {steps[-1].get('learning_rate', '-')}") | |
| if probes: | |
| by = defaultdict(list) | |
| for p in probes: | |
| by[p["step"]].append(p) | |
| ids = sorted({p["id"] for p in probes}) | |
| tags = {p["id"]: (p.get("tag") or p["id"][:14]) for p in probes} | |
| print("\n== probes (held-out pages read with generation): CER per page") | |
| print(f"{'step':>6s}" + "".join(f"{tags[i][:14]:>16s}" for i in ids) + f"{'mean':>9s}") | |
| for s in sorted(by): | |
| cer = {p["id"]: p for p in by[s]} | |
| cells = "".join(f"{(str(round(cer[i]['cer'], 3)) + ('L' if cer[i]['loop'] or cer[i]['hit_limit'] else '')) if i in cer else '-':>16s}" | |
| for i in ids) | |
| print(f"{s:>6d}" + cells + f"{mean(by[s], 'cer'):>9.4f}") | |
| al = alerts(rows, steps, probes, a.window) | |
| print("\n== alerts: " + ("none" if not al else "\n - " + "\n - ".join(al))) | |
| if a.plot: | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt | |
| ws = windows(rows, max(10, a.window // 4)) | |
| x = [w[-1]["sample"] for w in ws] | |
| fig, ax = plt.subplots(2, 3, figsize=(15, 8)) | |
| for axis, k in zip(ax.flat, ["loss", "ce", "kl", "fixed", "broken", "acc"]): | |
| axis.plot(x, [mean(w, k) for w in ws], label="model") | |
| if k == "acc": | |
| axis.plot(x, [mean(w, "ref_acc") for w in ws], label="start model") | |
| axis.legend() | |
| axis.set_title(k) | |
| axis.set_xlabel("samples") | |
| fig.tight_layout() | |
| fig.savefig(run / "curves.png", dpi=110) | |
| print(f"curves -> {run / 'curves.png'}") | |
| if __name__ == "__main__": | |
| main() | |