带有numpy中的矩阵的和向量
numpy是一个开源的Python科学计算库，提供了丰富的数学函数和数据结构，特别适用于处理大规模的多维数组和矩阵运算。在numpy中，矩阵是二维的数组，而向量是一维的数组。
矩阵的和是指将两个矩阵对应位置的元素相加得到的新矩阵。要计算矩阵的和，可以使用numpy的add函数。例如，假设有两个矩阵A和B，可以使用以下代码计算它们的和：
import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
C = np.add(A, B)
print(C)输出结果为：
[[ 6 8]
[10 12]]向量的和是指将两个向量对应位置的元素相加得到的新向量。同样地，可以使用numpy的add函数来计算向量的和。例如，假设有两个向量x和y，可以使用以下代码计算它们的和：
import numpy as np
x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
z = np.add(x, y)
print(z)输出结果为：
[5 7 9]numpy中的矩阵和向量的操作非常方便，可以快速进行数值计算和数据处理。在云计算领域，numpy常用于处理大规模数据集和进行科学计算，例如机器学习、数据分析等领域。
腾讯云提供了强大的云计算服务，其中包括云服务器、云数据库、云存储等产品。具体推荐的腾讯云产品和产品介绍链接地址可以根据实际需求来确定，可以参考腾讯云官方网站获取最新的产品信息。
相关·内容
2回答
压缩格式块对角矩阵的有效线性代数
、、、、
我有一个线性系统，其中所有的矩阵都是块对角的。它们的N块形状相同。
矩阵以压缩格式存储为具有形状(N, n, m)的numpy数组，而向量的形状为(N, m)。
目前，我将矩阵向量积实现为
import numpy as np
def mvdot(m, v):
return (m * np.expand_dims(v, -2)).sum(-1)
由于广播规则，如果矩阵的所有块都是相同的，我只能将其存储在一个具有(1, n, m)形状的数组中:带有向量(N, m)的乘积仍然给出正确的(N, n)向量。
我的问题是：
如何实现一个有效的矩阵乘积，从两个形状为(N, n, m)和(N,
浏览 4提问于2016-12-20得票数 2
回答已采纳
我不能像在MxN中那样从numpy矩阵中总结出一个1xN矩阵。 我创建了一个带有特征的np.arange(9).reshape(3,3)矩阵，如下所示： int buf[9];
for (int i{0}; i < 9; ++i) {
buf[i] = i;
}
m = Map<MatrixXi>(buf, 3,3); 然后我沿行方向计算平均值： m2 = m.rowwise().mean(); 我想广播m2到3x3矩阵，然后从m中减去它，我该怎么做呢？
浏览 14提问于2019-01-03得票数 0
回答已采纳
3回答
我有p = [1,2,3,4]。我希望每一行都有一个带有p的100x4 numpy矩阵。创造这个的最好方法是什么？
我试过pvect = np.array(p for i in range(10))，但这似乎不对。
浏览 7提问于2022-08-06得票数 1
回答已采纳
2回答
例如，我有一个投影矩阵方程，它适用于一维向量：
其中P是投影矩阵，T是转置。
我们知道，我们不能简化这个分数(通过取消项)，因为分母是一个点积(因此0维标量，数字)和分子是矩阵(列乘以行是矩阵)。
我不知道如何在numpy中定义这个方程的函数，考虑到我使用的当前函数没有区分这些项，乘法被视为具有交换性质。我使用的是numpy.multiply方法：
>>> import numpy as np
>>> a = np.array(a)
>>> a*a.T
array([1, 4, 9])
>>> a.T*a
a
浏览 0提问于2018-04-04得票数 2
回答已采纳
我很好奇是否还有其他人碰到过这个。我有一个数据集，有大约350 k的样本，每个样本都有4k的稀疏特性。稀疏填充率约为0.5%。数据存储在带有scipy.sparse.csr.csr_matrix的dtype='numpy.float64'对象中。
我将此作为sklearn的Logistic回归分类器的输入。文档表明稀疏CSR矩阵是该分类器的可接受输入。然而，当我训练分类器时，我的内存性能非常差；我的进程的内存使用量从~150 MB激增到填充所有可用内存，然后随着内存交换到磁盘上，所有东西都会停止运转。
有人知道为什么这个分类器会将稀疏矩阵扩展成密集矩阵吗？目前，我在更新的ana
浏览 0提问于2014-10-07得票数 4
回答已采纳
矩阵的L2-范数的平方应与所有行/列L2-范数的平方之和相匹配。参考资料：
在Matlab中考虑跟随随机(4,3)矩阵
Computed using a = rand(4,3)
0.0400 0.4357 0.9144
0.5551 0.9048 0.5755
0.1675 0.1772 0.3001
0.4189 0.0403 0.2407
整体矩阵的L2范数是：
norm(a1)^2 = 2.7806
列平方和的L2范数：
norm(a1(:,1))^2 + norm(a1(:,2))^2 + norm(a1(:,3))^2 = 2.933
浏览 2提问于2018-03-02得票数 1
回答已采纳
2回答
我正在翻译一些MATLAB代码，在理解MATLAB和Python的numpy之间的语法差异时遇到了一些问题。
在MATLAB中，我有一个6乘6的矩阵，A，以及6个浮点值，a，b，c，d，e，f。
B = A*[a;b;c;d;e;f];
生成一个6乘1的矩阵B。所以我认为MATLAB操作符'*‘必须对应于数值操作符numpy.dot()。
在我的Python代码中，我有相同的矩阵A，以及相同的a，b，c，d，e和f的值。
B = numpy.dot(A, [[a],[b],[c],[d],[e],[f]])
不会产生相同的矩阵B，也不会
B = numpy.dot(A, [a,b,c,
浏览 0提问于2015-07-22得票数 0
我有一个很大的(351,351) numpy过渡矩阵。我想使用numpy找到状态向量(我也尝试了使用相同的函数)。
sstate = np.linalg.eig(T)[1][:,0]
所以，我认为这应该给出优势左特征值的特征向量。主要的左特征值是1+0j。这是正确的，主要的左特征值应该是1，我对此有点陌生，所以我不知道如何处理虚数。此外，sstate向量包含所有复数。现在，为了检查这是否正确，我执行以下矩阵乘法：
np.dot(sstate,T)
如果操作正确，这将返回与“sstate.‘”相同的向量。我不知道为什么这不管用。想象的数字会是问题吗？此外，是否有可能这个转移矩阵不包含一个稳态矢量
浏览 1提问于2015-02-13得票数 4
回答已采纳
1回答
矩阵x向量的列标量乘法
、、、
基本上，我想执行矩阵A和向量B的按列标量乘法，其中矩阵A的每一列都乘以向量B中的相应值。我有一个方法，如下所示。
def scale_matrix(self, matrix, vector):
"""
Performs scalar multiplication of matrix and vector column wise
"""
for value, index in enumerate(vector):
matrix[:, index] *= value
return matrix
浏览 11提问于2017-03-05得票数 0
回答已采纳
从线性代数中我们知道，任何对称矩阵(我们称之为A)的特征向量都是正交的，也就是说，如果M是所有特征向量的矩阵，则应该得到|det(M)| = 1。我本希望在numpy.linalg.eig中看到这一点，但得到了以下行为：
import numpy as np
def get_det(A, func, decimals=12):
eigenvectors = func(A)[1]
return np.round(np.absolute(np.linalg.det(eigenvectors)), decimals=decimals)
n = 100
x = np.meshgri
浏览 14提问于2022-06-23得票数 4
我有一个输入文件格式如下：
* 1 *
[[1.0 2.0 3.0 4.0] [ 5.0 6.0 7.0 8.0]] [1.5 2.5 3.5]
* 2 *
[[8.0 7.0 6.0 5.0] [ 1.0 2.0 3.0 4.0]] [4.5 5.5 6.5]
矩阵和向量的大小尚不清楚。我想把星内的数，矩阵和向量分成三个不同的变量(it，mtx，vect)。
我想知道在numpy.array中是否有一种简单的读取矩阵和向量的方法？我成功地得到了恒星内部的数字，但是对于有矩阵mtx和向量vect的直线，我找不到一种快速而恰当的方法。
这里是我的代码示例，在这里我试图得到向量，但是这里有一个错
浏览 4提问于2017-03-28得票数 1
回答已采纳
1回答
Numpy矩阵乘法行为
、、、
我有一个问题，要理解numpy中的矩阵乘法。例如，我有以下矩阵(2d numpy数组)：
a = [ [ 1. 1. ]
[ 1. 2. ]
[ 1. 3. ] ]
和下面的行向量θ：
theta = [ 1. 1. ]
将a与θ相乘的唯一方法是首先在列向量中转换θ，然后得到结果：
result = [ [ 2. ]
[ 3. ]
[ 4. ] ]
当我将矩阵和行向量相乘时(不进行转换)
result = np.dot(a,theta)
我明白了：
result = [ 2. 3. 4. ]
这怎么可能？我是说，我没有变换矩阵
浏览 3提问于2016-10-22得票数 0
回答已采纳
1回答
我正在用ruby编写一个机器学习算法，它使用梯度下降和logistic回归。
算法工作良好，只是在红宝石中，矩阵之间的点积非常慢。
我开始使用gem RubyPython，它允许您将像numpy这样的python库导入到ruby中，并使用它的函数。
numpy的性能令人印象深刻。这个应用程序的运行速度快了1000%，只是我总是半途而废。
有没有人知道其他方法来加速红宝石中两个矩阵的点积？
浏览 2提问于2015-05-19得票数 4
回答已采纳
假设我们要计算矩阵和列向量的点积：
因此，在Numpy/Python中，我们将：
a=numpy.asarray([[1,2,3], [4,5,6], [7,8,9]])
b=numpy.asarray([[2],[1],[3]])
a.dot(b)
在以下方面的成果：
数组([13，31，49])
到目前为止，还不错，但是为什么这也能工作呢？
b=numpy.asarray([2,1,3])
a.dot(b)
在以下方面的成果：
数组(13、31、49)
I预期2,1,3是行向量(应用点积需要转置)，但Numpy似乎默认将数组看作列向量(在矩阵乘法的情况下)？
这是
浏览 1提问于2016-01-05得票数 6
2回答
作为当前的任务，我需要计算120*120矩阵的特征值和特征向量。首先，我在Java (Apache库)和Python2.7 (Numpy库)的简单2×2矩阵上测试了这些计算。我有一个与特征向量不匹配的问题，如下所示：
//Java
import org.apache.commons.math3.linear.EigenDecomposition;
import org.apache.commons.math3.linear.MatrixUtils;
import org.apache.commons.math3.linear.RealMatrix;
public class Temporar
浏览 4提问于2016-11-15得票数 6
回答已采纳
给定下列马尔可夫矩阵：
import numpy, scipy.linalg
A = numpy.array([[0.9, 0.1],[0.15, 0.85]])
平稳概率存在并等于[.6, .4]。这很容易通过获取矩阵的大幂来验证：
B = A.copy()
for _ in xrange(10): B = numpy.dot(B,B)
这里是B[0] = [0.6, 0.4]。到现在为止还好。根据
平稳概率向量定义为在过渡矩阵的应用下不发生变化的向量；也就是说，它被定义为概率矩阵的左特征向量，与特征值1相关联：
因此，我应该能够计算出特征值为1的左特征向量，这也给出了平稳概率。有一
浏览 6提问于2012-05-08得票数 4
回答已采纳
3回答
如何将两个向量相乘得到一个矩阵？
、、、、
在numpy运算中，我有两个向量，假设向量A是4X1，向量B是1X5，如果我做AXB，应该会得到一个大小为4X5的矩阵。
但我尝试了很多次，做了许多类型的重塑和转置，它们要么都会抛出错误，说明没有对齐，要么返回单个值。
我应该如何得到我想要的矩阵的输出积？
浏览 0提问于2015-02-18得票数 38
回答已采纳
1回答
我正在尝试将两个NumPy数组放入一个矩阵或水平堆叠它们。每个数组有76个元素长，我希望结束矩阵有76行和2列。基本上，我有一个速度/频率模型，并希望在每一行中有两列对应的频率/速度值。
下面是我的代码(“f”是频率，“v”是之前已经定义的速度值)：
print(f.shape)
print(v.shape)
print(type(f))
print(type(v))
x = np.concatenate((f, v), axis = 1)
这会返回
(76,)
(76,)
<class 'numpy.ndarray'>
<class 'numpy.n
浏览 13提问于2022-09-09得票数 0
回答已采纳
1回答
我用numpy的linalg.eig来寻找矩阵的特征值和向量。下面的矩阵有一个形式的单特征向量(t,0)。但是python给了我不同的结果：
>>> a = np.matrix('2. 0. ; 1. 2.')
>>> print np.linalg.eig(a)
(array([ 2., 2.]), matrix([[ 0.00000000e+00, 4.44089210e-16],
[ 1.00000000e+00, -1.00000000e+00]]))
怎么啦？
浏览 3提问于2015-09-30得票数 4
4回答
对于numpy，我可以这样做一个简单的矩阵乘法：
a = numpy.ones((3, 2))
b = numpy.ones((2, 1))
result = a.dot(b)
但是，这不适用于PyTorch：
a = torch.ones((3, 2))
b = torch.ones((2, 1))
result = torch.dot(a, b)
此代码引发以下错误：
RuntimeError:一维张量，但得到二维张量和二维张量
如何在PyTorch中执行矩阵乘法？
浏览 9提问于2017-06-13得票数 84
回答已采纳
我想弄清楚如何计算numpy中矩阵的Frobenius。这样我就可以得到矩阵x中每一行的2-范数:我的问题是关于numpy的linalg.norm模块中的linalg.norm参数，以及如何描述一个矩阵的哪个范数可以计算。我可以通过设置ord=2获得Frobenius范数，但是它说只有设置ord=None才能给出Frobenius范数。
以下是我的例子：
x = np.array([[0, 3, 4],
[1, 6, 4]])
我发现可以使用以下代码行实现Frobenius规范：
x_norm = np.linalg.norm(x, ord = 2, axis=1
浏览 0提问于2018-07-05得票数 0
回答已采纳
3回答
Scipy和Numpy返回归一化特征向量。我试图将向量用于物理应用程序，而我需要它们不被规范化。
例如，a = np.matrix('-3, 2; -1, 0') W,V = spl.eig(a)
返回[-2,-1]的特征值(W)和模态矩阵(V) (特征值作为列) [[ 0.89442719 0.70710678][ 0.4472136 0.70710678]]
我需要原始模态矩阵[[2 1][1 1]]
浏览 3提问于2015-06-19得票数 2
回答已采纳
我想使用Numba来向量化一个函数，该函数将计算矩阵的每一行。这实际上将Numpy ufunc应用于矩阵，而不是遍历行。根据
您可能会问自己，“为什么我要使用@jit装饰器来编译一个简单的迭代循环呢？”答案是NumPy功能自动获得其他功能，如缩减、积累或广播。
考虑到这一点，我连一个玩具例子都找不到。下面的简单示例试图计算每一行中的元素之和。
import numba, numpy as np
# Define the row-wise function to be vectorized:
@numba.guvectorize(["void(float64[:],float6
浏览 0提问于2018-07-16得票数 7
回答已采纳
1回答
当我numpy.append两个3-D矩阵时会发生什么？
例如。a是形状(662,887，3)的矩阵，b是形状(77, 103, 100)的矩阵。
我使用numpy.append创建了一个矩阵c，它的形状是(2554682,)。
这是什么意思？这里发生何事？
浏览 1提问于2017-07-11得票数 0
回答已采纳
1回答
我必须找到矩阵的特征值，它包含5030行和3列。在使用numpy.linalg.eig(矩阵)函数时，它给出了
LinAlgError: Last 2 **dimensions** of the array must be square
对于本征值，矩阵必须是平方的，这是必须的吗？或者有什么方法可以找到矩阵的特征值(5030 *3)。
浏览 0提问于2020-04-16得票数 0
回答已采纳
1回答
我有一个非负浮点数的对称NumPy矩阵D。ith行和jth列中的数字表示对象i和j之间的距离，无论它们是什么。矩阵很大(大约10,000行/列)。我想检查矩阵中的所有距离是否都符合三角形不等式，即:对于所有i，j，k都是D[i,j]<=D[i,k]+D[k,j]。 这个问题可以通过使用三重嵌套循环来解决，但效率很低。但是，有没有更快的、矢量化的解决方案呢？
浏览 20提问于2019-01-06得票数 3
回答已采纳
2回答
维数500x2000x30的矩阵A和维数30x5的矩阵B。
您可以认为2000x30有500个实例，因为矩阵A是维数500x2000x30的。
我想把A中的每个1x2000x30与矩阵B相乘，得到大小为1x2000x5的新矩阵。
也就是说，A X B应该给我一个维数500x2000x5的矩阵
很明显，通过矩阵A循环500次是一种解决方案，但是有一个有效的方法来实现这一点吗？
编辑:A和B都是numpy数组
浏览 8提问于2016-11-18得票数 1
回答已采纳
1回答
我需要为我的工作生成大量的随机均值不变正交矩阵。均值不变矩阵具有A*1_n=1_n性质，其中1_n是标量1基本np.ones(n)的大小为n的向量.我使用Python，特别是Numpy来创建我的矩阵，但是我想确保我的方法是正确的，也是最有效的。另外，我还想介绍我尝试过的三种不同的正交化方法的结果，并希望能解释为什么一种方法比另一种方法更快。在这篇文章的结尾，我问了四个关于我的发现的问题。
一般情况下，为了创建一个均不变的随机正交矩阵A，需要创建一个随机平方矩阵M1，将其第一列替换为1列，并将该矩阵正交化。然后，再用另一个矩阵M2这样做，最终的均值不变随机正交矩阵A= M1*(M2.T)。这一过
浏览 20提问于2021-02-26得票数 0
2回答
我构造了一个100*100矩阵k，并希望使用numpy.linalg.eig对角化它。
k=np.zeros((100,100))
np.fill_diagonal(k,-2)
np.fill_diagonal(k[1:,:-1],1.5)
np.fill_diagonal(k[:-1,1:],0.5)
当我尝试更小的矩阵时，例如
w,v=np.linalg.eig(k[:10,:10])
特征值w和特征向量v是实数。但当我尝试更大的矩阵或整个完整矩阵时
w,v=np.linalg.eig(k)
w和v被证明是复数，虚部是不可忽略的。
我也尝试过scipy.linalg.eig，它也有类似的问
浏览 1提问于2018-02-27得票数 2
2回答
计算矩阵的每个元素
、、、
下面是我必须为Numpy矩阵中的每个元素计算的公式：
Mi_j = Sum_v(Av * Xi_v) + Sum_v(Bv * Wj_v) + Sum_v(Gv * Zij_v)
我不太明白如何用numpy的方式编码它(在python中，它太长了)：矢量化/切片/C Api。
你有什么建议，你能给我举个简单的例子吗？我对裸皮很陌生。
@编辑索引
A，B，G是一维x，x，x的数组
也适用于Xi和Wj (X是矩阵，W是矩阵)
Zij是一个一维数组。
浏览 5提问于2013-03-11得票数 4
回答已采纳
2回答
NumPy矩阵加列向量
、、、、
我正在使用numpy.matrix。如果我添加一个带有1x3或3x1向量的3x3矩阵，我会得到一个3x3矩阵。
这不应该是undefined吗？如果没有，对此的解释是什么？
示例：
a = np.matrix('1 1 1; 1 1 1; 1 1 1')
b = np.matrix('1 1 1')
a + b #or a + np.transpose(b)
输出：
matrix([[2, 2, 2],
[2, 2, 2],
[2, 2, 2]])
浏览 1提问于2013-04-01得票数 6
回答已采纳
10回答
数值协方差矩阵
、、
假设我有两个长度为25的向量，我想计算它们的协方差矩阵。我试着用numpy.cov做这件事，但总是得到一个2x2的矩阵。
>>> import numpy as np
>>> x=np.random.normal(size=25)
>>> y=np.random.normal(size=25)
>>> np.cov(x,y)
array([[ 0.77568388, 0.15568432],
[ 0.15568432, 0.73839014]])
使用rowvar标志也无济于事--我得到的结果完全相同。
浏览 9提问于2013-02-23得票数 22
回答已采纳
3回答
假设我有矩阵A和B。
A是一个三维数组/张量(？)。
[1,2,3,4]
[5,6,7,8]
[1,2,3,4]
[5,6,7,8]
比如说，有4个不同的二维矩阵，就像上面那个横跨第三维的矩阵。
B是一个矩阵。
[1,2,3,4]
在B中也有4个，每个都是相同的。
如何将每个向量相乘(？)B中的每个2d矩阵在A中。
[1,2,3,4]*[1,2,3,4]*[1;2;3;4]
[5,6,7,8]
[1,2,3,4]
[5,6,7,8]
将有四种上述类型的乘法来获得四个4x1向量。我已经用numpy尝试过了：
y = numpy.aran
浏览 6提问于2014-03-27得票数 1
给定任意长度的二维数组，我希望将“基本”数组中的每个值提高到“指数”数组中的每个幂，以生成一个2d数组/矩阵。
a = [a0, a1, a2, ... , an]
b = [b0, b1, b2, ... , bm]
期望产出：
[a0^b0, a1^b0, ... , an^b0 ;
a0^b1, a1^b1, ... , an^b1 ;
...
a0^bm, a1^bm, ... , an^bm ]
我来自Matlab背景，在这里可以很容易地实现列和行向量：
a.^b
如本文所述：
然而，在带有numpy或way等的Python中，我找不到任何简单的方法来做到这一点。我必须假设有
浏览 3提问于2020-02-21得票数 1
回答已采纳
3回答
我使用numpy中的linalg来计算带符号实数的矩阵的特征值和特征向量。我已经阅读了，但仍然没有掌握特征向量的归一化。下面是一个直接来自的示例
import numpy as np
from numpy import linalg as la
a = np.matrix([[2, 1], [1, 2]], dtype=np.float)
eigh_vals, eigh_vects = np.linalg.eig(a)
print 'eigen_values='
print eigh_vals
print '
浏览 0提问于2017-12-14得票数 2
1回答
我尝试使用Numpy库为python找到幂零矩阵公式。我将使用特定的矩阵(3x3)，并检查矩阵是否为幂零。我该怎么做？
浏览 15提问于2021-04-20得票数 1
我目前正在尝试用numpy实现特征脸，但它似乎在我的32位Linux系统上遇到了困难(我使用32位，因为以前对64位的闪存和java的支持不好，我的处理器是64位的…)。，因为当尝试将两个向量相乘以得到一个矩阵(向量*转置向量)时，numpy会给我
ValueError: broadcast dimensions too large.
我读到这是由于内存太少，可以用64位来解决。有什么方法可以绕过这一点吗？矩阵将是528000*528000个元素。根据我的论文，协方差矩阵需要这个大矩阵(将所有这些大矩阵相加，然后除以矩阵的数量)。
我的代码片段看起来像这样(我不明白为什么numpy给我一个矩阵
浏览 2提问于2011-06-23得票数 2
回答已采纳
我是一名从事地球物理反演的研究员。它需要求解线性系统：Au = rhs。这里A通常是稀疏矩阵，但rhs和u可以是稠密矩阵，也可以是向量。为了进行基于梯度的反演，需要进行灵敏度计算，需要大量的矩阵矩阵和矩阵向量乘法。最近，我在矩阵(稀疏)-矩阵(稠密)乘法中发现了一种奇怪的行为，下面是一个例子：
import numpy as np
import scipy.sparse as sp
n = int(1e6)
m = int(100)
e = np.ones(n)
A = sp.spdiags(np.vstack((e, e, e)), np.array([-1, 0, 1]), n, n)
A
浏览 6提问于2017-04-21得票数 3
回答已采纳
1回答
我正在试用numpy.linalg.eig，输出结果和预期的不一样
Ax =λx
A是矩阵λ是特征值x是特征向量
这是密码
import numpy as np
from numpy import linalg
A = np.array([[2,3],[-1,3]])
eigenvalues,eigenvectors = linalg.eig(A)
leftside = A[0]*eigenvectors[:,0]
rightside = eigenvalues[0]*eigenvectors[:,0]
print(leftside)
print(rightside)
我希望左边和右边相等
浏览 3提问于2022-01-15得票数 0
回答已采纳
2回答
有两个int矩阵A和B，有超过1000行和10K列，我通常需要将它们转换为浮动矩阵以获得加速比(4x或更多)。
我想知道为什么会这样？我意识到在浮点矩阵乘法中存在大量的优化和矢量化，如AVX等。但是，对于整数有这样的AVX2指令(如果我没有弄错的话)。而且，对于整数，不能使用SSE和AVX吗？
为什么在矩阵代数库(如Numpy或Eigen )下面没有一个启发式的方法来捕捉这一点，并像浮点一样更快地执行整数矩阵乘法？
关于接受的答案：虽然@sascha的答案非常有用，但@chatz的答案是int乘乘法速度慢的实际原因，不管是否存在BLAS整数矩阵运算。
浏览 11提问于2017-07-28得票数 26
回答已采纳
1回答
在下面的代码中，m是numpy矩阵，absm是矩阵m绝对值的矩阵副本。
m[absm < limit] = 0
如果对应的矩阵值小于极限，则使用此方法将m中的所有矩阵值转换为0。
这已经很好了，但是现在我想排除这段代码的前n行，只有当它们位于n下面的行中时，才能将值转换为零，而且我不太确定如何实现。
非常感谢
浏览 3提问于2017-02-13得票数 0
回答已采纳
1回答
我正在寻找简单的稀疏向量实现，可以映射到内存中，类似于numpy.memmap。
不幸的是，numpy实现只处理全向量。示例用法：
vec = SparseVector('/tmp/file.dat') # SparseVector is the class I'm looking for
vec[10] = 10
vec[50] = 21
for key in vec:
print vec[key] # 10, 21
我创建了表示稀疏矩阵的scipy类，但是2维使用起来很笨拙，因为我需要制作只有一行的矩阵，然后使用vec[0,i]。
有什么建议吗？
浏览 0提问于2015-04-11得票数 3
2回答
我的问题是:我试图通过(截断的)Karhunen变换对随机过程进行谱分解，但我的协方差矩阵实际上是一个1参数矩阵族，我需要一种方法来估计/可视化我的随机过程是如何依赖这个参数的。为此，我需要一种跟踪numpy.linalg.eigh()生成的特征向量的方法。
为了让您对我的问题有一个了解，这里有一个示例玩具问题:假设我有一组点{xs}，以及一个与参数a有关的协方差C(x，y) =1/(1+a*(Xs)^2)的随机过程R。对于0,1范围内的网格点随机样本和给定的一个(例如，a=1)的选择，我可以填充我的协方差矩阵并实现Karhunen变换：
num_x = 1000
xs = numpy.arr
浏览 4提问于2013-06-14得票数 2
我已经使用numpy编写了代码，它接受一个大小为(m X N)的数组...行(m)是由(n)个特征组成的单个观测值...并创建大小为(m×m)的平方距离矩阵。此距离矩阵是给定观测值与所有其他观测值的距离。例如，行0列9是观察值0和观察值9之间的距离。 import numpy as np
#import cupy as np
def l1_distance(arr):
return np.linalg.norm(arr, 1)
X = np.random.randint(low=0, high=255, size=(700,4096))
distance = np.empty(
浏览 15提问于2020-10-22得票数 0
回答已采纳
在numpy中，一些操作返回形状为(R, 1)的操作，但有些操作返回(R,)。这将使矩阵乘法更加繁琐，因为需要显式的reshape。例如，给定一个矩阵M，如果我们想要执行numpy.dot(M[:,0], numpy.ones((1, R)))，其中R是行数(当然，同样的问题也发生在列上)。我们将得到matrices are not aligned错误，因为M[:,0]是形状(R,)，而numpy.ones((1, R))是形状(1, R)。
所以我的问题是：
形状(R, 1)和(R,)有什么区别？我知道字面上是数字列表和列表列表，其中所有的列表都只包含一个数字。只是想知道为什么不设计nu
浏览 6提问于2014-02-26得票数 410
回答已采纳
当我以下列方式编写代码时：
from numpy import *
H = array([1,1])
Ht = transpose(H)
Ht
我得到了与H相同的矩阵，而不是H的转置。
但是，当我以如下方式改变矩阵H时：
from numpy import *
H = array(([1,1],[2,3]))
Ht = transpose(H)
Ht
我得到了H的转位。
我不明白这里发生了什么。它是使用转置函数的方式，还是定义矩阵的方式？
浏览 0提问于2018-08-26得票数 0
回答已采纳
2回答
当涉及到scipy稀疏矩阵时，我对乘法运算符*的行为感到有点困惑。运算符似乎实现了矩阵乘法，而不是像numpy数组那样实现组件乘法。
检查这一点的一些代码：
from scipy.sparse import lil_matrix
A = lil_matrix(-numpy.eye(2))
b = lil_matrix(numpy.ones((2,2)))
print (A * B).toarray()
结果如下：
[[-1. -1.]
[-1. -1.]]
scipy.sparse模块的并没有详细介绍这一点，我想知道是否有明确的乘法行为规范？
此外，对于具有大量稀疏矩阵和数值矩阵或数组的乘法
浏览 1提问于2012-12-06得票数 4
2回答
我有一个nxn矩阵C，并使用numpy.linalg中的inv求逆以获得Cinverse。我的C矩阵具有10**4阶的元素，但是我的Cinverse矩阵具有10**12阶或更高阶的元素(不确定是否正确)。当我执行numpyp.dot(C,Cinverse)时，我得不到单位矩阵。为什么会这样呢？
我有一个向量x，我将它自身相乘，得到一个矩阵。
x=array([ 121.41191662, 74.22830468, 73.23156336, 75.48354975,
79.89580817])
c=np.outer(xvector,xvector)
这是一个5x5矩阵。
然
浏览 0提问于2017-02-15得票数 0
在这种情况下，我需要从稀疏矩阵中提取一行，并将其与密集行的点积相乘。使用scipy的csr_matrix，这似乎比使用numpy的密集数组乘法要慢得多。这让我大吃一惊，因为我预计稀疏点积涉及的操作会少得多。下面是一个示例：
import timeit as ti
sparse_setup = 'import numpy as np; import scipy.sparse as si;' + \
'u = si.eye(10000).tocsr()[10];' + \
'v = np.rand
浏览 2提问于2015-11-20得票数 3
1回答
我试图用numpy来规范python中的向量。我做了以下工作：
matrix_norm = numpy.linalg.norm(matrix1[:,0], ord='fro')
print(matrix_norm)
matrix1的大小是: 1000×1400。我试图为矩阵的第一列找到规范化值。它给了我以下的例外：
“向量的无效范数序”
请帮帮忙！提前谢谢..。:)
浏览 2提问于2016-10-23得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
