Python 如何将第一列中的稀疏矩阵行相加，并将其他列归零，使原始矩阵的维数相同？

我有一个稀疏矩阵B，我想通过对第一列中的所有行求和，然后将第一列除以“2”，并使其他列为零，从B得到稀疏矩阵a

from numpy import array
from scipy import csr_matrix

row = array([0,0,1,2,2,2])
col = array([0,2,2,0,1,2])
data = array([1,2,3,4,5,6])

B = csr_matrix( (data,(row,col)), shape=(3,3) )

A = B.copy()

A = A.sum(axis=1)/2
# A shape becomes 1 x 3 instead of 3 x 3 here!

---

我认为这可以通过几种方式来实现。你的身体很好

In [275]: from scipy.sparse import csr_matrix 
     ...:  
     ...: row = np.array([0,0,1,2,2,2]) 
     ...: col = np.array([0,2,2,0,1,2]) 
     ...: data = np.array([1,2,3,4,5,6.])    # make float 
     ...:  
     ...: B = csr_matrix( (data,(row,col)), shape=(3,3) )                                              
In [276]: A = B.copy()                                                                                 
In [277]: A                                                                                            
Out[277]: 
<3x3 sparse matrix of type '<class 'numpy.float64'>'
    with 6 stored elements in Compressed Sparse Row format>

或者，该列和矩阵可用于直接构造

A

，使用与定义

B

相同的输入样式：

In [289]: A1  = B.sum(axis=1)/2                                                                        
In [290]: A1                                                                                           
Out[290]: 
matrix([[1.5],
        [1.5],
        [7.5]])
In [296]: row = np.arange(3)                                                                           
In [297]: col = np.zeros(3,int)                                                                        
In [298]: data = A1.A1                                                                                 
In [299]: A = csr_matrix((data, (row, col)), shape=(3,3))                                              
In [301]: A                                                                                            
Out[301]: 
<3x3 sparse matrix of type '<class 'numpy.float64'>'
    with 3 stored elements in Compressed Sparse Row format>
In [302]: A.A                                                                                          
Out[302]: 
array([[1.5, 0. , 0. ],
       [1.5, 0. , 0. ],
       [7.5, 0. , 0. ]])

[289]中的

：A1=B.sum（轴=1）/2
In[290]：A1
出[290]：
矩阵（[[1.5]，
[1.5],
[7.5]])
[296]中：row=np.arange（3）
[297]中：col=np.zero（3，int）
在[298]中：数据=A1.A1
[299]中：A=csr_矩阵（（数据，（行，列）），形状=（3,3））
在[301]中：A
Out[301]：
在[302]中：A.A
Out[302]：
数组（[[1.5,0,0.]，
[1.5, 0. , 0. ],
[7.5, 0. , 0. ]])

我不知道哪种方法最快。你的

sparse.hstack

看起来不错，不过在封面下，

hstack

正在从

coo

格式构建

行、列、数据

数组，并创建一个新的

coo_矩阵

。虽然它是可靠的，但并不是特别精简

In [286]: A = csr_matrix(np.zeros(B.shape))   # may be better method                                                         
In [287]: A[:,0]  = B.sum(axis=1)/2                                                                    
/usr/local/lib/python3.6/dist-packages/scipy/sparse/_index.py:126: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.
  self._set_arrayXarray(i, j, x)
In [288]: A                                                                                            
Out[288]: 
<3x3 sparse matrix of type '<class 'numpy.float64'>'
    with 3 stored elements in Compressed Sparse Row format>

In [289]: A1  = B.sum(axis=1)/2                                                                        
In [290]: A1                                                                                           
Out[290]: 
matrix([[1.5],
        [1.5],
        [7.5]])
In [296]: row = np.arange(3)                                                                           
In [297]: col = np.zeros(3,int)                                                                        
In [298]: data = A1.A1                                                                                 
In [299]: A = csr_matrix((data, (row, col)), shape=(3,3))                                              
In [301]: A                                                                                            
Out[301]: 
<3x3 sparse matrix of type '<class 'numpy.float64'>'
    with 3 stored elements in Compressed Sparse Row format>
In [302]: A.A                                                                                          
Out[302]: 
array([[1.5, 0. , 0. ],
       [1.5, 0. , 0. ],
       [7.5, 0. , 0. ]])