140 lines
6.0 KiB
Python
140 lines
6.0 KiB
Python
#!/usr/bin/env python3
|
|
"""train_jev.py — jev v1 训练: xlm-roberta-base 判别式文档级相关性打分(校准概率)
|
|
输入: --data 目录下 train.jsonl / calibration.jsonl / eval.jsonl / injection.jsonl
|
|
输出: --out 目录下 model/(最佳权重) + metrics.json + train.log 由外层 tee 落盘
|
|
损失: BCE(hard) + 0.5*MSE(sigmoid(logit), soft) — 校准概率是 jev 的第一公民
|
|
指标: AUC + ECE(15 bins) @ calibration, 每 epoch 选最佳
|
|
"""
|
|
import json, os, argparse, math, random
|
|
import torch
|
|
import torch.nn.functional as F
|
|
from torch.utils.data import Dataset, DataLoader
|
|
from transformers import AutoTokenizer, get_cosine_schedule_with_warmup
|
|
try:
|
|
from transformers import XLMRobertaTokenizerFast as XTok
|
|
except Exception:
|
|
from transformers import XLMRobertaTokenizer as XTok
|
|
from transformers import XLMRobertaForSequenceClassification
|
|
|
|
def load_jsonl(p):
|
|
return [json.loads(l) for l in open(p, encoding="utf-8")]
|
|
|
|
class PairDS(Dataset):
|
|
def __init__(self, rows, tok, max_len=512):
|
|
self.rows, self.tok, self.max_len = rows, tok, max_len
|
|
def __len__(self):
|
|
return len(self.rows)
|
|
def __getitem__(self, i):
|
|
r = self.rows[i]
|
|
enc = self.tok(r["query"], r["doc_text"][:2200], truncation="only_second",
|
|
max_length=self.max_len, padding="max_length", return_tensors="pt")
|
|
soft = r.get("soft_label")
|
|
soft = float(soft) if soft is not None else float(r["hard_label"])
|
|
return {"input_ids": enc["input_ids"][0], "attention_mask": enc["attention_mask"][0],
|
|
"hard": torch.tensor(float(r["hard_label"])), "soft": torch.tensor(soft)}
|
|
|
|
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 auc(probs, labels):
|
|
pos = sorted(p for p, y in zip(probs, labels) if y > 0.5)
|
|
neg = sorted(p for p, y in zip(probs, labels) if y <= 0.5)
|
|
if not pos or not neg:
|
|
return 0.5
|
|
import bisect
|
|
wins = sum(bisect.bisect_left(neg, p) for p in pos)
|
|
return wins / (len(pos) * len(neg))
|
|
|
|
def evaluate(model, loader, dev):
|
|
model.eval()
|
|
probs, labels = [], []
|
|
with torch.no_grad():
|
|
for b in loader:
|
|
out = model(input_ids=b["input_ids"].to(dev), attention_mask=b["attention_mask"].to(dev))
|
|
probs += torch.sigmoid(out.logits[:, 0]).tolist()
|
|
labels += b["hard"].tolist()
|
|
model.train()
|
|
return {"auc": round(auc(probs, labels), 4), "ece": round(ece(probs, labels), 4),
|
|
"n": len(labels)}
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser()
|
|
ap.add_argument("--data", required=True)
|
|
ap.add_argument("--out", required=True)
|
|
ap.add_argument("--base", default="xlm-roberta-base")
|
|
ap.add_argument("--epochs", type=int, default=3)
|
|
ap.add_argument("--bs", type=int, default=32)
|
|
ap.add_argument("--lr", type=float, default=2e-5)
|
|
ap.add_argument("--lambda-soft", type=float, default=0.5)
|
|
args = ap.parse_args()
|
|
os.makedirs(args.out, exist_ok=True)
|
|
|
|
dev = "cuda" if torch.cuda.is_available() else "cpu"
|
|
print(f"[jev] device={dev} base={args.base}", flush=True)
|
|
try:
|
|
tok = XTok.from_pretrained(args.base)
|
|
model = XLMRobertaForSequenceClassification.from_pretrained(args.base, num_labels=1).to(dev)
|
|
except Exception:
|
|
import traceback
|
|
tail = traceback.format_exc()[-1200:]
|
|
try:
|
|
with open("/dev/termination-log", "a") as f:
|
|
f.write("\nEXC-TAIL:\n" + tail)
|
|
except Exception:
|
|
pass
|
|
raise
|
|
|
|
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)
|
|
|
|
dl = DataLoader(PairDS(train, tok), batch_size=args.bs, shuffle=True, num_workers=2, drop_last=True)
|
|
dl_cal = DataLoader(PairDS(calib, tok), batch_size=64, num_workers=2)
|
|
|
|
steps = len(dl) * args.epochs
|
|
opt = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=0.01)
|
|
sch = get_cosine_schedule_with_warmup(opt, int(0.06 * steps), steps)
|
|
scaler = torch.amp.GradScaler(enabled=dev == "cuda")
|
|
best = {"auc": 0.0}
|
|
gstep = 0
|
|
for ep in range(args.epochs):
|
|
for b in dl:
|
|
with torch.autocast("cuda", enabled=dev == "cuda"):
|
|
out = model(input_ids=b["input_ids"].to(dev), attention_mask=b["attention_mask"].to(dev))
|
|
logits = out.logits[:, 0].float()
|
|
hard = b["hard"].to(dev); soft = b["soft"].to(dev)
|
|
loss = F.binary_cross_entropy_with_logits(logits, hard) + \
|
|
args.lambda_soft * F.mse_loss(torch.sigmoid(logits), soft)
|
|
opt.zero_grad()
|
|
scaler.scale(loss).backward()
|
|
scaler.unscale_(opt)
|
|
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
|
|
scaler.step(opt); scaler.update(); sch.step()
|
|
gstep += 1
|
|
if gstep % 100 == 0:
|
|
print(f"[jev] ep{ep} step{gstep}/{steps} loss={loss.item():.4f}", flush=True)
|
|
m = evaluate(model, dl_cal, dev)
|
|
print(f"[jev] epoch {ep} calibration: {m}", flush=True)
|
|
if m["auc"] > best["auc"]:
|
|
best = {"auc": m["auc"], "ece": m["ece"], "epoch": ep}
|
|
model.save_pretrained(os.path.join(args.out, "model"))
|
|
tok.save_pretrained(os.path.join(args.out, "model"))
|
|
json.dump({"best": best, "base": args.base, "train_pairs": len(train)},
|
|
open(os.path.join(args.out, "metrics.json"), "w"), indent=1)
|
|
print(f"[jev] DONE best={best}", flush=True)
|
|
with open("/dev/termination-log", "w") as f:
|
|
f.write(f"jev training done best={best}")
|
|
|
|
if __name__ == "__main__":
|
|
main()
|