使用SciPy进行稀疏不完全LU分解时的内存使用
稀疏不完全LU分解是一种用于解决线性方程组的方法，它可以有效地处理大规模稀疏矩阵。在使用SciPy进行稀疏不完全LU分解时，内存使用是一个重要的考虑因素。
稀疏不完全LU分解是将稀疏矩阵分解为一个下三角矩阵L和一个上三角矩阵U的乘积，其中L具有非零元素的位置与原始矩阵相同，而U具有非零元素的位置与原始矩阵相反。这种分解可以减少矩阵的存储空间和计算复杂度。
在使用SciPy进行稀疏不完全LU分解时，内存使用主要取决于以下几个因素：
- 稀疏矩阵的大小：较大的稀疏矩阵需要更多的内存来存储。
- 稀疏矩阵的稀疏性：稀疏矩阵中非零元素的比例越低，内存使用越少。
- 稀疏矩阵的存储格式：SciPy提供了多种存储格式，如COO、CSR、CSC等，不同的存储格式对内存使用有不同的影响。
- 稀疏不完全LU分解的参数设置：SciPy提供了一些参数用于控制分解的精度和内存使用，合理设置这些参数可以优化内存使用。
为了减少内存使用，可以考虑以下几点：
- 使用适当的稀疏矩阵存储格式：不同的存储格式适用于不同类型的稀疏矩阵，选择合适的存储格式可以减少内存使用。
- 调整稀疏不完全LU分解的参数：根据实际需求，调整分解的参数可以控制内存使用和分解的精度。
- 分块处理：如果稀疏矩阵过大无法一次性加载到内存中，可以考虑将矩阵分块处理，逐块进行稀疏不完全LU分解。
腾讯云提供了一系列云计算产品，如云服务器、云数据库、云存储等，可以满足各种云计算需求。具体关于稀疏不完全LU分解的腾讯云产品和产品介绍链接地址，可以参考腾讯云官方文档或咨询腾讯云客服人员。
相关·内容
考虑以下代码：
import numpy as np
import scipy.sparse.linalg
# Setup
A = scipy.sparse.csc_matrix([[1, -3], [-1, 4]])
b = np.array([1, 0])
spilu = scipy.sparse.linalg.spilu(A) # Find ILU decomposition
x = spilu.solve(b) # Use an iterative method to solve Ax = b ?
这将导致x成为Ax = b的解决方案。
据我所知，scipy.sparse.li
浏览 10提问于2020-04-20得票数 1
回答已采纳
我有以下一段代码，其中我使用命令scipy.linalg.lu()计算给定方阵的L矩阵，然后再次执行相同的操作，只是使用scipy.sparse.linalg.splu()将其应用于给定矩阵的稀疏形式。代码如下：
import numpy as np
from scipy.sparse.linalg import splu
from scipy.sparse import csc_matrix
import scipy.linalg
A1 = csc_matrix([[1., 0, 0.], [5., 0, 2], [0, -1., 0]])
A2 = np.array([[1., 0, 0.
浏览 2提问于2018-12-07得票数 1
1回答
对于我的情况，它是40000*40000元素，我只需要这个矩阵来计数特征值。
我的问题是如何将矩阵存储在内存中，以便找到特征值。下面是矩阵的详细信息：
A=np.array([((Nx-2)(Nz-2))[1/4],((Nx-2)(Nz-2))[1/2],((Nx-2)(Nz-2))[2],((Nx-2)(Nz-2))[1/2],((Nx-2)(Nz-2))[1/4]])
diags=np.array([-Nx,-1,0,1,Nx])
M=spdiags(A, diags, (Nx-2)(Nz-2), (Nx-2)(Nz-2)).toarray()
alpha=np.linalg.eigval
浏览 0提问于2018-06-29得票数 1
回答已采纳
使用的区别是什么
scipy.sparse.linalg.factorized(A)
和
scipy.sparse.linalg.splu(A)
它们都使用.solve(rhs)方法返回对象，并且在文档中都说它们使用LU分解。我想知道他们俩的表现有什么不同。
更具体地说，我正在编写一个python/numpy/scipy应用程序来实现动态有限元模型。我需要在每个时间步骤上求解一个方程Au = f。A是稀疏且相当大的，但不依赖于时间步骤，所以我想在此之前投入一些时间来加快迭代速度(可能有数千个迭代)。我尝试使用scipy.sparse.linalg.inv(A)，但是当矩阵的大小很大时，它会
浏览 0提问于2019-07-28得票数 5
回答已采纳
对于线性矩阵方程的求解，可以使用numpy.linalg.solve来实现LAPACK例程。
根据文档
DGESV computes the solution to a real system of linear equations
A * X = B,
where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
The LU decomposition with partial pivoting and row interchanges is
used to factor A as
A = P * L
浏览 2提问于2017-06-21得票数 3
如何打印使用SuperLU的splu计算的稀疏L和U矩阵？
我的MWE：
>>> import scipy
>>> import scipy.sparse
>>> import scipy.sparse.linalg
>>> from numpy import array
>>> M = scipy.array([ [19,0,21,21,0],[12,21,0,0,0],[0,12,16,0,0],[0,0,0,5,21],[12,12,0,0,18] ])
>>> cscM = sc
浏览 0提问于2013-05-25得票数 2
回答已采纳
1回答
如何在教学中实施ILU前置器？
、、、、
对于scipy.sparse.linalg中的迭代求解器(如bicg、gmres等)，可以为矩阵A添加预条件器。然而，并不是很清楚我应该给什么作为预条件。如果我使用ilu = sp.sparse.linalg.spilu(A)，ilu不是任何矩阵，而是包含许多东西的对象。
有人问了一个类似的问题，用于Python2.7，但我不为自己工作(Python3.7，枕1.1.0版)
那么，我的问题是，如何将不完全LU预条件用于这些迭代算法？
浏览 2提问于2019-11-16得票数 2
回答已采纳
3回答
我无法在matlab中完成完整的旋转。假设我有一些不稀疏的矩阵：
A = [0,1,1,1;0,1,0,0;1,1,1,1;0,0,0,-1]
当我试图在matlab中使用lu命令时，它不喜欢它，因为它并不稀疏：
>> [L,U,P,Q] = lu(A)
Error using lu
Too many output arguments.
甚至连文档都说它必须是稀疏的：
对于稀疏非空A，L，U，P，Q= lu(A)，返回单位下三角矩阵L，上三角矩阵U，行置换矩阵P，列重排矩阵Q，使得P_A_Q = L*U，如果A是空的或不稀疏的，lu会显示错误消息。语句lu(A，‘矩阵’)返回相
浏览 5提问于2017-11-29得票数 1
我将使用LU分解来求解一个线性方程Ax =b。当我将此代码用于较小的矩阵时，代码工作得很好，但当我输入大矩阵时，它就不起作用了。相反，它说： Traceback (most recent call last):
File "main.py", line 18, in <module>
LU = linalg.lu_factor(A)
File "/opt/virtualenvs/python3/lib/python3.8/site-packages/scipy/linalg/decomp_lu.py", line 76, in l
浏览 149提问于2021-01-14得票数 0
2回答
我正在尝试将主成分分析应用于巨大的稀疏矩阵，在下面的链接中它说sklearn的randomizedPCA可以处理scipy稀疏格式的稀疏矩阵。
然而，我总是得到错误。有人能指出我做错了什么吗？
输入矩阵'X_train‘包含float64格式的数字：
>>>type(X_train)
<class 'scipy.sparse.csr.csr_matrix'>
>>>X_train.shape
(2365436, 1617899)
>>>X_train.ndim
2
>>>X_train
浏览 1提问于2015-11-09得票数 19
我把这个贴在了上，但没有得到任何关注。只要我在其中一个得到答复，我就会通知另一个。
我有一个矩阵B，它是稀疏的，并试图利用一个函数scipy.sparse.linalg.spilu专门为稀疏矩阵分解B。请您解释一下为什么这个函数比通用矩阵的函数scipy.linalg.lu效率低得多？非常感谢!
import numpy as np
import scipy.linalg as la
import scipy.sparse.linalg as spla
import time
from scipy import sparse
from scipy.sparse import csc_matr
浏览 4提问于2020-06-01得票数 0
回答已采纳
3回答
根据我对LU分解的理解，这意味着对于下三角矩阵L和上三角矩阵U，矩阵A可以写为A= LU。
然而，scipy中与LU分解(，，)相关的函数似乎涉及第三个矩阵P，使得A= PLU，P是置换矩阵( L，U与前面一样)。
这个排列矩阵的意义是什么？如果“真正的”LU分解总是可能的，为什么P不是单位矩阵呢？
浏览 0提问于2014-04-22得票数 3
1回答
我正试图得到矩阵的LU组成。由于建议scipy.linalg.lu可能不太精确，所以我决定确保最大绝对误差远小于我正在处理的矩阵的最小元素。
下面是一个代码片段，在这里我尝试对A的转置进行LU分解：
print min([min(r[np.nonzero(r)], key=abs) for r in A], key=abs), "min"
P, L, U = scipy.linalg.lu(np.transpose(A))
B=np.matmul(np.matmul(P,L),U)
浏览 4提问于2020-02-07得票数 0
回答已采纳
3回答
我正在尝试使用sklearn库在Python语言中将信号分解成大型稀疏矩阵中的组件(矩阵分解)。
我利用scipy的scipy.sparse.csc_matrix来构建我的数据矩阵。然而，我不能进行任何分析，比如因子分析或独立成分分析。我唯一能做的就是使用truncatedSVD或scipy的scipy.sparse.linalg.svds来执行主成分分析。
有没有人知道在python中对稀疏矩阵进行ICA或FA的解决方法？任何帮助都将不胜感激！谢谢。
浏览 1提问于2015-04-29得票数 2
5回答
大矩阵反演方法
、、、、
嗨，我一直在研究矩阵求逆(线性代数)，我想用C++模板编程来实现这个算法，我发现有很多种方法，比如:Gauss消去法或LU分解法，我找到了函数LU_factorize (c++ boost library)。
我想知道是否还有其他方法，从程序员或数学家的角度来看，哪种方法更好(优点/缺点)？
如果没有其他更快的方法，那么boost库中是否已经有了(矩阵)反演函数?因为我已经搜索了很多，但是没有找到任何方法。
浏览 8提问于2010-07-28得票数 4
回答已采纳
1回答
我似乎无法从CG的CG和稀疏矩阵算法中获益。
当我试图解这个带状矩阵方程时
import time
import scipy.sparse.linalg as ssla
import scipy.sparse as ss
import numpy as np
size = 3000
x = np.ones(size)
A = ss.diags([1, -2, 1], [-1, 0, 1], shape=[size, size]).toarray()
print 'cond. nr.:{}'.format(np.linalg.cond(A))
b = np.dot(A, x)
浏览 6提问于2016-07-18得票数 0
我试图找出在python中寻找稀疏、对称和实矩阵行列式的最快方法。使用sparse模块，但非常惊讶没有行列式函数。我知道我可以使用LU分解来计算行列式，但是没有一种简单的方法，因为scipy.sparse.linalg.splu的返回是一个对象，并且实例化一个密集的L和U矩阵是不值得的--我也可以做sp.linalg.det(A.todense())，其中A是我的枕形稀疏矩阵。
我也有点惊讶，为什么其他人没有遇到有效的行列式计算的问题。如何使用splu计算行列式？
我调查了pySparse和scikits.sparse.chlmod。对于我来说，后者现在并不实用--需要安装包，而且在我陷入所有
浏览 0提问于2013-10-01得票数 26
回答已采纳
我有以下代码，其结果非常令人困惑：
import numpy as np
import scipy.linalg
B = np.array([[2,-1,-2],[-4,6,3],[-4,-2,8]])
P,L,U = scipy.linalg.lu(B)
print(L)
返回以下内容：
[[ 1. 0. 0. ] [ 1. 1. 0. ] [-0.5 -0.25 1. ]]
但这不是B的LU分解中正确的L矩阵，据我所知，命令scipy.linalg.lu(矩阵)只计算你输入的任何矩阵的LU分解矩阵。然而，在这种情况下，L矩阵是不正确的。这里发生什么事情
浏览 1提问于2018-12-06得票数 0
我试图将一个大型(150000,150000)稀疏矩阵反演如下：
import scipy as sp
import scipy.sparse.linalg as splu
#Bs is a large sparse matrix with shape=(150000,150000)
#calculating the sparse inverse
iBs=splu.inv(Bs)
导致以下错误消息：
Traceback (most recent call last):
iBs=splu.inv(Bs)
File "/usr/lib/python2.7/dist-pack
浏览 7提问于2015-12-17得票数 14
回答已采纳
5回答
正如前面所解释的，我目前正在开发一个小型线性代数库，用于个人项目中。矩阵被实现为C++向量，元素赋值( a(i，j) = v；)被委托给向量的元素赋值。对于我的项目，我需要解决大量的方程式系统，为此，我实现了方阵的LU分解(高斯消除)。在当前的实现中，我通过缓存L和U矩阵来避免每次LU分解时都重新计算，问题是因为我将元素赋值委托给向量，所以我找不到一种方法来判断矩阵是否被更改以及是否重新计算分解。对如何解决这个问题有什么想法吗？
谢谢
浏览 6提问于2009-01-14得票数 1
回答已采纳
2回答
我正在用Python语言在scipy.sparse中进行稀疏矩阵乘法A^-1@B。A和B都以csc格式存储。A和B的大小大约是1E+6 x 2E+5和1E+6 x 1E+6，我的直觉告诉我不应该颠倒A，而应该交替使用scipy.sparse.spsolve。但是spsolve(A，B)给了我内存问题。我也尝试过像gmres和cg这样的迭代求解器。但是由于这种迭代求解器的结果通常是密集的，所以内存问题仍然会出现。有没有人知道是否有合适的方法来解决这个大规模的问题？非常感谢你们！
浏览 0提问于2020-07-07得票数 2
2回答
我必须实现稀疏矩阵，并对其进行一些分解，如Cholesky分解，LU分解，QR分解。
实际上，我发现了一个名为JAMA的库，它能够对密集矩阵执行此操作。
但我必须实现稀疏矩阵。
有没有人可以分享他们实现稀疏矩阵的经验，或者有没有库可以实现它。
浏览 0提问于2011-08-27得票数 0
回答已采纳
2回答
有没有一种方法可以避免将零作为内部a循环的一部分？作为一个可笑的测试，我尝试了一个条件来停止乘法，如果它遇到一个零，当然这比只做乘法要慢。我的偏好是让LU矩阵保持不变，而不是重新排列以使零消失(稀疏)。在本例中，语言在转换为VB.net之前是VBA。
For k = 1 To i - 1
If LU(j, k) <> 0 and LU(k, i) <> 0 Then temp = temp - LU(j, k) * LU(k, i)
Next k
谢谢。
浏览 1提问于2015-09-23得票数 0
2回答
我试图理解使用numpy和and库进行LU分解的必要性。据我所知，我们想要解Ax = b，首先将A分解成两个三角矩阵L和U，然后通过求解Ly =b来求解LUx =b，然后求解Ux = y，通过求解三角形矩阵，我们可以减少与高斯消除相比的时间。
所以，我在蟒蛇中厌倦了这个想法，用的是numpy和scipy。
我首先用玩具例子构造A和b：
A = np.array([[2, 1, 0, 5], [1, 2, 1, 2], [0, 1, 2, 4], [1, 3, 6, 4.5]])
b = np.array([9, 10, -2, 3])
然后首先在np.solve中解决这个玩具示例
%timei
浏览 0提问于2018-04-07得票数 0
我很难理解什么时候使用稀疏版本的expm会比普通版本更好。
如果我取一个密度矩阵M，它恰好是稀疏的，大小为4000 x 4000矩阵并计算scipy.linalg.expm(M)，这大约需要25秒。如果然后执行M_sparse = sparse.csc_matrix(M)并计算scipy.sparse.linalg.expm(M_sparse)，则至少运行10分钟。
scipy.sparse.linalg.expm的正确用例是什么？它是否适用于大得多的矩阵？
浏览 5提问于2021-12-28得票数 2
1回答
我在R中有以下矩阵A：
# [,1] [,2] [,3] [,4]
# [1,] -1.1527778 0.4444444 0.375 0.3333333
# [2,] 0.5555556 -1.4888889 0.600 0.3333333
# [3,] 0.6250000 0.4000000 -1.825 0.8000000
# [4,] 0.6666667 0.6666667 0.200 -1.5333333
A <- structure(c(-1.15277777777778, 0.55555555555
浏览 2提问于2017-01-10得票数 2
回答已采纳
2回答
我的代码如下所示：
from sklearn.datasets import load_svmlight_files
import numpy as np
perm1 =np.random.permutation(25000)
perm2 = np.random.permutation(25000)
X_tr, y_tr, X_te, y_te = load_svmlight_files(("dir/file.feat", "dir/file.feat"))
#randomly shuffle data
X_train = X_tr[perm1,:].to
浏览 3提问于2014-05-26得票数 3
回答已采纳
1回答
由The提供的LU分解函数返回置换矩阵P。
P,L,U = scipy.linalg.lu(A)
其中A是一个矩形矩阵。但是，问题的大小不允许存储P (甚至是临时的)，因为它的大小，我真的需要一个计算置换向量的函数(如Matlab中的[L,U,P] = lu(A,'vector') )。我找到了一个漏洞函数
LU,p,info = scipy.linalg.lapack.dgetrf(A)
它似乎返回向量p，但我了解到后者不是实际的置换向量，因为它包含两倍相同的值()。因此，我正在寻找另一个函数(可能来自另一个库)来执行这个带旋转的LU分解。由于计算时间也很重要，我不认为自己实
浏览 7提问于2020-02-14得票数 0
4回答
在有限元问题的上下文中，我有一个12800x12800的稀疏矩阵。我试图用MATLAB的\运算符解这个线性系统，但我得到了一个内存不足的错误，使用mldivide。所以我想知道有没有办法加快速度。
我的意思是，像LU分解这样的东西在不再得到内存错误方面真的会有帮助吗？我在首选项中将堆大小增加到256 GB，这是我可以达到的最大值，但仍然出现内存不足错误。
另外，这只是一个一般性的问题。我的笔记本电脑上现在有8 8GB的内存。升级到16 at会有帮助吗？或者我可以为MATLAB分配更多的内存？我对这些东西很不熟悉。
浏览 2提问于2013-11-04得票数 5
1回答
学习关于LU分解的知识，我使用的教科书声称，一旦计算了初始矩阵L和U(假设不需要旋转矩阵P)，从零开始求解Ly =b，然后Ux =y比Ax =b要快得多。但是，当我用随机的A⊆R^(10 X 10)矩阵和b⊆R^(10 X 1)在我的系统上运行它时，它的速度要慢得多(12.49秒比6.17秒)。
这是我的密码：
import numpy as np
from scipy.linalg import lu
from numpy.random import rand
from numpy.linalg import solve
from timeit import timeit as durati
浏览 2提问于2021-02-07得票数 2
回答已采纳
1回答
熊猫数据的高效读写
、、、、
我有一只熊猫数据，我想把它们分成几个小的100 K行，然后保存到磁盘上，这样我就可以读取数据并逐一处理。我尝试过使用dill和hdf存储，因为csv和原始文本似乎需要很长时间。
我正在对包含大约500 k行和五列混合数据的数据子集进行试验。两个包含字符串，一个整数，一个浮点数，最后一个包含来自sklearn.feature_extraction.text.CountVectorizer的双图计数，存储为一个scipy.sparse.csr.csr_matrix稀疏矩阵。
这是我遇到问题的最后一篇专栏。转储和加载数据是没有问题的，但是当我尝试实际访问数据时，它是一个pandas.Series对象
浏览 3提问于2017-05-16得票数 1
回答已采纳
我们知道消除大致需要1/3 n^3操作，如果我们使用存储在内存中的LU分解，它将简化为n^2操作。如果我们有一个带上对角线和下对角线的带状矩阵，我们可以跳过零，把它降到大约nw^2操作，如果我们使用LU分解，它可以在大约2nw操作中完成。 在scipy.linalg中，我们有lu_factor和lu_solve，但它们似乎没有针对频带矩阵进行优化。我们也有solve_banded，但它直接解决了Ax=b。如何对带状矩阵进行有效的LU分解，并使用带状三角L和U有效地执行前向和后向消去法
浏览 42提问于2019-01-14得票数 0
最近我发明了一种新方法。新方法与CUDA (在20到40 new之间)非常完美，我已经成功地测试了它。当我试图用旧的方法来比较时，问题就来了。该方法是在CPU上实现的。它首先对A=LU进行LU分解，然后运行forward+back步骤来解决(LU)x=b.。旧方法非常好的一点是，A不会改变，因此只能进行一次LU分解，而开销只是forward+backward解决方案。A是稀疏和对称正定。(我相信这在许多问题上是相当普遍的做法，例如固定领域的流体模拟。)
为了使比较公平，我想在GPU上实现旧的方法。但我在cuSolver或cuSparse中没有发现任何稀疏的LU分解。我应该用其他图书馆来计算吗？
浏览 4提问于2015-04-06得票数 1
1回答
我对计算大型、稀疏、复杂(浮点)矩阵的行列式的对数很感兴趣。我的第一个想法是使用LU分解，即：
srand(123)
A=complex.(rand(3,3), rand(3,3))
LUF=lufact(A)
LUFs=lufact(sparse(A))
if round(det(LUFs[:L])*det(LUFs[:U])-det(A[LUFs[:p], LUFs[:q]]), 5)==0
println("Sparse LU determinant is correct\n")
else
println("Sparse LU determi
浏览 11提问于2017-12-21得票数 2
回答已采纳
我用LU预处理编写了一个共轭梯度求解器(用于线性方程组)，我以nvidia研究社区的Maxim Naumov博士的为指导，其残差更新步骤要求求解一个下三角矩阵系统，然后求解一个上三角矩阵系统，然后将其分为两个阶段：
分析阶段(利用稀疏模式并决定并行化水平)。
解决方案本身。
根据与此主题相关的所有帖子，以及Naumov的论文本身，分析阶段要比解决阶段慢得多，但是它只执行了一次，所以在考虑整个执行时间时不应该是一个问题，但是在我的程序中，分析阶段需要整个解决方案时间的35%-45%(执行所有迭代所需的时间！)，这是相当烦人的，另一件事是，我确信矩阵的稀疏模式不允许大量并行化，因为
浏览 4提问于2012-07-08得票数 3
回答已采纳
我需要解一个线性方程(Ax = b)，它有一个很大的稀疏的A和多次不同的b。因此，LU (如果A是对称的，则是Cholesky )，因式分解是非常可取的。
我正在使用armadillo库，我听说可以使用下面的函数：
spsolve(x, A, b, "superlu");
为了解决这样一个系统。我不太关心检索L和U矩阵。然而，最重要的是，每次我调用spsolve时，L和U都不会被重新计算。
spsolve(x, A, b, "superlu")是否存储LU分解?如果不是，是否有方法检索所述矩阵？
浏览 0提问于2018-10-20得票数 1
我对计数数据的对数感兴趣，这些数据是我对文本数据进行计数得到的。我很想测试这种转换(标准化)是否有助于提高sklearn中模型的性能。
这就是我所拥有的：
TEXT = [data[i].values()[3] for i in range(len(data))]
from sklearn.feature_extraction.text import CountVectorizer
vectorizer = CountVectorizer(min_df=0.01,max_df = 2.5, lowercase = False, stop_words = 'english')
浏览 37提问于2016-07-31得票数 1
回答已采纳
2回答
我在Python中有一个非常简单的脚本，但由于某种原因，在运行大量数据时会出现以下错误：
*** glibc detected *** python: double free or corruption (out): 0x00002af5a00cc010 ***
我习惯了C或C++中出现的这些错误，当一个人试图释放已经被释放的内存时。然而，根据我对Python的理解(尤其是我编写代码的方式)，我真的不明白为什么会发生这种情况。
以下是代码：
#!/usr/bin/python -tt
浏览 4提问于2013-02-16得票数 34
回答已采纳
我正在使用scipy最小化函数。它调用的函数是用Cython编译的，并且有一个我编写的底层C++实现，但这并不重要。由于某些原因，当我运行我的程序时，它会创建尽可能多的线程来填满我所有的cpus。例如，如果我运行top，我看到800%的cpu正在被使用，或者在htop上，我可以看到正在使用8个单独的处理器，而我创建的程序只在一个处理器上运行。我甚至不认为scipy具有并行处理功能，我也找不到任何与此相关的文档。可能发生了什么，有什么方法可以控制它吗？
浏览 5提问于2017-02-25得票数 3
回答已采纳
我有一个用scipy.sparse.csc_matrix.toarray()转换成数组的。当我对一个小的数据集使用该函数时，它工作得很好。但是，当我将其用于大型数据集时，python解释器在调用函数时立即崩溃，并且窗口关闭，没有出现错误消息。我尝试转换为数组的矩阵是用sklearn.feature_extraction.text.CountVectorizer创建的。我在Ubuntu 12.04上运行python 2.7.3。更复杂的是，当我试图从终端运行脚本以保存任何错误消息时，日志没有记录任何错误消息，并且实际上在脚本中更早地停止(尽管如果没有调用toarray()则是完整的)。
浏览 0提问于2014-07-01得票数 2
2回答
LU分解N^3
、、、
假设我有一个正方形的N×N对称实矩阵A，我想要计算A的LU分解，它的复杂度(例如O(N^2)，O(N^3)等).做这件事的最佳算法
如果A是稠密矩阵
如果A是稀疏矩阵？
浏览 2提问于2014-01-10得票数 0
我有一个非常大的稀疏Numpy矩阵(类型为numpy.ndarray)。矩阵太大了，很可能必须存储在虚拟内存中。如何有效地将其转换为稀疏的枕木矩阵(来自scipy.sparse)(用于算术操作)？
下面是dok_matrix的直接转换，这可能是由于内存问题而失败的。将dok_matrix更改为csr_matrix会导致相同的内存问题。
In [1]: N=int(1e6)
In [2]: from scipy.sparse import dok_matrix
In [3]: import numpy as np
In [4]: mat=np.zeros((N,N))
In [5]: d
浏览 13提问于2022-08-19得票数 0
回答已采纳
1回答
我有两个稀疏矩阵A(亲和力矩阵)和D(对角矩阵)，维数为100000*100000。我必须计算拉普拉斯矩阵L= D^(-1/2)*A*D^(-1/2)。我正在使用scipy CSR格式的稀疏矩阵。
我没有找到任何方法来求稀疏矩阵的逆。如何求稀疏矩阵的L和逆矩阵？还建议使用python来做这件事是否有效，或者我是否应该调用matlab函数来计算L？
浏览 1提问于2012-02-12得票数 3
1回答
如果我有N个独立的优化问题，一般情况下，独立地解决每个问题还是组合这些问题会更快呢？牛顿法对于给定的精度p有时间复杂度log(p) *(计算导数比的时间)，假设有合理的种子。如果多元Newton Raphson时间复杂度不随维数而定，那么给定p处的复杂度仍将取决于梯度/哈森计算和线性求解器。我主要是为了提高代码效率:我想用每个子集正则化或全局正则化来拟合数据子集的似然函数。如果两者在成本上是相似的，我可以实现一个牛顿优化器，它可以将各种正则化惩罚作为函数参数，在适当的时候在稀疏和密集的求解器之间切换。
下面，稀疏求解器胜过单独的via循环，但我想知道它是否只是python循环开销(使用Cyth
浏览 1提问于2017-01-27得票数 1
回答已采纳
我尝试将形状为(1482535,67826)的scipy.sparse.csr.csr_matrix存储到数据帧中，但收到如下错误。我在Google Cloud平台上运行，有4个4CPU和208 GB内存。我不能再增加我的记忆了。我该如何解决这个问题？如有任何建议，欢迎光临。
type(x_train_bow_name)`
scipy.sparse.csr.csr_matrix
data1 = pd.DataFrame(x_train_bow_name.toarray())`
-------------------------------------
浏览 51提问于2019-11-05得票数 5
2回答
我是艾根的新手，我在处理稀疏的LU问题。我发现，如果我创建一个向量b(n)，本征可以计算Ax=b方程的x(n)。
问题：
如何显示L& U，这是原矩阵A的分解结果？
如何在特征中插入非零？现在我只是用一些小的稀疏矩阵来测试，所以我一个一个地插入非零，但是如果我有一个大的矩阵，我如何在我的程序中输入这个矩阵呢？
浏览 0提问于2014-08-22得票数 1
回答已采纳
1回答
我需要用cuda计算矩阵(双数组)的行列式，我希望使用LU分解来实现这一点。我在cusolverSp.h中没有找到设备函数，只有主机函数cusolverSpDcsrlsvluHost。我看Cuda7.0和Cuda7.5。
我不明白为什么我找不到它，因为它是在官方文档中描述的：
设备上的Cholesky分解等其他功能也能工作。
它实施了吗？如果是，我在哪里能找到它？
谢谢你的帮助!
浏览 3提问于2015-08-27得票数 0
回答已采纳
我在这方面研究了很多，但找不到解决这个问题的实际方法。我正在使用scipy创建csr稀疏矩阵，并希望从所有1的等价矩阵中减去此矩阵。在scipy和numpy表示法中，如果矩阵不是稀疏的，我们可以通过简单地编写1- MatrixVariable来实现。但是，如果Matrix是稀疏的，则不会实现此操作。我可以想到下面这个显而易见的解决方案：
迭代整个稀疏矩阵，将所有零元素设置为1，将所有非零元素设置为0。
但这将创建一个矩阵，其中大多数元素为1，只有少数元素为0，这不再是稀疏的，并且由于其巨大的大小无法转换为密集。
有什么替代的和有效的方法可以做到这一点呢？
谢谢。
浏览 3提问于2013-07-02得票数 3
1回答
进程对象间共享SciPy稀疏数组
、、、、
我最近一直在学习，并且遇到了一个障碍。我有一个稀疏的SciPy数组(CSC-格式)，我需要在5个工作进程之间共享只读格式。我读过和 (numpy-shared)，但这似乎只适用于密集类型。
如何在5个多处理过程对象之间不复制(或最小拷贝)的情况下共享scipy.sparse.csc_matrix()？即使是numpy共享方法似乎也需要复制整个数组，即使这样，我也不能仅仅将scipy.sparse转换为mp.Array()。有人能帮我指出正确的方向吗？
谢谢!
浏览 2提问于2013-07-16得票数 9
回答已采纳
传统智慧指出，如果您使用相同的A和不同的b多次求解Ax = b，则应该对LU使用LU分解。如果我使用p, l, u = scipy.linalg.lu(A)并在一个循环中多次求解 x = scipy.linalg.solve(l, p.T@b)
x = scipy.linalg.solve(u, x) 这最终比仅仅使用 x = scipy.linalg.solve(A,b) 在循环中。scipy.linalg.solve()不是针对使用向前和向后替换的上对角线系统和下对角线系统进行了优化吗？或者，有没有可能存在一些编译技巧，其中python认识到它可以为scipy.linalg.solve部
浏览 45提问于2020-10-22得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
