Question

我正在使用sympy来构建一个稀疏（N ^ 2 x N ^ 2）矩阵，并尝试将其转换为稀疏的scipy矩阵。它用于有限差分法中，根据k向量k =（kx，ky）求解2D网格上的Schrödinger方程。

SciPy的密集矩阵

我目前的方法是使用lambdify从一个对称矩阵A创建函数B，该矩阵为某个k向量提供一个有限差分矩阵，然后将其转换为稀疏矩阵M。

N = 80
kx, ky = sp.symbols('kx ky')

A = dill.load(open("./A_{0}".format(N), "rb"))

B = sp.lambdify([kx, ky], A)

M = sparse.csc_matrix(B(1,0))

dill.dump(B, open("./B_{0}".format(N), "wb"))

我的问题是，一旦N> = 80，我会收到lambdify的内存溢出错误（超过32 GB），并且lambdify进程被杀死。

Lambdify一个稀疏的Sympy矩阵

或者，我想直接为lambdify提供一个稀疏矩阵，但是我不知道哪种类型的稀疏矩阵sympy正在创建...

B = sp.lambdify([kx, ky], sp.SparseMatrix(A))
M = B(1,0)

...并尝试对M = B(1,0)行中的B求值会导致错误

File "<lambdifygenerated-1>", line 2, in _lambdifygenerated
TypeError: __init__() got multiple values for argument 'shape'

我正在使用Python 3.7.6，sympy 1.6和scipy 1.4.1

Answer 1

虽然我在scipy.sparse上做了很多工作，但之前从未使用过sy.SparseMatrix。查看文档，我可以制作一个简单的文档（在isympy会话中）：

In [4]: A = SparseMatrix(4,4, {(1,1): x, (3,3):y})                              

In [5]: A                                                                       
Out[5]: 
⎡0  0  0  0⎤
⎢          ⎥
⎢0  x  0  0⎥
⎢          ⎥
⎢0  0  0  0⎥
⎢          ⎥
⎣0  0  0  y⎦

In [6]: B=lambdify([x,y], A)                                                    

In [7]: B                                                                       
Out[7]: <function _lambdifygenerated(x, y)>

In [10]: M=B(10,20)                                                             
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-442f4a9e4340> in <module>
----> 1 M=B(10,20)

<lambdifygenerated-1> in _lambdifygenerated(x, y)
      1 def _lambdifygenerated(x, y):
----> 2     return (coo_matrix([x, y], ([1, 3], [1, 3]), shape=(4, 4)))

TypeError: __init__() got multiple values for argument 'shape'

所以我收到了您的错误消息。并且也清楚地表明了它试图创建哪种稀疏矩阵。你没看到吗我很想在这一点上停下来，因为您显然拥有有价值的信息！

===

B.__doc__是：

Created with lambdify. Signature:

func(x, y)

Expression:

Matrix([[0, 0, 0, 0], [0, x, 0, 0], [0, 0, 0, 0], [0, 0, 0, y]])

Source code:

def _lambdifygenerated(x, y):
    return (coo_matrix([x, y], ([1, 3], [1, 3]), shape=(4, 4)))

这就是回溯所显示的。显然，它正在尝试制作sparse.coo_matrix。但是有一个错误，()的缺失层。设置矩阵的正确方法是：

In [11]: from scipy import sparse                                               
In [14]: sparse.coo_matrix(([x,y],([1,3], [1,3])), shape=(4,4))                 
Out[14]: 
<4x4 sparse matrix of type '<class 'numpy.object_'>'
    with 2 stored elements in COOrdinate format>

In [15]: print(_)                                                               
  (1, 1)    x
  (3, 3)    y

我不能对带有符号B和x的{{1}}进行任何操作（甚至不显示为密集的）。

但是，如果将其放在函数中，则可以为y和x提供数值。

因此In [16]: def foo(x,y): ...: return sparse.coo_matrix(([x,y],([1,3], [1,3])), shape=(4,4)) ...: In [17]: foo(10,20).A Out[17]: array([[ 0, 0, 0, 0], [ 0, 10, 0, 0], [ 0, 0, 0, 0], [ 0, 0, 0, 20]]) lambdify错误。我不会尝试提出解决方案。

如何有效地稀疏化稀疏矩阵？

SciPy的密集矩阵

Lambdify一个稀疏的Sympy矩阵

1 个答案: