Loss feed from trainer stdout (sqlite UILogger stays empty); accurate step timing from tqdm elapsed

run_ai_toolkit.py

@@ -11,11 +11,15 @@ Runs inside the job container:
      with the transparency sentence appended (won the caption A/B)
   3. write the training YAML (qwen_image_2 arch, rgba: true, rank 32)
   4. launch `python run.py <yaml>`, teeing stdout to /work/train_stdout.log
-  5. side thread polls the trainer's SQLite loss_log.db and pushes loss/lr
-     to Trackio
+  5. side thread parses the tqdm loss lines from that stdout and pushes
+     loss -> Trackio. (ai-toolkit's UI logger writes loss_log.db but leaves
+     the metrics table empty until process exit, so stdout is the source.)
   6. on success, upload every saved .safetensors PLUS train_stdout.log and a
-     dump of the loss SQLite (loss_log.jsonl) to the Hub repo — the job log
-     API truncates its middle, so the loss curve must live on the Hub.
+     loss dump (loss_log.jsonl) to the Hub repo — the job log API truncates
+     its middle, so the loss curve must live on the Hub.
+
+Timing note: wall clock around run.py includes model load + latent caching,
+so the real s/step is taken from the tqdm elapsed clock, not from t0.
 
 Usage:
   python run_ai_toolkit.py --steps 50 --resolution 768 \
@@ -27,6 +31,7 @@ import argparse
 import glob
 import json
 import os
+import re
 import sqlite3
 import subprocess
 import sys
@@ -40,6 +45,8 @@ WORK = Path("/work")
 LORA_REPO = "ysharma/orbit-alpha-lora"
 PROJECT = "qwen21-rgba-orbit-lora"
 
+TQDM_RE = re.compile(r"(\d+)/(\d+) \[(\d+):(\d+)<[^\]]*?loss: ([0-9.eE+-]+)")
+
 YAML_TEMPLATE = """\
 job: extension
 config:
@@ -139,63 +146,63 @@ def materialize():
         print(f"{sub}: {n} files")
 
 
+def parse_tqdm(text):
+    """[(step, total, elapsed_s, loss), ...] from tqdm lines, last wins."""
+    out = {}
+    for m in TQDM_RE.finditer(text):
+        step, total, mm, ss, loss = m.groups()
+        out[int(step)] = (int(step), int(total), int(mm) * 60 + int(ss),
+                          float(loss))
+    return out
+
+
 def tail_loss_to_trackio(space_id, stop_event, state):
-    """Poll loss_log.db (schema-agnostic) and push metrics to Trackio."""
+    """Tail the trainer's stdout log and push per-step loss to Trackio."""
     import trackio
     trackio.init(project=PROJECT, space_id=space_id)
-    db = None
-    last_step = -1
+    logged = set()
     while not stop_event.is_set():
-        if db is None:
-            hits = glob.glob("/work/output/**/loss_log.db", recursive=True)
-            if hits:
-                db = hits[0]
-                print(f"[tail] polling {db}", flush=True)
-        if db is not None:
-            try:
-                conn = sqlite3.connect(f"file:{db}?mode=ro", uri=True, timeout=10)
-                try:
-                    cols = [r[1] for r in conn.execute(
-                        "PRAGMA table_info(metrics)").fetchall()]
-                    if cols:
-                        vcol = ("value" if "value" in cols
-                                else "value_text" if "value_text" in cols
-                                else cols[-1])
-                        rows = conn.execute(
-                            f"SELECT step, key, CAST({vcol} AS REAL) FROM metrics "
-                            "WHERE step > ? ORDER BY step", (last_step,)).fetchall()
-                        logs = {}
-                        for step, key, val in rows:
-                            try:
-                                val = float(val)
-                            except (TypeError, ValueError):
-                                continue
-                            logs[key] = val  # keep the latest value per key
-                            last_step = max(last_step, step)
-                        if logs:
-                            trackio.log(logs, step=last_step)
-                            state["last_step"] = last_step
-                            state["last_loss"] = logs.get("loss")
-                finally:
-                    conn.close()
-            except sqlite3.Error as e:
-                print(f"[tail] sqlite read skipped: {e}", flush=True)
+        try:
+            text = Path("/work/train_stdout.log").read_text(errors="ignore")
+            found = parse_tqdm(text)
+            for step in sorted(found):
+                if step in logged:
+                    continue
+                _, _, _, loss = found[step]
+                trackio.log({"loss": loss}, step=step)
+                logged.add(step)
+                state["last_step"] = step
+                state["last_loss"] = loss
+        except Exception as e:
+            print(f"[tail] {type(e).__name__}: {e}", flush=True)
         time.sleep(10)
     trackio.finish()
 
 
+def dump_loss_stdout():
+    """Dump the parsed tqdm loss curve to JSONL (the reliable source)."""
+    text = Path("/work/train_stdout.log").read_text(errors="ignore")
+    found = parse_tqdm(text)
+    out = Path("/work/loss_log.jsonl")
+    with open(out, "w") as f:
+        for step in sorted(found):
+            _, total, elapsed, loss = found[step]
+            f.write(json.dumps({"step": step, "loss": loss,
+                                "elapsed_s": elapsed}) + "\n")
+    print(f"[dump] {len(found)} loss rows -> {out}", flush=True)
+    return out
+
+
 def dump_loss_db():
-    """Dump the metrics table of loss_log.db to JSONL (best-effort)."""
+    """Dump the metrics table of loss_log.db to JSONL (best-effort backup)."""
     hits = glob.glob("/work/output/**/loss_log.db", recursive=True)
     if not hits:
-        print("[dump] no loss_log.db found", flush=True)
         return None
-    out = Path("/work/loss_log.jsonl")
+    out = Path("/work/loss_db.jsonl")
     n = 0
     with open(out, "w") as f, sqlite3.connect(f"file:{hits[0]}?mode=ro", uri=True) as conn:
         cols = [r[1] for r in conn.execute("PRAGMA table_info(metrics)").fetchall()]
         if not cols:
-            print("[dump] metrics table missing", flush=True)
             return None
         vcol = ("value" if "value" in cols
                 else "value_text" if "value_text" in cols else cols[-1])
@@ -207,7 +214,7 @@ def dump_loss_db():
                 continue
             f.write(json.dumps({"step": step, "key": key, "value": val}) + "\n")
             n += 1
-    print(f"[dump] {n} metric rows -> {out}", flush=True)
+    print(f"[dump] {n} sqlite metric rows -> {out}", flush=True)
     return out
 
 
@@ -266,14 +273,24 @@ def main():
     t = threading.Thread(target=tail_loss_to_trackio,
                          args=(args.trackio_space, stop, state), daemon=True)
     t.start()
-    t0 = time.time()
+    wall0 = time.time()
     with open("/work/train_stdout.log", "w") as tee:
         proc = subprocess.run([sys.executable, "run.py", str(yaml_path)],
                               cwd=str(aitk), stdout=tee,
                               stderr=subprocess.STDOUT)
-    train_s = time.time() - t0
+    wall_s = time.time() - wall0
     stop.set(); t.join(timeout=30)
-    loss_dump = dump_loss_db()
+
+    # real step timing comes from the tqdm elapsed clock
+    text = Path("/work/train_stdout.log").read_text(errors="ignore")
+    found = parse_tqdm(text)
+    train_s, s_per_step = None, None
+    if found:
+        last = found[max(found)]
+        train_s, s_per_step = float(last[2]), last[2] / last[0]
+    loss_dump = dump_loss_stdout()
+    db_dump = dump_loss_db()
+
     if proc.returncode != 0:
         tail = open("/work/train_stdout.log").read()[-4000:]
         print("TRAIN FAILED\n" + tail, flush=True)
@@ -286,11 +303,13 @@ def main():
         raise SystemExit(proc.returncode)
 
     # 6. ship it
-    print(f"DONE train_seconds={train_s:.1f} s_per_step={train_s / args.steps:.3f} "
-          f"last_step={state['last_step']} last_loss={state['last_loss']}", flush=True)
+    print(f"DONE wall_seconds={wall_s:.1f} train_seconds={train_s} "
+          f"s_per_step={s_per_step} last_step={state['last_step']} "
+          f"last_loss={state['last_loss']}", flush=True)
     upload_artifacts(run_name, extra_files=[
         ("/work/train_stdout.log", "train_stdout.log"),
         (loss_dump, "loss_log.jsonl"),
+        (db_dump, "loss_db.jsonl"),
     ])
     print("UPLOADED OK", flush=True)