| 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 |
|
|
| |
| |
| |
| @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") |
|
|
| |
| |
| |
| 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())) |
|
|
| |
| 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 |
|
|
| |
| |
| 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:]) |
|
|
| |
| 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] |
| |
| 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 |
|
|
| |
| 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 |
|
|
| |
| log("[5/8] Zero-inclusive local sign reliability") |
| rel = np.ones((N, cfg.F, cfg.S), dtype=np.float16) |
| |
| 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) |
|
|
| |
| |
| |
| 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) |
| |
| 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)} |
| |
| 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 |
|
|
| |
| 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) |
|
|
| |
| |
| 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 |
|
|
| |
| |
| |
| 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 |
|
|
| |
| 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: |
| |
| |
| 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]) |
| |
| 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 |
|
|
| |
| |
| 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 |
|
|
| |
| 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())) |
|
|
| |
| 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] |
|
|
| |
| |
| 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] |
|
|
| |
| |
| 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] |
| |
| 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 |
|
|
| |
| |
| |
| 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 |
|
|
