File size: 6,286 Bytes
cd2abf6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | """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):
# Truncate the document before assembling, so the yes/no position is never cut off.
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()
|