| """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 sys |
| import time |
| from pathlib import Path |
|
|
| sys.path.insert(0, str(Path(__file__).parent)) |
|
|
| 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) |
| if best[2] is None: |
| raise RuntimeError("no decoder block list found") |
| return best |
|
|
|
|
| def build_example(tok, topic: str, lines: list[dict]) -> dict: |
| import torch |
|
|
| from director_probe import SLOT_MAX, SYSTEM, build_prompt, trim |
|
|
| 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']}：{trim(l['text'], SLOT_MAX[i])}" |
| for i, l in enumerate(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 |
|
|
| 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" |
| if not path.exists(): |
| path = ROOT / "webfm-eval" / "director" / "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() |
|
|
