v0.5-nordk: RDK全剥离纯公开数据 + Laya noul 训练脚本
This commit is contained in:
parent
700afc572a
commit
db28cdb6f0
184
train_laya_noul.py
Normal file
184
train_laya_noul.py
Normal file
@ -0,0 +1,184 @@
|
||||
#!/usr/bin/env python3
|
||||
"""train_laya_noul.py — Laya DecisionModel 自研训练循环 (noul 二分类)
|
||||
绕开未发布的 laya.train 模块, 直接用 build_sequence + DecisionModel.forward
|
||||
用法: python3 train_laya_noul.py <mmBERT目录> <输出目录>
|
||||
数据: /tmp/jd/{train,calibration,canary_en,canary_zh}.jsonl
|
||||
"""
|
||||
import json, os, sys, random, bisect
|
||||
import torch
|
||||
import torch.nn.functional as F
|
||||
from torch.utils.data import Dataset, DataLoader
|
||||
from transformers import AutoTokenizer, AutoConfig, AutoModel
|
||||
from peft import LoraConfig, get_peft_model
|
||||
|
||||
sys.path.insert(0, "/tmp/layasrc")
|
||||
from laya.common import build_sequence, build_model
|
||||
|
||||
# noul: markers = [false, true], true 位置 idx=1
|
||||
def load_jsonl(p):
|
||||
return [json.loads(l) for l in open(p, encoding="utf-8")]
|
||||
|
||||
class NoulDS(Dataset):
|
||||
def __init__(self, rows, tok, max_len=512):
|
||||
self.rows, self.tok, self.max_len = rows, tok, max_len
|
||||
self.q = {"t": "noul", "ins": INSTR, "crit": None}
|
||||
def __len__(self):
|
||||
return len(self.rows)
|
||||
def __getitem__(self, i):
|
||||
r = self.rows[i]
|
||||
state = f"用户问题: {r['query']}\n\n文档内容:\n{r['doc_text'][:2500]}"
|
||||
ids, markers = build_sequence(self.tok, state, self.q, self.max_len, 192)
|
||||
# markers[-1] 是 true marker (noul: [false, true])
|
||||
true_pos = markers[-1]
|
||||
# pad
|
||||
pad = self.max_len - len(ids)
|
||||
input_ids = ids + [self.tok.pad_token_id or 0] * pad
|
||||
attn = [1] * len(ids) + [0] * pad
|
||||
return {"input_ids": torch.tensor(input_ids), "attention_mask": torch.tensor(attn),
|
||||
"marker_pos": torch.tensor(markers), "marker_mask": torch.tensor([1] * len(markers) + [0] * (8 - len(markers))),
|
||||
"qtype": torch.tensor(2),
|
||||
"label": torch.tensor(float(r["hard_label"])),
|
||||
"soft": torch.tensor(float(r.get("soft_label") or r["hard_label"]))}
|
||||
|
||||
INSTR = "Does this document contain the information needed to answer the user's question? Answer based only on the document content."
|
||||
|
||||
def collate(batch):
|
||||
keys = batch[0].keys()
|
||||
return {k: torch.stack([b[k] for b in batch]) for k in keys}
|
||||
|
||||
def ece(probs, labels, n_bins=15):
|
||||
bins = [[] for _ in range(n_bins)]
|
||||
for p, y in zip(probs, labels):
|
||||
bins[min(int(p * n_bins), n_bins - 1)].append((p, y))
|
||||
e = 0.0
|
||||
for b in bins:
|
||||
if not b: continue
|
||||
conf = sum(p for p, _ in b) / len(b)
|
||||
acc = sum(y for _, y in b) / len(b)
|
||||
e += len(b) / len(probs) * abs(conf - acc)
|
||||
return e
|
||||
|
||||
def evaluate(model, loader, dev):
|
||||
model.eval()
|
||||
probs, labels = [], []
|
||||
with torch.no_grad():
|
||||
for b in loader:
|
||||
logits, _ = model(input_ids=b["input_ids"].to(dev), attention_mask=b["attention_mask"].to(dev),
|
||||
marker_pos=b["marker_pos"].to(dev), marker_mask=b["marker_mask"].to(dev),
|
||||
qtype=b["qtype"].to(dev))
|
||||
# noul: markers = [false, true], true marker 是最后一个有效 marker
|
||||
# logits shape: (batch, 8) — 取 true marker (index 1 in each pair... 简化: 取 max)
|
||||
# 实际: logits[..., 1] 对应 true marker (noul 只有 2 markers)
|
||||
p = torch.softmax(logits, -1)[..., 1] # index 1 = true
|
||||
probs += p.tolist()
|
||||
labels += b["label"].tolist()
|
||||
model.train()
|
||||
pos = sorted(p for p, y in zip(probs, labels) if y == 1)
|
||||
neg = sorted(p for p, y in zip(probs, labels) if y == 0)
|
||||
auc = sum(bisect.bisect_left(neg, p) for p in pos) / (len(pos) * len(neg)) if pos and neg else 0.0
|
||||
return {"auc": round(auc, 4), "ece": round(ece(probs, labels), 4), "n": len(labels)}
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--data", default="/tmp/jd")
|
||||
ap.add_argument("--base", default="/tmp/base")
|
||||
ap.add_argument("--out", default="/tmp/laya_out")
|
||||
ap.add_argument("--epochs", type=int, default=2)
|
||||
ap.add_argument("--bs", type=int, default=16)
|
||||
ap.add_argument("--lr", type=float, default=1e-4)
|
||||
ap.add_argument("--eval-data", default="/tmp/jd/eval_v2.jsonl")
|
||||
args = ap.parse_args()
|
||||
os.makedirs(args.out, exist_ok=True)
|
||||
|
||||
dev = "cuda" if torch.cuda.is_available() else "cpu"
|
||||
from transformers import AutoTokenizer, AutoModelForSequenceClassification
|
||||
# 加载 mmBERT bare encoder
|
||||
enc_cfg = AutoConfig.from_pretrained(args.base)
|
||||
enc = AutoModel.from_config(enc_cfg)
|
||||
d = enc.config.hidden_size
|
||||
# 构建 DecisionModel (从 laya.common 的架构)
|
||||
import laya_common as lc
|
||||
dm = lc.DecisionModel(enc, head_layers=2, n_act=2)
|
||||
dm.to(dev)
|
||||
# LoRA 只在 encoder attention
|
||||
lora = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05,
|
||||
target_modules=["Wqkv"], task_type=None)
|
||||
# 手动对 encoder 加 LoRA (peft 对 bare nn.Module 用 get_peft_model)
|
||||
dm.encoder = get_peft_model(dm.encoder, lora)
|
||||
dm.print_trainable_parameters()
|
||||
dm.train()
|
||||
|
||||
tok = AutoTokenizer.from_pretrained(args.base)
|
||||
|
||||
train = [r for r in load_jsonl(os.path.join(args.data, "train.jsonl")) if r.get("hard_label") in (0, 1)]
|
||||
calib = load_jsonl(os.path.join(args.data, "calibration.jsonl"))
|
||||
print(f"[jev] train={len(train)} calib={len(calib)}", flush=True)
|
||||
ds = NoulDS(train, tok)
|
||||
dl = DataLoader(ds, batch_size=args.bs, shuffle=True, num_workers=2, drop_last=True,
|
||||
collate_fn=collate)
|
||||
dl_cal = DataLoader(NoulDS(calib, tok), batch_size=32, collate_fn=collate)
|
||||
|
||||
canaries = {}
|
||||
for lang in ["en", "zh"]:
|
||||
p = os.path.join(args.data, f"canary_{lang}.jsonl")
|
||||
if os.path.exists(p):
|
||||
canaries[lang] = DataLoader(NoulDS(load_jsonl(p), tok), batch_size=32, collate_fn=collate)
|
||||
|
||||
n_params = sum(p.numel() for p in dm.parameters() if p.requires_grad)
|
||||
steps = len(dl) * args.epochs
|
||||
opt = torch.optim.AdamW([p for p in dm.parameters() if p.requires_grad], lr=args.lr, weight_decay=0.01)
|
||||
sch = get_cosine_schedule_with_warmup(opt, int(0.06 * steps), steps)
|
||||
best = {"sel": 0.0}
|
||||
gstep = 0
|
||||
for ep in range(args.epochs):
|
||||
for b in dl:
|
||||
logits, act = dm(input_ids=b["input_ids"].to(dev), attention_mask=b["attention_mask"].to(dev),
|
||||
marker_pos=b["marker_pos"].to(dev), marker_mask=b["marker_mask"].to(dev),
|
||||
qtype=b["qtype"].to(dev))
|
||||
# noul markers = [false, true]: true marker 是每对中最后一个有效
|
||||
# marker_mask (batch, 8): 每样本 2 个有效 marker
|
||||
# 简化: 取 logits[..., 1] (true marker 位置)
|
||||
true_logit = logits[:, 1].float()
|
||||
hard = b["label"].to(dev); soft = b["soft"].to(dev)
|
||||
loss = F.binary_cross_entropy_with_logits(true_logit, hard) + \
|
||||
0.5 * F.mse_loss(torch.sigmoid(true_logit), soft)
|
||||
opt.zero_grad()
|
||||
loss.backward()
|
||||
torch.nn.utils.clip_grad_norm_([p for p in dm.parameters() if p.requires_grad], 1.0)
|
||||
opt.step(); sch.step()
|
||||
gstep += 1
|
||||
if gstep % 100 == 0:
|
||||
print(f"[jev] ep{ep} step{gstep}/{steps} loss={loss.item():.4f}", flush=True)
|
||||
# calibration + canaries 评估
|
||||
dm.eval()
|
||||
def _auc(loader):
|
||||
ps, ls = [], []
|
||||
with torch.no_grad():
|
||||
for b in loader:
|
||||
lg, _ = dm(input_ids=b["input_ids"].to(dev), attention_mask=b["attention_mask"].to(dev),
|
||||
marker_pos=b["marker_pos"].to(dev), marker_mask=b["marker_mask"].to(dev),
|
||||
qtype=b["qtype"].to(dev))
|
||||
p = torch.softmax(lg.float(), -1)[..., 1]
|
||||
ps += p.tolist(); ls += b["label"].tolist()
|
||||
pos = sorted(p for p, y in zip(ps, ls) if y == 1)
|
||||
neg = sorted(p for p, y in zip(ps, ls) if y == 0)
|
||||
return sum(bisect.bisect_left(neg, p) for p in pos) / (len(pos) * len(neg)) if pos and neg else 0.0
|
||||
auc_cal = _auc(dl_cal)
|
||||
msg = f"[jev] epoch {ep} calib_auc={auc_cal:.4f}"
|
||||
sel = auc_cal
|
||||
for lang, dl_c in canaries.items():
|
||||
a = _auc(dl_c)
|
||||
msg += f" canary_{lang}={a:.4f}"
|
||||
sel = min(sel, a)
|
||||
print(msg, flush=True)
|
||||
if sel > best["sel"]:
|
||||
best = {"sel": sel, "calib_auc": auc_cal, "epoch": ep}
|
||||
torch.save(dm.state_dict(), os.path.join(args.out, "model.pt"))
|
||||
dm.train()
|
||||
print(f"[jev] DONE best={best}", flush=True)
|
||||
with open("/dev/termination-log", "w") as f:
|
||||
f.write(f"LAYA-NOUL DONE best={best}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
BIN
v05n/jev_part_00
Normal file
BIN
v05n/jev_part_00
Normal file
Binary file not shown.
BIN
v05n/jev_part_01
Normal file
BIN
v05n/jev_part_01
Normal file
Binary file not shown.
BIN
v05n/jev_part_02
Normal file
BIN
v05n/jev_part_02
Normal file
Binary file not shown.
BIN
v05n/jev_part_03
Normal file
BIN
v05n/jev_part_03
Normal file
Binary file not shown.
Loading…
x
Reference in New Issue
Block a user