canho's picture
Add files using upload-large-folder tool
1d04739 verified
Raw History Blame Contribute Delete
9.73 kB
#!/usr/bin/env python3
"""Rank the gold D for each gold pair's query p in a pool of cross-field cited papers.
Pool = phase-1 cited-works pool (12,211, same order as data/emb/pool_ids.json) + gold D papers not already in it.
Models: bm25 (own implementation), colbert (pylate colbertv2.0, run in the denseon-lateon venv), gemini (cached pool + new embeddings).
Usage: retrieval_eval.py --model bm25|colbert --run runs/gold2_v2_sonnet45 --out runs/retrieval"""
import argparse, json, math, os, re, sys
from collections import Counter
from pathlib import Path
HERE = Path(__file__).resolve().parent; ROOT = HERE.parent; D = ROOT / 'data'
GOLD_IDS = ['diffusion_jarzynski', 'ewc_yang', 'per_singerfrank', 'curiosity_ryandeci', 'ntm_rigotti', 'debias_sweeney']
def load_pool():
cited = {}
for fn in ['cited_works.jsonl', 'cited_works_s2.jsonl']:
for l in open(D / fn):
w = json.loads(l); cited[w['id'].rsplit('/', 1)[-1] if w['id'].startswith('https') else w['id']] = w
ids = json.load(open(D / 'emb' / 'pool_ids.json'))
docs = {i: ((cited[i].get('title') or '') + '. ' + (cited[i].get('abstract') or ''))[:4000] for i in ids}
titles = {i: cited[i].get('title') or '' for i in ids}
return ids, docs, titles
def load_gold(run, inp=None, ids=None):
if inp:
pairs = {p['pair_id']: p for p in json.load(open(inp))}
else:
pairs = {p['pair_id']: p for f in ('pairs_positive.json', 'pairs_negative.json') for p in json.load(open(D / 'gold' / f))}
out = []
for pid in (ids or GOLD_IDS):
if not (Path(run) / f'{pid}.json').exists(): continue
r = json.load(open(Path(run) / f'{pid}.json')); p = pairs[pid]
q = (r.get('problem') or {}).get('rewritten_problem') or (r.get('problem') or {}).get('extract', {}).get('problem') or ''
if not q: continue
out.append({'pair_id': pid, 'query': q, 'd_id': 'GOLD:' + pid, 'd_title': p['d']['title'], 'd_doc': (p['d']['title'] + '. ' + (p['d'].get('abstract') or ''))[:4000]})
return out
def load_pool_file(path):
pool = json.load(open(path)); ids = sorted(pool)
return ids, {i: (pool[i]['title'] + '. ' + (pool[i].get('abstract') or ''))[:4000] for i in ids}, {i: pool[i]['title'] for i in ids}
def build_pool(run, inp=None, sel=None, pool_file=None):
ids, docs, titles = load_pool_file(pool_file) if pool_file else load_pool(); gold = load_gold(run, inp, sel)
norm = lambda t: re.sub(r'\W+', '', t.lower())[:40]
have = {norm(t): i for i, t in titles.items()}
for g in gold:
k = norm(g['d_title'])
if k in have: g['d_id'] = have[k]
else: ids.append(g['d_id']); docs[g['d_id']] = g['d_doc']; titles[g['d_id']] = g['d_title']
return ids, docs, titles, gold
def tok(s): return re.findall(r'[a-z0-9]+', s.lower())
def bm25_scores(ids, docs, query, k1=1.5, b=0.75):
toks = {i: tok(docs[i]) for i in ids}; N = len(ids); avg = sum(len(t) for t in toks.values()) / N
df = Counter(); [df.update(set(t)) for t in toks.values()]
q = tok(query); out = {}
for i in ids:
tf = Counter(toks[i]); L = len(toks[i]); s = 0.0
for w in q:
if w not in tf: continue
idf = math.log(1 + (N - df[w] + 0.5) / (df[w] + 0.5))
s += idf * tf[w] * (k1 + 1) / (tf[w] + k1 * (1 - b + b * L / avg))
out[i] = s
return out
def rank_of(scores, ids, gold_id):
order = sorted(ids, key=lambda i: -scores[i]); return order.index(gold_id) + 1, order[:10]
def main():
ap = argparse.ArgumentParser(); ap.add_argument('--model', required=True, choices=['bm25', 'colbert', 'gemini']); ap.add_argument('--run', default=str(HERE / 'runs' / 'gold2_v2_sonnet45')); ap.add_argument('--out', default=str(HERE / 'runs' / 'retrieval'))
ap.add_argument('--input', help='pairs JSON (slice runs); default gold files'); ap.add_argument('--ids-file', help='JSON list of pair ids to evaluate'); ap.add_argument('--pool', help='pool JSON {id: {title, abstract}} (default: phase-1 cross-field pool)')
a = ap.parse_args(); Path(a.out).mkdir(parents=True, exist_ok=True)
sel = json.load(open(a.ids_file)) if a.ids_file else None
ids, docs, titles, gold = build_pool(a.run, a.input, sel, a.pool); print('pool', len(ids), 'queries', len(gold), flush=True)
if a.pool and a.model == 'gemini':
# cached embeddings are for the phase-1 pool only; embed the whole custom pool (cached per pool file)
pass
results = []
if a.model == 'bm25':
for g in gold:
sc = bm25_scores(ids, docs, g['query']); r, top = rank_of(sc, ids, g['d_id'])
results.append({**{k: g[k] for k in ('pair_id', 'query', 'd_title')}, 'rank': r, 'top3': [titles[t][:80] for t in top[:3]], 'top10_ids': top})
print(f"[bm25] {g['pair_id']:22} rank={r:6d} top1={titles[top[0]][:70]}", flush=True)
elif a.model == 'gemini':
import numpy as np
from google import genai
from google.genai import types
key = [l.split('=', 1)[1].strip().strip('"\'') for l in open('/data1/seokwon/layerwise-maxsim-probe/.env') if l.startswith('GEMINI_API_KEY')][0]
client = genai.Client(api_key=key); MODEL = 'gemini-embedding-001'; DIM = 768
import time as _t
def embed(texts, task):
for attempt in range(8): # rate limits (429): back off, as upstream scripts/06_gemini_embed.py does
try:
r = client.models.embed_content(model=MODEL, contents=texts, config=types.EmbedContentConfig(task_type=task, output_dimensionality=DIM))
return np.array([e.values for e in r.embeddings], dtype=np.float32)
except Exception as ex:
wait = min(60, 10 * (attempt + 1)); print(f'retry {attempt + 1}: {str(ex)[:80]} sleep {wait}s', flush=True); _t.sleep(wait)
raise RuntimeError('embed failed')
if a.pool:
cache = Path(a.out) / 'gemini_pool.npy'
if cache.exists(): M = np.load(cache)
else:
cdir = Path(a.out) / 'gemini_chunks'; cdir.mkdir(exist_ok=True); chunks = []
for ci in range(0, len(ids), 100):
cf = cdir / f'{ci}.npy'
if cf.exists(): chunks.append(np.load(cf)); continue
v = embed([docs[i] for i in ids[ci:ci + 100]], 'RETRIEVAL_DOCUMENT'); np.save(cf, v); chunks.append(v); _t.sleep(1.0)
if (ci // 100) % 20 == 0: print(f'embedded {ci + 100}/{len(ids)}', flush=True)
M = np.concatenate(chunks); np.save(cache, M)
new = []
else:
pool_ids = json.load(open(D / 'emb' / 'pool_ids.json')); M = np.load(D / 'emb' / f'pool_{DIM}.npy')
assert ids[:len(pool_ids)] == pool_ids
new = ids[len(pool_ids):]
if new:
cache = Path(a.out) / 'gemini_new_docs.npy'
Mn_new = np.load(cache) if cache.exists() else embed([docs[i] for i in new], 'RETRIEVAL_DOCUMENT'); np.save(cache, Mn_new)
M = np.concatenate([M, Mn_new])
Q = embed([g['query'] for g in gold], 'RETRIEVAL_QUERY')
S = (Q / np.linalg.norm(Q, axis=1, keepdims=True)) @ (M / np.linalg.norm(M, axis=1, keepdims=True)).T
for qi, g in enumerate(gold):
sc = {i: float(S[qi, j]) for j, i in enumerate(ids)}; r, top = rank_of(sc, ids, g['d_id'])
results.append({**{k: g[k] for k in ('pair_id', 'query', 'd_title')}, 'rank': r, 'top3': [titles[t][:80] for t in top[:3]], 'top10_ids': top})
print(f"[gemini] {g['pair_id']:22} rank={r:6d} top1={titles[top[0]][:70]}", flush=True)
else:
os.environ.setdefault('HF_HOME', '/data1/seokwon/hf_cache'); os.environ['HF_HUB_DISABLE_XET'] = '1'
import torch, numpy as np; torch.set_num_threads(int(os.environ.get('NTHREADS', '48')))
from pylate import models
model = models.ColBERT(model_name_or_path='colbert-ir/colbertv2.0', query_length=128, document_length=300, device='cpu')
Q = model.encode([g['query'] for g in gold], is_query=True, batch_size=32, convert_to_tensor=True, show_progress_bar=False)
Q = [q if isinstance(q, torch.Tensor) else torch.tensor(q) for q in Q]
S = np.zeros((len(gold), len(ids)), dtype=np.float32); CH = 256
for ci in range(0, len(ids), CH):
Dm = model.encode([docs[i] for i in ids[ci:ci + CH]], is_query=False, batch_size=32, convert_to_tensor=True, show_progress_bar=False)
Dm = [d if isinstance(d, torch.Tensor) else torch.tensor(d) for d in Dm]
Ld = max(d.shape[0] for d in Dm); Dp = torch.zeros(len(Dm), Ld, Dm[0].shape[1]); mask = torch.zeros(len(Dm), Ld, dtype=torch.bool)
for i, d in enumerate(Dm): Dp[i, :d.shape[0]] = d; mask[i, :d.shape[0]] = True
for qi, q in enumerate(Q):
sim = torch.einsum('qe,dte->dqt', q, Dp).masked_fill(~mask[:, None, :], float('-inf'))
S[qi, ci:ci + CH] = sim.max(dim=2).values.sum(dim=1).numpy()
if (ci // CH) % 8 == 0: print(f'{min(ci + CH, len(ids))}/{len(ids)}', flush=True)
for qi, g in enumerate(gold):
sc = {i: float(S[qi, j]) for j, i in enumerate(ids)}; r, top = rank_of(sc, ids, g['d_id'])
results.append({**{k: g[k] for k in ('pair_id', 'query', 'd_title')}, 'rank': r, 'top3': [titles[t][:80] for t in top[:3]], 'top10_ids': top})
print(f"[colbert] {g['pair_id']:22} rank={r:6d} top1={titles[top[0]][:70]}", flush=True)
json.dump({'model': a.model, 'pool_size': len(ids), 'results': results}, open(Path(a.out) / f'{a.model}.json', 'w'), ensure_ascii=False, indent=1)
if __name__ == '__main__':
main()