通过向量之差创建矩阵的矢量化(例如，对于numpy)
向量之差创建矩阵的矢量化是指使用向量之间的差来构造矩阵的操作。在NumPy这样的库中，可以使用矩阵减法来实现这一操作。
矩阵的矢量化操作在计算效率和代码简洁性方面都具有优势。通过向量之差创建矩阵的矢量化可以在不使用显式循环的情况下高效地生成矩阵，同时提供更简洁的代码。
应用场景： 这种矢量化操作在许多数据处理和科学计算的场景中都非常有用。例如，当需要生成一个矩阵，其中每个元素是两个向量对应位置之差时，可以使用矢量化操作来实现。
推荐的腾讯云相关产品： 腾讯云提供了一系列适用于云计算的产品和服务。以下是几个推荐的腾讯云产品，可用于支持矢量化操作：
- 弹性计算 - 提供了云服务器、容器服务等资源，可用于搭建运行矢量化操作的计算环境。了解更多：腾讯云弹性计算
- 弹性容器实例 - 提供一种简单、高效的容器化部署方式，可用于运行矢量化操作的容器化应用。了解更多：腾讯云弹性容器实例
- 云数据库 - 提供了多种数据库服务，如云数据库MySQL、云数据库MongoDB等，可用于存储和管理与矢量化操作相关的数据。了解更多：腾讯云云数据库
- 弹性文件存储 - 提供了高可靠、可扩展的文件存储服务，可用于存储与矢量化操作相关的数据。了解更多：腾讯云弹性文件存储
注意：以上推荐的腾讯云产品仅供参考，实际选择应根据具体需求进行。
参考链接：
相关·内容
1回答
数据：θ是N个角度的向量。
问题：如何从θ中生成N2D旋转矩阵向量？
在没有矢量化的情况下，我可以想到一个for循环：
import numpy as np
N = 100
theta = np.random.rand(N)*2*np.pi
def R(theta_v):
Rotation = np.empty((len(theta_v), 2, 2))
for k, theta in enumerate(theta_v):
Rotation[k] = np.array([ [np.cos(theta), -np.sin(theta)], [np.sin(t
浏览 0提问于2021-06-07得票数 1
回答已采纳
1回答
我想以有效的方式对Numpy矩阵的每一行应用一个函数。我发现使用np.apply_along_matrix(function, 1, array)会给我想要的结果。然而，这是令人难以置信的慢，特别是当使用非常大的矩阵。
我知道，将函数映射到矩阵行的更有效和正确的方法是将其矢量化，但我不知道如何正确地向量化这个函数(请注意，我并不是指np.vectorize(function)，因为这将适用于每个元素，而不是每一行)。
import numpy as np
def f(x):
return x * x.sum() # Multiply each element of a vector
浏览 0提问于2020-08-28得票数 1
回答已采纳
1回答
我有一个矩阵(numpy 2d数组)，其中每一行都是有效的概率分布。我有另一个向量(numpy 1d数组)，同样是一个prob。我需要计算矩阵的每一行和向量之间的KL散度。在不使用for循环的情况下可以这样做吗？
问了同样的问题，但没有一个答案能解决我的问题。其中一个建议使用for循环，这是我想避免的，因为我有大量的数据。另一个答案是在tensorflow中提供了一个解决方案，但我想要的是numpy数组。
计算两个向量之间的KL散度，但当其中一个向量是矩阵时，我无法得到如何使用它。
浏览 2提问于2019-07-21得票数 0
回答已采纳
1回答
所以我有了这个定义，
DP[i,j] = f[i,j] + min(DP[i−1, j −1], DP[i−1, j], DP[i−1, j +1])
它定义了从NxM矩阵的顶部到矩阵底部的最小累积成本。F中的每个单元格表示一个值/成本(1.2、0、10等)从另一个牢房进入那个牢房。
矩阵可能很大(1500x1500，它是)，而我编写的DP算法对于我的矩阵每运行一秒钟。这个矩阵每次执行需要运行数百次，所以程序的总运行时间是几分钟。这个循环大约是我瓶颈的99%，所以我尝试使用Python/numpys矢量化方法来优化这个循环。我只能进入Numpy和Scipy。
注意:我根本不使用python编程
浏览 2提问于2021-03-21得票数 1
回答已采纳
我已经创建了一个由50个随机生成的(x，y)对组成的矩阵，我需要将它转换成一个矩阵，它显示从任意点(行)到所有其他点(列中)的距离。这应该导致对角线0，并且是一个50x50矩阵。
我将使用公式计算距离：
创建距离矩阵：
n = 50
x = round(runif(n)*1000)
y = round(runif(n)*1000)
coordinates = cbind(x,y)
head(coordinates)
x y
[1,] 266 478
[2,] 372 861
[3,] 573 438
[4,] 908 245
[5,] 202 71
[6,] 898
浏览 4提问于2019-09-24得票数 0
1回答
从给定的邻接矩阵生成可达矩阵的最佳算法是什么？有warshall的算法，但这不是最好的方法。有一些其他的方法，但程序更多的理论。是否有任何模块可以轻松地创建一个可达矩阵。我正在研究python 2.7。
浏览 4提问于2016-05-12得票数 8
我很想知道为什么这个代码不起作用。如果有人知道是什么原因导致matlab发现这么多错误，我们将不胜感激。
m = 1;
c = 1.5;
fun =@(x, epsilon) 1 .* (1 - (1 - cos(x))/(2.*epsilon)).^c .* cos(m.*x);
a = @(ep) acos(1-(2*ep));
lm =@(e) 1/(2.*pi) .* integral(@(x)fun(x, e), -1.*a(e), a(e));
fprintf('ball bearing at 0.6 is %4.4f', lm(0.6));
我试图复制的函数是(
浏览 0提问于2018-11-23得票数 1
回答已采纳
1回答
我试图找到一个解释，为什么我使用Numba的矩阵乘法比使用NumPy的点函数慢得多。虽然我使用Numba编写矩阵乘法函数的最基本的代码，但我不认为性能显著降低是由于算法。为简单起见，我考虑两个k x k方阵，A和B。我的代码是
1 @njit('f8[:,:](f8[:,:], f8[:,:])')
2 def numba_dot(A, B):
3
4 k=A.shape[1]
5 C = np.zeros((k, k))
6
7 for i in range(k):
8 for j in
浏览 0提问于2021-04-06得票数 1
我想弄清楚如何计算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
回答已采纳
我想使用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
回答已采纳
我知道如何用numpy来求解基本的线性矩阵方程。
但是，我有一个矩阵A，方程A^2 + xA + yI = 0，其中x和y不是向量，而是标量。I是单位矩阵，0是维数匹配A的零矩阵。
对于小型矩阵来说，这是一个非常简单的方法(当然，假设存在一个解决方案)，但是我正在练习一个编码面试，并希望用python来解决类似的问题。也许给出的矩阵很大..。
下面是一个样本矩阵A，它得到解x=-2，y=1：
np.array([[1,1,0],
[0,1,0]
[0,0,1]]
在纸上，这与解线性方程组x= -2和x+y=-1一样容易。我所面临的问题是将上述形式的方程解
浏览 4提问于2020-02-22得票数 1
回答已采纳
我试图计算二进制向量和二进制向量矩阵之间的Hamming距离。我能找到的最快的方法是在Numpy中使用无符号8位整数：
import numpy as np
np.count_nonzero(data[0] != data, axis=1)
然而，这种方法的问题是，它首先查找所有不同的位元，然后对差异的数量进行求和。这不是有点浪费吗？我尝试在C++中实现一个基本版本，在这个版本中，我还会对不同的位数进行计数，这样在结束时不需要和，但这要慢得多。可能是因为Numpy使用SIMD指令。
所以我的问题是。在Numpy / Python / Cython中有使用SIMD指令直接计算Hamming距离
浏览 2提问于2021-01-13得票数 0
回答已采纳
我有一些关于在计算和cpu架构上节省计算能力的问题，因为我想和朋友一起创建一个2d游戏，它可以处理尽可能多的对象和参数，以学习高效计算。我们现在使用的是pygame，但可以实现c和fasm函数。
所以：
1.可以通过降低商的除法或二进位的精度来节省处理能力吗？
这种精度必须在二进制小数位ofc中，因为小数点的0.1在二进制的逗号后面有一个重复的小数部分，所以假设您将它设置为0.125，即二进制中的0.001=3小数位。我的意思是，你可以使用长除法来达到某个分数位，但我想这并不是更有效，因为处理器将不得不再次将每个中间结果加载到寄存器中。由于x86处理器在4个不同版本中都有自己的DIV指令，所以
浏览 2提问于2020-02-22得票数 0
1回答
离开Fortran已经几年了，现在我不得不拿起它，重新开始工作。
我想用entry(i,j)构造一个f(x_i,y_j)形式的矩阵，其中f是两个变量的函数，例如f(x,y)=cos(x-y)。在Matlab或Python(Numpy)中，有一些有效的方法来处理这种特定的问题。我不知道Fortran是否有这样的优化。
顺便说一句，在Fortran中，向量化操作比do/for循环快吗(就像Matlab和Numpy中的情况一样)？
浏览 3提问于2015-03-17得票数 0
回答已采纳
我试图从Tensorflow内置的稀疏矩阵乘法API中获取性能优势。建议tf.embedding_lookup_sparse是正确的方法。
但是，embedding_lookup_sparse的性能似乎在中有些令人失望。虽然它执行较小的矩阵乘法，<1,3196>和<3196,1024>，但稀疏度为0.1的稀疏矩阵不能获得密集矩阵乘法。
如果我的实现是正确的，我认为原因之一是Tensorflow使用COO格式保存所有索引-非零对。我不是这个领域的专家，但是，这不是众所周知的CSR格式在这种计算中表现得更好吗？对于稀疏矩阵表示，Tensorflow内部使用COO格式而不是C
浏览 6提问于2016-06-08得票数 4
回答已采纳
1回答
我正在用ruby编写一个机器学习算法，它使用梯度下降和logistic回归。
算法工作良好，只是在红宝石中，矩阵之间的点积非常慢。
我开始使用gem RubyPython，它允许您将像numpy这样的python库导入到ruby中，并使用它的函数。
numpy的性能令人印象深刻。这个应用程序的运行速度快了1000%，只是我总是半途而废。
有没有人知道其他方法来加速红宝石中两个矩阵的点积？
浏览 2提问于2015-05-19得票数 4
回答已采纳
1回答
Hermitian矩阵的特征向量
、、、、
Hermitian矩阵是一个复方阵，等于它的共轭转置。其矩阵元素满足以下条件：
每次我用Python计算Hermitian矩阵的特征向量时，特征向量的第一个系数是一个纯实数。这是Hermitian矩阵的属性吗？
我附加了一个代码片段来生成一个Hermitian矩阵，计算它的特征向量，并打印出对应于最小特征值的特征向量。
import numpy as np
from numpy import linalg as LA
N = 5 # Set size of a matrix
# Generate real part of the matrix at first
real_matr
浏览 0提问于2018-05-02得票数 3
回答已采纳
给定形状(height, width)的Numpy矩阵，我正在寻找最快的方法来创建形状(height, width, 4)的另一个Numpy矩阵，其中4表示RGBA值。我想做这个基于值的工作；因此，对于第一个矩阵中所有的0值，我希望在第二个矩阵中的同一位置有一个[255, 255, 255, 0]值。
我想用NumPy来做这件事，而不需要像下面这样缓慢地迭代：
for i in range(0, height):
for j in range(0, width):
if image[i][j] = 0:
new_image[i][j] = [25
浏览 4提问于2020-05-07得票数 1
回答已采纳
给定以下数值矩阵：
import numpy as np
mymatrix = np.matrix('-1 0 1; -2 0 2; -4 0 4')
matrix([[-1, 0, 1],
[-2, 0, 2],
[-4, 0, 4]])
和以下函数(sigmoid/logistic)：
import math
def myfunc(z):
return 1/(1+math.exp(-z))
我希望获得一个新的NumPy数组/矩阵，其中每个元素都是将myfunc函数应用于原始矩阵中相应元素的结果。
map(myfunc,
浏览 2提问于2017-03-04得票数 60
最近，我发现自己越来越多地在大量结构化数据(如点和多边形)上使用NumPy数组来进行内存管理和计算速度。在这样做的过程中，我总是需要对整个数组执行一些函数f(x)。根据经验和谷歌搜索，迭代数组并不是这样做的，因此，内置的函数应该被矢量化并广播到整个数组。
查看的文档，我们得到了下面的示例：
def myfunc(a, b):
"Return a-b if a>b, otherwise return a+b"
if a > b:
return a - b
else:
return a + b
>>&
浏览 16提问于2022-04-17得票数 0
回答已采纳
我正在做一些性能分析，我想知道，当数据类型已知(double)时，numpy是否将其标准数组操作矢量化。
a, b = (some numpy arrays)
c = a + b #Is this vectorized?
编辑:此操作是矢量化的吗，即计算是否由SIMD操作组成？
浏览 13提问于2017-07-06得票数 30
回答已采纳
1回答
在矩阵的每一列上应用函数的最快方法是什么？
我使用的函数是pwelch，但是任何函数的概念都应该是相同的。目前，我正在循环通过我的矩阵作为这样。
X = ones(5);
for i = 1:5 % length of the number of columns
result = somefunction(X(:,i))
end
有什么方法可以矢量化这段代码吗？
浏览 6提问于2015-04-21得票数 3
回答已采纳
如果我有numpy数组A和B，那么我可以用以下公式计算它们的矩阵乘积的迹：
tr = numpy.linalg.trace(A.dot(B))
然而，当在跟踪中只使用对角元素时，矩阵乘法A.dot(B)不必要地计算矩阵乘积中的所有非对角线条目。相反，我可以这样做：
tr = 0.0
for i in range(n):
tr += A[i, :].dot(B[:, i])
但是这在Python代码中执行循环，并且不像numpy.linalg.trace那样明显。
有没有更好的方法来计算numpy数组的矩阵乘积的迹？做这件事最快或最常用的方式是什么？
浏览 1提问于2013-09-17得票数 17
回答已采纳
1回答
如何求大稀疏矩阵的伪逆？
、、、、
我必须反演一个大型稀疏矩阵(50000 X 12000)。它最初以numpy.ndarray的形式存储，矩阵的大小约为3.5GB。我已经尝试过使用numpy.linalg.pinv来转换这个矩阵，但是它崩溃了jupyter笔记本内核。将此numpy.ndarray转换为scipy.sparse.csr_matrix (稀疏矩阵格式)是可行的，但我不知道有任何函数可以计算csr_matrix的伪逆。
如何求大型稀疏矩阵的伪逆？
浏览 4提问于2022-09-06得票数 0
3回答
我目前正试图优化一段代码，其要点是，我们遍历并计算一组值，并将它们写入矩阵。计算的顺序并不重要：
mat = np.zeros((n, n))
mat.fill(MAX_VAL)
for i in xrange(0, smallerDim):
for j in xrange(0,n):
similarityVal = doACalculation(i,j, data, cache)
mat[i][j] = abs(1.0 / (similarityVal + 1.0))
我分析了这段代码，发现大约90%的时间花在将值写回矩阵(最后一行)上。
我想知道做
浏览 1提问于2013-12-26得票数 1
回答已采纳
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
2回答
我有两个365x1矩阵s1和s2，均值和标准差向量。我想模拟一个新的365x1矩阵的正态分布。我使用的代码是
sim<-matrix(rep(NA,365),nrow=365,ncol=1)
for (i in 1:365){y<-rnorm(1,s1[i,],s2[i,])
sim[i,]<-y[i]}
但是，它只生成第一个值。我应该如何修复我的代码？非常感谢!
浏览 0提问于2013-07-17得票数 0
给定下列马尔可夫矩阵：
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
回答已采纳
2回答
我和R一起工作，我有这样的代码：
for (i in 1:10)
for (j in 1:100)
if (data[i] == paths[j,1])
cluster[i,4] <- paths[j,2]
其中：
data是有100行的向量，1 columnpaths是有100行的矩阵，5 columnscluster是有100行和5列的矩阵。
我的问题是:如何避免使用"for“循环来迭代矩阵？我不知道apply函数(lapply，tapply.)在这种情况下是有用的。
例如，当j=10000时，这是一个问题，因为执行时间非常长。
浏览 5提问于2010-06-02得票数 1
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
1回答
我想从矩阵中提取线性独立的样本。我想对其使用特征值。但问题是基于numpy/scipy的函数会给出排序后的特征值列表。通过该方法，我丢失了原始矩阵的哪个特征值对应于哪个行向量的信息，以便小心地删除它们。 我尝试创建自己的代码来计算特征值： numpy.linalg.solve(numpy.linalg.det(I,A)) 其中，A是原始矩阵，I是单位。但这给出了错误，而且是不正确的。我能用什么方法解决这个问题？
浏览 17提问于2019-05-26得票数 0
回答已采纳
1回答
我编写了一个函数，返回一个向量A，等于另一个向量F的稀疏矩阵的乘积。矩阵的非零值以稀疏(Nnz)表示，rowind(nnz)和colind(nnz)分别包含每个稀疏值的行和列。用do kx下面的两行向量化(现在注释的)内循环比较简单.我看不出如何向量化外部循环，因为pos对于不同的kx有不同的大小。
问题是:外部循环( kx=1，nxy)能被矢量化吗?如果是，如何实现？
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
弗拉基米尔·F正确地推测我来自Python/Octave世界。当我解决的PDE变得更大时，我已经将(返回)转移到fortran，
浏览 2提问于2017-05-20得票数 1
回答已采纳
1回答
当我numpy.append两个3-D矩阵时会发生什么？
例如。a是形状(662,887，3)的矩阵，b是形状(77, 103, 100)的矩阵。
我使用numpy.append创建了一个矩阵c，它的形状是(2554682,)。
这是什么意思？这里发生何事？
浏览 1提问于2017-07-11得票数 0
回答已采纳
2回答
我发现，如果一个矩阵(几乎)是满的，那么将其存储在稀疏中会导致(更多)更多的计算时间。
虽然以稀疏的形式存储一个完整的矩阵是微不足道的，但我只想知道这一事实背后的原因。
我的猜测是稀疏的索引读数将是计算时间的主要贡献者。还有其他优雅的想法吗？
浏览 3提问于2011-08-15得票数 4
回答已采纳
1回答
我正在开发一种用于最短路径查找的机器人。该系统由移动机器人、轨迹规划器、运动控制器、视觉传感器、ZigBee无线通信装置和迷宫地形组成。摄像机用于在迷宫中捕捉移动机器人的图像。开发了基于颜色标记识别的图像处理和分析算法，确定了机器人的位置和方向，我正在用java开发其软件部分。
我的目标是从捕获的image.And中创建一个连接节点的图，应用最短路径算法(BFS)找到最短的path.In，这条黑线表示路径，红色表示合并节点。
我编写了一个程序将图像转换成矩阵。标记白色像素为0，黑色1，红色2。我的计划是从这个矩阵中估计连接节点。我怎样才能做到呢？有别的办法吗？请帮帮我
浏览 1提问于2015-10-22得票数 2
回答已采纳
1回答
我想验证一下，我是否理解了许多机器学习讲座/笔记/视频中提到的向量化代码的概念。
我对此做了一些阅读，发现CPU和GPU有一个指令集，名为SIMD；单指令多个数据。
例如，这是通过将两个变量移动到两个特殊的64/128位寄存器，然后一次添加所有位来实现的。
我也读过像GCC这样的大多数现代编译器，例如，如果使用-Ofast标志打开优化，即
-Ofast -无视严格的标准遵守。-Ofast启用所有-O3优化。它还支持并非对所有符合标准的程序都有效的优化。它开启了数学和特定于Fortran的fno保护父母和-f堆栈数组。
在可能的情况下，-Ofast应该自动将用C/C++编写的任何循环矢量
浏览 0提问于2018-12-20得票数 1
回答已采纳
11回答
我试图实现一个函数，它计算矩阵中每个元素的Relu导数，然后在矩阵中返回结果。我在用Python和Numpy。
根据其他交叉验证值，x的Relu导数在x>0时为1，x<0时为0，未定义为0，当x ==为0时为0。
目前，我有以下代码：
def reluDerivative(self, x):
return np.array([self.reluDerivativeSingleElement(xi) for xi in x])
def reluDerivativeSingleElement(self, xi):
if xi > 0:
retur
浏览 10提问于2017-09-25得票数 19
回答已采纳
1回答
我想更好地了解外部是如何工作的，以及如何向量化函数。下面是我正在尝试做的一个最小的例子:我有一组数字2,3,4。对于(a,b)的每个组合，创建一个对角线上的a a b b b对角矩阵，然后用它做一些事情，例如计算它的行列式(这只是为了演示目的)。计算结果应写在一个3x3的矩阵中，每个组合一个字段。
下面的代码不起作用-显然，outer (或my.func)不理解我不希望应用整个lambdas向量-您可以看到，当您取消注释包含的print命令时，情况就是这样。
lambdas <- c(1:2)
my.func <- function(lambda1,lambda2){
# prin
浏览 5提问于2014-01-30得票数 2
我看到有人试图用python和numpy来做模拟。然而，它是安静的缓慢。我读了他的代码，它告诉我，他只在处理数组/矩阵计算时使用numpy包，所有其他变量和代码都是在python主控制台(即用于循环)中定义的。
我的问题是：
是否有必要将所有变量都写入numpy变量，例如np.float，以获得numpy包的全部功能？
而且，据我所理解，python的for循环很慢。但我不想为了简单和可实现性而使用cython。是否有一种方法可以让numpy使用一些特殊的迭代过程来加速计算？我看到了一个看上去像它但不太明白的页面()。基本上，如何充分利用ofnumpy软件包的能力？
浏览 0提问于2018-09-07得票数 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
回答已采纳
1回答
我是刚接触python的人，我需要您的帮助。
我有三个矩阵，特别是：
矩阵M(矩阵类: scipy.sparse.csc.csc_matrix)，维数:N；矩阵G(矩阵类: numpy.ndarray)，维数:C；矩阵L(矩阵类: numpy.ndarray)，维数:T.
其中:n= 10000，C= 1000，T= 20。
我想计算一下，这个分数：
我尝试使用两个for循环，一个用于i-index，另一个用于c。此外，我使用一个dot乘积来得到方程中的最后一次和。但是我的实现需要太多的时间才能给出结果。
这就是我所实施的：
score = 0.0
for i in
浏览 0提问于2021-03-03得票数 1
回答已采纳
1回答
给定一个numpy矩阵，我希望创建一个由从起始矩阵的列计算的列组成的新矩阵。我可以用向量运算来完成，但它并不是很优雅。举个例子，我想计算一下简单的增长率。
起始矩阵：
m = np.matrix(np.random.random_integers(1,100, size=(5,3)))
matrix([[ 96, 61, 100],
[ 18, 82, 17],
[ 59, 35, 58],
[ 26, 97, 95],
[ 25, 49, 32]])
所需计算矩阵g：
g0 = np.empty((5, 1))
g0[
浏览 1提问于2015-08-08得票数 0
回答已采纳
2回答
在朱莉娅和它的语法方面我是个完完全全的菜鸟。我试图跟随关于朱莉娅的半定值编程的文章.
如果有人能帮我弄清楚In[4]中的for循环实际上做了什么，我会很感激的：
for i in 1:m
A[:, (i-1)*n+1:i*n] .= random_mat_create(n)
b[i] = tr(A[:, (i-1)*n+1:i*n]*X_test)
end
据我理解，它应该创建一个矩阵的向量，A (m )，以及m维向量b。关于A的索引和b的索引，我完全搞不懂。
--我想解释一下这个代码的 :, (i-1)*n+1:i*n 部分。我在这里问这个问题，是因为我也不知道在朱莉娅文档中搜索什么。
浏览 2提问于2020-12-22得票数 3
回答已采纳
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
回答已采纳
2回答
假设我想建立这个方程(电机，6个阶段)：
Vs = Rs*Is + d/dt*(Ls*Is)
其中所有变量都是矩阵，因此：
Vs = va1 vb1 vc1 va2 vb2 vc2‘(列向量)
Is = ia1 ib1 ic1 ia2 ib2 ic2‘(列向量)
Ls和Rs为6x6矩阵(常数)
在我看来，Vs是输入向量，也是输出向量，所以我需要重新排列方程。
我已经看到，这是不可能在Simulink给转移Fcn块的矩阵，至少不是一个多输入多输出系统。
是否有办法在Simulink上实现这一点，仍然使用矩阵Ls和Rs而不“解”方程？
谢谢
浏览 2提问于2014-06-18得票数 0
回答已采纳
1回答
我目前有3个矩阵：X (Nx1)，Y (N )和Xi (N (j + k))。
为了简单地描述我的问题，我假设j=0
本质上，我想要的是一个N矩阵A，其中：
A(:,t) = interp1(X,Y(:,t),Xi(:,t))
换句话说，A的第n列对应于基于X和Y(:,n)的Xi第n列的插值值。
我目前正在使用循环来创建矩阵A。另一个选项是使用以下命令：
interp1(X,Y,Xi)
这个命令的问题是，MATLAB将创建一个N x k x k矩阵，因为它在Xi中的所有列中为Y中的每一列内插。因此，避免循环带来的任何速度好处都会被执行的额外插值所抵消，特别是在k较大的情况下。
还有我错过的第三
浏览 1提问于2013-06-28得票数 1
回答已采纳
我有一个名为X_valid的1000x784数据矩阵(10000个示例和784个特征)，我想将以下函数应用于此矩阵中的每一行，并获得数值结果：
def predict_prob(x_valid, cov, mean, prior):
return -0.5 * (x_valid.T.dot(np.linalg.inv(cov)).dot(x_valid) + mean.T.dot(
np.linalg.inv(cov)).dot(mean) + np.linalg.slogdet(cov)[1]) + np.log(
prior)
(x_valid仅仅是一行数据)。我使
浏览 0提问于2016-03-07得票数 4
当我以下列方式编写代码时：
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回答
将大型矩阵相乘很长时间。如何才能解决这个问题。我使用galois图书馆，而numpy，我认为它仍然应该稳定工作。我试着用numpy实现我的GF4算法和乘矩阵，但这需要更长的时间。感谢您的回复。
当r= 2,3,4,5,6快速乘以时，需要很长的时间。对我来说，这些不是很大的矩阵。这只是一个代码片段。给出了给定r的某一族的矩阵的大小n，k，并将这些参数的矩阵相乘。
import numpy as np
import galois
def family_Hamming(q,r):
n = int((q**r-1)/(q-1))
k = int((q**r-1)/(q-1)-r)
浏览 9提问于2022-11-30得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
