director: few-shot prompt + honest contract (8-40 chars)

kaggle/director_probe.py

@@ -1,12 +1,17 @@
-"""Probe: can Qwen3.5-0.8B write a script that the TTS front end can consume?
+"""Director stage: turn a topic into a script the TTS front end can consume.
 
-The failure in v2/v3 was not the schema alone. A line that is *valid JSON* can
-still be unusable for Ming: five characters is long enough for the whisper voice
-to collapse, digits and Latin words bypass the normaliser we turned off, and
-emoji break the text encoder. So this measures the contract, not just the syntax.
+Why the contract and not just "valid JSON": a line that parses can still be
+unusable. Five characters is short enough for the whisper voice to collapse into
+silence, digits and Latin words bypass the normaliser we turned off, and emoji
+break the text encoder. So the checks here are the ones the radio stage needs.
 
-Runs on transformers 5.x, which cannot share a process with Ming (pinned at
-4.46.3). That is why the director is a separate stage with its own JSON file.
+Runs on transformers 5.x. Ming pins 4.46.3, so this is a separate process and
+leaves a JSON file behind rather than calling TTS directly.
+
+Modes (`MODE`):
+  probe   - N samples with the prompt as written, report pass rate
+  collect - rejection-sample accepted scripts into sft.jsonl
+  eval    - score the current model on a fixed topic list
 """
 import json
 import os
@@ -14,37 +19,55 @@ import re
 import time
 from pathlib import Path
 
-import torch
-
 ROOT = Path(os.environ.get("WORK_ROOT", "/kaggle/working"))
 MODEL_ID = os.environ.get("DIRECTOR_MODEL", "Qwen/Qwen3.5-0.8B")
-OUT = ROOT / "director"
+ADAPTER = os.environ.get("ADAPTER", "")
+MODE = os.environ.get("MODE", "probe")
 N_SAMPLES = int(os.environ.get("N_SAMPLES", "6"))
+OUT = ROOT / "director"
 
-STYLES = {"开场", "叙述", "故事", "耳语"}
-MIN_CHARS, MAX_CHARS = 8, 30
-# Anything outside this set has to be handled by a normaliser we deliberately
-# turned off, so the director is not allowed to emit it.
-ALLOWED = re.compile(r"^[\u4e00-\u9fff，。？！、；：…—]+$")
+N_LINES = 6
+STYLES = ["开场", "叙述", "故事", "叙述", "耳语", "耳语"]
+MIN_CHARS, MAX_CHARS = 8, 40
+ALLOWED = re.compile(r"^[\u4e00-\u9fff，。？！、；：…——“”‘’「」《》]+$")
 
-PROMPT = """你是一档深夜电台的编剧。写一段约 60 秒的节目串词，一共 6 句。
+TOPICS = [
+    "雨夜的末班公交", "一家很老的唱片店", "海边的灯塔", "凌晨的便利店",
+    "搬家时翻出的旧照片", "楼下那棵一直没有开花的树", "深夜的收音机",
+    "一场没有下完的雨",
+]
 
-硬性规则：
-1. 正好 6 句，顺序是：开场、叙述、故事、叙述、耳语、耳语。
-2. 每句 8 到 30 个汉字。
-3. 只能用汉字和中文标点（，。？！），不要数字、英文、emoji、括号、引号。
-4. 内容要连贯：讲一件小事，最后两句压低声音收尾。
+SYSTEM = "你是深夜电台的编剧，只输出 JSON 数组，不解释，不用代码块。"
 
-只输出一个 JSON 数组，不要解释，不要代码块。格式：
-[{"style":"开场","text":"..."},{"style":"叙述","text":"..."},{"style":"故事","text":"..."},{"style":"叙述","text":"..."},{"style":"耳语","text":"..."},{"style":"耳语","text":"..."}]"""
+RULES = """写一段约 60 秒的深夜电台串词。
+
+规则：
+1. 正好 6 组，style 依次是：开场、叙述、故事、叙述、耳语、耳语。
+2. 每组是一个独立的大括号对象，形如 {"style":"叙述","text":"..."}，六组之间用逗号隔开。
+3. text 每句 8 到 40 个汉字，只能有汉字和，。？！这几种标点。
+4. 不要数字、英文、emoji、引号、括号；不要提前结束，一定写满 6 组。"""
+
+SHOT = """例子：
+[{"style":"开场","text":"晚上好，这里是深夜频道，我是今晚陪你的人。"},{"style":"叙述","text":"窗外的雨下了一整晚，路灯把水汽照成一片模糊的黄。"},{"style":"故事","text":"很多年前这条街上有一家很小的唱片店，老板总在打烊前放同一首歌。"},{"style":"叙述","text":"如果你还醒着，就把灯关小一点，让声音替你把今天收好。"},{"style":"耳语","text":"后来店关了，歌还在。"},{"style":"耳语","text":"晚安，我们明天见。"}]"""
 
 
 def log(msg: str) -> None:
     print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)
 
 
+def build_prompt(topic: str, few_shot: bool = True) -> str:
+    head = RULES if few_shot else "写一段约 60 秒的深夜电台串词，正好 6 组 style 依次是开场、叙述、故事、叙述、耳语、耳语。"
+    body = f"{head}\n\n{SHOT}\n\n现在写「{topic}」。" if few_shot else f"{head}\n\n题目：{topic}。只输出 JSON 数组。"
+    return body
+
+
 def parse(raw: str) -> list[dict]:
-    """Same tolerant extraction the runtime uses: pair-scan, not json.loads."""
+    """Pair-scan instead of json.loads.
+
+    The 0.8B model reliably writes the fields and unreliably the braces: one
+    observed answer opened a single object and repeated "style"/"text" six
+    times. Scanning for the pairs survives that; json.loads cannot.
+    """
     pairs = re.findall(r'"style"\s*:\s*"([^"]*)"\s*,\s*"text"\s*:\s*"([^"]*)"', raw)
     if not pairs:
         pairs = [(s, t) for t, s in re.findall(
@@ -53,65 +76,93 @@ def parse(raw: str) -> list[dict]:
 
 
 def check(lines: list[dict]) -> dict:
-    """Every reason the TTS front end would have to reject this script."""
     bad = []
-    if len(lines) != 6:
+    if len(lines) != N_LINES:
         bad.append(f"count={len(lines)}")
-    if lines and lines[0].get("style") != "开场":
-        bad.append("first!=开场")
     for i, l in enumerate(lines):
         t = l.get("text", "")
-        if l.get("style") not in STYLES:
+        if i < N_LINES and l.get("style") != STYLES[i]:
             bad.append(f"L{i}:style={l.get('style')!r}")
         if not (MIN_CHARS <= len(t) <= MAX_CHARS):
             bad.append(f"L{i}:len={len(t)}")
         if not ALLOWED.match(t):
             bad.append(f"L{i}:chars")
-    whisper_at = [i for i, l in enumerate(lines) if l.get("style") == "耳语"]
-    if whisper_at and whisper_at[-1] < len(lines) - 2:
-        bad.append("whisper not at the end")
     return {"ok": not bad, "violations": bad}
 
 
-def main() -> None:
+def load_model():
+    import torch
     from transformers import AutoModelForCausalLM, AutoTokenizer
 
-    OUT.mkdir(parents=True, exist_ok=True)
-    log(f"loading {MODEL_ID}")
     tok = AutoTokenizer.from_pretrained(MODEL_ID)
-    model = AutoModelForCausalLM.from_pretrained(MODEL_ID, dtype=torch.float16).cuda().eval()
-    log(f"loaded, {sum(p.numel() for p in model.parameters())/1e6:.0f}M params")
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID, dtype=torch.float16, device_map="cuda:0").eval()
+    if ADAPTER and Path(ADAPTER).exists():
+        from peft import PeftModel
+        model = PeftModel.from_pretrained(model, ADAPTER).eval()
+        log(f"adapter {ADAPTER}")
+    log(f"loaded {MODEL_ID} -> {sum(p.numel() for p in model.parameters())/1e6:.0f}M params")
+    return tok, model
+
 
-    msgs = [{"role": "user", "content": PROMPT}]
+def sample(tok, model, topic: str, few_shot: bool = True) -> dict:
+    import torch
+
+    msgs = [{"role": "system", "content": SYSTEM},
+            {"role": "user", "content": build_prompt(topic, few_shot)}]
     text = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
     ids = tok([text], return_tensors="pt").to("cuda")
+    t0 = time.time()
+    with torch.no_grad():
+        gen = model.generate(**ids, max_new_tokens=512, do_sample=True,
+                             temperature=0.8, top_p=0.9, top_k=20,
+                             repetition_penalty=1.05,
+                             pad_token_id=tok.eos_token_id)
+    raw = tok.decode(gen[0][ids["input_ids"].shape[1]:], skip_special_tokens=True)
+    lines = parse(raw)
+    return {"topic": topic, "seconds": round(time.time() - t0, 1),
+            "n_tokens": int(gen.shape[1] - ids["input_ids"].shape[1]),
+            "lines": lines, "raw": raw, **check(lines)}
+
 
-    results = []
-    for k in range(N_SAMPLES):
-        t0 = time.time()
-        with torch.no_grad():
-            gen = model.generate(**ids, max_new_tokens=512, do_sample=True,
-                                 temperature=0.8, top_p=0.9, top_k=20,
-                                 repetition_penalty=1.05,
-                                 pad_token_id=tok.eos_token_id)
-        raw = tok.decode(gen[0][ids["input_ids"].shape[1]:], skip_special_tokens=True)
-        dt = time.time() - t0
-        lines = parse(raw)
-        v = check(lines)
-        results.append({"sample": k, "seconds": round(dt, 1),
-                        "n_tokens": int(gen.shape[1] - ids["input_ids"].shape[1]),
-                        "lines": lines, "raw": raw, **v})
-        log(f"#{k} {dt:.0f}s parsed={len(lines)} ok={v['ok']} {v['violations'][:4]}")
-        for l in lines:
-            log(f"     [{l.get('style')}] {len(l.get('text',''))}字 {l.get('text')}")
-
-    ok = sum(1 for r in results if r["ok"])
-    log(f"pass {ok}/{len(results)}")
-    lens = [len(l["text"]) for r in results for l in r["lines"]]
-    if lens:
-        lens.sort()
-        log(f"line length: min {lens[0]} median {lens[len(lens)//2]} max {lens[-1]}")
-    (OUT / "probe.json").write_text(json.dumps(results, ensure_ascii=False, indent=1))
+def main() -> None:
+    OUT.mkdir(parents=True, exist_ok=True)
+    tok, model = load_model()
+
+    if MODE == "probe":
+        rows = [sample(tok, model, TOPICS[i % len(TOPICS)]) for i in range(N_SAMPLES)]
+        for r in rows:
+            log(f"{r['topic'][:8]:<10} {r['seconds']:>4}s n={len(r['lines'])} ok={r['ok']} {r['violations'][:3]}")
+            for l in r["lines"]:
+                log(f"     [{l.get('style')}] {len(l.get('text',''))}字 {l.get('text')}")
+        ok = sum(r["ok"] for r in rows)
+        log(f"pass {ok}/{len(rows)}")
+        (OUT / "probe.json").write_text(json.dumps(rows, ensure_ascii=False, indent=1))
+
+    elif MODE == "collect":
+        target = int(os.environ.get("TARGET", "120"))
+        got = []
+        tries = 0
+        ticks = 0
+        while len(got) < target and ticks < 40:
+            topic = TOPICS[ticks % len(TOPICS)]
+            r = sample(tok, model, topic)
+            tries += 1
+            ticks += 1
+            if r["ok"]:
+                got.append({"topic": topic, "lines": r["lines"]})
+            if tries % 10 == 0:
+                log(f"{tries} tried, {len(got)} kept ({len(got)/tries:.0%})")
+        with open(OUT / "sft.jsonl", "w") as f:
+            for g in got:
+                f.write(json.dumps(g, ensure_ascii=False) + "\n")
+        log(f"kept {len(got)} of {tries}")
+
+    elif MODE == "eval":
+        rows = [sample(tok, model, TOPICS[i % len(TOPICS)]) for i in range(N_SAMPLES)]
+        ok = sum(r["ok"] for r in rows)
+        log(f"pass {ok}/{len(rows)}")
+        (OUT / "eval.json").write_text(json.dumps(rows, ensure_ascii=False, indent=1))
 
 
 if __name__ == "__main__":