scipy稀疏矩阵和导致密集矩阵-如何加强结果稀疏性？
scipy稀疏矩阵是指在使用scipy库进行矩阵运算时，采用了一种特殊的数据结构来存储矩阵，以减少内存占用和提高计算效率。稀疏矩阵是指矩阵中大部分元素为0的矩阵。
在实际应用中，很多矩阵是稀疏的，即大部分元素为0，只有少数非零元素。对于这种情况，使用稀疏矩阵可以节省大量的内存空间，并且在进行矩阵运算时可以提高计算效率。
为了加强结果的稀疏性，可以采取以下几种方法：
- 压缩稀疏矩阵：对于已知稀疏矩阵，可以使用压缩算法对其进行压缩，以减少存储空间。常见的压缩算法有CSR（Compressed Sparse Row）和CSC（Compressed Sparse Column）等。
- 稀疏矩阵运算：在进行矩阵运算时，可以利用稀疏矩阵的特点，选择适合稀疏矩阵的运算算法，以减少计算量。例如，对于稀疏矩阵的乘法运算，可以使用稀疏矩阵的压缩格式进行运算，避免对所有元素进行计算。
- 稀疏矩阵分解：对于某些应用场景，可以将稀疏矩阵分解为更加稀疏的形式，以进一步减少非零元素的数量。常见的矩阵分解方法有SVD（奇异值分解）和LU分解等。
- 数据预处理：在使用稀疏矩阵进行计算之前，可以对原始数据进行预处理，以增强结果的稀疏性。例如，可以通过阈值处理、归一化等方法将原始数据转化为稀疏矩阵。
对于scipy稀疏矩阵的具体使用和相关产品，可以参考腾讯云的文档和产品介绍：
- 腾讯云文档：https://cloud.tencent.com/document/product/845
- 腾讯云产品介绍：https://cloud.tencent.com/product/tc3
请注意，以上答案仅供参考，具体的应用场景和推荐产品需要根据实际需求进行选择。
相关·内容
1回答
假设我们有一个大小为NxN的矩阵A，A是稀疏的，而N非常大。所以我们自然而然地希望存储的是scipy稀疏矩阵。
我们还有一个大小为NxK的密集numpy数组q，其中K相对较小。
我们如何最有效地执行q.T * A * q，其中*是矩阵乘法，以获得KxK结果？
我们想要的一部分可以高效地完成，那就是A * q，但是一旦你这样做了，你就物化了一个密集数组，然后你需要与另一个密集数组相乘。
有没有比q.T.dot(A.dot(q))更快的方法？
浏览 1提问于2016-09-17得票数 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
3回答
假设我有Numpy数组p和一个稀疏矩阵q，这样
>>> p.shape
(10,)
>>> q.shape
(10,100)
我想做一个p和q的点乘积。当我尝试使用numpy时，我得到以下结果：
>>> np.dot(p,q)
Traceback (most recent call last):
File "/usr/local/lib/python2.7/dist packages/IPython/core/interactiveshell.py", line 2883, in run_code
exec(co
浏览 4提问于2015-06-25得票数 1
回答已采纳
我有一个很大的(100K X 30K)和(非常)稀疏的svmlight格式的数据集，我按如下方式加载：
import numpy as np
from scipy.cluster.vq import kmeans2
from scipy.spatial.distance import pdist, squareform
from sklearn.datasets import load_svmlight_file
X,Y = load_svmlight_file("somefile_svm.txt")
它返回一个稀疏的scipy数组X
我只需要计算所有训练点的成对距离如下
D
浏览 2提问于2012-01-22得票数 5
我正在做一些量子计算的数值模拟，我希望找到一个大的厄米特矩阵(~2^14行/列)的特征向量
我在一台24核/48线程的XEON机器上运行。代码最初是在Qutip库的帮助下编写的。我发现包含的eigenstates()函数只使用我的机器上的一个线程，所以我正在尝试找到一种更快的方法来做到这一点。
我尝试使用scipy.linalg、eig()和eigh()函数，以及scipy.sparse.linalg eig()和eigh()，但这两个函数似乎都比Qutip中内置的函数慢。
我已经看到一些建议，我可能会从使用slepc4py中获得一些加速，但是这个包的文档似乎非常缺乏。我找不到如何将numpy
浏览 34提问于2017-02-03得票数 4
3回答
我正在尝试使用sklearn库在Python语言中将信号分解成大型稀疏矩阵中的组件(矩阵分解)。
我利用scipy的scipy.sparse.csc_matrix来构建我的数据矩阵。然而，我不能进行任何分析，比如因子分析或独立成分分析。我唯一能做的就是使用truncatedSVD或scipy的scipy.sparse.linalg.svds来执行主成分分析。
有没有人知道在python中对稀疏矩阵进行ICA或FA的解决方法？任何帮助都将不胜感激！谢谢。
浏览 1提问于2015-04-29得票数 2
F是CSR稀疏矩阵。
(0, 0) 28.9009663001
(0, 1) -9.21359549996
...
(7, 6) -10.2135955
(7, 7) 30.9009663001
C也是CSR稀疏矩阵。
(0, 0) 1.0782887739
(1, 0) -1.33369825452
(2, 0) 1.74824228278
(3, 0) -2.55552434318
(4, 0) 3.08435514293
(5, 0) -1.94369861339
(6, 0) 1.47753839244
(7, 0) -2.0
浏览 1提问于2014-02-02得票数 0
我在SciPy稀疏矩阵上搜索一个矩阵平方根操作，比如scipy.linalg.sqrtm (非元素平方根)，但是我什么也找不到。换句话说，scipy.sparse.linalg.sqrtm不存在。有没有人知道如何对稀疏矩阵进行这种操作(除了转换为密集矩阵和使用SciPy的linalg.sqrtm)
人们已经提出了通过sparse_matrix**power在稀疏矩阵上进行矩阵幂的方法，但是它只能处理整数幂。
浏览 5提问于2017-05-12得票数 2
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
比如说，我们有一个枕木稀疏矩阵
from scipy.sparse import csc_matrix
mat = scipy.sparse.csc_matrix([[0, 1, 2]
[0, -1, 3]])
柱状均值是0, 0, 2.5，所以从列的每个元素减去柱状均值后的结果应该是，
[
[0, 1, -.5]
[0, -1, .5]
]
由于矩阵是巨大的，是否有一种有效的方法，即不使用.toarray()计算它？
浏览 0提问于2020-07-25得票数 0
回答已采纳
1回答
我正在使用Python、numpy和scipy对我为文本分析创建的主题模型的输出进行一些层次聚类。
我将我的测试语料库应用于ldamodel，因此它成为一个词袋表示。然后我把它变成了一个矩阵。现在，我想使用scipy来创建一个矩阵的链接矩阵。但它给出了值错误:使用序列设置数组元素。我猜这是因为只有形状相同的数组才能聚集在一起。我的矩阵在列表中的列表之间有长度上的差异。我现在只是不知道如何解决这个问题。下面是代码的一小部分。我不知道这是否有帮助。我真的希望有人能帮我。
import numpy as np
X = np.array(corpus)
from matplotlib im
浏览 0提问于2017-01-13得票数 0
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
回答已采纳
我用Armadillo来解决一些线性代数问题。它有稀疏矩阵的SpMat<float>和稠密矩阵的Mat<float>。
假设我有稀疏矩阵S_a和S_b，以及稠密矩阵D。我需要计算产生的S_a*S_b和S_a*D，结果在这两种情况下都会很密集。
我可以将稀疏矩阵转换为密集矩阵，然后再进行乘法，但这将是效率低下的(这些矩阵非常大)。有没有办法让Armadillo在不执行中间转换步骤的情况下将结果存储到稠密矩阵中？
浏览 4提问于2017-10-24得票数 0
回答已采纳
我想生成一个大型的稀疏矩阵并对其求和，但我经常遇到MemoryError。因此，我尝试通过执行此操作，但发现在求和之后，数据类型又变成了numpy matrix。
window = 10
np.random.seed = 0
mat = sparse.csc_matrix(np.random.rand(100, 120)>0.5, dtype='d')
print type(mat)
>>> <class 'scipy.sparse.csc.csc_matrix'>
mat_head = mat[:,0:window
浏览 116提问于2018-06-06得票数 5
回答已采纳
1回答
假设我想要计算二次形式的x^T A y，其中x和y是NumPy向量，为了提高效率，我将A存储为SciPy csc_matrix。
似乎执行计算的一种方法是
(x * A).dot(y)
因为SciPy对矩阵产品使用*，而NumPy使用.dot。
虽然这种方法给了我正确的答案，但它似乎与我的直觉相反，我想知道是否有更好的可读性/更有效的方法？
浏览 12提问于2018-01-14得票数 1
回答已采纳
通过这种方式可以读取密集数据：
# tf - tensorflow, np - numpy, sess - session
m = np.ones((2, 3))
placeholder = tf.placeholder(tf.int32, shape=m.shape)
sess.run(placeholder, feed_dict={placeholder: m})
如何将枕稀疏矩阵(例如scipy.sparse.csr_matrix)读入tf.placeholder或tf.sparse_placeholder？
浏览 1提问于2017-05-11得票数 1
2回答
设矩阵A为对角矩阵，B为随机矩阵，均为N×N。我们希望利用矩阵A的稀疏性来优化点积，即点(B，A)。
但是，如果我们使用矩阵A的稀疏性来计算乘积，我们就看不到任何优势(而且速度要慢得多)。
import numpy as np
from scipy.sparse import csr_matrix
# Matrix sizes
N = 1000
#-- matrices generation --
A = np.zeros((N,N), dtype=complex)
for i in range(N):
A[i][i] = np.random.rand()
B = np.random
浏览 4提问于2017-03-01得票数 1
回答已采纳
2回答
求巨型稀疏矩阵的最大特征值
、、、、
我正在尝试寻找一个非常稀疏的邻接矩阵的最大特征值。我已经尝试了所有可用的方法：
mat = scipy.io.mmread(f)
mat = scipy.sparse.csr_matrix(mat)
G = nx.to_networkx_graph(mat)
mat = None
# compute largest eigenvalue
L = nx.normalized_laplacian_matrix(G)
# impl 1
e = numpy.linalg.eigvals(L.A)
# impl 2
e, _ = scipy.sparse.linalg.eigs(L.A, k=1,
浏览 1提问于2018-11-28得票数 4
我在这方面研究了很多，但找不到解决这个问题的实际方法。我正在使用scipy创建csr稀疏矩阵，并希望从所有1的等价矩阵中减去此矩阵。在scipy和numpy表示法中，如果矩阵不是稀疏的，我们可以通过简单地编写1- MatrixVariable来实现。但是，如果Matrix是稀疏的，则不会实现此操作。我可以想到下面这个显而易见的解决方案：
迭代整个稀疏矩阵，将所有零元素设置为1，将所有非零元素设置为0。
但这将创建一个矩阵，其中大多数元素为1，只有少数元素为0，这不再是稀疏的，并且由于其巨大的大小无法转换为密集。
有什么替代的和有效的方法可以做到这一点呢？
谢谢。
浏览 3提问于2013-07-02得票数 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
回答已采纳
我把这个贴在了上，但没有得到任何关注。只要我在其中一个得到答复，我就会通知另一个。
我有一个矩阵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
回答已采纳
1回答
让我们假设A是一个(scipy)稀疏矩阵，tf值，B是一个(numpy)数组，具有数据的一些附加特性。
A和B的每一行对应于相同的观察结果。
我想将这些矩阵/数组连接起来，因为我想将它们传递给sklearn模型来训练它，而且我不认为我可以单独传递它们。
根据这个答案()，有两种方法可以连接这些数组：
将稀疏数组(A)转换为密集数组，然后连接
将完全密集数组(B)转换为稀疏矩阵
但是，(1)在我的例子中，基本上是不可能的，因为我的例子中的A太大了。
因此，我可以考虑将我的完全密集数组(B)转换为稀疏数组。
但是，我的问题是，这样做是否会丢失任何信息(例如，通过将一个完全密集的数组
浏览 0提问于2019-08-05得票数 0
1回答
优化Scipy稀疏矩阵
、、、
我有一个稀疏矩阵，目前我正在枚举每一行，并根据每一行的信息执行一些计算。每一行都完全独立于其他行。然而，对于大的矩阵，这个代码非常慢(大约需要2个小时)，而且我也不能将矩阵转换为密集的矩阵(限于8 8GB )。
import scipy.sparse
import numpy as np
def process_row(a, b):
"""
a - contains the row indices for a sparse matrix
b - contains the column indices for a sparse matrix
浏览 0提问于2016-04-13得票数 0
1回答
我想使用Scipy (v0.18.1)中的布尔运算来组合稀疏(二进制)数组的列。对于密集矩阵，它可以很好地这样做：
data[:,5] & ~data[:,23] & data[:,400]
它会折叠成一根柱子。然而，在使用稀疏数组执行此操作时，我得到了一个错误。
布尔部分出错：
"unsupported operand type(s) for &: 'csc_matrix' and 'csc_matrix'"
~(反转)部分出错：
bad operand type for unary ~: 'csc_matrix
浏览 2提问于2017-05-06得票数 2
1回答
我试图求解一个方程组，它是一个100万×100万平方矩阵和100万个解向量。
要做到这一点，我使用np.linalg.solve(矩阵，答案)，但它需要很长时间。
有办法加快速度吗？
谢谢@Chris，但这并没有回答这个问题，因为我也尝试过使用Scipy模块，它仍然需要很长的时间来解决。我不认为我的电脑能在RAM中保存那么多数据
为了清楚起见，我刚刚发现我想要解的矩阵的名称是Hilbert矩阵
浏览 13提问于2022-06-28得票数 5
为了更好地解释我的用例，A是一个稀疏矩阵，tf值是一个稀疏的矩阵，而B是一个数组，它具有数据的一些附加特性。
我已经分到了训练集和测试集，所以在我的例子中，A和B只是关于训练集的。我(希望)在这段代码之后对测试集做同样的操作。
我想将这些矩阵/数组连接起来，因为我想将它们传递给一个sklearn ML模型来训练它，我不认为我可以单独传递它们。
所以我试着这么做：
C = np.concatenate((A, B.T), axis=1)
其中A是<class 'scipy.sparse.csr.csr_matrix'>，B是<class 'numpy.n
浏览 0提问于2019-08-05得票数 3
2回答
我有一个大矩阵存储为一个scipy.sparse.csc_matrix，并希望从大矩阵中的每一个列中减去一个列向量。这是一个相当常见的任务，当您正在做的事情，如标准化/标准化，但我似乎找不到适当的方式来有效地做到这一点。
下面是一个演示的示例：
# mat is a 3x3 matrix
mat = scipy.sparse.csc_matrix([[1, 2, 3],
[2, 3, 4],
[3, 4, 5]])
#vec is a 3x1 matrix (or a
浏览 3提问于2013-11-19得票数 6
回答已采纳
1回答
如何使用scipy的稀疏矩阵在Python中实现下面的MATLAB命令？
B=[zeros(numrowsA), A; A', zeros(numcolumnsA)];
浏览 4提问于2014-10-20得票数 0
回答已采纳
如何对scipy稀疏矩阵的行进行混洗？ 有一个scikitlearn.utils.shuffle，但它返回一个新的矩阵，因此对于非常大的稀疏矩阵，混洗不是就地完成的，而是复制矩阵。 有numpy.random.Generator.shuffle，但它似乎是work only for CSR matrices。 如何有效地打乱scipy稀疏矩阵的行数，不管它是以什么格式存储在内存中的？
浏览 14提问于2020-12-02得票数 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
回答已采纳
SVC似乎处理那些可以采用稀疏矩阵的内核与那些不使用稀疏矩阵的内核不同。然而，如果用户提供的内核编写来获取稀疏矩阵，并且在拟合期间提供了稀疏矩阵，那么它仍然将稀疏矩阵转换为密集，并将内核视为密集的，因为内核不是scikit中预先定义的稀疏内核之一。
有没有一种方法可以强迫SVC识别内核是稀疏的，而不是在将稀疏矩阵传递给内核之前将其转换成密集矩阵？
编辑1:最小工作示例
例如，如果SVC在创建时将核的字符串“线性”传递给SVC，则使用线性核，稀疏矩阵直接传递给线性核，如果拟合时提供稀疏矩阵，则支持向量存储为稀疏矩阵。但是，如果将linear_kernel函数本身传递给SVC，则稀疏矩阵在传递到内
浏览 1提问于2016-09-12得票数 2
我有一个大维数的稀疏矩阵，我想取每一行元素的和，i，并用结果填充对角线。我该怎么做？
我的粗野方法：
A = np.sum(A, axis=1)
D = np.diag(A)
我该如何用枕木来处理这个问题？
编辑:我正在使用scipy.sparse并将A初始化为csr_matrix。我读过医生的书，但也许我读错了，或者遗漏了什么。对于sparse.diags(D)，我只是得到了一个列数组，即当我试图将稀疏矩阵转化为np.array时，它没有给出对角矩阵。
浏览 3提问于2021-05-08得票数 0
回答已采纳
当我试图将矩阵s (任何可用的稀疏类型)分配给NumPy数组a时，如下所示：
a[:] = s
我得到了一个TypeError
TypeError: float()参数必须是字符串或数字
有办法绕过这件事吗？
我了解todense()和toarray()方法，但我非常希望避免不必要的复制，我更愿意对NumPy数组和SciPy稀疏矩阵使用相同的代码。现在，我不关心从稀疏矩阵中得到的值效率很低。
是否有某种与NumPy索引分配有关的稀疏矩阵的包装器？
如果没有，有什么建议可以让我自己去建造这样的东西吗？
在这种情况下，是否有与NumPy合作的不同稀疏数组库？
更新：
我在NumPy源代码中
浏览 9提问于2014-11-14得票数 2
回答已采纳
我有一个表单的Sympy表达式
exp = 0.5*y1**2 + 2*y1*y2 + 2.5*x5**2 + 5.0*x6**2 - 25.0*exp(2.0*I*x4)*exp(1.0*I*x5) - 25.0*exp(2.0*I*x4) + 100.0 - 25.0*exp(-2.0*I*x4) - 25.0*exp(-2.0*I*x4)*exp(-1.0*I*x5)
我想将上面的表达式转换为一个使用变量作为参数的函数。此外，参数以稀疏的csc矩阵作为输入，而不是变量。因此，我使用以下代码将其转换为函数。
func = lambdify((y1,y2,x4,x5,x6),exp,
浏览 3提问于2021-03-06得票数 1
1回答
我有一个大的二维ndarray，A和我想要计算最大特征值和相关联的特征向量对的奇异值。从NumPy文档来看，NumPy似乎只能计算完整的SVD (numpy.linalg.svd)，而SciPy有完全满足我需要的方法(scipy.sparse.linalg.svds)，但是使用稀疏矩阵，我不想执行A的转换，因为这需要额外的计算时间。
到目前为止，我一直在SciPy svds上直接使用A，但是文档阻止将ndarrays传递给这些方法。
是否有一种方法可以使用接受ndarray对象的方法来执行此任务？
浏览 6提问于2017-02-18得票数 2
回答已采纳
1回答
数组与稀疏矩阵的相关性
、、、
我有一个稀疏矩阵(x)和一个数组(y)。我想计算矩阵中的每一列和数组之间的相关性。下面显示的是一个非常简单的方法，但速度很慢。我希望有人能有一个更快/更好的方法。
import numpy as np
from scipy.sparse import rand as r1
from numpy.random import rand as r2
np.random.seed(1000)
nrow,ncol = 50000,4000
x = r1(nrow, ncol, format='csr', density=.05)
y = (r2(nrow)<=.6).astyp
浏览 0提问于2018-01-11得票数 3
回答已采纳
1回答
我使用的是相当大的旋转矩阵，它具有具有大量零的固有属性。为了减少内存消耗，并在将这些旋转矩阵与其他矩阵/向量相乘时，可能会减少计算量，我想使用稀疏矩阵数据结构。我已经找到了关于SciPy稀疏矩阵的文档，但是我不太明白这些文档是如何工作的，它们之间有什么区别。()
什么是Python中用于旋转矩阵的最佳稀疏数据结构？
浏览 2提问于2015-03-07得票数 2
回答已采纳
1回答
我试图计算一个大矩阵的乘法逆(~ >40000x40000)。这可以通过例如numpy.linalg.inv或scipy.linalg.inv来完成。很不幸，在我可以访问的HPC上，计算失败.。
numpy.linalg.inv(I-A)或scipy.linalg.inv(I-A)等价于(I-A)^-1，D5可以通过I + A + AA + AAA + AAAA ...或I + A + A^2 + A^3 + A^4 ...近似。
因为我不能运行linalg.inv，所以我编写了一个函数来近似它。然而，事实证明，用完整的矩阵运行我的函数非常慢。因此，我想知道我的代码是否是简单的低效/缺陷
浏览 0提问于2022-06-17得票数 0
回答已采纳
2回答
稀疏矩阵线性规划
、、、
我想在python中解决一个线性规划。变量数(从现在起称为N)非常大(~50000)，为了按照scipy.optimize.linprog要求的方式来表述这个问题，我必须构造两个N矩阵(A和B )。LP可以写成
minimize: c.x
subject to:
A.x <= a
B.x = b
x_i >= 0 for all i in {0, ..., n}
其中.表示点积，a、b和c是长度为N的向量。
我的经验是，构建这样大的矩阵(A和B都有)。50000x50000 = 25*10^8条目)带来了一些问题:如果硬件不是很强，NumPy可能会完全拒绝
浏览 0提问于2016-01-15得票数 8
回答已采纳
我的数据可以看作是10B条目(100 Mx100)的矩阵，这是非常稀疏的(< 1/100 * 1/100的条目是非零的)。我想用Tensorflow后端将数据输入到Keras神经网络模型中。
我的第一个想法是将数据扩展为密集数据，也就是说，将所有10B条目写入一系列CSV中，其中大多数条目为零。然而，这很快就淹没了我的资源(即便是做ETL的工作也让熊猫不堪重负，并导致postgres陷入困境)。所以我需要使用真正的稀疏矩阵。
我如何使用Keras (和Tensorflow)来做到这一点？虽然numpy不支持稀疏矩阵，但scipy和tensorflow都支持稀疏矩阵。关于这个想法有很多讨论
浏览 2提问于2017-01-08得票数 45
1回答
我有一个形状为(k,N)的numpy数组Z和一个形状为(N,n)的第二个数组X。
使用numpy广播，我可以很容易地获得一个新的具有形状(n,k,N)的数组H，它的片段是数组Z，它的行乘以X的列
H = Z.reshape((1, k, N)) * X.T.reshape((n, 1, N))
这很好用，而且速度快得出奇。现在，X是非常稀疏的，我想使用稀疏矩阵操作来进一步加速这个操作。
但是，如果我执行以下操作：
import scipy.sparse as sprs
spX = sprs.csr_matrix(X)
H = (Z.reshape((1,k,N))*spX.T.reshape(
浏览 0提问于2016-11-17得票数 3
2回答
稀疏矩阵的高效最近邻搜索
、、、
我有一个庞大的数据(文本)语料库，我已经将其转换为稀疏术语文档矩阵(我使用scipy.sparse.csr.csr_matrix来存储稀疏矩阵)。我希望为每个文档找到前n个最近的邻居匹配。我希望Python scikit-learn库中的NearestNeighbor例程(准确地说是sklearn.neighbors.NearestNeighbor)可以解决我的问题，但是使用空间分区数据结构(如KD trees或Ball trees )的高效算法不能处理稀疏矩阵。只有蛮力算法才能处理稀疏矩阵(这在我的情况下是不可行的，因为我正在处理大型语料库)。
稀疏矩阵的最近邻搜索(用Python或任何其他
浏览 1提问于2013-08-11得票数 9
1回答
我用特征的LSCG迭代求解一个过定的系统，我用稀疏矩阵来表示，我认为它太了。重复地说，我的意思是：
//The following is pseudo code
main() {
//compute A
A=..
//compute B
B=..
while(someCondition)
{
x=solve(A,B)
//based on x alter A and B
A=..
B=..
}
}
例如，当A有36k行，18k cols
浏览 5提问于2017-09-02得票数 2
回答已采纳
1回答
我正在做一个简单的稀疏矩阵指数，a**16，使用ciply-0.17。(注意，不是按元素进行乘法)。然而，在我的机器上(运行Debian和Ubuntu )，这比使用for循环或做一些类似a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a之类的傻事要慢十倍。这没有道理，所以我想我做错了什么，但是什么？
import scipy.sparse
from time import time
a=scipy.sparse.rand(2049,2049,.002)
print ("Trying exponentiation (a**16)")
t=time()
x=a**1
浏览 1提问于2017-06-19得票数 11
回答已采纳
设a是一个大的scipy.sparse矩阵，IJ={(i0，j0)，(i1，j1)，…}是一组位置。如何有效地将a中IJ位置中的所有条目设置为0？有点像a[IJ]=0。
在Mathematica中，我将创建一个新的稀疏矩阵b，其背景值为1(而不是0)，以及IJ中的所有条目。然后，我将使用a=a*b (逐项乘法).在这里，这似乎不是一个选择。
一个玩具例子：
import scipy.sparse as sp
import numpy as np
np.set_printoptions(linewidth=200,edgeitems=5,precision=4)
m=n=10**1;
a=sp.
浏览 4提问于2020-11-04得票数 0
回答已采纳
1回答
我用np.save('X', X)保存了一个枕形的csr矩阵。当我用np.load('X.npy')加载它时，我得到了以下内容：
array(<240760x110493 sparse matrix of type '<class 'numpy.float64'>' with 20618831 stored elements in Compressed Sparse Row format>, dtype=object)
但是，我不能使用索引(如X[0,0]或X[:10,:10] or X[0]都给出
浏览 8提问于2016-02-12得票数 1
回答已采纳
3回答
如果我对numpy.zeros矩阵做同样的操作，它就能工作。但对于枕骨稀疏矩阵，它不起作用。为什么？
import scipy.sparse as sparse
import scipy as sp
a = sparse.lil_matrix((3,3), dtype=int)
a[0,0] = 0
a[1,1] = 1
a[2,2] = 2
b = a.sum(0)
bo = (-b).argsort()
ao = sp.take(a, bo, axis=1)
我知道错误：
ValueError: axis(=1) out of bounds
为什么这不起作用。有人能告诉我怎么修吗？或者用枕
浏览 9提问于2016-02-14得票数 0
回答已采纳
1回答
我想实现以下操作：B = diag(u) @ K @ diag(v) -一些矩阵K的乘积，从左和右到对角线矩阵。显式创建稠密矩阵和2矩阵-矩阵积是非常昂贵的.在这种情况下，如果K是一个np.ndarray，我想出了以下解决方案：
u[:, None] * K * v[None, :]
这很好，因为广播是发生的，但是如果K是一个scipy.sparse.csr_matrix，我会遇到维度错误匹配的问题：
ValueError: dimension mismatch
我试过了
u[:, None] * K.multiply(v[None, :])
计算左操作数，但乘法也失败。对于稀疏矩阵，人们应该
浏览 6提问于2020-12-07得票数 0
回答已采纳
3回答
所以，我使用非常稀疏的numpy数组来做一些Kmeans分类--很多很多的零。我想我应该使用scipy的'sparse‘包来减少存储开销，但我对如何创建数组而不是矩阵感到有点困惑。
我已经阅读了有关如何创建稀疏矩阵的教程：
为了模拟一个数组，我只创建了一个1xN矩阵，但正如您可能猜到的那样，Asp.dot(Bsp)并不能很好地工作，因为您不能将两个1xN矩阵相乘。我必须将每个数组转置为Nx1，这是相当糟糕的，因为我将在每次点积计算时都这样做。
接下来，我尝试创建一个第1列和第1行的NxN矩阵(这样您就可以将两个矩阵相乘，然后将左上角作为点积)，但结果证明效率非常低。
我很想使用scip
浏览 2提问于2010-03-30得票数 52
回答已采纳
1回答
我在Python/Scipy中处理相当大的矩阵。我需要从大矩阵(加载到coo_matrix)中提取行，并将它们用作对角线元素。目前我这样做的方式如下：
import numpy as np
from scipy import sparse
def computation(A):
for i in range(A.shape[0]):
diag_elems = np.array(A[i,:].todense())
ith_diag = sparse.spdiags(diag_elems,0,A.shape[1],A.shape[1], format = "csc&#
浏览 2提问于2011-12-01得票数 5
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
