File size: 3,192 Bytes
f7b6133 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 | 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
|