标签: sparse-matrix

我有两个大的稀疏矩阵:

In [3]: trainX
Out[3]: 
<6034195x755258 sparse matrix of type '<type 'numpy.float64'>'
        with 286674296 stored elements in Compressed Sparse Row format>

In [4]: testX
Out[4]: 
<2013337x755258 sparse matrix of type '<type 'numpy.float64'>'
        with 95423596 stored elements in Compressed Sparse Row format>

加载总共大约5 GB RAM.请注意,这些矩阵非常稀疏(占用0.0062%).

对于每一行testX,我想找到的最近邻trainX,返回其相应的标签,在发现trainY. trainY是一个长度相同的列表,trainX并且有许多类.(一个类由1-5个单独的标签组成,每个标签是20,000个中的一个,但是类的数量与我现在要做的事情无关.)

我正在使用sklearnKNN算法来做到这一点:

from sklearn import neighbors

clf = neighbors.KNeighborsClassifier(n_neighbors=1)
clf.fit(trainX, trainY)
clf.predict(testX[0])

甚至预测1项testX需要一段时间(即30-60秒之类的东西,但如果你乘以200万,那就变得非常不可能了).我的笔记本电脑有16GB的RAM开始交换一下,但确实设法完成了1项testX.

我的问题是,我怎么能这样做才能在合理的时间内完成？在大型EC2实例上说一晚？只是拥有更多的内存并防止交换速度足够快(我的猜测是否定的).也许我可以以某种方式利用稀疏性来加速计算？

谢谢.

说我想从a中删除对角线scipy.sparse.csr_matrix.这样做有效吗？我在sparsetools模块中看到有C返回对角线的功能.

基于其他SO答案在这里和这里我目前的方法如下:

def csr_setdiag_val(csr, value=0):
    """Set all diagonal nonzero elements
    (elements currently in the sparsity pattern)
    to the given value. Useful to set to 0 mostly.
    """
    if csr.format != "csr":
        raise ValueError('Matrix given must be of CSR format.')
    csr.sort_indices()
    pointer = csr.indptr
    indices = csr.indices
    data = csr.data
    for i in range(min(csr.shape)):
        ind = indices[pointer[i]: pointer[i + 1]]
        j =  ind.searchsorted(i)
        # matrix has only elements up until diagonal …

我有一个SQL表,我可以作为Pandas数据框读入,具有以下结构:

user_id    value
1          100
1          200
2          100
4          200

它是矩阵的表示,所有值都是1或0.此矩阵的密集表示如下所示:

    100  200
1   1    1
2   1    0
4   0    1

通常,要进行此转换,您可以使用pivot,但在我的情况下,在第一个表中有数十或数亿行,因此会得到一个充满零的大密集矩阵,拖动成本很高.您可以将其转换为稀疏,但是到目前为止需要大量资源.

现在我正在研究一种解决方案,为每个user_id分配行号,排序,然后在重新组合成SparseDataFrame之前将'value'列拆分为SparseSeries.有没有更好的办法？

我正在尝试使用SparseTensor来表示全连接层中的权重变量。
但是，TensorFlow 0.8 似乎不允许将 SparseTensor 用作 tf.Variable。
有什么办法可以解决这个问题吗？

我试过了

import tensorflow as tf

a = tf.constant(1)
b = tf.SparseTensor([[0,0]],[1],[1,1])

print a.__class__  # shows <class 'tensorflow.python.framework.ops.Tensor'>
print b.__class__  # shows <class 'tensorflow.python.framework.ops.SparseTensor'>

tf.Variable(a)     # Variable is declared correctly
tf.Variable(b)     # Fail

顺便说一下，我使用 SparseTensor 的最终目标是永久屏蔽一些密集形式的连接。因此，在计算和应用梯度时会忽略这些修剪后的连接。

在我当前的 MLP 实现中，SparseTensor 及其稀疏形式的matmul ops 成功地报告了推理输出。但是，使用 SparseTensor 声明的权重不会随着训练步骤的进行而训练。

如何以简单的一行代码（并且快速！）列出 a 的所有非零元素csr_matrix？

我正在使用这段代码：

edges_list = list([tuple(row) for row in np.transpose(A.nonzero())])
weight_list = [A[e] for e in edges_list]

但执行起来需要相当长的时间。

我的最终目标是在 Python 中加速矩阵向量乘积的计算，可能是通过使用支持 CUDA 的 GPU。矩阵 A 约为 15k x 15k 且稀疏（密度 ~ 0.05），向量 x 为 15k 元素且密集，我正在计算 Ax。我必须多次执行此计算，因此使其尽可能快是理想的。

我当前的非 GPU“优化”是将 A 表示为 scipy.sparse.csc_matrix 对象，然后简单地计算 A.dot(x)，但我希望在连接了几个 NVIDIA GPU 的 VM 上加快速度，并且尽可能只使用 Python（即不手动写出详细的内核函数）。我已经使用 cudamat 库成功地加速了密集矩阵向量产品，但不适用于稀疏情况。网上有一些针对稀疏案例的建议，例如使用pycuda，或scikit-cuda，或anaconda 的加速包，但没有大量信息，因此很难知道从哪里开始。

我不需要非常详细的说明，但是如果有人以前解决过这个问题并且可以为最简单的方法提供一个“大图”路线图，或者有一个基于 GPU 的稀疏矩阵加速的想法 -矢量积将超过 scipy 的稀疏算法，这将非常有帮助。

我在 Julia 中有一个稀疏数组，想迭代它的非零条目。这样做的好方法是什么？

到目前为止，我有：

using SparseArrays

a = sprandn(20,20,0.3)

for (x,y,v) in a
  print(x,y,v)
end

我一直在处理一些文本数据，并且有一些稀疏矩阵和密集矩阵（numpy 数组）。我只是想知道如何正确地组合它们。

这些是数组的类型和形状：

list1 
<109248x9 sparse matrix of type '<class 'numpy.int64'>'
    with 152643 stored elements in Compressed Sparse Row format>

list2
<109248x3141 sparse matrix of type '<class 'numpy.int64'>'
    with 350145 stored elements in Compressed Sparse Row format>

list3.shape   ,  type(list3)
(109248, 300) ,  numpy.ndarray

list4.shape   ,  type
(109248, 51)  ,  numpy.ndarray

我只想将它们全部组合在一起作为一个密集矩阵。我尝试了一些 vstack 和 hstack 但无法弄清楚。任何帮助深表感谢。

Output required: (109248, 3501)

我必须求解 x 的大量“Ax=B”类型的线性矩阵方程，其中 A 是一个稀疏矩阵，主要填充主对角线，B 是一个向量。

我的第一种方法是通过 numpy.linalg.solve 使用密集的 numpy 数组来实现此目的，并且它可以很好地处理 (N,n,n) 维数组，其中 N 是线性矩阵方程的数量，n 是方阵维度。我首先将它与迭代所有方程的 for 循环一起使用，这实际上相当慢。但后来意识到，您也可以将 (N,n,n) 维矩阵直接传递给 numpy.linalg.solve ，而无需任何 for 循环（顺便说一下，我在阅读的文档中没有找到）。这已经大大提高了计算速度（详细信息见下文）。

但是，因为我有稀疏矩阵，所以我还查看了 scipy.sparse.linalg.spsolve 函数，它与相应的 numpy 函数执行类似的操作。使用 for 循环迭代所有方程比 numpy 解决方案快得多，但似乎不可能将 (N,n,n) 维数组直接传递给 scipy\xc2\xb4s spsolve。

这是我到目前为止所尝试的：

首先，我计算一些虚构的 A 矩阵和带有随机数的 B 向量以用于测试目的，包括稀疏和密集：

import numpy as np\nfrom scipy import sparse\nfrom scipy.sparse.linalg import spsolve\n\nnumber_of_systems = 100 #corresponds to N in the text\nnumber_of_data_points = 1000 #corresponds to n in the text\n\n#calculation of sample matrices (dense and sparse)\nA_sparse …

我需要在 Tensorflow 中求解 A(y)x = b 形式的方程，其中 A 是一个大的稀疏带矩阵，也是其他一些张量（如 y）的函数。当然，解 x 也将是张量 y 的函数。求解 x 后，我想获取 x 相对于 y 的梯度。

我考虑了两个选择： 1. 使用稀疏外部库来有效地反转 A，例如scipy.sparse. 为此，我需要将张量转换为 numpy 数组，然后再转换回张量。这种方法的问题是我无法将渐变磁带与外部库（例如scipy.sparse. 2. 使用与梯度带配合使用的 Tensorflow 矩阵求逆。对于大型矩阵来说，这非常慢，因为它没有利用张量的稀疏性。我无法在 Tensorflow 中找到稀疏反转实现。

我需要的一个简单的小例子：

y = tf.constant(3.14)
A = my_sparse_tensor(shape=(1000, 1000)) # Arbitrary function that returns a sparse tensor
b = tf.ones(shape=(1000, 1))
with tf.GradientTape() as g:
  g.watch(y)
  A = A * y
  x = tf.matmul(sparse_invert(A), b)
dx_dy = g.gradient(x, y)

当然，A 对 y 的依赖性比本例复杂得多。在 Tensorflow …