From d345e25db472739cf6dcc2715338b052432d4ebf Mon Sep 17 00:00:00 2001 From: "dingbin.wang" Date: Fri, 6 Nov 2026 00:48:33 +0800 Subject: [PATCH] train_all r40: clean-soft MSE mask + random-window aug + max_len 1024 + temperature calibration --- train_all.py | 105 +++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 94 insertions(+), 11 deletions(-) diff --git a/train_all.py b/train_all.py index 561a726..cd772c9 100644 --- a/train_all.py +++ b/train_all.py @@ -40,6 +40,13 @@ def ece(probs, labels, nbins=15): sum(p for p, _ in b) / len(b) - sum(y for _, y in b) / len(b)) return e +def bisect_auc(probs, labels): + 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) + if not pos or not neg: + return 0.0 + return sum(bisect.bisect_left(neg, p) for p in pos) / (len(pos) * len(neg)) + def phase_data(): """v05n tar.gz 分片重组 → DATA_DIR/train.jsonl""" import glob, shutil, tarfile @@ -169,6 +176,7 @@ def run(args): MMBERT_DIR = args.base if args.out: OUT_DIR = args.out + os.makedirs(OUT_DIR, exist_ok=True) # 让早期 log 能落盘 if not phase_env(): sys.exit(1) @@ -177,6 +185,8 @@ def run(args): if not (args.tiny or phase_mmbert()): sys.exit(1) + import random + import math import torch import torch.nn.functional as F from torch.utils.data import Dataset, DataLoader @@ -184,28 +194,50 @@ def run(args): from laya.common import build_sequence dev = "cuda" if torch.cuda.is_available() else "cpu" - log(f"device={dev} tiny={args.tiny}") + log(f"device={dev} tiny={args.tiny} max_len={args.max_len} head_len={args.head_len} " + f"win={args.win_tokens} aug_p={args.aug_p}") dm, tok = build_model(dev, tiny=args.tiny) class NoulDS(Dataset): - def __init__(self, rows, max_len=512, head_len=192, doc_cap=2500): - self.rows, self.max_len, self.head_len, self.doc_cap = rows, max_len, head_len, doc_cap + def __init__(self, rows, max_len=None, head_len=None, train_aug=False): + self.rows = rows + self.max_len = max_len or args.max_len + self.head_len = head_len or args.head_len + self.win_tokens = args.win_tokens + self.aug_p = args.aug_p + self.train_aug = train_aug self.q = {"t": "noul", "ins": INSTR, "crit": None} + self.rng = random.Random(20261105) + def _doc_window(self, text): + if not self.train_aug: + return text + ids = tok(text[:12000], add_special_tokens=False)["input_ids"] + if len(ids) <= self.win_tokens: + return text + if self.rng.random() < self.aug_p: + s = self.rng.randrange(0, len(ids) - self.win_tokens + 1) + return tok.decode(ids[s:s + self.win_tokens]) + return text 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'][:self.doc_cap]}" + state = f"用户问题: {r['query']}\n\n文档内容:\n{self._doc_window(r['doc_text'])}" ids, markers = build_sequence(tok, state, self.q, self.max_len, self.head_len) pad = self.max_len - len(ids) mm = [True] * len(markers) + [False] * (8 - len(markers)) + soft = r.get("soft_label") + if soft is None: + soft = r["hard_label"] + soft_clean = float(soft) if soft in (0, 1) else -1.0 return {"input_ids": torch.tensor(ids + [0] * pad), "attention_mask": torch.tensor([1] * len(ids) + [0] * pad), "marker_pos": torch.tensor(markers + [0] * (8 - len(markers))), "marker_mask": torch.tensor(mm), "qtype": torch.tensor(2), "label": torch.tensor(float(r["hard_label"])), - "soft": torch.tensor(float(r.get("soft_label") or r["hard_label"]))} + "soft": torch.tensor(float(soft)), + "soft_clean": torch.tensor(soft_clean)} def collate(batch): return {k: torch.stack([b[k] for b in batch]) for k in batch[0]} @@ -246,7 +278,7 @@ def run(args): os.makedirs(OUT_DIR, exist_ok=True) nw = 0 if args.tiny else 2 - dl = DataLoader(NoulDS(train), batch_size=args.bs, shuffle=True, + dl = DataLoader(NoulDS(train, train_aug=True), batch_size=args.bs, shuffle=True, num_workers=nw, drop_last=True, collate_fn=collate) dl_cal = DataLoader(NoulDS(calib), batch_size=32, collate_fn=collate) @@ -266,9 +298,13 @@ def run(args): logits = fwd(b) 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) + # MSE 校准项只作用于 soft∈{0,1} 的干净行 (47% 正例 soft=0.5 是标注缺失 + # 的填充值, 0.5*MSE 会把概率系统性拉向 0.5 → r39 校准差的总根因) + soft_clean = b["soft_clean"].to(dev) + mask = soft_clean >= 0 + loss = F.binary_cross_entropy_with_logits(true_logit, hard) + if mask.any(): + loss = loss + 0.2 * F.mse_loss(torch.sigmoid(true_logit)[mask], soft_clean[mask]) opt.zero_grad() loss.backward() torch.nn.utils.clip_grad_norm_( @@ -286,13 +322,56 @@ def run(args): log(f"saved best (auc={best_auc:.4f})") log(f"TRAINING-DONE best_auc={best_auc:.4f}") + + # ===== 温度校准: best 模型在 calib 全集上 grid-search T (min NLL) ===== + calib_info = {"best_auc": best_auc} + best_path = os.path.join(OUT_DIR, "model.pt") + if os.path.exists(best_path): + dm.load_state_dict(torch.load(best_path, map_location=dev, weights_only=False)) + was = dm.training + dm.eval() + z_all, y_all = [], [] + with torch.no_grad(): + for b in dl_cal: + lg = fwd(b, no_grad=True) + z_all += lg[..., 1].float().tolist() + y_all += b["label"].tolist() + if was: + dm.train() + def nll_at(T): + tot = 0.0 + for z, y in zip(z_all, y_all): + p = 1.0 / (1.0 + math.exp(-z / T)) + p = min(max(p, 1e-6), 1 - 1e-6) + tot -= math.log(p) if y == 1 else math.log(1 - p) + return tot / len(z_all) + probs_raw = [1 / (1 + math.exp(-z)) for z in z_all] + best_T, n_at_best = 1.0, nll_at(1.0) + T = 0.30 + while T <= 4.001: + n = nll_at(T) + if n < n_at_best: + best_T, n_at_best = T, n + T += 0.05 + probs_T = [1 / (1 + math.exp(-z / best_T)) for z in z_all] + calib_info = { + "best_auc": best_auc, "calib_n": len(z_all), + "auc_raw": round(bisect_auc(probs_raw, y_all), 4), + "ece_raw": round(ece(probs_raw, y_all), 4), + "temperature": round(best_T, 2), + "auc_calibrated": round(bisect_auc(probs_T, y_all), 4), + "ece_calibrated": round(ece(probs_T, y_all), 4), + } + log(f"CALIBRATION T={best_T:.2f} raw(ece={calib_info['ece_raw']}) " + f"calibrated(ece={calib_info['ece_calibrated']}) auc={calib_info['auc_calibrated']}") json.dump({"best_auc": best_auc, "train_pairs": len(train), "steps": gstep, "epochs": args.epochs, - "pretrain_calib": m0, "final_calib": m}, + "pretrain_calib": m0, "final_calib": m, "calibration": calib_info}, open(os.path.join(OUT_DIR, "training_log.json"), "w"), ensure_ascii=False, indent=1) os.makedirs(os.path.join(DATA_DIR, "logs"), exist_ok=True) - json.dump({"best_auc": best_auc, "train_pairs": len(train), "steps": gstep}, + json.dump({"best_auc": best_auc, "train_pairs": len(train), "steps": gstep, + "calibration": calib_info}, open(os.path.join(DATA_DIR, "logs", f"{args.tag}_result.json"), "w"), ensure_ascii=False, indent=1) if not args.tiny: @@ -370,4 +449,8 @@ if __name__ == "__main__": ap.add_argument("--out", default=None, help="覆盖 OUT_DIR") ap.add_argument("--tiny", action="store_true", help="冒烟模式: 随机初始化 + 64 条数据") ap.add_argument("--tag", default="r36", help="产物回传标签") + ap.add_argument("--max_len", type=int, default=512, help="序列总长 (r40=1024)") + ap.add_argument("--head_len", type=int, default=192, help="question 头部预算") + ap.add_argument("--win_tokens", type=int, default=800, help="随机窗口 token 数") + ap.add_argument("--aug_p", type=float, default=0.4, help="随机窗口采样概率") run(ap.parse_args())