geomretrieval/index.py

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