我有一个稀疏的988x1向量(a中的一列csr_matrix)scipy.sparse.有没有办法获得其均值和标准偏差而无需将稀疏矩阵转换为密集矩阵？
numpy.mean 似乎只适用于密集的载体.
我有一些scipy稀疏矩阵(目前采用CSR格式),我需要与密集的numpy 1D向量相乘.该向量称为G:
print G.shape, G.dtype
(2097152,) complex64
每个稀疏矩阵都有形状(16384,2097152)并且非常稀疏.密度约为4.0e-6.我有一个名为100的这些稀疏矩阵的列表spmats.
我可以很容易地将每个矩阵相乘G:
res = [spmat.dot(G) for spmat in spmats]
这导致(16384,)如预期的形状的密集矢量列表.
我的应用程序是相当性能的,因此我尝试了替代方法,即首先将所有稀疏矩阵连接成一个大的sparce矩阵,然后只使用一次这样的调用dot():
import scipy.sparse as sp
SPMAT = sp.vstack(spmats, format='csr')
RES = SPMAT.dot(G)
这导致一个长矢量RES具有形状(1638400,),并且是res上述所有结果矢量的连接形式,如预期的那样.我检查过结果是一样的.
也许我完全错了,但我预计第二种情况应该比第一种情况要快,因为numpy调用,内存分配,python对象的创建,python循环等等都少得多.我不关心时间需要连接稀疏矩阵,只需要计算结果的时间.%timeit然而,根据:
%timeit res = [spmat.dot(G) for spmat in spmats]
10 loops, best of 3: 91.5 ms per loop
%timeit RES = SPMAT.dot(G)
1 loops, best of 3: 389 ms per …我正在尝试对两个大型稀疏矩阵进行元素乘法。两者的大小都在 (400K X 500K) 左右，大约有 100M 元素。
但是，它们可能不会在相同位置具有非零元素，并且它们可能不会具有相同数量的非零元素。在任何一种情况下，我都可以将一个矩阵的非零值和另一个矩阵中的零值相乘为零。
我在每种方法中都不断耗尽内存（8GB），这没有多大意义。我不应该。这些是我尝试过的。
A 和 B 是稀疏矩阵（我尝试过 COO 和 CSC 格式）。
# I have loaded sparse matrices A and B, and have a file opened in write mode
row,col = A.nonzero()
index = zip(row,col)
del row,col
for i,j in index :
# Approach 1
A[i,j] *= B[i,j]
# Approach 2
someopenfile.write(' '.join([str(i),str(j),str(A[j,j]*B[i,j]),'\n']))
# Approach 3
if B[i,j] != 0 :
A[i,j] = A[i,j]*B[i,j] # or, I wrote it to a file instead
# like …我想用python解决一个线性程序。变量的数量（从现在开始我称之为 N）非常大（~50000），为了以scipy.optimize.linprog需要的方式表述问题，我必须构造两个 N x 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 可能根本拒绝构建如此大的矩阵（参见例如使用 Python 和 NumPy 的非常大的矩阵），即使 NumPy 创建矩阵没有问题，也存在巨大的性能问题。对于 NumPy 必须处理的大量数据，这是很自然的。
然而，尽管我的线性程序带有 N 个变量，但我使用的矩阵非常稀疏。其中一个只有第一行的条目，另一个只有前 M 行，其中 M < N/2。当然，我想利用这个事实。
据我所知（例如，尝试使用稀疏矩阵和失败来解决 Scipy 优化问题），scipy.optimize.linprog不适用于稀疏矩阵。因此，我有以下问题： …
我正在尝试使用 xgboost 在分类问题上运行 -using python - ，其中我有一个numpy 矩阵 X（行 = 观察和列 = 特征）中的数据和一个numpy 数组 y 中的标签。因为我的数据很稀疏，所以我想让它使用稀疏版本的 X 来运行，但是当发生错误时，我似乎遗漏了一些东西。
这是我所做的：
# Library import
import numpy as np
import xgboost as xgb
from xgboost.sklearn import XGBClassifier
from scipy.sparse import csr_matrix
# Converting to sparse data and running xgboost
X_csr = csr_matrix(X)
xgb1 = XGBClassifier()
xgtrain = xgb.DMatrix(X_csr, label = y ) #to work with the xgb format
xgtest = xgb.DMatrix(Xtest_csr)
xgb1.fit(xgtrain, y, eval_metric='auc')
dtrain_predictions = xgb1.predict(xgtest)
等等...
现在尝试拟合分类器时出现错误： …
你如何在 CSR 中表示空行？
假设我们有以下矩阵：
* MATRIX 1 *
a 0 0
0 b 0
0 0 c
val = [ a b c ]
col = [ 0 1 2 ]
row = [ 0 1 2 ] <- makes sense!
—————————————————————
* MATRIX 2 *
a b c
0 0 0
0 0 0
val = [ a b c ]
col = [ 0 1 2 ]
row = [ 0 ] <— makes sense…? but how about… …我为文本分析做了一个预处理部分，在删除停用词和词干后，如下所示：
test[col] = test[col].apply(
lambda x: [ps.stem(item) for item in re.findall(r"[\w']+", x) if ps.stem(item) not in stop_words])
train[col] = train[col].apply(
lambda x: [ps.stem(item) for item in re.findall(r"[\w']+", x) if ps.stem(item) not in stop_words])
我有一个列有“清理词”列表的列。这是一列中的 3 行：
['size']
['pcs', 'new', 'x', 'kraft', 'bubble', 'mailers', 'lined', 'bubble', 'wrap', 'protection', 'self', 'sealing', 'peelandseal', 'adhesive', 'keeps', 'contents', 'secure', 'tamper', 'proof', 'durable', 'lightweight', 'kraft', 'material', 'helps', 'save', 'postage', 'approved', 'ups', 'fedex', 'usps']
['brand', 'new', 'coach', 'bag', 'bought', 'rm', 'coach', 'outlet']
我现在想将 CountVectorizer 应用于此列：
from …我想将稀疏矩阵转换为类型（行、列、值）的数据框。我发现诸如http://r.789695.n4.nabble.com/Converting-sparse-matrix-to-data-frame-in-Matrix-package-td2332012.html之类的问题在问题中以行、列开头,value 并创建一个稀疏矩阵。我想要逆，我不能使用 as.matrix 函数，因为矩阵太大。这是一个小例子。
r = c(1,2,2,3,3)
c = c(4,1,2,3,5)
v = c(1,2,1,3,1)
a = sparseMatrix(i=r,j=c,x=v)
3 x 5 sparse Matrix of class "dgCMatrix"
[1,] . . . 1 .
[2,] 2 1 . . .
[3,] . . 3 . 1
我可以得到一个 data.frame
r c v
1 1 4 1
2 2 1 2
3 2 2 1
4 3 3 3
5 3 5 1
谢谢
我想知道是否有一个带有 Python 绑定的快速磁盘键值存储，它支持对单独键的数百万次读/写调用。我的问题涉及计算一个非常大的语料库（维基百科）中的单词共现，并不断更新共现计数。这涉及使用 64 位密钥和 64 位值读取和写入约 3 亿个值 70 次。
我还可以将我的数据表示为尺寸约为 2M x 2M 的上三角稀疏矩阵。
到目前为止我已经尝试过：
目前唯一运行良好的解决方案是 LMDB，但运行时间约为 12 天，这似乎不合理，因为我感觉自己没有处理那么多数据。使用 .npz 将子矩阵（大约 300M 值）保存到磁盘几乎是即时的。
有任何想法吗？
我一直在尝试 Python 3 中可用的不同稀疏求解器，并比较它们之间的性能以及与 Octave 和 Matlab 的性能。我选择了直接和迭代方法，我将在下面更详细地解释这一点。
为了生成具有带状结构的适当稀疏矩阵，使用具有 N=250、N=500 和 N=1000 的方格网格的有限元来解决泊松问题。这导致矩阵 A=N^2xN^2 和向量 b=N^2x1 的维度，即最大的 NxN 是一百万。如果有人对复制我的结果感兴趣，我已经在以下链接中上传了矩阵 A 和向量 b（它将在 30 天后过期）在此处使用获取系统。矩阵存储在三元组 I,J,V 中，即前两列分别是行和列的索引，第三列是与这些索引对应的值。观察到 V 中有一些接近零的值是故意留下的。尽管如此，在 Matlab 和 Python 中的“间谍”矩阵命令之后仍保留带状结构。
为了进行比较，我使用了以下求解器：
Matlab 和 Octave，直接求解器：规范x=A\b.
Matlab 和 Octave，pcg 求解器：预处理共轭梯度，pcg 求解器pcg(A,b,1e-5,size(b,1))（不使用预处理器）。
Scipy (Python)，直接求解器：linalg.spsolve(A, b)其中 A 先前已格式化为csr_matrixformat。
Scipy (Python)，pcg 求解器： sp.linalg.cg(A, b, x0=None, tol=1e-05)
Scipy (Python)、UMFPACK 求解器：spsolve(A, b)使用from scikits.umfpack import spsolve. 这个求解器显然在 Linux 下可用（仅？），因为它使用了 libsuitesparse [Timothy Davis, …
python performance matlab scientific-computing sparse-matrix