标准化Scipy稀疏矩阵的有效方法

时间:2012-09-06 17:06:04

标签: python numpy scipy sparse-matrix

我想编写一个函数来规范化大型稀疏矩阵的行(使它们总和为1)。

from pylab import *
import scipy.sparse as sp

def normalize(W):
    z = W.sum(0)
    z[z < 1e-6] = 1e-6
    return W / z[None,:]

w = (rand(10,10)<0.1)*rand(10,10)
w = sp.csr_matrix(w)
w = normalize(w)

然而,这给出了以下例外:

File "/usr/lib/python2.6/dist-packages/scipy/sparse/base.py", line 325, in __div__
     return self.__truediv__(other)
File "/usr/lib/python2.6/dist-packages/scipy/sparse/compressed.py", line 230, in  __truediv__
   raise NotImplementedError

有没有相当简单的解决方案?我看过this,但我还不清楚如何进行划分。

5 个答案:

答案 0 :(得分:38)

这已在scikit-learn sklearn.preprocessing.normalize中实施。

from sklearn.preprocessing import normalize
w_normalized = normalize(w, norm='l1', axis=1)

axis=1应按行进行规范化,axis=0按列进行标准化。使用可选参数copy=False来修改矩阵。

答案 1 :(得分:3)

这是我的解决方案。

  • 转置A
  • 计算每个col的总和
  • 格式对角矩阵B,具有和的倒数
  • A * B等于标准化
  • 转置C

    import scipy.sparse as sp
    import numpy as np
    import math
    
    minf = 0.0001
    
    A = sp.lil_matrix((5,5))
    b = np.arange(0,5)
    A.setdiag(b[:-1], k=1)
    A.setdiag(b)
    print A.todense()
    A = A.T
    print A.todense()
    
    sum_of_col = A.sum(0).tolist()
    print sum_of_col
    c = []
    for i in sum_of_col:
        for j in i:
            if math.fabs(j)<minf:
                c.append(0)
            else:
                c.append(1/j)
    
    print c
    
    B = sp.lil_matrix((5,5))
    B.setdiag(c)
    print B.todense()
    
    C = A*B
    print C.todense()
    C = C.T
    print C.todense()
    

答案 2 :(得分:1)

虽然Aarons答案是正确的,但当我想针对sklearn未提供的绝对值的最大值进行标准化时,我实现了一个解决方案。我的方法使用非零条目并在csr_matrix.data数组中找到它们以快速替换那里的值。

def normalize_sparse(csr_matrix):
    nonzero_rows = csr_matrix.nonzero()[0]
    for idx in np.unique(nonzero_rows):
        data_idx = np.where(nonzero_rows==idx)[0]
        abs_max = np.max(np.abs(csr_matrix.data[data_idx]))
        if abs_max != 0:
            csr_matrix.data[data_idx] = 1./abs_max * csr_matrix.data[data_idx]

与sunan的解决方案相反,此方法不需要将矩阵强制转换为密集格式(这可能会引起存储问题),也不需要矩阵乘法。我在形状稀疏的矩阵(35'000,486'000)上测试了该方法,耗时约18秒。

答案 3 :(得分:0)

无需导入sklearn,转换为密集矩阵或乘法矩阵并利用csr矩阵的数据表示形式:

from scipy.sparse import isspmatrix_csr

def normalize(W):
    """ row normalize scipy sparse csr matrices inplace.
    """
    if not isspmatrix_csr(W):
        raise ValueError('W must be in CSR format.')
    else:
        for i in range(W.shape[0]):
            row_sum = W.data[W.indptr[i]:W.indptr[i+1]].sum()
            if row_sum != 0:
                W.data[W.indptr[i]:W.indptr[i+1]] /= row_sum

RememberW.indices是列索引的数组, W.data是对应的非零值的数组 W.indptr指向索引和数据中的行开始。

如果需要L1范数,则可以在取总和时添加numpy.abs(),或使用numpy.max()通过每行的最大值进行归一化。

答案 4 :(得分:0)

我发现这是一种无需使用内置函数的优雅方法。

import scipy.sparse as sp

def normalize(W):
    #Find the row scalars as a Matrix_(n,1)
    rowSumW = sp.csr_matrix(W.sum(axis=1))
    rowSumW.data = 1/rowSumW.data

    #Find the diagonal matrix to scale the rows
    rowSumW = rowSumW.transpose()
    scaling_matrix = sp.diags(rowSumW.toarray()[0])

    return scaling_matrix.dot(W)