Upload kaggle/director_lora_train.py with huggingface_hub

kaggle/director_lora_train.py

@@ -0,0 +1,195 @@
+"""Director LoRA, conservative configuration.
+
+Qwen3.5-0.8B is a hybrid model: 24 layers, 18 Gated DeltaNet `linear_attn`
+blocks and 6 ordinary `self_attn` blocks (every fourth layer), plus a vision
+tower and an MTP head. LoRA goes on the MLP of all 24 layers and the q/k/v/o
+projections of the 6 full-attention layers. Nothing in `linear_attn` is
+touched: its projections feed a recurrent scan, and its conv1d/A_log/dt_bias
+parameters are not plain Linears.
+
+Targets are discovered by name rather than by a short module-name list, so the
+vision tower and the MTP head cannot be matched by accident.
+
+Runs in a fresh interpreter with transformers 5.x (Ming's 4.46.3 cannot load
+Qwen3.5). The browser never loads this adapter: merge_and_unload() writes a
+plain fp16 checkpoint for the ONNX export step.
+"""
+import json
+import os
+import random
+import re
+import time
+from pathlib import Path
+
+ROOT = Path(os.environ.get("WORK_ROOT", "/kaggle/working"))
+BUNDLE = Path(os.environ.get("BUNDLE", str(ROOT / "webfm-eval")))
+# Deliberately NOT director/sft.jsonl: that path holds the old six-line radio
+# scripts, which use a different output protocol.
+DATA = Path(os.environ.get("DATA", str(ROOT / "director_lora" / "sft.jsonl")))
+OUT = Path(os.environ.get("LORA_OUT", str(ROOT / "director_lora")))
+MODEL_ID = os.environ.get("DIRECTOR_MODEL", "Qwen/Qwen3.5-0.8B")
+R = int(os.environ.get("R", "16"))
+ALPHA = int(os.environ.get("ALPHA", "32"))
+DROPOUT = float(os.environ.get("DROPOUT", "0.05"))
+LR = float(os.environ.get("LR", "1e-4"))
+EPOCHS = int(os.environ.get("EPOCHS", "2"))
+ACCUM = int(os.environ.get("ACCUM", "4"))
+MAX_LEN = int(os.environ.get("MAX_LEN", "2048"))
+SEED = int(os.environ.get("SEED", "20261107"))
+GRAD_CKPT = os.environ.get("GRAD_CKPT", "0") == "1"
+
+TARGET_RE = re.compile(
+    r"(^|\.)layers\.\d+\.("
+    r"mlp\.(gate_proj|up_proj|down_proj)"
+    r"|self_attn\.(q_proj|k_proj|v_proj|o_proj))$"
+)
+EXCLUDE = ("mtp", "vision", "visual", "multi_modal")
+
+
+def log(msg: str) -> None:
+    print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)
+
+
+def load_rows() -> list[dict]:
+    path = DATA if DATA.exists() else BUNDLE / "director_lora" / "sft.jsonl"
+    if not path.exists():
+        raise SystemExit(f"no training data at {DATA} or {path}")
+    rows = [json.loads(l) for l in path.read_text(encoding="utf-8").splitlines() if l.strip()]
+    log(f"{len(rows)} rows from {path}")
+    if not rows:
+        raise SystemExit("empty training set")
+    return rows
+
+
+def encode(tok, row: dict):
+    import torch
+
+    messages = row["messages"]
+    if not messages or messages[-1]["role"] != "user":
+        raise SystemExit("bad messages field in training row")
+    prompt = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    p_ids = tok(prompt, add_special_tokens=False)["input_ids"]
+    t_ids = tok(row["response"], add_special_tokens=False)["input_ids"] + [tok.eos_token_id]
+    ids = (p_ids + t_ids)[:MAX_LEN]
+    labels = ([-100] * len(p_ids) + t_ids)[:MAX_LEN]
+    if all(v == -100 for v in labels):
+        return None
+    return {"input_ids": torch.tensor([ids]), "labels": torch.tensor([labels])}
+
+
+def build_targets(model) -> list[str]:
+    import torch
+
+    names = [n for n, m in model.named_modules()
+             if isinstance(m, torch.nn.Linear)
+             and TARGET_RE.search(n)
+             and not any(x in n for x in EXCLUDE)]
+    mlp = sum(1 for n in names if ".mlp." in n)
+    attn = len(names) - mlp
+    log(f"targets: {len(names)} Linears ({mlp} MLP, {attn} self_attn)")
+    if mlp != 72 or attn != 24:
+        raise SystemExit(f"unexpected layer count ({mlp}/{attn}); check transformers version")
+    return names
+
+
+def main() -> None:
+    import torch
+    from peft import LoraConfig, get_peft_model
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    import transformers
+    log(f"transformers {transformers.__version__}, torch {torch.__version__}")
+    if int(transformers.__version__.split(".")[0]) < 5:
+        raise SystemExit("Qwen3.5 needs transformers >= 5; run in a fresh process")
+
+    random.seed(SEED)
+    torch.manual_seed(SEED)
+    rows = load_rows()
+
+    tok = AutoTokenizer.from_pretrained(MODEL_ID)
+    if not getattr(tok, "chat_template", None):
+        raise SystemExit("tokenizer has no chat template; the browser applies one")
+    log(f"eos={tok.eos_token_id} ({tok.decode([tok.eos_token_id])!r})")
+
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID, dtype=torch.bfloat16, device_map="cuda:0")
+    model.config.use_cache = False
+    if GRAD_CKPT:
+        model.gradient_checkpointing_enable()
+        model.enable_input_require_grads()
+
+    targets = build_targets(model)
+    cfg = LoraConfig(r=R, lora_alpha=ALPHA, lora_dropout=DROPOUT, bias="none",
+                     task_type="CAUSAL_LM", target_modules=targets)
+    model = get_peft_model(model, cfg)
+    trainable = [p for p in model.parameters() if p.requires_grad]
+    n_train = sum(p.numel() for p in trainable)
+    n_all = sum(p.numel() for p in model.parameters())
+    log(f"trainable {n_train/1e6:.2f}M / {n_all/1e6:.0f}M ({n_train/n_all:.2%})")
+
+    encoded = [x for x in (encode(tok, row) for row in rows) if x is not None]
+    log(f"encoded {len(encoded)} examples, max {max(x['input_ids'].shape[1] for x in encoded)} tokens")
+    opt = torch.optim.AdamW(trainable, lr=LR, betas=(0.9, 0.95), weight_decay=0.01)
+    model.train()
+    step, running, t0 = 0, 0.0, time.time()
+    for epoch in range(EPOCHS):
+        order = list(range(len(encoded)))
+        random.shuffle(order)
+        total = 0.0
+        for i, idx in enumerate(order):
+            batch = {k: v.cuda() for k, v in encoded[idx].items()}
+            loss = model(**batch).loss / ACCUM
+            loss.backward()
+            total += loss.item()
+            if (i + 1) % ACCUM == 0 or i + 1 == len(order):
+                torch.nn.utils.clip_grad_norm_(trainable, 1.0)
+                opt.step()
+                opt.zero_grad(set_to_none=True)
+                step += 1
+                running += loss.item() * ACCUM
+                if step % 25 == 0:
+                    log(f"epoch {epoch} step {step} loss {running/25:.4f} ({time.time()-t0:.0f}s)")
+                    running = 0.0
+        log(f"epoch {epoch} mean loss {total/max(1,len(order))*ACCUM:.4f}")
+    opt.zero_grad(set_to_none=True)
+
+    adapter = OUT / "adapter"
+    adapter.mkdir(parents=True, exist_ok=True)
+    model.save_pretrained(adapter)
+    tok.save_pretrained(adapter)
+    log(f"saved adapter -> {adapter}")
+
+    merged = OUT / "model_fp16"
+    merged.mkdir(parents=True, exist_ok=True)
+    model = model.merge_and_unload()
+    # The ONNX export strips the vision tower and the MTP head; only the text
+    # decoder is shipped to the browser.
+    if GRAD_CKPT:
+        model.gradient_checkpointing_disable()
+    model.config.use_cache = True
+    model.save_pretrained(merged, safe_serialization=True)
+    tok.save_pretrained(merged)
+    log(f"saved merged fp16 -> {merged}")
+
+    # Cheap sanity check: the merged model must still produce the protocol.
+    model.eval()
+    probe = rows[0]["messages"]
+    text = tok.apply_chat_template(probe, tokenize=False, add_generation_prompt=True)
+    ids = tok([text], return_tensors="pt").to("cuda")
+    with torch.no_grad():
+        gen = model.generate(**ids, max_new_tokens=160, do_sample=False,
+                             eos_token_id=tok.eos_token_id,
+                             pad_token_id=tok.eos_token_id)
+    out = tok.decode(gen[0][ids["input_ids"].shape[1]:], skip_special_tokens=True)
+    log("merged model sample:\n" + out[:400])
+    (OUT / "sample.txt").write_text(out, encoding="utf-8")
+    (OUT / "train_meta.json").write_text(json.dumps({
+        "model": MODEL_ID, "rows": len(encoded), "epochs": EPOCHS, "lr": LR,
+        "r": R, "alpha": ALPHA, "targets": len(targets), "trainable": n_train,
+        "steps": step, "seconds": round(time.time() - t0),
+    }, indent=1), encoding="utf-8")
+    log("done")
+
+
+if __name__ == "__main__":
+    main()