我有一个大的csr_matrix，我想获取每一行的前十个值及其索引。但我没有找到一个合适的方法来处理这个矩阵。
以下是我的当前解决方案，主要思路是逐行处理：
row = csr_matrix.getrow(row_number).toarray()[0].ravel()
top_ten_indicies = row.argsort()[-10:]
top_ten_values = row[row.argsort()[-10:]]
这样做并没有充分利用csr_matrix的优势，更像是一种暴力解决方案。
A2.sum(axis=1) # the fastest compile csr method
A2.A.sum(axis=1) # same, but with a dense intermediary
[np.sum(l.data) for l in A2] # iterate over the rows of A2
[np.sum(A2.getrow(i).data) for i in range(A2.shape[0])] # iterate with index
[np.sum(l) for l in A2.tolil().data] # sum the sublists of lil format
np.add.reduceat(A2.data, A2.indptr[:-1]) # with reduceat
A2.sum(axis=1) 是通过矩阵乘法实现的。虽然这与排序问题无关，但这是一个有趣的看待求和问题的方式。请记住，csr格式是为了有效地进行乘法而开发的。<8x47752 sparse matrix of type '<class 'numpy.float32'>'
with 32 stored elements in Compressed Sparse Row format>
In [694]: timeit np.add.reduceat(A2.data, A2.indptr[:-1])
100000 loops, best of 3: 7.41 µs per loop
In [695]: timeit A2.sum(axis=1)
10000 loops, best of 3: 71.6 µs per loop
In [696]: timeit [np.sum(l) for l in A2.tolil().data]
1000 loops, best of 3: 280 µs per loop
其他一切操作的执行时间都是1毫秒或更长。
我建议专注于开发您的单行函数，例如：
def max_n(row_data, row_indices, n):
i = row_data.argsort()[-n:]
# i = row_data.argpartition(-n)[-n:]
top_values = row_data[i]
top_indices = row_indices[i] # do the sparse indices matter?
return top_values, top_indices, i
tolil() 看起来最有前途。np.frompyfunc 创建 ufunc 的示例。 我不知道生成的函数是否具有 .reduceat 方法。
增加稀疏矩阵中前 k 个元素的值 - 获取 csr 的前 k 个元素（不按行）。 使用 argpartition。
np.frompyfunc 实现的行求和：In [741]: def foo(a,b):
return a+b
In [742]: vfoo=np.frompyfunc(foo,2,1)
In [743]: timeit vfoo.reduceat(A2.data,A2.indptr[:-1],dtype=object).astype(float)
10000 loops, best of 3: 26.2 µs per loop
这是一个相当不错的速度。但我想不出通过归约来实现argsort（需要两个参数的二进制函数）的方法。因此，对于这个问题来说，这可能是一个死胡同。
为了回答原始问题（对于像我这样找到这个问题的人来说），以下是一种使用基于@hpaulj's建议的多进程解决方案，该方案将数据转换为lil_matrix，并迭代行。
from multiprocessing import Pool
def _top_k(args):
"""
Helper function to process a single row of top_k
"""
data, row = args
data, row = zip(*sorted(zip(data, row), reverse=True)[:k])
return data, row
def top_k(m, k):
"""
Keep only the top k elements of each row in a csr_matrix
"""
ml = m.tolil()
with Pool() as p:
ms = p.map(_top_k, zip(ml.data, ml.rows))
ml.data, ml.rows = zip(*ms)
return ml.tocsr()
需要迭代每一行并分别获取每行的顶部索引。但是，这个循环可以进行jit优化（和并行化）以获得极快的函数。
@nb.njit(cache=True)
def row_topk_csr(data, indices, indptr, K):
m = indptr.shape[0] - 1
max_indices = np.zeros((m, K), dtype=indices.dtype)
max_values = np.zeros((m, K), dtype=data.dtype)
for i in nb.prange(m):
top_inds = np.argsort(data[indptr[i] : indptr[i + 1]])[::-1][:K]
max_indices[i] = indices[indptr[i] : indptr[i + 1]][top_inds]
max_values[i] = data[indptr[i] : indptr[i + 1]][top_inds]
return max_indices, max_values
这样调用：
top_pred_indices, _ = row_topk_csr(csr_mat.data, csr_mat.indices, csr_mat.indptr, K)
我需要经常执行这个操作，而且这个函数对我来说足够快，在1百万行 x 40万列的稀疏矩阵上运行时间小于1秒。
希望对您有所帮助。
lil格式开始）。 - hpauljargpartion比argsort更快。但仍然有一个问题，那就是你是否可以比逐行迭代更好。lil和csr是最快的两种格式。 - hpaulj