| """Train a citation-ranking student: Qwen3-Reranker + LoRA, pairwise logistic loss within each group. |
| |
| python code/train_student.py --labels jev_labels.jsonl --base Qwen/Qwen3-Reranker-4B \ |
| --out runs/student_4b --seed 42 |
| python code/train_student.py --base Qwen/Qwen3-Reranker-4B --zero-shot --out runs/qwen4b_zs |
| |
| --labels is the output of label_jev.py (target = jev / 5) or any JSONL with the fields of |
| benchmark/training_groups.jsonl plus a numeric "target". The script trains on the "natural" groups |
| (add --include-mixed for the cross-query groups), saves the adapter, and writes predictions on |
| benchmark/passages.jsonl in the format read by code/reproduce_tables.py. About two hours for the |
| 4B on one RTX 3090.""" |
| import argparse |
| import json |
| import os |
| import random |
| from collections import defaultdict |
|
|
| import torch |
|
|
| ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| PREFIX = ("<|im_start|>system\nJudge whether the Document meets the requirements based on the Query " |
| "and the Instruct provided. Note that the answer can only be \"yes\" or \"no\".<|im_end|>\n" |
| "<|im_start|>user\n") |
| SUFFIX = "<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n" |
| INSTRUCT = ("Given a user query, judge whether this passage would be cited by a generative answer " |
| "engine (Perplexity, ChatGPT Search, Gemini) writing an answer to the query") |
|
|
|
|
| def encode(tok, pairs, max_len, device): |
| |
| texts = [] |
| for q, d in pairs: |
| ids = tok(d, add_special_tokens=False).input_ids |
| if len(ids) > max_len - 160: |
| d = tok.decode(ids[:max_len - 160]) |
| texts.append(PREFIX + f"<Instruct>: {INSTRUCT}\n<Query>: {q}\n<Document>: {d}" + SUFFIX) |
| return tok(texts, padding=True, return_tensors="pt").to(device) |
|
|
|
|
| def logodds(model, enc, yes, no): |
| last = model(**enc).logits[:, -1, :] |
| return last[:, yes] - last[:, no] |
|
|
|
|
| def load_groups(path, include_mixed, subset, seed): |
| rows = [json.loads(l) for l in open(path)] |
| rows = [r for r in rows if include_mixed or r["kind"] == "natural"] |
| for r in rows: |
| r.setdefault("target", r["jev"] / 5.0) |
| if subset < 1.0: |
| qs = sorted({r["query"] for r in rows}) |
| keep = set(random.Random(seed).sample(qs, round(len(qs) * subset))) |
| rows = [r for r in rows if r["query"] in keep] |
| groups = defaultdict(list) |
| for r in rows: |
| groups[r["group"]].append(r) |
| return [g for g in groups.values() if len(g) >= 2] |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--base", default="Qwen/Qwen3-Reranker-4B") |
| ap.add_argument("--labels") |
| ap.add_argument("--out", required=True) |
| ap.add_argument("--zero-shot", action="store_true") |
| ap.add_argument("--include-mixed", action="store_true") |
| ap.add_argument("--subset", type=float, default=1.0, help="share of training queries kept") |
| ap.add_argument("--epochs", type=int, default=4) |
| ap.add_argument("--lr", type=float, default=1e-4) |
| ap.add_argument("--max-len", type=int, default=1024) |
| ap.add_argument("--min-diff", type=float, default=0.05, help="pairs with a smaller target gap are skipped") |
| ap.add_argument("--seed", type=int, default=42) |
| args = ap.parse_args() |
| random.seed(args.seed) |
| torch.manual_seed(args.seed) |
| os.makedirs(args.out, exist_ok=True) |
| device = "cuda" if torch.cuda.is_available() else "cpu" |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| tok = AutoTokenizer.from_pretrained(args.base, padding_side="left") |
| model = AutoModelForCausalLM.from_pretrained(args.base, torch_dtype=torch.bfloat16).to(device) |
| yes, no = tok.convert_tokens_to_ids("yes"), tok.convert_tokens_to_ids("no") |
|
|
| if not args.zero_shot: |
| from peft import LoraConfig, get_peft_model |
| model.gradient_checkpointing_enable() |
| model.enable_input_require_grads() |
| model = get_peft_model(model, LoraConfig( |
| r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM", |
| target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"])) |
| groups = load_groups(args.labels, args.include_mixed, args.subset, args.seed) |
| params = [p for p in model.parameters() if p.requires_grad] |
| optim = torch.optim.AdamW(params, lr=args.lr) |
| total = len(groups) * args.epochs |
| sched = torch.optim.lr_scheduler.LambdaLR(optim, lambda s: max(0.0, 1.0 - s / total)) |
| for ep in range(args.epochs): |
| model.train() |
| order = list(range(len(groups))) |
| random.Random(args.seed + ep).shuffle(order) |
| for gi in order: |
| g = groups[gi] |
| lo = logodds(model, encode(tok, [(r["query"], r["text"]) for r in g], args.max_len, device), |
| yes, no).float() |
| t = torch.tensor([r["target"] for r in g], device=device) |
| diff = t[:, None] - t[None, :] |
| mask = diff > args.min_diff |
| if not mask.any(): |
| continue |
| w = diff[mask] |
| loss = (w * torch.nn.functional.softplus(-(lo[:, None] - lo[None, :])[mask])).sum() / w.sum() |
| loss.backward() |
| torch.nn.utils.clip_grad_norm_(params, 1.0) |
| optim.step() |
| sched.step() |
| optim.zero_grad() |
| print(f"epoch {ep + 1}/{args.epochs} done", flush=True) |
| model.save_pretrained(os.path.join(args.out, "adapter")) |
|
|
| model.eval() |
| rows = [json.loads(l) for l in open(os.path.join(ROOT, "benchmark", "passages.jsonl"))] |
| preds = {} |
| with torch.no_grad(): |
| for i in range(0, len(rows), 16): |
| chunk = rows[i:i + 16] |
| lo = logodds(model, encode(tok, [(r["query"], r["text"]) for r in chunk], args.max_len, device), yes, no) |
| preds.update({f"{r['query']}||{r['src_idx']}": v for r, v in zip(chunk, lo.float().cpu().tolist())}) |
| json.dump(preds, open(os.path.join(args.out, "predictions.json"), "w")) |
| print(f"{len(preds)} predictions written to {args.out}/predictions.json") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
