背景

Question

背景

我正在从事一个涉及解决大型不确定方程组的项目。

我目前的算法是计算表示给定系统的矩阵的SVD（numpy.linalg.svd），然后使用其结果来计算Moore-Penrose伪逆和矩阵的右零空间。我使用null空间来查找具有唯一解的所有变量，并使用伪逆来找出其值。

但是，MPP（摩尔彭罗斯伪逆）非常密集，对于我的服务器来说太大了。

问题

我发现以下paper，其中详细描述了保留MPP大部分基本属性的稀疏伪逆。这显然对我很感兴趣，但是我只是没有数学背景来了解他如何计算伪逆。可以用SVD计算吗？如果没有，那么最好的方法是什么？

详细信息

这些是我认为可能与文章相关的内容，但我还不足以理解

spinv（A）= arg min || B ||受制于BA =其中|| B ||表示B
这通常是一个不可解决的问题，因此我们将标准线性松弛与l1范数一起使用
sspinv（A）=ητ{[spinv（A）]}，其中ητ（u）= u1 | u |≥τ

编辑

找到我的代码以及有关实际实现here

的更多详细信息

Answer 1

据我了解，这是关于稀疏伪逆的论文：

它说

我们旨在使spinv（A）中的非零数最小化

这意味着您应该采用L0规范（请参阅David Donoho的定义here：非零条目的数量），这使问题变得很棘手。

spinv(A) = argmin ||B||_0 subject to B.A = I

所以他们转向凸松弛这个问题，以便可以通过线性编程来解决。

这通常是一个很难解决的问题，因此我们使用标准符合1范数的线性松弛。

那么轻松的问题是

spinv(A) = argmin ||B||_1 subject to B.A = I (6)

这有时称为Basis pursuit，并且往往会产生稀疏解（请参阅Boyd和Vandenberghe的凸优化，第 6.2个最小范数问题部分）。 / p>

因此，请解决此宽松的问题。

线性程序（6）是可分离的，可以通过计算一个一次排B

因此，您可以解决以下表格中的一系列问题以获得解决方案。

spinv(A)_i = argmin ||B_i||_1 subject to B_i.A = I_i

其中_i表示矩阵的第i行。

请参见here，了解如何将这个绝对值问题转换为线性程序。

在下面的代码中，我将问题稍微更改为spinv(A)_i = argmin ||B_i||_1 subject to A.B_i = I_i，其中_i是矩阵的第i列，因此问题变成了spinv(A) = argmin ||B||_1 subject to A.B = I。老实说，我不知道两者之间是否有区别。在这里，我使用scipy的linprog单面方法。我不知道单纯形的内部结构是否可以使用SVD。

import numpy as np
from scipy import optimize

# argmin ||B_i||_1 stubect to A.B_i = I_i, where _i is the ith column
# let B_i = u_i - v_i where u_i >= 0 and v_i >= 0
# then ||B_i||_1 = [1' 1'][u_i;v_i] which is the objective function
# and A.B_i = I_i becomes
# A.[u_i - v_i] = I_i
# [A -A][u_i;v_i] = I_i which is the equality constraint
# and [u_i;v_i] >= 0 the bounds
# here A is n x m (as opposed to m x n in paper)

A = np.random.randn(4, 6)
n, m = A.shape
I = np.eye(n)

Aeq = np.hstack((A, -A))
# objective
c = np.ones((2*m))
# spinv
B = np.zeros((m, n))

for i in range(n):
    beq = I[:, i]
    result = optimize.linprog(c, A_eq=Aeq, b_eq=beq)
    x = result.x[0:m]-result.x[m:2*m]
    B[:, i] = x

print('spinv(A) = \n' + str(B))
print('pinv(A) = \n' + str(np.linalg.pinv(A)))
print('A.B = \n' + str(np.dot(A, B)))

这是输出。 spinv(A)比pinv(A)稀疏。

spinv(A) = 
[[ 0.         -0.33361925  0.          0.        ]
 [ 0.04987467  0.          0.12741509  0.02897778]
 [ 0.          0.         -0.52306324  0.        ]
 [ 0.43848257  0.12114828  0.15678815 -0.19302049]
 [-0.16814546  0.02911103 -0.41089271  0.50785258]
 [-0.05696924  0.13391736  0.         -0.43858428]]
pinv(A) = 
[[ 0.05626402 -0.1478497   0.19953692 -0.19719524]
 [ 0.04007696 -0.07330993  0.19903311  0.14704798]
 [ 0.01177361 -0.05761487 -0.23074996  0.15597663]
 [ 0.44471989  0.13849828  0.18733242 -0.20824972]
 [-0.1273604   0.15615595 -0.24647117  0.38047901]
 [-0.04638221  0.09879972  0.21951122 -0.33244635]]
A.B = 
[[ 1.00000000e+00 -1.82225048e-17  6.73349443e-18 -2.39383542e-17]
 [-5.20584593e-18  1.00000000e+00 -3.70118759e-16 -1.62063433e-15]
 [-8.83342417e-18 -5.80049814e-16  1.00000000e+00  3.56175852e-15]
 [ 2.31629738e-17 -1.13459832e-15 -2.28503999e-16  1.00000000e+00]]

要进一步稀疏化矩阵，我们可以应用入门级硬阈值化，从而牺牲了反相特性并计算了近似稀疏伪逆

如果您不想将小条目保留在sparse-pinv中，则可以这样删除它们：

Bt = B.copy()
Bt[np.abs(Bt) < 0.1] = 0
print('sspinv_0.1(A) = \n' + str(Bt))
print('A.Bt = \n' + str(np.dot(A, Bt)))

获得

sspinv_0.1(A) = 
[[ 0.         -0.33361925  0.          0.        ]
 [ 0.          0.          0.12741509  0.        ]
 [ 0.          0.         -0.52306324  0.        ]
 [ 0.43848257  0.12114828  0.15678815 -0.19302049]
 [-0.16814546  0.         -0.41089271  0.50785258]
 [ 0.          0.13391736  0.         -0.43858428]]
A.Bt = 
[[ 9.22717491e-01  1.17555372e-02  6.73349443e-18 -1.10993934e-03]
 [ 1.24361576e-01  9.41538212e-01 -3.70118759e-16  1.15028494e-02]
 [-8.76662313e-02 -1.36349311e-02  1.00000000e+00 -7.48302663e-02]
 [-1.54387852e-01 -3.27969169e-02 -2.28503999e-16  9.39161039e-01]]

希望我回答了您的问题，如果您需要更多详细信息，请提供足够的参考。如果您有任何疑问，请告诉我。我不是专家，所以如果您对我的主张有任何疑问，可以随时咨询数学stackexchange的专家（当然没有任何代码），请让我知道。

这是一个有趣的问题。它使我能够重新绘制线性代数，并且几乎不了解优化，所以谢谢您：）

使用SVD计算Spinv

背景

问题

详细信息

编辑

1 个答案: