问题描述
像这样，在NumPy中这项任务非常简单
This task is pretty trivial in NumPy like so
import numpy as np
a= np.array([[1,2,3,0,9],[3,2,6,2,7],[0,0,0,8,0],[1,0,0,0,3]])
a + a[1]
输出:
array([[ 4, 4, 9, 2, 16],
[ 6, 4, 12, 4, 14],
[ 3, 2, 6, 10, 7],
[ 4, 2, 6, 2, 10]])
查看向量尺寸如何自动广播到矩阵的每一行.
See how the vector dimensions are automatically broadcasted to each row of the matrix.
但是当涉及到稀疏矩阵时，会出现尺寸失配错误.
But when it comes to sparse matrices, there is a dimension mismatch error.
from scipy.sparse import *
a= csr_matrix([[1,2,3,0,9],[3,2,6,2,7],[0,0,0,8,0],[1,0,0,0,3]])
a + a[1]
输出:
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-32-74c48fe5106e> in <module>()
2
3 a= csr_matrix([[1,2,3,0,9],[3,2,6,2,7],[0,0,0,8,0],[1,0,0,0,3]])
----> 4 a + a[1]
/opt/anaconda2/lib/python2.7/site-packages/scipy/sparse/compressed.pyc in __add__(self, other)
337 elif isspmatrix(other):
338 if (other.shape != self.shape):
--> 339 raise ValueError("inconsistent shapes")
340
341 return self._binopt(other,'_plus_')
ValueError: inconsistent shapes
有一个用于稀疏乘法的函数，例如a.multiply(a[1])代表a * a[1](可以很好地完成工作)，但是我找不到要加法的函数.
There is a function for sparse multiplication, e.g., a.multiply(a[1]) for a * a[1] (which does its job perfectly), but I couldn't find one for addition.
我是稀疏矩阵的新手.请帮忙.
I'm new to sparse matrices. Please help.
推荐答案
numpy样式广播尚未针对稀疏矩阵实现.
numpy style broadcasting has not been implemented for sparse matrices.
乘法，尤其是矩阵乘法，已经得到很好的发展.实际上，诸如行总和和行选择之类的动作被实现为矩阵乘法-例如M * <column vector of 1s>.乘法通常会导致矩阵稀疏.
Multiplication, especially matrix multiplication, is well developed. In fact actions like row sum and selection of rows are implemented as matrix multiplications - e.g. M * <column vector of 1s>. Multiplication often results in a matrix that's as sparse if not more so.
加法/减法没有很好地开发.它通常会导致矩阵更密集.极端情况是向所有元素添加标量.即使在您的示例中，结果也是密集的. a和a[1,:]都必须非常稀疏才能证明纯粹是稀疏的加法.
Addition/subtraction is not well developed. It often results in a denser matrix. The extreme case is adding a scalar to all elements. Even in your example, the result is dense. Both a and a[1,:] have to be quite sparse to justify a pure sparse addition.
In [713]: a= np.array([[1,2,3,0,9],[3,2,6,2,7],[0,0,0,8,0],[1,0,0,0,3]])
In [714]: aM = sparse.csr_matrix(a)
In [715]: aM
Out[715]:
<4x5 sparse matrix of type '<class 'numpy.int32'>'
with 12 stored elements in Compressed Sparse Row format>
我们可以通过矩阵乘法复制选定的行-首先是广播的密集方法:
We can replicate the selected row by matrix multiplication - first the broadcasted dense approach:
In [719]: np.ones((4,1))*aM[1,:]
Out[719]:
array([[ 3., 2., 6., 2., 7.],
[ 3., 2., 6., 2., 7.],
[ 3., 2., 6., 2., 7.],
[ 3., 2., 6., 2., 7.]])
In [720]: np.ones((4,1))*aM[1,:]+aM # dense matrix addition
Out[720]:
matrix([[ 4., 4., 9., 2., 16.],
[ 6., 4., 12., 4., 14.],
[ 3., 2., 6., 10., 7.],
[ 4., 2., 6., 2., 10.]])
稀疏矩阵乘法:
In [721]: sparse.csr_matrix(np.ones((4,1)))*aM[1,:]
Out[721]:
<4x5 sparse matrix of type '<class 'numpy.float64'>'
with 20 stored elements in Compressed Sparse Row format>
稀疏矩阵加法:
In [722]: sparse.csr_matrix(np.ones((4,1)))*aM[1,:]+aM
Out[722]:
<4x5 sparse matrix of type '<class 'numpy.float64'>'
with 20 stored elements in Compressed Sparse Row format>
In [723]: _.A
Out[723]:
array([[ 4., 4., 9., 2., 16.],
[ 6., 4., 12., 4., 14.],
[ 3., 2., 6., 10., 7.],
[ 4., 2., 6., 2., 10.]])
如果aM尤其是aM[1:]稀疏，这将是一个更好的演示.我也可以将np.ones指定为int dtype以匹配aM.并使其成为csc矩阵会更紧凑.
This would be a better demonstration if aM and especially aM[1:] was sparse. I could also have specified the np.ones as int dtype to match aM. And making it a csc matrix would be more compact.
这篇关于如何在Python中向稀疏矩阵添加稀疏行?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！