<pre><code>In [746]: A = sparse.csr_matrix([[1, 2, 0, 0],
...: ... [0, 0, 3, 4]])
In [747]: A
Out[747]:
<2x4 sparse matrix of type '<class 'numpy.longlong'>'
with 4 stored elements in Compressed Sparse Row format>
In [748]: print(A)
(0, 0) 1
(0, 1) 2
(1, 2) 3
(1, 3) 4
In [749]: v = np.array([1, 1])
</code></pre>
<p><code>A.T</code>返回一个新的矩阵,但为csc格式。否则,变化很小。但它不像密集转置那样是一种<code>view</code></p>
<pre><code>In [750]: A.T
Out[750]:
<4x2 sparse matrix of type '<class 'numpy.longlong'>'
with 4 stored elements in Compressed Sparse Column format>
In [755]: timeit A.T
82.9 µs ± 542 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
</code></pre>
<p>实际上,与制作原始稀疏矩阵所需的时间相比,该时间相当不错:</p>
<pre><code>In [759]: timeit A = sparse.csr_matrix([[1, 2, 0, 0], [0, 0, 3, 4]])
349 µs ± 356 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)
</code></pre>
<p>稀疏优化用于大型非常稀疏矩阵的矩阵乘法。使用密集阵列(只要它们适合内存),大多数其他操作都会更快</p>
<p>稀疏矩阵的默认乘法是矩阵</p>
<pre><code>In [752]: A.T*v
Out[752]: array([1, 2, 3, 4], dtype=int64)
In [753]: A.T.dot(v)
Out[753]: array([1, 2, 3, 4], dtype=int64)
In [754]: A.T@(v)
Out[754]: array([1, 2, 3, 4], dtype=int64)
</code></pre>
<p><code>@</code>,<code>__matmul__</code>委托给<code>__mul__</code>。稀疏<code>dot</code>也可以</p>
<p><code>*</code>和<code>dot</code>时间相同,<code>@</code>稍微慢一点。
In[758]:timeit A.T*(v)<br/>
每个回路95.6µs±424 ns(7次运行的平均值±标准偏差,每个10000个回路)</p>
<p>从时间中删除转置:</p>
<pre><code>In [760]: %%timeit A1=A.T
...: A1*v
7.77 µs ± 22.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
</code></pre>
<p>第二种方法使用稀疏元素乘法:</p>
<pre><code>In [774]: A.multiply(v[:,None]).sum(axis=0)
Out[774]: matrix([[1, 2, 3, 4]], dtype=int64)
</code></pre>
<p>这不如矩阵乘法有效</p>
<pre><code>In [775]: A.multiply(v[:,None])
Out[775]:
<2x4 sparse matrix of type '<class 'numpy.longlong'>'
with 4 stored elements in COOrdinate format>
In [776]: timeit A.multiply(v[:,None])
147 µs ± 1.14 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
</code></pre>
<p>结果是另一个稀疏矩阵<code>sum(axis=0)</code>实际上是作为矩阵乘法实现的。这个和的<code>extractor</code>矩阵是<code>sparse.csr_matrix([1,1])</code>。但这只是上一个例子中的<code>sparse_v</code></p>
<pre><code>In [787]: A.sum(axis=0)
Out[787]: matrix([[1, 2, 3, 4]], dtype=int64)
In [788]: timeit A.sum(axis=0)
242 µs ± 191 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)
</code></pre>
<p>应谨慎看待所有这些时间安排<code>A</code>很小,而且不是很稀疏。将此行和与更大的稀疏矩阵进行比较:</p>
<pre><code>In [799]: Ab = sparse.random(1000,1000,.001,'csr')
In [800]: timeit Ab.sum(axis=0)
269 µs ± 12.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [801]: timeit Ab.T*np.ones(1000)
118 µs ± 216 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
</code></pre>