| 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 |
|
|
