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