director: six prefixed lines instead of JSON

kaggle/director_sft.py

@@ -0,0 +1,123 @@
+"""Teach the 0.8B director the output contract, then score it.
+
+Zero-shot (and few-shot) the model gets the words right and the shape wrong:
+three of six samples stop after one line, and it writes the array as a single
+object with repeated keys. That is a formatting job, so it is worth a small
+fine-tune rather than more prompt engineering.
+
+Only the last few blocks and the head are trained. The base model already knows
+how to write Chinese; what it lacks is six lines of 8-40 characters in a fixed
+style order. Freezing the rest also keeps a 0.8B model training inside 15 GB.
+"""
+import json
+import os
+import time
+from pathlib import Path
+
+ROOT = Path(os.environ.get("WORK_ROOT", "/kaggle/working"))
+OUT = ROOT / "director"
+MODEL_ID = os.environ.get("DIRECTOR_MODEL", "Qwen/Qwen3.5-0.8B")
+TRAIN_LAYERS = int(os.environ.get("TRAIN_LAYERS", "6"))
+EPOCHS = int(os.environ.get("EPOCHS", "4"))
+LR = float(os.environ.get("LR", "1e-4"))
+ACCUM = int(os.environ.get("ACCUM", "4"))
+MAX_LEN = int(os.environ.get("MAX_LEN", "1024"))
+
+
+def log(msg: str) -> None:
+    print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)
+
+
+def find_blocks(model):
+    """Longest ModuleList of decoder blocks, whatever it is nested under."""
+    import torch.nn as nn
+
+    best = (0, None)
+    for name, mod in model.named_modules():
+        if isinstance(mod, nn.ModuleList) and len(mod) > best[0]:
+            best = (len(mod), (name, mod))
+    return best[1]
+
+
+def build_example(tok, topic: str, lines: list[dict]) -> dict:
+    import torch
+
+    from director_probe import SYSTEM, build_prompt
+
+    msgs = [{"role": "system", "content": SYSTEM},
+            {"role": "user", "content": build_prompt(topic)}]
+    prompt = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
+    target = "\n".join(f"{l['style']}：{l['text']}" for l in lines)
+    p_ids = tok(prompt, add_special_tokens=False)["input_ids"]
+    t_ids = tok(target, 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]
+    return {"input_ids": torch.tensor([ids]), "labels": torch.tensor([labels])}
+
+
+def train(rows: list[dict]) -> str:
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    from director_probe import build_prompt  # noqa: F401  (import check)
+
+    tok = AutoTokenizer.from_pretrained(MODEL_ID)
+    model = AutoModelForCausalLM.from_pretrained(MODEL_ID, dtype=torch.float32,
+                                                 device_map="cuda:0")
+    n_layers, (lname, blocks) = find_blocks(model)
+    log(f"blocks: {lname} x{n_layers}; training the last {TRAIN_LAYERS}")
+
+    for p in model.parameters():
+        p.requires_grad_(False)
+    for blk in list(blocks)[-TRAIN_LAYERS:]:
+        for p in blk.parameters():
+            p.requires_grad_(True)
+    for name, p in model.named_parameters():
+        if name.endswith(("lm_head.weight", "norm.weight", "final_norm.weight")):
+            p.requires_grad_(True)
+    trainable = [p for p in model.parameters() if p.requires_grad]
+    n_train = sum(p.numel() for p in trainable)
+    log(f"trainable {n_train/1e6:.0f}M of {sum(p.numel() for p in model.parameters())/1e6:.0f}M")
+
+    opt = torch.optim.AdamW(trainable, lr=LR, betas=(0.9, 0.95), weight_decay=0.01)
+    model.train()
+    step = 0
+    t0 = time.time()
+    for epoch in range(EPOCHS):
+        total = 0.0
+        for i, row in enumerate(rows):
+            ex = build_example(tok, row["topic"], row["lines"])
+            loss = model(**{k: v.cuda() for k, v in ex.items()}).loss / ACCUM
+            loss.backward()
+            total += loss.item()
+            if (i + 1) % ACCUM == 0:
+                torch.nn.utils.clip_grad_norm_(trainable, 1.0)
+                opt.step()
+                opt.zero_grad(set_to_none=True)
+                step += 1
+                if step % 10 == 0:
+                    log(f"epoch {epoch} step {step} loss {total/(i+1)*ACCUM:.4f} "
+                        f"({time.time()-t0:.0f}s)")
+        log(f"epoch {epoch} done, mean loss {total/max(1,len(rows))*ACCUM:.4f}")
+    opt.zero_grad(set_to_none=True)
+
+    out = OUT / "model"
+    out.mkdir(parents=True, exist_ok=True)
+    model.half().save_pretrained(out)
+    tok.save_pretrained(out)
+    log(f"saved {out} ({sum(f.stat().st_size for f in out.glob('*'))/1e6:.0f} MB)")
+    return str(out)
+
+
+def main() -> None:
+    OUT.mkdir(parents=True, exist_ok=True)
+    path = OUT / "sft.jsonl"
+    rows = [json.loads(l) for l in path.read_text().splitlines() if l.strip()]
+    log(f"{len(rows)} training scripts from {path}")
+    if not rows:
+        raise SystemExit("no training data")
+    train(rows)
+
+
+if __name__ == "__main__":
+    main()