File size: 5,973 Bytes
3bc7886 | 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 | """engram.py - the retrieval side of the Beam engram (10-19): question -> static key -> IVF (Optane lists) top-N passages ->
cross-encoder re-rank (ms-marco-MiniLM-L6-v2, as cowork-cli retrieval_v2) -> top-k passages to inject BEFORE inference
(cowork paper: pre-injection 0.94 vs a retrieval tool 0.51-0.63; always-inject beats gated).
from engram import Engram; eg = Engram(); eg.retrieve("question", k=3) -> [{pid, title, section, text, score}]
python engram.py "question" # prints the hits
Tables (10-20): "wiki" is the root table (index/, passages/); every other table is tables/<name>/{index,passages}.
Engram(tables=["wiki", "health"]) splits the NCAND first-stage candidates over the tables and re-ranks them together;
hits carry "table" (pids are only unique within a table).
Env: NPROBE (512: 10-19 sweep, gold article in top 200 0.62 at 32 -> 0.68, flat after; 83 ms), NCAND (100), THREADS (4),
TABLES (wiki), HYBRID (1: tables with a bm25/ index split their candidates half static, half BM25 - tools/bm25.py)."""
import os, re, sys, glob, bisect, time
import numpy as np, faiss, torch
import pyarrow.parquet as pq
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import static_embed
os.environ.setdefault("HF_HOME", "/mnt/optane/hf-cache")
E = "/mnt/optane/engram"
class Passages:
"""pid (file_idx << 32 | n) -> row n of passages/<file>.parquet, read one 4096-row group at a time (cached)"""
def __init__(self, root=E):
self.files = {}
for f in glob.glob(f"{root}/passages/*.parquet"):
a, b = os.path.basename(f)[:-8].split("_"); pf = pq.ParquetFile(f)
starts = np.cumsum([0] + [pf.metadata.row_group(i).num_rows for i in range(pf.metadata.num_row_groups)])
self.files[int(b) + 100 * int(a)] = (pf, starts)
self.cache = {}
def get(self, pid):
fi, n = int(pid) >> 32, int(pid) & 0xFFFFFFFF
pf, st = self.files[fi]; rg = bisect.bisect_right(st, n) - 1
key = (fi, rg)
if key not in self.cache:
if len(self.cache) > 512:
self.cache.clear()
self.cache[key] = pf.read_row_group(rg, columns=["title", "section", "text"]).to_pylist()
return self.cache[key][n - st[rg]]
def table_root(name):
return E if name == "wiki" else f"{E}/tables/{name}"
class Engram:
def __init__(self, nprobe=int(os.environ.get("NPROBE", 512)), ncand=int(os.environ.get("NCAND", 100)), rerank=True, tables=None):
faiss.omp_set_num_threads(int(os.environ.get("THREADS", 4))); torch.set_num_threads(int(os.environ.get("THREADS", 4)))
self.tables, self.lex = {}, {}
for t in tables or os.environ.get("TABLES", "wiki").split(","):
path = os.environ.get("INDEX") if t == "wiki" and os.environ.get("INDEX") else f"{table_root(t)}/index/engram.index"
ix = faiss.read_index(path) # OnDisk lists mmap themselves; IO_FLAG_MMAP here segfaults search
faiss.extract_index_ivf(ix).nprobe = nprobe; self.tables[t] = (ix, Passages(table_root(t)))
if os.environ.get("HYBRID", "1") != "0" and os.path.exists(f"{table_root(t)}/bm25/meta.json"):
import bm25
self.lex[t] = bm25.open_index(table_root(t))
self.ncand = ncand; self.ce = None
if rerank:
from transformers import AutoTokenizer, AutoModelForSequenceClassification
self.ct = AutoTokenizer.from_pretrained("cross-encoder/ms-marco-MiniLM-L6-v2")
self.ce = AutoModelForSequenceClassification.from_pretrained("cross-encoder/ms-marco-MiniLM-L6-v2").eval()
def candidates(self, q, n=None, tables=None):
qv = static_embed.embed([q]); ts = [t for t in (tables or self.tables) if t in self.tables]; out = []
for t in ts:
m = max(1, (n or self.ncand) // len(ts)); m_lex = m // 2 if t in self.lex else 0
s, ids = self.tables[t][0].search(qv, m - m_lex)
got = [(t, int(i), float(v)) for i, v in zip(ids[0], s[0]) if i >= 0]
if m_lex and q.strip():
lx = self.lex[t]; lx.reload(); se = lx.searcher(); seen = {i for _, i, _ in got}
terms = re.sub(r"[\W_]+", " ", q.lower()).split() or ["the"] # one token per term: no phrase queries (no positions)
for sc, a in se.search(lx.parse_query(" ".join(terms), ["text"]), m_lex + len(got)).hits:
pid = se.doc(a)["pid"][0]
if pid not in seen and len(got) < m:
got.append((t, pid, float(sc))); seen.add(pid)
out += got
return out
def retrieve(self, q, k=3, tables=None, extra=()):
"""extra: more first-stage queries (e.g. q + a draft answer, 10-20 two-pass); each gets an equal share of NCAND, the
union is de-duplicated and re-ranked against q alone, so a draft can widen the net but cannot bias the ranking"""
qs = [q] + [x for x in extra if x and x.strip()]; seen, cand = set(), []
for x in qs:
for t, i, v in self.candidates(x, n=max(2, self.ncand // len(qs)), tables=tables):
if (t, i) not in seen:
seen.add((t, i)); cand.append((t, i, v))
hits = [dict(table=t, pid=i, first=v, **self.tables[t][1].get(i)) for t, i, v in cand]
if self.ce is not None and hits:
with torch.inference_mode():
b = self.ct([q] * len(hits), [h["text"] for h in hits], padding=True, truncation=True, max_length=256, return_tensors="pt")
sc = self.ce(**b).logits[:, 0].tolist()
for h, v in zip(hits, sc):
h["score"] = v
hits.sort(key=lambda h: -h["score"])
return hits[:k]
if __name__ == "__main__":
eg = Engram(); t0 = time.time()
for h in eg.retrieve(" ".join(sys.argv[1:]), k=5):
print(f"{h.get('score', h['first']):7.3f} {h['text'][:200]}")
print(f"{time.time() - t0:.2f} s")
|