如何在Python中不使用numpy的情况下将两个稀疏矩阵相乘？
在Python中，可以使用稀疏矩阵库scipy.sparse来实现稀疏矩阵的相乘，而不依赖于numpy。下面是一个示例代码：
import scipy.sparse as sp
# 创建稀疏矩阵
matrix1 = sp.csr_matrix([[1, 0, 2], [0, 0, 3], [4, 5, 0]])
matrix2 = sp.csr_matrix([[1, 0, 2], [0, 0, 3], [4, 5, 0]])
# 稀疏矩阵相乘
result = matrix1.dot(matrix2)
# 打印结果
print(result.toarray())在上述代码中，我们首先使用sp.csr_matrix函数创建了两个稀疏矩阵matrix1和matrix2。然后，通过调用dot方法实现了稀疏矩阵的相乘，并将结果存储在result变量中。最后，通过调用toarray方法将稀疏矩阵转换为普通的二维数组，并打印出结果。
需要注意的是，scipy.sparse库提供了多种稀疏矩阵的存储格式，如CSR、CSC、COO等。在上述示例中，我们使用了CSR格式的稀疏矩阵，你也可以根据实际需求选择其他格式。
关于稀疏矩阵的优势，它可以有效地存储和处理大规模稀疏数据，节省内存空间和计算资源。稀疏矩阵在很多领域都有广泛的应用，比如自然语言处理、推荐系统、网络分析等。
腾讯云提供了云计算相关的产品和服务，其中包括云服务器、云数据库、云存储等。你可以访问腾讯云官方网站（https://cloud.tencent.com/）了解更多关于腾讯云的产品和服务信息。
相关·内容
2回答
我在使用COO稀疏矩阵作为亲和传播的输入时遇到了问题，但是对于numpy数组来说，它工作得非常好。
举个例子，假设我的相似矩阵是：
[[1.0, 0.9, 0.2]
[0.9, 1.0, 0.0]
[0.2, 0.0, 1.0]]
Numpy矩阵版本
import numpy as np
import sklearn.cluster
simnp = np.array([[1,0.9,0.2],[0.9,1,0],[0.2,0,1]])
affprop = sklearn.cluster.AffinityPropagation(affinity="precomputed")
浏览 0提问于2016-03-03得票数 1
回答已采纳
2回答
计算大型矩阵特征值的最快方法
、、、、
到目前为止，我使用numpy.linalg.eigvals来计算至少有1000行/列的二次矩阵的特征值，并且在大多数情况下，大约有五分之一的条目是非零的(我不知道这是否应该被视为稀疏矩阵)。我发现了另一个，表明scipy可能会做得更好。
但是，由于我必须计算数十万个不断增大的大矩阵的特征值(可能多达20000行/列，是的，我需要它们的所有特征值)，这总是需要非常长的时间。如果我能加快速度，即使是最小的一点，也很可能是值得的。
所以我的问题是:在不局限于python的情况下，有没有更快的方法来计算特征值？
浏览 1提问于2013-07-04得票数 5
回答已采纳
1回答
我有许多稀疏矩阵(目前是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,)的密集向量列表。
我的应用程序对性能非常关键，所以我尝试了一个替代方法，即首先将所有稀疏矩阵连接
浏览 1提问于2013-05-25得票数 7
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
回答已采纳
2回答
Python矩阵分解
、、、、
我用python编写了以下代码
###############################################################################
"""
@INPUT:
R : a matrix to be factorized, dimension N x M
P : an initial matrix of dimension N x K
Q : an initial matrix of dimension M x K
K : the number of
浏览 0提问于2015-12-08得票数 0
3回答
使用稀疏矩阵与numpy数组
、、、、
我用Python创建了一些带有字计数的numpy数组:行是文档，列是单词X的计数。如果我有大量的零计数，人们建议在进一步处理这些数组时使用稀疏矩阵，例如在分类器中。然而，当向Scikit 中输入numpy数组与稀疏矩阵时，它似乎没有多大区别。所以我想知道三件事：
说
稀疏矩阵是大多数元素为零的矩阵。
这是否是确定何时使用稀疏矩阵格式的适当方法--只要> 50 %的值为零？还是说以防万一才有意义呢？
稀疏矩阵对像我这样的任务的性能有多大的帮助，特别是与numpy数组或标准列表相比？
到目前为止，我将数据收集到一个numpy数组中，然后转换为csr_matrix in 。
浏览 5提问于2016-05-01得票数 46
回答已采纳
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
回答已采纳
1回答
稀疏矩阵商的确定
、、、、
我希望在python2.7中划分两个稀疏矩阵，本质上是k = numerator / denominator，其结果是sp.csr_matrix类型的稀疏矩阵。我正在使用scipy as sp和numpy as np。
为了做到这一点，我遵循取分子的点积和分母的逆的线性格式。这两个项目都是sp.csr_matrix(([],([],[])),shape=[R,R])格式的。
K本身的计算是
k = sp.csr_matrix(numerator.dot(sp.linalg.inv(denominator)))
这样做会返回警告：
SparseEfficiencyWarning: splu re
浏览 1提问于2016-10-14得票数 0
回答已采纳
在Python中使用SciPy/Numpy连接稀疏矩阵的最有效方法是什么？
在这里，我使用了以下内容：
>>> np.hstack((X, X2))
array([ <49998x70000 sparse matrix of type '<class 'numpy.float64'>'
with 1135520 stored elements in Compressed Sparse Row format>,
<49998x70000 sparse matrix of type &#
浏览 140提问于2013-10-31得票数 43
回答已采纳
2回答
我试图找出一个巨大矩阵和它自身之间的点积。
NonZero - 577731的(371744,36154) Num的形状非常稀疏
mat1是scipy.sparse.csr_matrix如果我使用mat1 * mat1.T我得到了一个值错误，这看起来像它的，因为结果矩阵中有太多的非零元素，索引指针根据溢出
dp_data = data_m * data_m.T
File "/usr/lib/python2.7/dist-packages/scipy/sparse/base.py", line 247, in __mul__
return self._mul_
浏览 7提问于2014-07-22得票数 2
1回答
假设我想要计算二次形式的x^T A y，其中x和y是NumPy向量，为了提高效率，我将A存储为SciPy csc_matrix。
似乎执行计算的一种方法是
(x * A).dot(y)
因为SciPy对矩阵产品使用*，而NumPy使用.dot。
虽然这种方法给了我正确的答案，但它似乎与我的直觉相反，我想知道是否有更好的可读性/更有效的方法？
浏览 12提问于2018-01-14得票数 1
回答已采纳
1回答
给定代码片段：
B = A @ M - T
其中A是CSR 的稀疏矩阵，M和T是两个numpy阵列。
问题：在矩阵运算期间，numpy是将A看作一个密集矩阵，还是M和T处理为两个稀疏矩阵？
我怀疑后一种情况是正确的，因为生成的矩阵B不是稀疏格式的。
我还注意到，如果我将A格式更改为稠密，则此操作要慢得多，这与我的猜测有些矛盾。
浏览 3提问于2020-10-16得票数 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回答
我有一个稀疏矩阵(从python函数接收)，我想将其转换为numpy矩阵。numpy矩阵不适合本地内存，我想把它放到pySpark中的RDD中。我一般不太熟悉Spark，因此我不知道如何将本地spase矩阵加载到RDD中。
浏览 2提问于2015-06-17得票数 1
1回答
我正在使用Python、numpy和scipy对我为文本分析创建的主题模型的输出进行一些层次聚类。
我将我的测试语料库应用于ldamodel，因此它成为一个词袋表示。然后我把它变成了一个矩阵。现在，我想使用scipy来创建一个矩阵的链接矩阵。但它给出了值错误:使用序列设置数组元素。我猜这是因为只有形状相同的数组才能聚集在一起。我的矩阵在列表中的列表之间有长度上的差异。我现在只是不知道如何解决这个问题。下面是代码的一小部分。我不知道这是否有帮助。我真的希望有人能帮我。
import numpy as np
X = np.array(corpus)
from matplotlib im
浏览 0提问于2017-01-13得票数 0
2回答
C语言中的稀疏矩阵乘法
、、、
我有两个矩阵市场格式的稀疏矩阵文件：
row col val
1 1 3.0
1 2 1.0
2 3 2.0
etc...
目前，我已经将文件分成了6个数组：
row_A[], col_A[], val_A[], row_B[] …
它们分别包含行索引、列索引和值。
我想轻松地将这两个矩阵相乘，而不必首先将它们转换为密集矩阵格式。有没有这样做的算法？
我在Quora上找到了这个伪代码，但我不确定它是不是最好的实现，或者它将如何在C：中实现
multiply(A,B):
for r in A.rows:
for c in A.rows[r]:
fo
浏览 1提问于2018-10-26得票数 2
2回答
我在python中有一个简单的“矩阵”，我想对其进行稀疏处理： np.array([[5.72756493, 0. , 0. ],
[2.86378246, 4.96021673, 0. ],
[5.72756493, 3.30681115, 2.33826859]]) 我想将其简化为以下形式： np.array([[5.72756493, 0. , 0. ],
[2.86378246, 4.96021673, 0. ],
[0.
浏览 50提问于2019-09-17得票数 0
回答已采纳
1回答
我试图创建一个非常庞大的稀疏矩阵，它有一个形状(447957347, 5027974)。它含有3 289 288 566个元素。
但是，当我使用csr_matrix创建scipy.sparse时，它会返回如下内容：
<447957346x5027974 sparse matrix of type '<type 'numpy.uint32'>'
with -1005678730 stored elements in Compressed Sparse Row format>
创建矩阵的源代码是：
indptr = np.array(
浏览 0提问于2014-04-30得票数 8
回答已采纳
python scipy sps.rand()中提供的方法生成(0,1)范围内随机值的稀疏矩阵。我们如何生成大于1的离散随机值，如2、3等？在scipy中有什么方法吗，numpy？
浏览 3提问于2016-10-26得票数 0
1回答
我在python中工作，用的是大小为n的稀疏矩阵A，我使用的是csr_matrix格式，我把矩阵包装成线性算子，这样我就可以使用slinalg包了。
我需要计算A^T*A积。然而，我无法设法找到适当的例程来实现这一点。我可以使用线性算子的matmat函数，但这要求我将矩阵转换为密集格式。
在python中(即使有不同的包)，我如何在不转换为密集矩阵的情况下，将两个稀疏矩阵相乘呢？我的矩阵很大，由于内存需求，转换会导致崩溃。
浏览 4提问于2020-08-16得票数 0
回答已采纳
我正在使用python、sklearn和numpy，我正在创建以下稀疏矩阵：
feats = tfidf_vect.fit_transform(np.asarray(tweets))
print(feats)
feats=np.log(np.asarray(feats))
但是，当我应用日志时，我会得到以下错误：
Traceback (most recent call last):
File "src/ef_tfidf.py", line 100, in <module>
feats=np.log(np.asarray(f
浏览 2提问于2015-12-03得票数 0
回答已采纳
2回答
假设我有一个10000 x 10000的矩阵W，其中有随机数，以及两个10000维的向量U和V，U中有随机数，V中充满了零。使用numpy或pytorch，计算U@W和V@W需要相同的时间。我的问题是，有没有一种方法可以优化矩阵乘法，让它在计算过程中跳过或忽略零，这样V@W这样的东西就可以更快地计算出来？ import numpy as np
W = np.random.rand(10000, 10000)
U = np.random.rand(10000)
V = np.zeros(10000)
y1 = U @ W
y2 = V @ W
# computing y2 should t
浏览 70提问于2019-05-24得票数 1
回答已采纳
1回答
我注意到SciPy稀疏矩阵和numpy数组在传递到函数时被修改的方式存在明显的不一致性。特别是，我想知道是否有人能解释为什么下面的a稀疏矩阵没有被func全局修改，但是b数组是：
from scipy import sparse
import numpy as np
def func(m):
m += m
a = sparse.identity(2)
b = np.array([1, 2])
print(a.todense()) # [[1,0],[0,1]]
func(a)
print(a.todense()) # Still [[1,0],[0,1]]. Why???
pr
浏览 6提问于2022-06-24得票数 0
回答已采纳
1回答
求解密集点稀疏
、、、
我有稀疏矩阵S
<14940x14940 sparse matrix of type '<class 'numpy.float64'>'
with 39840 stored elements in COOrdinate format>
和密集向量d
Out[7]: (1, 14940)
并希望计算具有预期尺寸1 x 14940的d dot S。由于尺寸的原因，这应该是可行的。但是，np.dot不了解其参数的类型，因此
np.dot(d, S)
会导致崩溃。接下来，
d.dot(S)
怪异地导致了
Out[4]:
array([[
浏览 4提问于2018-07-04得票数 0
2回答
我在Python中有一个非常简单的脚本，但由于某种原因，在运行大量数据时会出现以下错误：
*** glibc detected *** python: double free or corruption (out): 0x00002af5a00cc010 ***
我习惯了C或C++中出现的这些错误，当一个人试图释放已经被释放的内存时。然而，根据我对Python的理解(尤其是我编写代码的方式)，我真的不明白为什么会发生这种情况。
以下是代码：
#!/usr/bin/python -tt
浏览 4提问于2013-02-16得票数 34
回答已采纳
1回答
我正在尝试做一些非常简单的事情，但是对Python中关于稀疏矩阵和向量的大量信息感到困惑。
我想创建两个向量，x和y，一个长度为5，另一个长度为6，是稀疏的。然后我想在每一个中设置一个坐标。然后我想创建一个矩阵A，sparse，它是5 x 6，然后加上x和y之间的外积，然后我想对这个矩阵A进行奇异值分解。
下面是我尝试过的方法，它在很多方面都出错了。
from scipy import sparse;
import numpy as np;
import scipy.sparse.linalg as ssl;
x = sparse.bsr_matrix(np.zeros(5));
x[1]
浏览 2提问于2016-03-30得票数 0
1回答
点积稀疏矩阵
、、、、
在python中有两个稀疏矩阵(a和b)，它们具有以下维度：
a = <240760x2177930 sparse matrix of type '<class 'numpy.float64'>'
with 1127853 stored elements in Compressed Sparse Row format>
和
b = <240760x2177930 sparse matrix of type '<class 'numpy.float64'>'
with 439
浏览 2提问于2016-04-22得票数 7
回答已采纳
1回答
我有两个矩阵
a = matrix(((1.4) ,(2.5) ,(1.96),(6.25),(12.25))
和
b = matrix(((1 ,1,1,1,1),(2,2,2,2,2)))
当我将这些矩阵相乘时
product = b*a
我收到一个错误
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/local/lib/python2.6/dist-packages/numpy-1.7.0-py2.6-linux-i6
浏览 0提问于2013-04-02得票数 2
回答已采纳
我正在使用一个只接受numpy.array对象的python库。然而，我的数据是高维的，并且非常稀疏，为了让库获得整个数据，将其加载到内存中的效率非常低。我想在一个内存高效的python对象中包装一个稀疏矩阵。我找到了scipy.sparse，但是这个库的方法(显然)拒绝了数据类型。我希望稀疏矩阵对象是隐藏(包装)在numpy对象后面的。
In [16]: x
Out[16]:
<3x3 sparse matrix of type '<type 'numpy.float64'>'
with 6 stored elements in Co
浏览 0提问于2015-11-19得票数 2
1回答
我目前正在尝试对文本进行分类。我的数据集太大了，正如所建议的那样，我需要使用稀疏矩阵。我的问题是，将元素添加到稀疏矩阵的正确方法是什么？比方说，我有一个矩阵X，它是我的输入。
X = np.random.randint(2, size=(6, 100))
现在这个矩阵X看起来像ndarray的ndarray (或类似的东西)。
如果我这样做了
X2 = csr_matrix(X)
我有稀疏矩阵，但如何向稀疏矩阵添加另一个元素？例如，这个密集元素:1，0，0，1，1，1，0，...,0,1,0到一个稀疏向量，我如何将它添加到稀疏输入矩阵中？
(顺便说一句，我是python，scipy，numpy
浏览 0提问于2012-12-06得票数 7
回答已采纳
我在Spyder上使用findspark.init()设置了一个简单的findspark.init()环境，并且我正在本地主机上运行代码。我不明白如何使用BlockMatrix在Spark中使用简单的矩阵乘法需要花费几个小时和几个小时，而在numpy上运行相同的代码需要几分钟。
下面是我使用的代码：
import numpy as np
import pandas as pd
from sklearn import cross_validation as cv
import itertools
import random
import findspark
import time
start=t
浏览 4提问于2017-06-11得票数 2
2回答
下面的代码运行得太慢了，尽管一切似乎都是矢量化的。
from numpy import *
from scipy.sparse import *
n = 100000;
i = xrange(n); j = xrange(n);
data = ones(n);
A=csr_matrix((data,(i,j)));
x = A[i,j]
问题似乎是索引操作是作为python函数实现的，调用A[i,j]会导致以下分析输出
500033 function calls in 8.718 CPU seconds
Ordered by: internal time
浏览 1提问于2010-03-09得票数 6
回答已采纳
2回答
我正在使用一个相当密集的numpy数组(例如20-50%)，但具有相同值的较大区域。例如，我可能有一个类似如下的数组：
[[0 0 0 0]
[1 2 3 4]
[0 0 0 0]
[3 4 5 6]]
与其将填充了相同值的行(第0行)作为单独的行存储在内存中，是否有一种方法可以共享行内存，从而使行0和行2都访问相同的内存？我正在寻找一些东西，要么是内置于numpy中的，要么是允许普通numpy函数与这样的数组一起工作的。我需要让它看起来像是我仍在使用numpy数组。
以下是一些注意事项：
我知道我可以在python中创建一个对象，它只是将输入索引映射到一些numpy数组中的数据索引，但
浏览 2提问于2018-05-14得票数 0
3回答
初始化高维稀疏矩阵
、、、
我想使用sklearn初始化300,000 x 300,0000稀疏矩阵，但它需要内存，就好像它不是稀疏的一样： >>> from scipy import sparse
>>> sparse.rand(300000,300000,.1) 它会给出错误： MemoryError: Unable to allocate 671. GiB for an array with shape (300000, 300000) and data type float64 这与我使用numpy进行初始化时的错误相同。 np.random.normal(size=[
浏览 48提问于2020-11-16得票数 3
回答已采纳
我试图对一组数据点进行聚类，这些数据点表示为稀疏的枕矩阵，即，
>>> print type(X)
<class 'scipy.sparse.csr.csr_matrix'>
>>> print X.shape
(57, 1038)
>>> print X[0]
(0, 223) 0.471313296962
(0, 420) 0.621222153695
(0, 1030) 0.442688836467
(0, 124) 0.442688836467
但是，当我将这个矩阵输
浏览 0提问于2013-11-14得票数 0
回答已采纳
我要解的是线性系统，它由大的稀疏矩阵组成。
我一直在使用scipy.sparse库，以及它的linalg子库来完成这个任务，但是我无法让一些线性求解器工作。
下面是一个工作示例，它为我再现了这个问题：
from numpy.random import random
from scipy.sparse import csc_matrix
from scipy.sparse.linalg import spsolve, minres
N = 10
A = csc_matrix( random(size = (N,N)) )
A = (A.T).dot(A) # force the matrix
浏览 2提问于2017-10-11得票数 5
回答已采纳
1回答
我试图将一个稀疏的实数矩阵与一个复数向量相乘，但程序无法编译。如果我将向量改为实数，或将矩阵改为密集，那么所有内容都会通过。示例代码如下：
#define ARMA_64BIT_WORD
#include <armadillo>
#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace arma;
int main(){
size_t n(5);
vec vR(randu<vec>(n)), vI(randu<vec>(n
浏览 3提问于2015-05-27得票数 1
2回答
编辑:参见，在那里我学会了如何使用Numba并行化Python中的稀疏矩阵-向量乘法，并且能够与Matlab结合。
原题：
我观察到，在Matlab中，稀疏矩阵向量乘法比Python (使用枕稀疏矩阵)快4到5倍。下面是Matlab命令行的一些细节：
>> whos A
Name Size Bytes Class Attributes
A 47166x113954 610732376 double sparse
>> whos ATran
浏览 5提问于2017-08-04得票数 3
Tensorflow具有稀疏到密集矩阵乘法的实现tf.sparse_tensor_dense_matmul，但它是否具有稀疏到密集的元素乘法(两个张量具有相同的形状)？我希望避免将稀疏张量转换为密集张量，因为它不适合内存。
浏览 6提问于2017-08-03得票数 1
1回答
让我们假设A是一个(scipy)稀疏矩阵，tf值，B是一个(numpy)数组，具有数据的一些附加特性。
A和B的每一行对应于相同的观察结果。
我想将这些矩阵/数组连接起来，因为我想将它们传递给sklearn模型来训练它，而且我不认为我可以单独传递它们。
根据这个答案()，有两种方法可以连接这些数组：
将稀疏数组(A)转换为密集数组，然后连接
将完全密集数组(B)转换为稀疏矩阵
但是，(1)在我的例子中，基本上是不可能的，因为我的例子中的A太大了。
因此，我可以考虑将我的完全密集数组(B)转换为稀疏数组。
但是，我的问题是，这样做是否会丢失任何信息(例如，通过将一个完全密集的数组
浏览 0提问于2019-08-05得票数 0
3回答
我需要将两个大矩阵相乘，并对它们的列进行排序。
import numpy
a= numpy.random.rand(1000000, 100)
b= numpy.random.rand(300000,100)
c= numpy.dot(b,a.T)
sorted = [argsort(j)[:10] for j in c.T]
这个过程需要大量的时间和内存。有没有办法加快这个过程？如果不是，我如何计算执行此操作所需的RAM？我目前有一个EC2机器，有4 4GB内存，没有交换。
我想知道这个操作是否可以序列化，并且我不必将所有内容都存储在内存中。
浏览 5提问于2014-07-31得票数 8
回答已采纳
1回答
我在R中有一个非常大且稀疏的矩阵，它是用“矩阵”包创建的，我想在python + numpy中处理。R对象是csc格式，如果我使用矩阵包中的函数writeMM导出它，输出如下所示：
%%MatrixMarket matrix coordinate real general
4589 17366 160441
22 1 5.954510725783322
36 1 29.77255362891661
41 1 23.81804290313329
74 1 5.954510725783322
116 1 59.54510725783322
127 1 11.909021451566645
159
浏览 5提问于2015-07-23得票数 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
回答已采纳
3回答
在python中有没有一种简单的方法来处理稀疏矩阵？
下面是我对非稀疏矩阵进行混洗的方法：
index = np.arange(np.shape(matrix)[0])
np.random.shuffle(index)
return matrix[index]
我如何使用numpy sparse来做这件事？
浏览 3提问于2012-09-02得票数 9
回答已采纳
1回答
用稀疏矩阵相乘稠密矩形矩阵
、、、、
我使用Python、Numpy和Scipy包来进行矩阵计算。我试图执行计算X.transpose() * W * X，其中X是2x3稠密矩阵，W是稀疏对角线矩阵。(下面是非常简化的例子)
import numpy
import scipy.sparse as sp
X = numpy.array([[1, 1, 1],[2, 2, 2]])
W = sp.spdiags([1, 2], [0], 2, 2).tocsr()
我需要找到稠密矩阵X.transpose和稀疏矩阵W的乘积。
我所知道的一种方法是在右边不接受稀疏矩阵。
>>> sp.csr_matrix.dot(
浏览 5提问于2014-02-09得票数 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回答
稀疏矩阵线性规划
、、、
我想在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
回答已采纳
1回答
我想把我的稀疏scipy.lil_matrix矩阵除以向量，再得到稀疏矩阵。假设我有2个lil_matrix变量和2个numpy数组a, b, c, d，如下所示
In [1]: a
Out[1]:
<4x3 sparse matrix of type '<class 'numpy.float64'>'
with 11 stored elements in LInked List format>
In [2]: b
Out[2]:
<4x1 sparse matrix of type '<class &#
浏览 1提问于2018-02-18得票数 2
回答已采纳
用python对矩阵进行奇异值分解求解。我的代码不工作，它说矩阵不对齐
>>> from numpy import*
>>> from numpy.linalg import qr
>>> A = mat([[1.,2.],[4.,5.],[7.,8.]])
>>> U,s,V =linalg.svd(A)
>>> S = diag(s)
>>> print U
[[-0.17259857 0.89640564 0.40824829]
[-0.50818671 0.2740065
浏览 0提问于2015-11-13得票数 0
def simrank_sparse(A,c,maxiter,eps=1e-4):
if not sp.issparse(A):
raise Exception("Input is not a sparse matrix ")
n=sp.csr_matrix.get_shape(A)[0]
Q=misc.get_column_normalized_matrix(A)
sim=sp.eye(n)
I=sp.eye(n)
sim_prev=sp.csr_matrix(sim)
for t in range
浏览 1提问于2017-07-17得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
云直播活动推荐
腾讯云开发者
