Add job-0.5b-v7.py (v7 + bench-v1, trackio crash fixed) and its local validator

job-0.5b-v7.py

@@ -0,0 +1,181 @@
+# /// script
+# dependencies = ["trl>=0.12.0", "peft>=0.7.0", "transformers>=4.44", "datasets", "accelerate"]
+# ///
+"""SakThai 0.5B config-upgrade fine-tune on combined-v7, scored on sakthai-bench-v1.
+
+Changes vs the 2026-07-29 run that died at step 60/252:
+  * report_to="none" — trackio's config->parquet export cannot serialise PEFT's
+    empty `rank_pattern` struct and killed that run at the first checkpoint push
+    (pyarrow ArrowNotImplementedError). No logger is worth losing a 2h run.
+  * save_strategy="no" + a single push after training — no mid-run hub pushes,
+    so an upload hiccup can never destroy a nearly-finished run.
+  * trains on combined-v7 minus every row reserved by sakthai-bench-v1 and every
+    row that so much as *offers* a held-out tool.
+  * eval reads the balanced bench (simple / parallel / irrelevance_tools /
+    irrelevance_no_tools) and reports the unseen-tool slice separately.
+"""
+import re, json, gc, hashlib, collections, urllib.request
+import torch
+from datasets import load_dataset, concatenate_datasets
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import LoraConfig, get_peft_model, PeftModel
+from trl import SFTTrainer, SFTConfig
+
+USER, BASE_MODEL = "Nanthasit", "Qwen/Qwen2.5-0.5B-Instruct"
+OLD_MERGED   = f"{USER}/sakthai-context-0.5b-merged"
+ADAPTER_REPO = f"{USER}/sakthai-context-0.5b-tools-v2"
+MERGED_REPO  = f"{USER}/sakthai-context-0.5b-merged-v2"
+DATASET      = f"{USER}/sakthai-combined-v7"
+BENCH        = f"{USER}/sakthai-bench-v1"
+EXCLUDE_URL  = f"https://huggingface.co/datasets/{BENCH}/resolve/main/train_exclude_fingerprints.json"
+MAX_LEN = 1536
+
+tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+# ── Manual ChatML renderer. Qwen's built-in template cannot render this data:
+#    content=None on tool turns, arguments as a JSON string, tool results
+#    sometimes lists. Validated locally on real rows before every run. ──────
+def _text(c):
+    return "" if c is None else (c if isinstance(c, str) else json.dumps(c, ensure_ascii=False))
+def _tools_block(tools):
+    if not tools: return ""
+    sigs = "\n".join(json.dumps(t, ensure_ascii=False) for t in tools)
+    return ("\n\n# Tools\n\nYou may call one or more functions. Signatures are within "
+            "<tools></tools>:\n<tools>\n" + sigs + "\n</tools>\n\nFor each call return:\n"
+            "<tool_call>\n{\"name\": <name>, \"arguments\": <json>}\n</tool_call>")
+def _assistant_body(m):
+    body = _text(m.get("content"))
+    for tc in (m.get("tool_calls") or []):
+        fn = tc.get("function", tc); a = fn.get("arguments", "{}")
+        if not isinstance(a, str): a = json.dumps(a, ensure_ascii=False)
+        body += ("\n" if body else "") + '<tool_call>\n{"name": "%s", "arguments": %s}\n</tool_call>' % (fn.get("name", ""), a)
+    return body
+def _render_msg(m, tools_sys):
+    r = m.get("role")
+    if r == "system": return "<|im_start|>system\n" + _text(m.get("content")) + _tools_block(tools_sys) + "<|im_end|>\n"
+    if r == "user":   return "<|im_start|>user\n" + _text(m.get("content")) + "<|im_end|>\n"
+    if r == "tool":   return "<|im_start|>user\n<tool_response>\n" + _text(m.get("content")) + "\n</tool_response><|im_end|>\n"
+    if r == "assistant": return "<|im_start|>assistant\n" + _assistant_body(m) + "<|im_end|>\n"
+    return ""
+def render_chatml(messages, tools, add_generation_prompt=False):
+    messages = messages or []
+    out = []
+    if not (messages and messages[0].get("role") == "system") and tools:
+        out.append("<|im_start|>system\nYou are a helpful assistant." + _tools_block(tools) + "<|im_end|>\n")
+    for i, m in enumerate(messages):
+        out.append(_render_msg(m, tools if (i == 0 and m.get("role") == "system") else None))
+    if add_generation_prompt: out.append("<|im_start|>assistant\n")
+    return "".join(out)
+
+def fingerprint(messages):
+    return hashlib.sha1(json.dumps(messages, sort_keys=True, ensure_ascii=False).encode()).hexdigest()
+
+# ── Data: v7 minus everything the benchmark reserves ─────────────────────
+with urllib.request.urlopen(EXCLUDE_URL) as r:
+    _ex = json.load(r)
+EXCLUDE = set(_ex["fingerprints"])
+HELD_OUT_TOOLS = set(_ex["held_out_tools"])
+print(f"bench reserves {len(EXCLUDE)} rows; held-out tools: {sorted(HELD_OUT_TOOLS)}")
+
+def _keep(ex):
+    if fingerprint(ex["messages"]) in EXCLUDE:
+        return False
+    names = {(t.get("function") or {}).get("name") or t.get("name") for t in (ex.get("tools") or [])}
+    return not (names & HELD_OUT_TOOLS)
+
+def to_text(ex): return {"text": render_chatml(ex["messages"], ex.get("tools") or None)}
+
+main = load_dataset(DATASET, split="train")
+print("v7 train rows:", len(main))
+main = main.filter(_keep)
+print("after bench exclusion:", len(main))
+train_ds = main.map(to_text, remove_columns=main.column_names)
+try:
+    supp = load_dataset(f"{USER}/sakthai-irrelevance-supplement", split="train").filter(_keep)
+    train_ds = concatenate_datasets([train_ds, supp.map(to_text, remove_columns=supp.column_names)])
+except Exception as e:
+    print("supplement skipped:", e)
+train_ds = train_ds.filter(lambda e: bool(e["text"]) and len(e["text"]) > 20)
+# Drop over-length rows rather than truncate them: a row cut at MAX_LEN can end
+# mid-<tool_call>, which teaches the model to emit unterminated calls (~4% of v7).
+_before = len(train_ds)
+train_ds = train_ds.filter(lambda e: len(tokenizer(e["text"]).input_ids) <= MAX_LEN)
+print(f"dropped {_before - len(train_ds)} rows longer than {MAX_LEN} tokens")
+print("train examples:", len(train_ds))
+
+# ── Train FIRST, push ONCE ───────────────────────────────────────────────
+model = AutoModelForCausalLM.from_pretrained(BASE_MODEL, torch_dtype=torch.bfloat16, device_map="cuda")
+model.config.use_cache = False
+model = get_peft_model(model, LoraConfig(
+    r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM", use_rslora=True,
+    target_modules=["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"]))
+model.print_trainable_parameters()
+args = SFTConfig(output_dir="out-0.5b-v2", num_train_epochs=2, per_device_train_batch_size=8,
+                 gradient_accumulation_steps=2, learning_rate=2e-4,
+                 lr_scheduler_type="cosine", warmup_ratio=0.03, logging_steps=10,
+                 save_strategy="no", bf16=True, max_length=MAX_LEN, packing=False,
+                 dataset_text_field="text", push_to_hub=False, report_to="none",
+                 run_name="sakthai-0.5b-v2-mlp-rslora-v7")
+trainer = SFTTrainer(model=model, args=args, train_dataset=train_ds, processing_class=tokenizer)
+trainer.train()
+
+trainer.model.push_to_hub(ADAPTER_REPO); tokenizer.push_to_hub(ADAPTER_REPO)
+print(f"pushed adapter -> {ADAPTER_REPO}")
+del trainer, model; gc.collect(); torch.cuda.empty_cache()
+
+base = AutoModelForCausalLM.from_pretrained(BASE_MODEL, torch_dtype=torch.bfloat16, device_map="cuda")
+merged = PeftModel.from_pretrained(base, ADAPTER_REPO).merge_and_unload()
+merged.push_to_hub(MERGED_REPO); tokenizer.push_to_hub(MERGED_REPO)
+del base, merged; gc.collect(); torch.cuda.empty_cache()
+print(f"Trained + pushed: {ADAPTER_REPO} and {MERGED_REPO}")
+
+# ── Eval on the balanced bench (non-fatal) ───────────────────────────────
+_TC = re.compile(r"<tool_call>\s*(\{.*?\})\s*</tool_call>", re.DOTALL)
+TEST = load_dataset(BENCH, split="test")
+CATS = ("simple", "parallel", "irrelevance_tools", "irrelevance_no_tools")
+
+def _pred(t):
+    o = []
+    for mm in _TC.findall(t):
+        try: o.append(json.loads(mm).get("name"))
+        except Exception: pass
+    return [n for n in o if n]
+
+def eval_repo(repo_id, label):
+    m = AutoModelForCausalLM.from_pretrained(repo_id, torch_dtype=torch.bfloat16, device_map="cuda"); m.eval()
+    b = collections.defaultdict(lambda: [0, 0]); ho = [0, 0]
+    for ex in TEST:
+        msgs, tools, cat = ex["messages"], (ex.get("tools") or None), ex["category"]
+        idx = next((i for i, mm in enumerate(msgs) if mm.get("role") == "assistant"), None)
+        if idx is None: continue
+        gold = ex["gold_tools"]
+        prompt = render_chatml(msgs[:idx], tools, add_generation_prompt=True)
+        ids = tokenizer(prompt, return_tensors="pt", add_special_tokens=False).input_ids.to(m.device)
+        with torch.no_grad():
+            out = m.generate(ids, max_new_tokens=200, do_sample=False, pad_token_id=tokenizer.eos_token_id)
+        pred = _pred(tokenizer.decode(out[0][ids.shape[1]:], skip_special_tokens=True))
+        if cat.startswith("irrelevance"):
+            ok = len(pred) == 0
+        elif cat == "simple":
+            ok = bool(gold) and gold[0] in pred
+        else:
+            ok = set(gold).issubset(set(pred))
+        b[cat][0] += int(ok); b[cat][1] += 1
+        if ex.get("held_out_tool"):
+            ho[0] += int(ok); ho[1] += 1
+    print(f"\n=== sakthai-bench-v1: {label} ({repo_id}) ===")
+    print(f"{'category':<22}{'pass':>5}{'total':>6}{'acc':>8}")
+    tc = tt = 0
+    for c in CATS:
+        p, t = b[c]; tc += p; tt += t
+        print(f"{c:<22}{p:>5}{t:>6}{(f'{100*p/t:5.1f}%' if t else '  n/a'):>8}")
+    print(f"{'OVERALL':<22}{tc:>5}{tt:>6}{(f'{100*tc/tt:5.1f}%' if tt else '  n/a'):>8}")
+    print(f"{'(held-out tools)':<22}{ho[0]:>5}{ho[1]:>6}{(f'{100*ho[0]/ho[1]:5.1f}%' if ho[1] else '  n/a'):>8}")
+    del m; gc.collect(); torch.cuda.empty_cache()
+
+for repo, lbl in [(OLD_MERGED, "BEFORE"), (MERGED_REPO, "AFTER")]:
+    try: eval_repo(repo, lbl)
+    except Exception as e: print(f"[eval skipped for {repo}] {type(e).__name__}: {e}")
+print("\nDone. Compare BEFORE / AFTER above.")

validate.py

@@ -0,0 +1,109 @@
+"""Validate every non-GPU part of the job script against real rows, locally.
+
+The meta-lesson from the earlier fast-fails: anything that isn't the GPU itself
+gets proven here first. Checks:
+  1. renderer runs on every v7 + bench row without raising, and emits sane ChatML
+  2. the bench-exclusion filter reproduces the builder's arithmetic
+  3. the eval scorer is an oracle-pass: gold output must score 100% in every
+     category, otherwise the metric is broken before the model ever runs
+  4. token-length distribution vs MAX_LEN (silent truncation check)
+"""
+import json, re, sys, collections, importlib.util, pathlib
+
+# Lift the pure functions out of the job script verbatim — no torch, no training
+# body — so what is validated here is exactly the code that will run on the GPU.
+src = pathlib.Path("job-0.5b-v7.py").read_text()
+start = src.index("def _text(c):")
+end = src.index("# ── Data: v7 minus")
+ns = {"json": json, "hashlib": __import__("hashlib")}
+exec(compile(src[start:end], "job-pure", "exec"), ns)
+render_chatml = ns["render_chatml"]
+fingerprint = ns["fingerprint"]
+_TC = re.compile(r"<tool_call>\s*(\{.*?\})\s*</tool_call>", re.DOTALL)
+
+def _pred(t):
+    o = []
+    for mm in _TC.findall(t):
+        try: o.append(json.loads(mm).get("name"))
+        except Exception: pass
+    return [n for n in o if n]
+
+def load(p):
+    return [json.loads(l) for l in open(p) if l.strip()]
+
+train = load("v7/data/train.jsonl")
+bench = load("bench/test.jsonl")
+excl = json.load(open("bench/train_exclude_fingerprints.json"))
+EXCLUDE, HELD = set(excl["fingerprints"]), set(excl["held_out_tools"])
+fail = 0
+
+# ── 1. renderer ──────────────────────────────────────────────────────────
+bad, empty = 0, 0
+lens = []
+for ds, name in ((train, "v7 train"), (bench, "bench")):
+    for i, ex in enumerate(ds):
+        try:
+            t = render_chatml(ex["messages"], ex.get("tools") or None)
+        except Exception as e:
+            bad += 1
+            if bad <= 3: print(f"  RENDER FAIL {name}[{i}]: {type(e).__name__}: {e}")
+            continue
+        if not t or len(t) < 20:
+            empty += 1
+        lens.append(len(t))
+        if "<|im_start|>" not in t or "<|im_end|>" not in t:
+            bad += 1
+print(f"1. renderer: {len(lens)} rows rendered, {bad} failures, {empty} suspiciously short")
+fail += bad + empty
+
+# ── 2. exclusion filter reproduces the builder ───────────────────────────
+def keep(ex):
+    if fingerprint(ex["messages"]) in EXCLUDE:
+        return False
+    names = {(t.get("function") or {}).get("name") or t.get("name") for t in (ex.get("tools") or [])}
+    return not (names & HELD)
+
+kept = [ex for ex in train if keep(ex)]
+bench_fps = {r["fingerprint"] for r in bench}
+leaked = sum(1 for ex in kept if fingerprint(ex["messages"]) in bench_fps)
+tool_leak = sum(1 for ex in kept
+                if {(t.get("function") or {}).get("name") or t.get("name")
+                    for t in (ex.get("tools") or [])} & HELD)
+print(f"2. filter: {len(train)} -> {len(kept)} kept; bench rows leaked into train: {leaked}; "
+      f"held-out tool schemas visible: {tool_leak}")
+fail += leaked + tool_leak
+
+# ── 3. oracle pass on the eval scorer ────────────────────────────────────
+buckets = collections.defaultdict(lambda: [0, 0])
+for ex in bench:
+    msgs, cat, gold = ex["messages"], ex["category"], ex["gold_tools"]
+    idx = next((i for i, m in enumerate(msgs) if m.get("role") == "assistant"), None)
+    if idx is None:
+        continue
+    # the oracle emits exactly what the reference assistant turn contains
+    body = ns["_assistant_body"](msgs[idx])
+    pred = _pred(body)
+    if cat.startswith("irrelevance"):
+        ok = len(pred) == 0
+    elif cat == "simple":
+        ok = bool(gold) and gold[0] in pred
+    else:
+        ok = set(gold).issubset(set(pred))
+    buckets[cat][0] += int(ok); buckets[cat][1] += 1
+print("3. oracle scorer (gold output must score 100%):")
+for c in ("simple", "parallel", "irrelevance_tools", "irrelevance_no_tools"):
+    p, t = buckets[c]
+    flag = "" if p == t else "   <-- BROKEN"
+    print(f"     {c:<22}{p:>4}/{t:<4} {100*p/t if t else 0:5.1f}%{flag}")
+    fail += (t - p)
+
+# ── 4. truncation ────────────────────────────────────────────────────────
+# rough char->token ratio for Qwen on this data is ~3.4 chars/token
+approx = sorted(l / 3.4 for l in lens)
+over = sum(1 for a in approx if a > 1536)
+p50, p95, p99 = (approx[int(len(approx) * q)] for q in (0.5, 0.95, 0.99))
+print(f"4. length: ~p50={p50:.0f} p95={p95:.0f} p99={p99:.0f} tokens; "
+      f"{over} rows ({100*over/len(approx):.1f}%) exceed MAX_LEN=1536")
+
+print("\nRESULT:", "PASS" if fail == 0 else f"FAIL ({fail} problems)")
+sys.exit(1 if fail else 0)