director: six prefixed lines instead of JSON

kaggle/director_probe.py

@@ -1,17 +1,20 @@
 """Director stage: turn a topic into a script the TTS front end can consume.
 
-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.
+The 0.8B model is good at prose and bad at JSON punctuation: zero-shot it wrote
+the array as one object with repeated keys, and in 3 of 6 samples it closed the
+bracket after a single line. Few-shot fixed the structure but not the counts.
+
+So the director no longer writes JSON. It writes six prefixed lines, which is
+pattern completion - the thing a small LM is actually reliable at - and the host
+does the parsing. `parse_script` still accepts JSON if a model insists.
 
 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.
+leaves a 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
+  collect - keep accepted scripts (repairing lengths) into sft.jsonl
+  eval    - score the current model on the fixed topic list
 """
 import json
 import os
@@ -23,12 +26,12 @@ ROOT = Path(os.environ.get("WORK_ROOT", "/kaggle/working"))
 MODEL_ID = os.environ.get("DIRECTOR_MODEL", "Qwen/Qwen3.5-0.8B")
 ADAPTER = os.environ.get("ADAPTER", "")
 MODE = os.environ.get("MODE", "probe")
-N_SAMPLES = int(os.environ.get("N_SAMPLES", "6"))
+N_SAMPLES = int(os.environ.get("N_SAMPLES", "8"))
 OUT = ROOT / "director"
 
-N_LINES = 6
-STYLES = ["开场", "叙述", "故事", "叙述", "耳语", "耳语"]
+SLOTS = ["开场", "叙述", "故事", "叙述", "耳语", "耳语"]
 MIN_CHARS, MAX_CHARS = 8, 40
+LATIN_OR_DIGIT = re.compile(r"[A-Za-z0-9]")
 ALLOWED = re.compile(r"^[\u4e00-\u9fff，。？！、；：…——“”‘’「」《》]+$")
 
 TOPICS = [
@@ -37,18 +40,21 @@ TOPICS = [
     "一场没有下完的雨",
 ]
 
-SYSTEM = "你是深夜电台的编剧，只输出 JSON 数组，不解释，不用代码块。"
+SYSTEM = "你是深夜电台的编剧。按给定格式写串词，不解释，不加标题。"
+
+RULES = """写一段约 60 秒的深夜电台串词。一共六行，每行以标签开头，格式是「标签：正文」。
 
-RULES = """写一段约 60 秒的深夜电台串词。
+六行的标签依次是：开场、叙述、故事、叙述、耳语、耳语。
 
-规则：
-1. 正好 6 组，style 依次是：开场、叙述、故事、叙述、耳语、耳语。
-2. 每组是一个独立的大括号对象，形如 {"style":"叙述","text":"..."}，六组之间用逗号隔开。
-3. text 每句 8 到 40 个汉字，只能有汉字和，。？！这几种标点。
-4. 不要数字、英文、emoji、引号、括号；不要提前结束，一定写满 6 组。"""
+正文规则：每行 8 到 40 个汉字；只能用汉字和，。？！这几种标点；不要数字、英文、emoji、引号、括号。"""
 
-SHOT = """例子：
-[{"style":"开场","text":"晚上好，这里是深夜频道，我是今晚陪你的人。"},{"style":"叙述","text":"窗外的雨下了一整晚，路灯把水汽照成一片模糊的黄。"},{"style":"故事","text":"很多年前这条街上有一家很小的唱片店，老板总在打烊前放同一首歌。"},{"style":"叙述","text":"如果你还醒着，就把灯关小一点，让声音替你把今天收好。"},{"style":"耳语","text":"后来店关了，歌还在。"},{"style":"耳语","text":"晚安，我们明天见。"}]"""
+SHOT = """示例：
+开场：晚上好，这里是深夜频道，我是今晚陪你的人。
+叙述：窗外的雨下了一整晚，路灯把水汽照成一片模糊的黄。
+故事：很多年前这条街上有一家很小的唱片店，老板总在打烊前放同一首歌。
+叙述：如果你还醒着，就把灯关小一点，让声音替你把今天收好。
+耳语：后来店关了，歌还在。
+耳语：晚安，我们明天见。"""
 
 
 def log(msg: str) -> None:
@@ -56,36 +62,52 @@ def log(msg: str) -> None:
 
 
 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]:
-    """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(
-            r'"text"\s*:\s*"([^"]*)"\s*,\s*"style"\s*:\s*"([^"]*)"', raw)]
-    return [{"style": s, "text": t} for s, t in pairs if t.strip()]
+    head = f"{RULES}\n\n{SHOT}" if few_shot else RULES
+    return f"{head}\n\n现在写「{topic}」，只输出这六行。"
+
+
+def parse_script(raw: str) -> list[dict]:
+    """Read either six prefixed lines or (if a model insists) a JSON array."""
+    out = []
+    for line in raw.splitlines():
+        line = line.strip().strip("`").strip()
+        if not line:
+            continue
+        m = re.match(r"^(开场|叙述|故事|耳语)\s*[：:]\s*(.+)$", line)
+        if m:
+            out.append({"style": m.group(1), "text": m.group(2).strip()})
+            continue
+        m = re.search(r'"style"\s*:\s*"([^"]*)"\s*,\s*"text"\s*:\s*"([^"]*)"', line)
+        if m:
+            out.append({"style": m.group(1), "text": m.group(2)})
+    if not out:
+        pairs = re.findall(r'"style"\s*:\s*"([^"]*)"\s*,\s*"text"\s*:\s*"([^"]*)"', raw)
+        out = [{"style": s, "text": t} for s, t in pairs if t.strip()]
+    return out
+
+
+def trim(text: str) -> str:
+    """Cut an over-long line at its last clause boundary under the limit."""
+    if len(text) <= MAX_CHARS:
+        return text
+    cut = text[:MAX_CHARS]
+    for i in range(len(cut) - 1, MIN_CHARS - 1, -1):
+        if cut[i] in "，。？！":
+            return cut[:i] + "。"
+    return cut[: MAX_CHARS - 1] + "。"
 
 
 def check(lines: list[dict]) -> dict:
     bad = []
-    if len(lines) != N_LINES:
+    if len(lines) != len(SLOTS):
         bad.append(f"count={len(lines)}")
     for i, l in enumerate(lines):
         t = l.get("text", "")
-        if i < N_LINES and l.get("style") != STYLES[i]:
+        if i < len(SLOTS) and l.get("style") != SLOTS[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):
+        if LATIN_OR_DIGIT.search(t) or not ALLOWED.match(t):
             bad.append(f"L{i}:chars")
     return {"ok": not bad, "violations": bad}
 
@@ -119,7 +141,7 @@ def sample(tok, model, topic: str, few_shot: bool = True) -> dict:
                              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)
+    lines = parse_script(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)}
@@ -129,7 +151,7 @@ def main() -> None:
     OUT.mkdir(parents=True, exist_ok=True)
     tok, model = load_model()
 
-    if MODE == "probe":
+    if MODE in ("probe", "eval"):
         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]}")
@@ -137,32 +159,31 @@ def main() -> None:
                 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))
+        (OUT / f"{MODE}.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)]
+        target = int(os.environ.get("TARGET", "160"))
+        max_tries = int(os.environ.get("MAX_TRIES", "600"))
+        kept, tries = [], 0
+        while len(kept) < target and tries < max_tries:
+            topic = TOPICS[tries % 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%})")
+            if len(r["lines"]) != len(SLOTS):
+                continue
+            # The label is positional anyway (it decides which voice speaks),
+            # so relabel by position and repair over-long lines instead of
+            # throwing the whole script away.
+            lines = [{"style": SLOTS[i], "text": trim(l["text"])} for i, l in enumerate(r["lines"])]
+            if any(LATIN_OR_DIGIT.search(l["text"]) or len(l["text"]) < MIN_CHARS for l in lines):
+                continue
+            kept.append({"topic": topic, "lines": lines})
+            if len(kept) % 10 == 0:
+                log(f"{tries} tried, {len(kept)} kept ({len(kept)/tries:.0%})")
         with open(OUT / "sft.jsonl", "w") as f:
-            for g in got:
+            for g in kept:
                 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))
+        log(f"kept {len(kept)} of {tries}")
 
 
 if __name__ == "__main__":