Upload 18 files

geomretrieval/__init__.py

@@ -0,0 +1,10 @@
+"""Frozen sparse geometric retrieval package."""
+from .config import FrozenConfig
+from .index import GeometricIndex
+from .beir import load_beir_zip, load_beir_directory
+from .metrics import evaluate_run
+
+__all__ = ["FrozenConfig", "GeometricIndex", "load_beir_zip", "load_beir_directory", "evaluate_run"]
+__version__ = "0.1.0"
+
+from .rag_top10 import RAGTop10Config, RAGTop10Ranker

geomretrieval/baselines.py

@@ -0,0 +1,48 @@
+"""Optional dense ANN baseline helpers.
+
+These deliberately accept PRECOMPUTED embeddings. They never run a transformer.
+Install with: pip install 'geomretrieval[ann]'
+"""
+from __future__ import annotations
+import time
+import numpy as np
+
+
+def faiss_flat_ip(corpus: np.ndarray, queries: np.ndarray, k: int = 100):
+    import faiss
+    xb = np.ascontiguousarray(corpus.astype(np.float32))
+    xq = np.ascontiguousarray(queries.astype(np.float32))
+    index = faiss.IndexFlatIP(xb.shape[1])
+    index.add(xb)
+    t0 = time.perf_counter()
+    D, I = index.search(xq, k)
+    ms = (time.perf_counter() - t0) * 1000.0 / len(xq)
+    return I, D, ms
+
+
+def faiss_hnsw_ip(corpus: np.ndarray, queries: np.ndarray, k: int = 100, M: int = 32, ef_search: int = 128):
+    import faiss
+    xb = np.ascontiguousarray(corpus.astype(np.float32))
+    xq = np.ascontiguousarray(queries.astype(np.float32))
+    index = faiss.IndexHNSWFlat(xb.shape[1], M, faiss.METRIC_INNER_PRODUCT)
+    index.hnsw.efSearch = ef_search
+    index.add(xb)
+    t0 = time.perf_counter()
+    D, I = index.search(xq, k)
+    ms = (time.perf_counter() - t0) * 1000.0 / len(xq)
+    return I, D, ms
+
+
+def faiss_ivf_flat_ip(corpus: np.ndarray, queries: np.ndarray, k: int = 100, nlist: int = 4096, nprobe: int = 64):
+    import faiss
+    xb = np.ascontiguousarray(corpus.astype(np.float32))
+    xq = np.ascontiguousarray(queries.astype(np.float32))
+    quant = faiss.IndexFlatIP(xb.shape[1])
+    index = faiss.IndexIVFFlat(quant, xb.shape[1], nlist, faiss.METRIC_INNER_PRODUCT)
+    index.train(xb)
+    index.add(xb)
+    index.nprobe = nprobe
+    t0 = time.perf_counter()
+    D, I = index.search(xq, k)
+    ms = (time.perf_counter() - t0) * 1000.0 / len(xq)
+    return I, D, ms

geomretrieval/beir.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+import csv
+import json
+import os
+import tempfile
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class BEIRDataset:
+    corpus_ids: list[str]
+    corpus_texts: list[str]
+    queries: dict[str, str]
+    qrels: dict[str, dict[str, float]]
+    name: str = "dataset"
+
+
+def _find(root: Path, basename: str) -> Path:
+    hits = list(root.rglob(basename))
+    if not hits:
+        raise FileNotFoundError(f"Could not find {basename!r} under {root}")
+    if len(hits) > 1:
+        # Prefer the shallowest path, which is normally the dataset root.
+        hits.sort(key=lambda p: len(p.parts))
+    return hits[0]
+
+
+def load_beir_directory(path: str | os.PathLike, split: str = "test") -> BEIRDataset:
+    root = Path(path)
+    corpus_path = _find(root, "corpus.jsonl")
+    queries_path = _find(root, "queries.jsonl")
+    qrels_hits = list(root.rglob(f"qrels/{split}.tsv"))
+    if not qrels_hits:
+        # Some archives flatten qrels paths.
+        qrels_hits = [p for p in root.rglob(f"{split}.tsv") if p.parent.name == "qrels"]
+    if not qrels_hits:
+        raise FileNotFoundError(f"Could not find qrels/{split}.tsv under {root}")
+    qrels_path = qrels_hits[0]
+
+    corpus_ids, corpus_texts = [], []
+    with corpus_path.open("r", encoding="utf-8") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            obj = json.loads(line)
+            did = str(obj.get("_id", obj.get("id")))
+            title = obj.get("title", "") or ""
+            text = obj.get("text", "") or ""
+            merged = (title + " " + text).strip()
+            corpus_ids.append(did)
+            corpus_texts.append(merged)
+
+    queries = {}
+    with queries_path.open("r", encoding="utf-8") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            obj = json.loads(line)
+            qid = str(obj.get("_id", obj.get("id")))
+            queries[qid] = obj.get("text", "") or ""
+
+    qrels: dict[str, dict[str, float]] = {}
+    with qrels_path.open("r", encoding="utf-8") as f:
+        reader = csv.DictReader(f, delimiter="\t")
+        for row in reader:
+            # BEIR normally uses query-id, corpus-id, score.
+            qid = str(row.get("query-id", row.get("query_id", row.get("qid"))))
+            did = str(row.get("corpus-id", row.get("corpus_id", row.get("docid"))))
+            score = float(row.get("score", row.get("relevance", row.get("rel", 0))))
+            qrels.setdefault(qid, {})[did] = score
+
+    name = corpus_path.parent.name
+    return BEIRDataset(corpus_ids, corpus_texts, queries, qrels, name=name)
+
+
+def load_beir_zip(path: str | os.PathLike, split: str = "test") -> BEIRDataset:
+    """Load a standard BEIR zip without requiring internet access."""
+    with tempfile.TemporaryDirectory(prefix="geomretrieval_beir_") as td:
+        with zipfile.ZipFile(path, "r") as zf:
+            zf.extractall(td)
+        return load_beir_directory(td, split=split)

geomretrieval/cli.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+
+from .beir import load_beir_zip, load_beir_directory
+from .config import FrozenConfig
+from .index import GeometricIndex
+from .metrics import evaluate_run
+
+
+def _dataset(path: str, split: str):
+    return load_beir_zip(path, split) if str(path).lower().endswith(".zip") else load_beir_directory(path, split)
+
+
+def cmd_build(args):
+    ds = _dataset(args.dataset, args.split)
+    cfg = FrozenConfig(max_features=args.max_features, min_df=args.min_df)
+    idx = GeometricIndex.build(ds.corpus_texts, ds.corpus_ids, cfg, verbose=True)
+    idx.save(args.output)
+    print(f"saved index -> {args.output}")
+
+
+def cmd_eval(args):
+    ds = _dataset(args.dataset, args.split)
+    idx = GeometricIndex.load(args.index)
+    # Evaluate only qrels-bearing queries.
+    queries = {qid: ds.queries[qid] for qid in ds.qrels if qid in ds.queries}
+    run, timing = idx.batch_search(queries, k=args.k, timing=True)
+    metrics = evaluate_run(run, ds.qrels, ks=(10, 100), ndcg_k=10, mrr_k=10)
+    out = {"dataset": ds.name, **metrics, **timing}
+    print(json.dumps(out, indent=2, sort_keys=True))
+    if args.run_json:
+        Path(args.run_json).write_text(json.dumps(run, indent=1))
+
+
+def cmd_search(args):
+    idx = GeometricIndex.load(args.index)
+    ids, scores = idx.search(args.query, k=args.k, return_scores=True)
+    for r, (d, s) in enumerate(zip(ids, scores), start=1):
+        print(f"{r:3d}\t{d}\t{s:.6f}")
+
+
+def main():
+    p = argparse.ArgumentParser(prog="geomretrieval")
+    sp = p.add_subparsers(dest="cmd", required=True)
+
+    b = sp.add_parser("build", help="Build frozen sparse index from a BEIR dataset/archive")
+    b.add_argument("dataset")
+    b.add_argument("output")
+    b.add_argument("--split", default="test")
+    b.add_argument("--max-features", type=int, default=50_000)
+    b.add_argument("--min-df", type=int, default=1)
+    b.set_defaults(func=cmd_build)
+
+    e = sp.add_parser("eval", help="Evaluate an existing index on BEIR qrels")
+    e.add_argument("dataset")
+    e.add_argument("index")
+    e.add_argument("--split", default="test")
+    e.add_argument("--k", type=int, default=100)
+    e.add_argument("--run-json", default=None)
+    e.set_defaults(func=cmd_eval)
+
+    s = sp.add_parser("search", help="Search an existing index")
+    s.add_argument("index")
+    s.add_argument("query")
+    s.add_argument("--k", type=int, default=10)
+    s.set_defaults(func=cmd_search)
+
+    args = p.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

geomretrieval/config.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+from dataclasses import dataclass, asdict
+
+
+@dataclass(frozen=True)
+class FrozenConfig:
+    """Frozen MS-MARCO-developed configuration.
+
+    The point of the six-dataset campaign is transfer, not per-dataset tuning.
+    Only corpus-mechanical settings such as max_features/min_df should be changed
+    when a dataset physically requires it.
+    """
+
+    # Sparse lexical representation
+    max_features: int = 50_000
+    min_df: int = 1
+    lowercase: bool = True
+    token_pattern: str = r"(?u)\b\w\w+\b"
+
+    # Fuzzy index
+    F: int = 4                   # fuzzy memberships/document
+    B: int = 64                  # sparse center support
+    S: int = 16                  # signed residual support/membership
+
+    # Reliability
+    tau: float = 20.0
+    beta: float = -0.2
+    reliability_eps: float = 1e-6
+
+    # Corpus term geometry
+    L: int = 12                  # top terms/document used to estimate graph
+    graph_significance_tau: float = 10.0
+    assoc_k: int = 64            # first-order PPMI neighbors retained
+    route_k: int = 32            # second-order context neighbors retained
+    graph_block_size: int = 128
+
+    # Query routing
+    route_alpha: float = 0.10
+    route_budget: int = 32       # strongest total route coordinates; original terms preserved
+
+    # Head / tail scoring
+    head_k: int = 10
+    gamma_head: float = 0.5
+    gamma_tail: float = 1.0
+    lambda_membership: float = 2.0
+
+    # Final binary-support reranker
+    rerank_pool: int = 2_000
+    lambda_lex: float = 2.5
+    length_b: float = 0.2
+    semantic_k: int = 16
+    lambda_sem: float = 0.05
+
+    # Requested output depth
+    output_k: int = 100
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "FrozenConfig":
+        return cls(**d)

geomretrieval/geometry.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+import numpy as np
+from scipy import sparse
+from sklearn.preprocessing import normalize
+
+from .config import FrozenConfig
+from .utils import csr_row_topk_matrix
+
+
+def _keep_top_sparse_rows(mat: sparse.csr_matrix, k: int, exclude_diagonal_offset: int | None = None) -> sparse.csr_matrix:
+    rows, cols, vals = [], [], []
+    for r in range(mat.shape[0]):
+        a, b = mat.indptr[r], mat.indptr[r + 1]
+        idx, dat = mat.indices[a:b], mat.data[a:b]
+        if exclude_diagonal_offset is not None:
+            diag = exclude_diagonal_offset + r
+            mask = idx != diag
+            idx, dat = idx[mask], dat[mask]
+        if len(dat) == 0:
+            continue
+        kk = min(k, len(dat))
+        pick = np.argpartition(dat, -kk)[-kk:]
+        pick = pick[np.argsort(dat[pick])[::-1]]
+        rows.extend([r] * kk)
+        cols.extend(idx[pick].tolist())
+        vals.extend(dat[pick].astype(np.float32).tolist())
+    return sparse.csr_matrix((np.asarray(vals, np.float32), (rows, cols)), shape=mat.shape)
+
+
+def build_term_graphs(X: sparse.csr_matrix, cfg: FrozenConfig) -> tuple[sparse.csr_matrix, sparse.csr_matrix]:
+    """Build first-order significance-shrunk PPMI A and second-order context graph G.
+
+    Both are built blockwise; a dense vocabulary x vocabulary matrix is never
+    instantiated.
+    """
+    N, M = X.shape
+    T = csr_row_topk_matrix(X, cfg.L, binary=True)
+    n_i = np.asarray(T.sum(axis=0)).ravel().astype(np.float64)
+
+    A_rows, A_cols, A_vals = [], [], []
+    bs = cfg.graph_block_size
+    for start in range(0, M, bs):
+        end = min(M, start + bs)
+        # co[r,j] = number of documents in which term start+r and j both appear
+        # among the document's top-L TF-IDF coordinates.
+        co = (T[:, start:end].T @ T).tocsr()
+        for local in range(end - start):
+            i = start + local
+            a, b = co.indptr[local], co.indptr[local + 1]
+            js = co.indices[a:b]
+            nij = co.data[a:b].astype(np.float64)
+            mask = (js != i) & (nij > 0) & (n_i[js] > 0) & (n_i[i] > 0)
+            js, nij = js[mask], nij[mask]
+            if not len(js):
+                continue
+            ppmi = np.log((nij * float(N) + 1e-12) / (n_i[i] * n_i[js] + 1e-12))
+            ppmi = np.maximum(ppmi, 0.0)
+            score = (nij / (nij + cfg.graph_significance_tau)) * ppmi
+            pos = score > 0
+            js, score = js[pos], score[pos]
+            if not len(score):
+                continue
+            kk = min(cfg.assoc_k, len(score))
+            pick = np.argpartition(score, -kk)[-kk:]
+            pick = pick[np.argsort(score[pick])[::-1]]
+            A_rows.extend([i] * kk)
+            A_cols.extend(js[pick].tolist())
+            A_vals.extend(score[pick].astype(np.float32).tolist())
+
+    A = sparse.csr_matrix((np.asarray(A_vals, np.float32), (A_rows, A_cols)), shape=(M, M))
+    A.eliminate_zeros()
+
+    An = normalize(A, norm="l2", axis=1, copy=True)
+    G_rows, G_cols, G_vals = [], [], []
+    for start in range(0, M, bs):
+        end = min(M, start + bs)
+        sim = (An[start:end] @ An.T).tocsr()
+        for local in range(end - start):
+            i = start + local
+            a, b = sim.indptr[local], sim.indptr[local + 1]
+            js = sim.indices[a:b]
+            vv = sim.data[a:b]
+            mask = (js != i) & (vv > 0)
+            js, vv = js[mask], vv[mask]
+            if not len(vv):
+                continue
+            kk = min(cfg.route_k, len(vv))
+            pick = np.argpartition(vv, -kk)[-kk:]
+            pick = pick[np.argsort(vv[pick])[::-1]]
+            G_rows.extend([i] * kk)
+            G_cols.extend(js[pick].tolist())
+            G_vals.extend(vv[pick].astype(np.float32).tolist())
+    G = sparse.csr_matrix((np.asarray(G_vals, np.float32), (G_rows, G_cols)), shape=(M, M))
+    G.eliminate_zeros()
+    return A, G

geomretrieval/index.py

@@ -0,0 +1,500 @@
+from __future__ import annotations
+import json
+import os
+import time
+from pathlib import Path
+from typing import Iterable
+
+import joblib
+import numpy as np
+from scipy import sparse
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+from .config import FrozenConfig
+from .geometry import build_term_graphs
+from .utils import topk_sparse_row, zscore
+
+
+class GeometricIndex:
+    """Frozen sparse geometric retrieval index.
+
+    The implementation follows the final handoff architecture:
+      TF-IDF -> F=4 fuzzy routing -> B=64 sparse centers -> S=16 signed
+      residuals -> inverse local sign-variance reliability -> significance
+      scoring -> second-order vocabulary routing -> binary whole-document
+      support reranking.
+    """
+
+    def __init__(self, config: FrozenConfig | None = None):
+        self.config = config or FrozenConfig()
+        self.vectorizer: TfidfVectorizer | None = None
+        self.doc_ids: np.ndarray | None = None
+        self.X: sparse.csr_matrix | None = None
+
+    # ------------------------------------------------------------------
+    # BUILD
+    # ------------------------------------------------------------------
+    @classmethod
+    def build(
+        cls,
+        texts: list[str],
+        doc_ids: list[str] | None = None,
+        config: FrozenConfig | None = None,
+        verbose: bool = True,
+    ) -> "GeometricIndex":
+        self = cls(config)
+        cfg = self.config
+        N = len(texts)
+        if doc_ids is None:
+            doc_ids = [str(i) for i in range(N)]
+        if len(doc_ids) != N:
+            raise ValueError("doc_ids and texts must have identical length")
+        self.doc_ids = np.asarray(doc_ids, dtype=object)
+
+        def log(msg):
+            if verbose:
+                print(msg, flush=True)
+
+        t0 = time.perf_counter()
+        log(f"[1/8] TF-IDF: N={N:,}, max_features={cfg.max_features:,}")
+        self.vectorizer = TfidfVectorizer(
+            max_features=cfg.max_features,
+            min_df=cfg.min_df,
+            lowercase=cfg.lowercase,
+            token_pattern=cfg.token_pattern,
+            norm="l2",
+            dtype=np.float32,
+            smooth_idf=True,
+            sublinear_tf=False,
+        )
+        X = self.vectorizer.fit_transform(texts).tocsr().astype(np.float32)
+        X.sort_indices()
+        self.X = X
+        self.idf = np.asarray(self.vectorizer.idf_, dtype=np.float32)
+        self.vocab_size = X.shape[1]
+        M = self.vocab_size
+        log(f"      shape={X.shape}, nnz={X.nnz:,}, {time.perf_counter()-t0:.2f}s")
+
+        # Whole-document binary support is simply the CSR sparsity pattern.
+        # Keep a separate compact CSR with uint8 data so query reranking never
+        # needs the TF-IDF amplitudes.
+        self.support_indptr = X.indptr.astype(np.int64, copy=True)
+        self.support_indices = X.indices.astype(np.int32, copy=True)
+
+        analyzer = self.vectorizer.build_analyzer()
+        self.doc_lengths = np.asarray([len(analyzer(t)) for t in texts], dtype=np.int32)
+        self.avg_doc_length = float(max(1.0, self.doc_lengths.mean()))
+
+        # ---------------- Fuzzy memberships ----------------
+        log(f"[2/8] Fuzzy memberships F={cfg.F}")
+        branches = np.full((N, cfg.F), -1, dtype=np.int32)
+        memberships = np.zeros((N, cfg.F), dtype=np.float32)
+        for d in range(N):
+            a, b = X.indptr[d], X.indptr[d+1]
+            idx, dat = X.indices[a:b], X.data[a:b]
+            if not len(idx):
+                continue
+            ii, vv = topk_sparse_row(idx, dat, cfg.F)
+            n = len(ii)
+            branches[d, :n] = ii
+            den = float(vv.sum())
+            memberships[d, :n] = vv / den if den > 0 else 1.0 / n
+        self.branches = branches
+        self.memberships = memberships
+
+        # Flatten memberships and sort by branch. This one structure serves as
+        # the branch inverted index while preserving the document/slot identity.
+        flat_branch = branches.ravel()
+        valid_flat = np.flatnonzero(flat_branch >= 0).astype(np.int64)
+        order = np.argsort(flat_branch[valid_flat], kind="stable")
+        self.branch_order = valid_flat[order]
+        sorted_br = flat_branch[self.branch_order]
+        counts = np.bincount(sorted_br, minlength=M)
+        self.branch_offsets = np.zeros(M + 1, dtype=np.int64)
+        np.cumsum(counts, out=self.branch_offsets[1:])
+
+        # ---------------- Sparse shared centers ----------------
+        log(f"[3/8] Sparse branch centers B={cfg.B}")
+        wr = np.repeat(np.arange(N, dtype=np.int32), cfg.F)
+        wc = branches.ravel()
+        wd = memberships.ravel()
+        valid = wc >= 0
+        W = sparse.csr_matrix((wd[valid], (wr[valid], wc[valid])), shape=(N, M), dtype=np.float32)
+        branch_mass = np.asarray(W.sum(axis=0)).ravel().astype(np.float32)
+        center_terms = np.full((M, cfg.B), -1, dtype=np.int32)
+        center_values = np.zeros((M, cfg.B), dtype=np.float32)
+        block = 256
+        for start in range(0, M, block):
+            end = min(M, start + block)
+            C = (W[:, start:end].T @ X).tocsr()
+            for local in range(end-start):
+                j = start + local
+                if branch_mass[j] <= 0:
+                    continue
+                a, b = C.indptr[local], C.indptr[local+1]
+                idx = C.indices[a:b]
+                dat = C.data[a:b] / branch_mass[j]
+                if not len(dat):
+                    continue
+                kk = min(cfg.B, len(dat))
+                pick = np.argpartition(dat, -kk)[-kk:]
+                ii, vv = idx[pick], dat[pick]
+                # Sorted term IDs make residual construction and later lookup cheap.
+                oo = np.argsort(ii)
+                ii, vv = ii[oo], vv[oo]
+                center_terms[j, :kk] = ii
+                center_values[j, :kk] = vv
+        self.center_terms = center_terms
+        self.center_values = center_values
+        del W
+
+        # ---------------- Signed residual codes ----------------
+        log(f"[4/8] Signed residuals S={cfg.S} (document-present coordinates only)")
+        res_terms = np.full((N, cfg.F, cfg.S), -1, dtype=np.int32)
+        res_signs = np.zeros((N, cfg.F, cfg.S), dtype=np.int8)
+        res_center = np.zeros((N, cfg.F, cfg.S), dtype=np.float32)
+
+        for d in range(N):
+            a, b = X.indptr[d], X.indptr[d+1]
+            didx, dval = X.indices[a:b], X.data[a:b]
+            if not len(didx):
+                continue
+            for s in range(cfg.F):
+                j = int(branches[d, s])
+                if j < 0:
+                    continue
+                cidx = center_terms[j]
+                cval = center_values[j]
+                maskc = cidx >= 0
+                ck, cv = cidx[maskc], cval[maskc]
+                c_at_doc = np.zeros(len(didx), dtype=np.float32)
+                if len(ck):
+                    pos = np.searchsorted(ck, didx)
+                    ok = pos < len(ck)
+                    oi = np.flatnonzero(ok)
+                    if len(oi):
+                        p = pos[oi]
+                        same = ck[p] == didx[oi]
+                        chosen = oi[same]
+                        c_at_doc[chosen] = cv[pos[chosen]]
+                residual = dval - c_at_doc
+                kk = min(cfg.S, len(residual))
+                pick = np.argpartition(np.abs(residual), -kk)[-kk:]
+                pick = pick[np.argsort(np.abs(residual[pick]))[::-1]]
+                res_terms[d, s, :kk] = didx[pick]
+                res_signs[d, s, :kk] = np.where(residual[pick] >= 0, 1, -1).astype(np.int8)
+                res_center[d, s, :kk] = c_at_doc[pick]
+        self.res_terms = res_terms
+        self.res_signs = res_signs
+        self.res_center_values = res_center
+
+        # ---------------- Reliability ----------------
+        log("[5/8] Zero-inclusive local sign reliability")
+        rel = np.ones((N, cfg.F, cfg.S), dtype=np.float16)
+        # Global sign variance: zeros are implicit over all valid memberships.
+        n_memberships_total = max(1, len(self.branch_order))
+        global_count = np.zeros(M, dtype=np.float64)
+        global_sum = np.zeros(M, dtype=np.float64)
+        for d0 in range(0, N, 50_000):
+            tt = res_terms[d0:d0+50_000].ravel()
+            zz = res_signs[d0:d0+50_000].ravel().astype(np.float64)
+            ok = tt >= 0
+            global_count += np.bincount(tt[ok], minlength=M)
+            global_sum += np.bincount(tt[ok], weights=zz[ok], minlength=M)
+        g_e2 = global_count / n_memberships_total
+        g_e1 = global_sum / n_memberships_total
+        global_var = np.maximum(g_e2 - g_e1 * g_e1, 0.0)
+        self.global_sign_var = global_var.astype(np.float32)
+
+        # Process one branch at a time. Each branch sees only its own memberships,
+        # so np.unique operates on a small local residual set rather than a giant
+        # vocabulary x vocabulary table.
+        flat_rel = rel.reshape(N * cfg.F, cfg.S)
+        flat_terms = res_terms.reshape(N * cfg.F, cfg.S)
+        flat_signs = res_signs.reshape(N * cfg.F, cfg.S)
+        for j in range(M):
+            a, b = self.branch_offsets[j], self.branch_offsets[j+1]
+            mpos = self.branch_order[a:b]
+            nj = len(mpos)
+            if nj == 0:
+                continue
+            terms_j = flat_terms[mpos].ravel()
+            signs_j = flat_signs[mpos].ravel().astype(np.float64)
+            ok = terms_j >= 0
+            if not np.any(ok):
+                continue
+            u, inv = np.unique(terms_j[ok], return_inverse=True)
+            cnt = np.bincount(inv).astype(np.float64)
+            sm = np.bincount(inv, weights=signs_j[ok]).astype(np.float64)
+            e2 = cnt / nj
+            e1 = sm / nj
+            lv = np.maximum(e2 - e1 * e1, 0.0)
+            shr = (cnt / (cnt + cfg.tau)) * lv + (cfg.tau / (cnt + cfg.tau)) * global_var[u]
+            w = np.power(shr + cfg.reliability_eps, cfg.beta)
+            # Keep the mean branch weight near one to avoid branch-scale artifacts.
+            if len(w) and np.isfinite(w).all() and w.mean() > 0:
+                w = w / w.mean()
+            lookup = {int(t): float(v) for t, v in zip(u, w)}
+            # Offline dictionary use is acceptable; query-time retrieval remains vectorized.
+            for p in mpos:
+                for r in range(cfg.S):
+                    t = int(flat_terms[p, r])
+                    if t >= 0:
+                        flat_rel[p, r] = np.float16(lookup.get(t, 1.0))
+        self.res_reliability = rel
+
+        # ---------------- Term geometry ----------------
+        log(f"[6/8] Term geometry L={cfg.L}, PPMI top={cfg.assoc_k}, context top={cfg.route_k}")
+        self.A, self.G = build_term_graphs(X, cfg)
+
+        # Index no longer requires TF-IDF corpus amplitudes for normal querying.
+        # Retain X only in-memory for diagnostics; save() omits it by default.
+        log("[7/8] Finalizing compact index")
+        self._fitted = True
+        self.build_seconds = time.perf_counter() - t0
+        log(f"[8/8] DONE in {self.build_seconds:.2f}s")
+        return self
+
+    # ------------------------------------------------------------------
+    # QUERY
+    # ------------------------------------------------------------------
+    def _query_vector(self, text: str) -> sparse.csr_matrix:
+        if self.vectorizer is None:
+            raise RuntimeError("Index is not fitted")
+        q = self.vectorizer.transform([text]).tocsr().astype(np.float32)
+        q.sort_indices()
+        return q
+
+    def _expanded_route(self, q: sparse.csr_matrix) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        cfg = self.config
+        M = self.vocab_size
+        qa, qb = q.indptr[0], q.indptr[1]
+        q_terms = q.indices[qa:qb]
+        q_vals = q.data[qa:qb]
+        route = np.zeros(M, dtype=np.float32)
+        route[q_terms] = q_vals
+
+        # Weak second-order semantic routing. Original coordinates are preserved.
+        for t, qv in zip(q_terms, q_vals):
+            a, b = self.G.indptr[t], self.G.indptr[t+1]
+            nb = self.G.indices[a:b]
+            sv = self.G.data[a:b]
+            route[nb] += cfg.route_alpha * float(qv) * sv
+
+        nonzero = np.flatnonzero(route > 0)
+        originals = set(map(int, q_terms.tolist()))
+        if len(nonzero) > cfg.route_budget:
+            # Preserve every literal query term; fill the remaining budget with
+            # strongest inferred coordinates.
+            inferred = np.asarray([i for i in nonzero if int(i) not in originals], dtype=np.int32)
+            budget = max(0, cfg.route_budget - len(originals))
+            if budget and len(inferred) > budget:
+                pick = np.argpartition(route[inferred], -budget)[-budget:]
+                inferred = inferred[pick]
+            elif budget == 0:
+                inferred = np.empty(0, dtype=np.int32)
+            chosen = np.asarray(sorted(originals), dtype=np.int32)
+            nonzero = np.concatenate([chosen, inferred])
+        # strongest first is convenient but not required for union routing
+        order = np.argsort(route[nonzero])[::-1]
+        return nonzero[order].astype(np.int32), route[nonzero[order]], q_terms
+
+    def search(self, text: str, k: int | None = None, return_scores: bool = False):
+        cfg = self.config
+        k = int(k or cfg.output_k)
+        q = self._query_vector(text)
+        q_dense = np.zeros(self.vocab_size, dtype=np.float32)
+        q_dense[q.indices] = q.data
+        route_terms, route_vals, q_terms = self._expanded_route(q)
+        if len(route_terms) == 0:
+            return ([], np.empty(0, np.float32)) if return_scores else []
+
+        route_dense = np.zeros(self.vocab_size, dtype=np.float32)
+        route_dense[route_terms] = route_vals
+
+        # Retrieve matching membership positions, not just docs, because fuzzy
+        # multi-branch evidence is part of the score.
+        pieces = []
+        for j in route_terms:
+            a, b = self.branch_offsets[j], self.branch_offsets[j+1]
+            if b > a:
+                pieces.append(self.branch_order[a:b])
+        if not pieces:
+            return ([], np.empty(0, np.float32)) if return_scores else []
+        flatpos = np.concatenate(pieces).astype(np.int64, copy=False)
+        docs = (flatpos // cfg.F).astype(np.int64)
+        slots = (flatpos % cfg.F).astype(np.int64)
+        br = self.branches[docs, slots]
+
+        terms = self.res_terms[docs, slots]
+        valid = terms >= 0
+        safe_terms = np.where(valid, terms, 0)
+        qv = q_dense[safe_terms]
+        local = np.sum(
+            self.res_reliability[docs, slots].astype(np.float32)
+            * (qv - self.res_center_values[docs, slots])
+            * self.res_signs[docs, slots].astype(np.float32)
+            * valid,
+            axis=1,
+        )
+        significance = np.sum((qv * qv) * valid, axis=1)
+        m = self.memberships[docs, slots]
+        rho = route_dense[br]
+
+        unique_docs, inv = np.unique(docs, return_inverse=True)
+        head_contrib = m * rho * local * np.power(np.maximum(significance, 0.0), cfg.gamma_head)
+        tail_contrib = m * rho * local * np.power(np.maximum(significance, 0.0), cfg.gamma_tail)
+        consensus_contrib = m * rho
+        head = np.bincount(inv, weights=head_contrib, minlength=len(unique_docs)).astype(np.float32)
+        tail = np.bincount(inv, weights=tail_contrib, minlength=len(unique_docs)).astype(np.float32)
+        consensus = np.bincount(inv, weights=consensus_contrib, minlength=len(unique_docs)).astype(np.float32)
+        tail = tail + cfg.lambda_membership * consensus
+
+        # Freeze precision head.
+        hk = min(cfg.head_k, len(unique_docs))
+        hidx = np.argpartition(head, -hk)[-hk:]
+        hidx = hidx[np.argsort(head[hidx])[::-1]]
+        frozen_docs = unique_docs[hidx]
+        frozen_set = set(map(int, frozen_docs.tolist()))
+
+        # Recall-oriented tail shortlist.
+        mask_tail = np.asarray([int(d) not in frozen_set for d in unique_docs], dtype=bool)
+        td = unique_docs[mask_tail]
+        ts = tail[mask_tail]
+        if len(td):
+            P = min(cfg.rerank_pool, len(td))
+            pidx = np.argpartition(ts, -P)[-P:]
+            shortlist_docs = td[pidx]
+            shortlist_tail = ts[pidx]
+
+            # Whole-document binary lexical support. This is deliberately term
+            # presence only; exact within-document TF was found unnecessary.
+            lex_vec = np.zeros(self.vocab_size, dtype=np.float32)
+            lex_vec[q.indices] = self.idf[q.indices]
+            lex = np.zeros(P, dtype=np.float32)
+
+            sem_vec = np.zeros(self.vocab_size, dtype=np.float32)
+            for t, qamp in zip(q.indices, q.data):
+                a, b = self.A.indptr[t], self.A.indptr[t+1]
+                nb = self.A.indices[a:b][:cfg.semantic_k]
+                sv = self.A.data[a:b][:cfg.semantic_k]
+                if len(nb):
+                    sem_vec[nb] += float(qamp) * sv * self.idf[nb]
+            sem = np.zeros(P, dtype=np.float32)
+
+            for i, d in enumerate(shortlist_docs):
+                a, b = self.support_indptr[d], self.support_indptr[d+1]
+                support = self.support_indices[a:b]
+                lex[i] = float(lex_vec[support].sum())
+                if cfg.length_b != 0:
+                    denom = (1.0 - cfg.length_b) + cfg.length_b * (float(self.doc_lengths[d]) / self.avg_doc_length)
+                    if denom > 0:
+                        lex[i] /= denom
+                sem[i] = float(sem_vec[support].sum())
+
+            final = zscore(shortlist_tail) + cfg.lambda_lex * zscore(lex) + cfg.lambda_sem * zscore(sem)
+            oo = np.argsort(final)[::-1]
+            ranked_tail = shortlist_docs[oo]
+            ranked_tail_scores = final[oo]
+
+            # If caller asks beyond the reranking pool, append remaining tail by
+            # the cheap score. This does not affect the usual top-100 evaluation.
+            shortlist_set = set(map(int, shortlist_docs.tolist()))
+            rest_mask = np.asarray([int(d) not in shortlist_set for d in td], dtype=bool)
+            rest_docs = td[rest_mask]
+            rest_scores = ts[rest_mask]
+            if len(rest_docs):
+                ro = np.argsort(rest_scores)[::-1]
+                ranked_tail = np.concatenate([ranked_tail, rest_docs[ro]])
+                ranked_tail_scores = np.concatenate([ranked_tail_scores, rest_scores[ro]])
+        else:
+            ranked_tail = np.empty(0, dtype=np.int64)
+            ranked_tail_scores = np.empty(0, dtype=np.float32)
+
+        ranked = np.concatenate([frozen_docs, ranked_tail])[:k]
+        # Head and tail score scales differ; scores are only for diagnostics.
+        hs = head[hidx]
+        scores = np.concatenate([hs, ranked_tail_scores])[:k]
+        ids = self.doc_ids[ranked].tolist()
+        if return_scores:
+            return ids, scores
+        return ids
+
+    def batch_search(self, queries: dict[str, str], k: int | None = None, timing: bool = False):
+        run: dict[str, list[str]] = {}
+        times_ms = []
+        for qid, text in queries.items():
+            t0 = time.perf_counter()
+            run[str(qid)] = self.search(text, k=k)
+            times_ms.append((time.perf_counter() - t0) * 1000.0)
+        if timing:
+            arr = np.asarray(times_ms, dtype=np.float64)
+            return run, {
+                "median_ms": float(np.median(arr)),
+                "mean_ms": float(np.mean(arr)),
+                "p95_ms": float(np.percentile(arr, 95)),
+                "qps": float(1000.0 / np.mean(arr)) if np.mean(arr) > 0 else float("inf"),
+            }
+        return run
+
+    # ------------------------------------------------------------------
+    # SERIALIZATION
+    # ------------------------------------------------------------------
+    def save(self, path: str | os.PathLike, include_tfidf_matrix: bool = False):
+        p = Path(path)
+        p.mkdir(parents=True, exist_ok=True)
+        joblib.dump(self.vectorizer, p / "vectorizer.joblib")
+        with (p / "config.json").open("w") as f:
+            json.dump(self.config.to_dict(), f, indent=2)
+        meta = {
+            "vocab_size": int(self.vocab_size),
+            "avg_doc_length": float(self.avg_doc_length),
+            "build_seconds": float(getattr(self, "build_seconds", 0.0)),
+        }
+        with (p / "meta.json").open("w") as f:
+            json.dump(meta, f, indent=2)
+        np.savez_compressed(
+            p / "arrays.npz",
+            doc_ids=self.doc_ids,
+            idf=self.idf,
+            support_indptr=self.support_indptr,
+            support_indices=self.support_indices,
+            doc_lengths=self.doc_lengths,
+            branches=self.branches,
+            memberships=self.memberships,
+            branch_order=self.branch_order,
+            branch_offsets=self.branch_offsets,
+            center_terms=self.center_terms,
+            center_values=self.center_values,
+            res_terms=self.res_terms,
+            res_signs=self.res_signs,
+            res_center_values=self.res_center_values,
+            res_reliability=self.res_reliability,
+            global_sign_var=self.global_sign_var,
+        )
+        sparse.save_npz(p / "assoc_ppmi.npz", self.A)
+        sparse.save_npz(p / "context_similarity.npz", self.G)
+        if include_tfidf_matrix and self.X is not None:
+            sparse.save_npz(p / "tfidf_corpus.npz", self.X)
+
+    @classmethod
+    def load(cls, path: str | os.PathLike) -> "GeometricIndex":
+        p = Path(path)
+        with (p / "config.json").open() as f:
+            cfg = FrozenConfig.from_dict(json.load(f))
+        self = cls(cfg)
+        self.vectorizer = joblib.load(p / "vectorizer.joblib")
+        with (p / "meta.json").open() as f:
+            meta = json.load(f)
+        a = np.load(p / "arrays.npz", allow_pickle=True)
+        for name in a.files:
+            setattr(self, name, a[name])
+        self.vocab_size = int(meta["vocab_size"])
+        self.avg_doc_length = float(meta["avg_doc_length"])
+        self.build_seconds = float(meta.get("build_seconds", 0.0))
+        self.A = sparse.load_npz(p / "assoc_ppmi.npz").tocsr()
+        self.G = sparse.load_npz(p / "context_similarity.npz").tocsr()
+        tfidf = p / "tfidf_corpus.npz"
+        self.X = sparse.load_npz(tfidf).tocsr() if tfidf.exists() else None
+        self._fitted = True
+        return self

geomretrieval/metrics.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+import math
+import numpy as np
+
+
+def _dcg(rels: list[float], exp_gain: bool = True) -> float:
+    total = 0.0
+    for rank, rel in enumerate(rels, start=1):
+        gain = (2.0 ** rel - 1.0) if exp_gain else rel
+        total += gain / math.log2(rank + 1.0)
+    return total
+
+
+def evaluate_run(
+    run: dict[str, list[str]],
+    qrels: dict[str, dict[str, float]],
+    ks: tuple[int, ...] = (10, 100),
+    ndcg_k: int = 10,
+    mrr_k: int = 10,
+    exp_gain: bool = True,
+) -> dict[str, float]:
+    """Binary top-K metrics plus graded nDCG.
+
+    'Accuracy' for retrieval is reported as Hit@K rather than ordinary
+    classification accuracy, which is meaningless with millions of negatives.
+    """
+    qids = [q for q in qrels if q in run]
+    if not qids:
+        raise ValueError("No query IDs overlap between run and qrels")
+
+    vals: dict[str, list[float]] = {}
+    for k in ks:
+        vals[f"P@{k}"] = []
+        vals[f"R@{k}"] = []
+        vals[f"Hit@{k}"] = []
+    vals[f"MRR@{mrr_k}"] = []
+    vals[f"nDCG@{ndcg_k}"] = []
+
+    for qid in qids:
+        ranked = run[qid]
+        qr = qrels[qid]
+        positive = {d for d, r in qr.items() if r > 0}
+        npos = max(1, len(positive))
+
+        for k in ks:
+            top = ranked[:k]
+            hits = sum(1 for d in top if d in positive)
+            vals[f"P@{k}"].append(hits / float(k))
+            vals[f"R@{k}"].append(hits / float(npos))
+            vals[f"Hit@{k}"].append(float(hits > 0))
+
+        rr = 0.0
+        for rank, d in enumerate(ranked[:mrr_k], start=1):
+            if d in positive:
+                rr = 1.0 / rank
+                break
+        vals[f"MRR@{mrr_k}"].append(rr)
+
+        observed = [float(qr.get(d, 0.0)) for d in ranked[:ndcg_k]]
+        ideal = sorted((float(r) for r in qr.values()), reverse=True)[:ndcg_k]
+        idcg = _dcg(ideal, exp_gain=exp_gain)
+        vals[f"nDCG@{ndcg_k}"].append(_dcg(observed, exp_gain=exp_gain) / idcg if idcg > 0 else 0.0)
+
+    out = {k: float(np.mean(v)) for k, v in vals.items()}
+    out["n_queries"] = float(len(qids))
+    return out

geomretrieval/rag_top10.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+
+"""Top-10 RAG ranking layer for the sparse geometric index.
+
+This module is the cleaned, path-independent version of the exact SciFact and
+TREC-COVID experiment scripts preserved under ``experiments/beir/*history.py``.
+It keeps the geometric index fixed and changes only the shortlist size P and
+the final top-10 set construction.
+
+Important implementation choices
+--------------------------------
+* Early rescue: binary whole-chunk IDF^1 support.
+* Final lexical signal: binary whole-chunk IDF^2 support, not TF^2.
+* Final components retain the validated per-query z-normalization.
+* Branch quality H_j is the mean of the top three branch-specific evidences.
+* Diversity is available only to the ten highest-quality branches.
+* Rank 1 is pure relevance; ranks 2..10 receive a soft diversity correction.
+* Repeated branches are allowed. There is no one-document-per-branch rule.
+"""
+
+from dataclasses import dataclass
+import time
+import numpy as np
+
+from .metrics import evaluate_run
+
+
+def _zscore(x):
+    x = np.asarray(x, np.float32)
+    if not len(x):
+        return x
+    sd = float(x.std())
+    return np.zeros_like(x) if sd < 1e-8 else (x - float(x.mean())) / sd
+
+
+def _minmax_hi(x):
+    """Map scores monotonically to [0, 1], high remains good."""
+    x = np.asarray(x, np.float32)
+    if not len(x):
+        return x
+    lo, hi = float(x.min()), float(x.max())
+    den = hi - lo
+    return np.ones_like(x) if den < 1e-8 else (x - lo) / den
+
+
+def _topk_large(score, k):
+    score = np.asarray(score)
+    n = len(score)
+    k = min(int(k), n)
+    if k <= 0:
+        return np.empty(0, np.int64)
+    if n <= k:
+        return np.argsort(score)[::-1]
+    ii = np.argpartition(score, -k)[-k:]
+    return ii[np.argsort(score[ii])[::-1]]
+
+
+@dataclass(frozen=True)
+class RAGTop10Config:
+    pool_size: int = 100
+    gamma: float = 0.25
+    lambda_membership: float = 0.125
+    pre_length_b: float = 0.2
+    final_length_b: float = 0.1
+    coordination_alpha: float = 0.25
+    lambda_lex: float = 4.0
+    lambda_sem: float = 0.3
+    lambda_rare: float = 1.0
+    semantic_k: int = 16
+    rare_topk: int = 3
+    hq_top_branches: int = 10
+    branch_quality_top_docs: int = 3
+    lambda_diversity: float = 0.1
+
+
+class RAGTop10Ranker:
+    """RAG-oriented shortlist and top-10 set selector.
+
+    ``GeometricIndex`` performs corpus indexing and stores the compact geometry.
+    This class consumes that frozen representation. It does not train a model,
+    rebuild centers, or alter residual codes.
+    """
+
+    def __init__(self, index, config: RAGTop10Config | None = None):
+        self.idx = index
+        self.cfg = config or RAGTop10Config()
+        self.M = int(index.vocab_size)
+
+    def _center_sparse(self, branch):
+        t = self.idx.center_terms[branch]
+        v = self.idx.center_values[branch]
+        ok = t >= 0
+        t = t[ok].astype(np.int32)
+        v = v[ok].astype(np.float32)
+        n = float(np.linalg.norm(v))
+        if n > 0:
+            v = v / n
+        order = np.argsort(t)
+        return t[order], v[order]
+
+    @staticmethod
+    def _spdot(a_t, a_v, b_t, b_v):
+        i = j = 0
+        s = 0.0
+        while i < len(a_t) and j < len(b_t):
+            if a_t[i] == b_t[j]:
+                s += float(a_v[i]) * float(b_v[j]); i += 1; j += 1
+            elif a_t[i] < b_t[j]:
+                i += 1
+            else:
+                j += 1
+        return s
+
+    def prepare(self, text: str):
+        """Retrieve geometric candidates and create the P-sized chunk shortlist."""
+        idx, cfg, M = self.idx, self.cfg, self.M
+        q = idx._query_vector(text)
+        if q.nnz == 0:
+            return None
+
+        q_dense = np.zeros(M, np.float32)
+        q_dense[q.indices] = q.data
+        route_terms, route_values, _ = idx._expanded_route(q)
+        if not len(route_terms):
+            return None
+        route_dense = np.zeros(M, np.float32)
+        route_dense[route_terms] = route_values
+
+        pieces = []
+        for j in route_terms:
+            a, b = idx.branch_offsets[j], idx.branch_offsets[j + 1]
+            if b > a:
+                pieces.append(idx.branch_order[a:b])
+        if not pieces:
+            return None
+
+        flat_pos = np.concatenate(pieces).astype(np.int64, copy=False)
+        docs = (flat_pos // idx.config.F).astype(np.int64)
+        slots = (flat_pos % idx.config.F).astype(np.int64)
+        branches = idx.branches[docs, slots]
+
+        terms = idx.res_terms[docs, slots]
+        valid = terms >= 0
+        safe_terms = np.where(valid, terms, 0)
+        qv = q_dense[safe_terms]
+        local = np.sum(
+            idx.res_reliability[docs, slots].astype(np.float32)
+            * (qv - idx.res_center_values[docs, slots])
+            * idx.res_signs[docs, slots].astype(np.float32)
+            * valid,
+            axis=1,
+        )
+        significance = np.sum((qv * qv) * valid, axis=1)
+        consensus = idx.memberships[docs, slots] * route_dense[branches]
+        branch_ev = (
+            consensus * local * np.power(np.maximum(significance, 0), cfg.gamma)
+        ).astype(np.float32)
+
+        unique_docs, inverse = np.unique(docs, return_inverse=True)
+        tail = np.bincount(inverse, weights=branch_ev, minlength=len(unique_docs)).astype(np.float32)
+        tail += cfg.lambda_membership * np.bincount(
+            inverse, weights=consensus, minlength=len(unique_docs)
+        ).astype(np.float32)
+
+        # Stage 1: cheap whole-chunk binary IDF^1 rescue before expensive final scoring.
+        qlex = np.zeros(M, np.float32)
+        qlex[q.indices] = idx.idf[q.indices]
+        lex1 = np.zeros(len(unique_docs), np.float32)
+        for i, d in enumerate(unique_docs):
+            a, b = idx.support_indptr[d], idx.support_indptr[d + 1]
+            support = idx.support_indices[a:b]
+            raw = float(qlex[support].sum())
+            den = (1 - cfg.pre_length_b) + cfg.pre_length_b * (
+                float(idx.doc_lengths[d]) / idx.avg_doc_length
+            )
+            lex1[i] = raw / (den if den > 0 else 1.0)
+
+        pre = _zscore(tail) + _zscore(lex1)
+        selected = _topk_large(pre, cfg.pool_size)
+        pool_docs = unique_docs[selected]
+        pool_tail = tail[selected]
+
+        # Preserve branch-specific evidence for robust branch-quality estimation.
+        pool_position = np.full(len(unique_docs), -1, np.int32)
+        pool_position[selected] = np.arange(len(selected), dtype=np.int32)
+        mapped = pool_position[inverse]
+        keep = mapped >= 0
+        mem_pool = mapped[keep].astype(np.int32)
+        mem_branch = branches[keep].astype(np.int32)
+        mem_ev = branch_ev[keep].astype(np.float32)
+
+        # Stage 2: final chunk evidence. No document TF is used here.
+        semvec = np.zeros(M, np.float32)
+        for t, amp in zip(q.indices, q.data):
+            a, b = idx.A.indptr[t], idx.A.indptr[t + 1]
+            nb = idx.A.indices[a:b][: cfg.semantic_k]
+            sv = idx.A.data[a:b][: cfg.semantic_k]
+            if len(nb):
+                semvec[nb] += float(amp) * sv * idx.idf[nb]
+
+        qset = set(map(int, q.indices))
+        rare = set(map(int, q.indices[np.argsort(idx.idf[q.indices])[::-1]][: cfg.rare_topk]))
+        nq = max(1, len(q.indices))
+        lex2 = np.zeros(len(pool_docs), np.float32)
+        sem = np.zeros(len(pool_docs), np.float32)
+        matched_count = np.zeros(len(pool_docs), np.float32)
+        rare_count = np.zeros(len(pool_docs), np.float32)
+
+        for i, d in enumerate(pool_docs):
+            a, b = idx.support_indptr[d], idx.support_indptr[d + 1]
+            support = idx.support_indices[a:b]
+            sem[i] = float(semvec[support].sum())
+            match = [int(t) for t in support if int(t) in qset]
+            raw = sum(float(idx.idf[t]) ** 2 for t in match)
+            den = (1 - cfg.final_length_b) + cfg.final_length_b * (
+                float(idx.doc_lengths[d]) / idx.avg_doc_length
+            )
+            lex2[i] = raw / (den if den > 0 else 1.0)
+            matched_count[i] = len(match)
+            rare_count[i] = sum(t in rare for t in match)
+
+        coverage = matched_count / nq
+        lex_adjusted = lex2 * np.power(np.maximum(coverage, 1e-6), cfg.coordination_alpha)
+        rare_coverage = rare_count / max(1, min(cfg.rare_topk, nq))
+        relevance = (
+            _zscore(pool_tail)
+            + cfg.lambda_lex * _zscore(lex_adjusted)
+            + cfg.lambda_sem * _zscore(sem)
+            + cfg.lambda_rare * _zscore(rare_coverage)
+        )
+
+        # Robust high-quality branch score H_j: mean top-r branch-specific evidence.
+        branch_pairs = {}
+        for pi, b, e in zip(mem_pool, mem_branch, mem_ev):
+            key = (int(b), int(pi))
+            if key not in branch_pairs or e > branch_pairs[key]:
+                branch_pairs[key] = float(e)
+        by_branch = {}
+        for (b, pi), e in branch_pairs.items():
+            by_branch.setdefault(b, []).append((e, pi))
+
+        H, docs_by_branch = {}, {}
+        for b, vals in by_branch.items():
+            vals.sort(key=lambda x: x[0], reverse=True)
+            r = min(cfg.branch_quality_top_docs, len(vals))
+            H[b] = float(np.mean([e for e, _ in vals[:r]]))
+            docs_by_branch[b] = np.asarray([pi for _, pi in vals], dtype=np.int32)
+
+        unique_branches = np.asarray(sorted(H.keys()), dtype=np.int32)
+        h = np.asarray([H[int(b)] for b in unique_branches], dtype=np.float32)
+        centers = [self._center_sparse(int(b)) for b in unique_branches]
+        cosine = np.eye(len(unique_branches), dtype=np.float32)
+        for i in range(len(unique_branches)):
+            for j in range(i + 1, len(unique_branches)):
+                cosine[i, j] = cosine[j, i] = self._spdot(*centers[i], *centers[j])
+
+        return {
+            "docs": pool_docs,
+            "relevance": relevance,
+            "route_docs": unique_docs,
+            "branches": unique_branches,
+            "branch_quality": h,
+            "cosine": cosine,
+            "docs_by_branch": docs_by_branch,
+        }
+
+    @staticmethod
+    def _deviation(cosine, selected_branch_indices):
+        """Squared distance of each unit branch center from selected-center centroid."""
+        if not selected_branch_indices:
+            return np.zeros(len(cosine), np.float32)
+        si = np.asarray(selected_branch_indices, np.int32)
+        centroid_norm_sq = float(np.mean(cosine[np.ix_(si, si)]))
+        return 1.0 + centroid_norm_sq - 2.0 * np.mean(cosine[:, si], axis=1)
+
+    def rank(self, packet, k: int = 10):
+        """Construct top-k; branch diversity affects only the first ten ranks."""
+        if packet is None or not len(packet["docs"]):
+            return []
+        cfg = self.cfg
+        base = packet["relevance"]
+        n = len(base)
+        order = np.argsort(base)[::-1]
+        first = int(order[0])
+        chosen = [first]
+        used = {first}
+
+        # Only top query-specific branches are eligible to receive a diversity bonus.
+        h = packet["branch_quality"]
+        eligible = np.argsort(h)[::-1][: min(cfg.hq_top_branches, len(h))]
+        doc_hq = [[] for _ in range(n)]
+        branch_to_index = {int(b): i for i, b in enumerate(packet["branches"])}
+        for bi in eligible:
+            b = int(packet["branches"][bi])
+            for pi in packet["docs_by_branch"].get(b, []):
+                doc_hq[int(pi)].append(int(bi))
+
+        selected_branches = []
+        if doc_hq[first]:
+            selected_branches = [max(doc_hq[first], key=lambda bi: float(h[bi]))]
+
+        # Ranks 2..10: relevance plus soft central-deviation bonus.
+        for _ in range(1, min(10, k, n)):
+            rem = np.asarray([i for i in range(n) if i not in used], dtype=np.int32)
+            if not len(rem):
+                break
+            dev = self._deviation(packet["cosine"], selected_branches)
+            if len(eligible):
+                dev_values = _minmax_hi(dev[eligible])
+                dev_map = {int(bi): float(v) for bi, v in zip(eligible, dev_values)}
+            else:
+                dev_map = {}
+            rel = _minmax_hi(base[rem])
+            bonus = np.zeros(len(rem), np.float32)
+            for ii, pi in enumerate(rem):
+                if doc_hq[int(pi)]:
+                    bonus[ii] = max(dev_map.get(bi, 0.0) for bi in doc_hq[int(pi)])
+            value = rel + cfg.lambda_diversity * bonus
+            pi = int(rem[int(np.argmax(value))])
+            chosen.append(pi)
+            used.add(pi)
+            if doc_hq[pi]:
+                bi = max(doc_hq[pi], key=lambda x: (dev_map.get(x, 0.0), float(h[x])))
+                selected_branches.append(int(bi))
+
+        # Beyond rank 10, ordinary relevance. This keeps the top-10 RAG mechanism isolated.
+        for pi in order:
+            pi = int(pi)
+            if len(chosen) >= min(k, n):
+                break
+            if pi not in used:
+                chosen.append(pi)
+                used.add(pi)
+        return packet["docs"][np.asarray(chosen[:k], dtype=np.int64)].tolist()
+
+    def search(self, text: str, k: int = 10, timing: bool = False):
+        t0 = time.perf_counter()
+        packet = self.prepare(text)
+        t1 = time.perf_counter()
+        local_ids = self.rank(packet, k=k)
+        t2 = time.perf_counter()
+        doc_ids = [str(self.idx.doc_ids[int(d)]) for d in local_ids]
+        if not timing:
+            return doc_ids
+        return doc_ids, {
+            "prepare_ms": (t1 - t0) * 1000.0,
+            "rank_ms": (t2 - t1) * 1000.0,
+            "total_ms": (t2 - t0) * 1000.0,
+            "route_size": 0 if packet is None else len(packet["route_docs"]),
+            "pool_size": 0 if packet is None else len(packet["docs"]),
+        }
+
+    def evaluate(self, dataset, k: int = 10):
+        run = {}
+        times = []
+        for qid in dataset.qrels:
+            docs, timing = self.search(dataset.queries[qid], k=k, timing=True)
+            run[str(qid)] = docs
+            times.append(timing)
+        metrics = evaluate_run(run, dataset.qrels, ks=(10,), ndcg_k=10, mrr_k=10, exp_gain=False)
+        metrics.update({
+            "median_total_ms": float(np.median([x["total_ms"] for x in times])),
+            "p95_total_ms": float(np.percentile([x["total_ms"] for x in times], 95)),
+            "median_rank_ms": float(np.median([x["rank_ms"] for x in times])),
+            "median_route_size": float(np.median([x["route_size"] for x in times])),
+            "median_pool_size": float(np.median([x["pool_size"] for x in times])),
+        })
+        return metrics, run

geomretrieval/utils.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+import numpy as np
+from scipy import sparse
+
+
+def topk_sparse_row(indices: np.ndarray, values: np.ndarray, k: int) -> tuple[np.ndarray, np.ndarray]:
+    """Return up to k largest values from one CSR row, descending by value."""
+    if len(values) <= k:
+        order = np.argsort(values)[::-1]
+    else:
+        pick = np.argpartition(values, -k)[-k:]
+        order = pick[np.argsort(values[pick])[::-1]]
+    return indices[order], values[order]
+
+
+def topk_abs_sparse_row(indices: np.ndarray, values: np.ndarray, k: int) -> tuple[np.ndarray, np.ndarray]:
+    """Return up to k largest absolute values from one sparse row."""
+    av = np.abs(values)
+    if len(values) <= k:
+        order = np.argsort(av)[::-1]
+    else:
+        pick = np.argpartition(av, -k)[-k:]
+        order = pick[np.argsort(av[pick])[::-1]]
+    return indices[order], values[order]
+
+
+def csr_row_topk_matrix(X: sparse.csr_matrix, k: int, binary: bool = False) -> sparse.csr_matrix:
+    """Keep top-k entries in every CSR row.
+
+    Used only offline to construct the term-geometry estimation matrix.
+    """
+    rows, cols, vals = [], [], []
+    for r in range(X.shape[0]):
+        a, b = X.indptr[r], X.indptr[r + 1]
+        idx, dat = X.indices[a:b], X.data[a:b]
+        if len(idx) == 0:
+            continue
+        ii, vv = topk_sparse_row(idx, dat, k)
+        rows.extend([r] * len(ii))
+        cols.extend(ii.tolist())
+        vals.extend(([1.0] * len(ii)) if binary else vv.tolist())
+    return sparse.csr_matrix((np.asarray(vals, np.float32), (rows, cols)), shape=X.shape)
+
+
+def zscore(x: np.ndarray, eps: float = 1e-8) -> np.ndarray:
+    x = np.asarray(x, dtype=np.float32)
+    s = float(x.std())
+    if s < eps:
+        return np.zeros_like(x)
+    return (x - float(x.mean())) / (s + eps)
+
+
+def padded_topk_dense_from_csr_row(row: sparse.csr_matrix, k: int, width: int | None = None):
+    """Top-k of a single CSR row, returned padded and term-id sorted.
+
+    Sorting term IDs rather than scores is useful for fast center lookup later.
+    """
+    width = width or k
+    idx, dat = row.indices, row.data
+    if len(dat):
+        ii, vv = topk_sparse_row(idx, dat, k)
+        order = np.argsort(ii)
+        ii, vv = ii[order], vv[order]
+    else:
+        ii = np.empty(0, dtype=np.int32)
+        vv = np.empty(0, dtype=np.float32)
+    out_i = np.full(width, -1, dtype=np.int32)
+    out_v = np.zeros(width, dtype=np.float32)
+    n = min(width, len(ii))
+    out_i[:n] = ii[:n]
+    out_v[:n] = vv[:n]
+    return out_i, out_v
+
+
+def lookup_sorted(keys: np.ndarray, vals: np.ndarray, query_keys: np.ndarray) -> np.ndarray:
+    """Lookup query keys in sorted padded key/value arrays; absent -> 0."""
+    valid = keys >= 0
+    k = keys[valid]
+    v = vals[valid]
+    if len(k) == 0 or len(query_keys) == 0:
+        return np.zeros(len(query_keys), dtype=np.float32)
+    pos = np.searchsorted(k, query_keys)
+    out = np.zeros(len(query_keys), dtype=np.float32)
+    ok = pos < len(k)
+    ok_idx = np.flatnonzero(ok)
+    if len(ok_idx):
+        p = pos[ok_idx]
+        same = k[p] == query_keys[ok_idx]
+        chosen = ok_idx[same]
+        out[chosen] = v[pos[chosen]]
+    return out