| """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) |
| 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"] |
| 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") |
|
|
