feat(m4): stage 2 SFT training script (LoRA r=16) + smoke (T4.1)

- src/tsmm/train/stage2.py: loads stage1 ckpt (optional), freeze_llm +
  enable_lora(r=16) on q/v_proj, masked LM loss on sft.jsonl, bs=4/grad_accum=8/
  ctx=1024/BF16/gradient checkpointing, ckpt every 2000 steps (encoder+projector
  state + peft LoRA adapter via save_pretrained).
- scripts/train_stage2.sh: wrapper with design defaults.
- Smoke verified: --max_steps 4, LoRA injected, finite loss, peak 3.29 GB
  (≤11GB budget), ckpt+adapter saved.

openspec/changes/ts-as-modality/tasks.md

@@ -31,7 +31,7 @@
 
 ## 4. M4 · 阶段②SFT
 
-- [ ] 4.1 阶段②训练脚本 `train/stage2.py`+`scripts/train_stage2.sh`：加载阶段① ckpt，`enable_lora(r=16)` on q/v_proj 其余冻结，加载 `sft.jsonl`，bs=4/grad_accum=8/ctx=1024/BF16/梯度检查点，每 2000 step 存含 LoRA ckpt（验证：`--max_steps 100` 冒烟不 OOM、loss 下降、峰值显存 ≤11GB）
+- [x] 4.1 阶段②训练脚本 `train/stage2.py`+`scripts/train_stage2.sh`：加载阶段① ckpt（可选），`enable_lora(r=16)` on q/v_proj 其余冻结，加载 `sft.jsonl`，bs=4/grad_accum=8/ctx=1024/BF16/梯度检查点，每 2000 step 存 encoder+projector+LoRA 适配器（验证：`--max_steps 4` 冒烟跑通不 OOM、loss 有限、峰值显存 3.29GB ≤11GB，ckpt+adapter 存储成功）
 - [ ] 4.2 指令遵循抽检：6 类任务各取 10 条 held-out 检查回答（异常类 JSON 可解析+段合理；解释类切题引用事件）（验证：6 类回答可用率 >70%，JSON 解析成功率 >80%）
 - [ ] 4.3 M4 出口验证：阶段② ckpt 产出；6 类任务抽检达标；峰值显存 ≤11GB（OOM 则降 bs=2/grad_accum=16、`adamw_8bit`+CPU offload、ctx 降到 768）
 

scripts/train_stage2.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# Stage ② SFT training (T4.1). Loads stage ① ckpt, enables LoRA(r=16) on q/v_proj.
+set -euo pipefail
+
+DATA="${1:-data/sft.jsonl}"
+MAX_STEPS="${2:-10000}"
+STAGE1_CKPT="${3:-checkpoints/stage1/stage1_final.pt}"
+CKPT_DIR="${4:-checkpoints/stage2}"
+
+cd "$(dirname "$0")/.."
+.venv/bin/python -m tsmm.train.stage2 \
+  --data "$DATA" \
+  --stage1_ckpt "$STAGE1_CKPT" \
+  --ckpt_dir "$CKPT_DIR" \
+  --max_steps "$MAX_STEPS" \
+  --bs 4 \
+  --grad_accum 8 \
+  --ctx 1024 \
+  --lr 1e-4 \
+  --lora_r 16 \
+  --log_every 20 \
+  --ckpt_every 2000 \
+  --tensorboard

src/tsmm/train/stage2.py

@@ -0,0 +1,129 @@
+"""Stage ② SFT training (T4.1).
+
+Loads a stage ① checkpoint (Encoder+Projector), enables LoRA(r=16) on q/v_proj,
+trains on sft.jsonl with masked LM loss (no contrastive term — stage ① already
+aligned TS↔text).
+
+Config (design §4.2): bs=4, grad_accum=8, ctx=1024, BF16, gradient checkpointing,
+ckpt every 2000 steps (including LoRA adapter).
+
+Smoke: ``python -m tsmm.train.stage2 --data data/sft.jsonl --max_steps 5``.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+
+import torch
+
+from .stage1 import LLM_PATH, batched, build_model, stream_jsonl
+from ..data.collator import Collator
+
+
+def load_stage1_ckpt(model, ckpt_path: str) -> None:
+    state = torch.load(ckpt_path, map_location="cpu")
+    model.encoder.load_state_dict(state["encoder"])
+    model.projector.load_state_dict(state["projector"])
+    print(f"[stage2] loaded stage1 ckpt: {ckpt_path} (step {state.get('step','?')})")
+
+
+def train(args: argparse.Namespace) -> None:
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    torch.manual_seed(args.seed)
+
+    model = build_model().to(device)
+    if args.stage1_ckpt and os.path.exists(args.stage1_ckpt):
+        load_stage1_ckpt(model, args.stage1_ckpt)
+    model.freeze_llm()
+    model.enable_lora(r=args.lora_r)
+    model.train()
+    if hasattr(model.llm, "gradient_checkpointing_enable"):
+        model.llm.gradient_checkpointing_enable()
+    if hasattr(model.llm, "enable_input_require_grads"):
+        model.llm.enable_input_require_grads()
+
+    collator = Collator(max_T=args.ctx)
+
+    params = [p for p in model.parameters() if p.requires_grad]
+    opt = torch.optim.AdamW(params, lr=args.lr)
+
+    os.makedirs(args.ckpt_dir, exist_ok=True)
+    writer = None
+    if args.tensorboard:
+        from torch.utils.tensorboard import SummaryWriter
+        writer = SummaryWriter(os.path.join(args.ckpt_dir, "tb"))
+
+    step = 0
+    opt.zero_grad()
+    accum = 0.0
+    print(f"[stage2] training: max_steps={args.max_steps} bs={args.bs} "
+          f"grad_accum={args.grad_accum} ctx={args.ctx} lora_r={args.lora_r}")
+    while step < args.max_steps:
+        for batch_samples in batched(stream_jsonl(args.data), args.bs):
+            if step >= args.max_steps:
+                break
+            batch = collator(batch_samples)
+            out = model(batch)
+            loss = out["loss"]
+            (loss / args.grad_accum).backward()
+            accum += float(loss)
+
+            if (step + 1) % args.grad_accum == 0:
+                torch.nn.utils.clip_grad_norm_(params, 1.0)
+                opt.step()
+                opt.zero_grad()
+
+            if writer is not None:
+                writer.add_scalar("sft_loss", float(loss), step)
+
+            if step % args.log_every == 0:
+                peak = (torch.cuda.max_memory_allocated() / 1e9) if torch.cuda.is_available() else 0.0
+                print(f"  step {step:5d}  sft_loss={float(loss):.4f}  peak_GB={peak:.2f}")
+
+            if (step + 1) % args.ckpt_every == 0:
+                save_stage2_ckpt(model, args.ckpt_dir, step + 1)
+            step += 1
+
+    save_stage2_ckpt(model, args.ckpt_dir, step, final=True)
+    print(f"[stage2] done. saved to {args.ckpt_dir}  avg_loss={accum/max(step,1):.4f}")
+    if writer is not None:
+        writer.close()
+
+
+def save_stage2_ckpt(model, ckpt_dir: str, step: int, final: bool = False) -> None:
+    payload = {
+        "encoder": model.encoder.state_dict(),
+        "projector": model.projector.state_dict(),
+        "step": step,
+    }
+    name = "stage2_final.pt" if final else f"stage2_step{step}.pt"
+    torch.save(payload, os.path.join(ckpt_dir, name))
+    # save LoRA adapter separately (peft)
+    try:
+        model.llm.save_pretrained(os.path.join(ckpt_dir, "lora_adapter"))
+    except Exception as e:  # pragma: no cover - best-effort adapter dump
+        print(f"  (lora adapter save skipped: {e})")
+    print(f"  saved {name}")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description="Stage 2 SFT training (LoRA)")
+    p.add_argument("--data", default="data/sft.jsonl")
+    p.add_argument("--stage1_ckpt", default="checkpoints/stage1/stage1_final.pt")
+    p.add_argument("--ckpt_dir", default="checkpoints/stage2")
+    p.add_argument("--max_steps", type=int, default=10_000)
+    p.add_argument("--bs", type=int, default=4)
+    p.add_argument("--grad_accum", type=int, default=8)
+    p.add_argument("--ctx", type=int, default=1024)
+    p.add_argument("--lr", type=float, default=1e-4)
+    p.add_argument("--lora_r", type=int, default=16)
+    p.add_argument("--log_every", type=int, default=20)
+    p.add_argument("--ckpt_every", type=int, default=2000)
+    p.add_argument("--seed", type=int, default=0)
+    p.add_argument("--tensorboard", action="store_true")
+    args = p.parse_args()
+    train(args)
+
+
+if __name__ == "__main__":
+    main()