Download bright_work/master_src/arpipe/retrieval_eval.py from canho/old-storage-backup: direct link, hf CLI and curl.
- Browser
- Download file 9.73 kB
-
https://huggingface.co/datasets/canho/old-storage-backup/resolve/main/bright_work/master_src/arpipe/retrieval_eval.py
- Command line
-
hf download hf://datasets/canho/old-storage-backup/bright_work/master_src/arpipe/retrieval_eval.py
-
curl -L -o retrieval_eval.py https://huggingface.co/datasets/canho/old-storage-backup/resolve/main/bright_work/master_src/arpipe/retrieval_eval.py
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() | |