了解numpy np.tensordot
numpy是一个在Python中常用的科学计算库，提供了快速、高效的数组运算功能。np.tensordot是numpy库中的一个函数，用于计算张量的点积。
具体来说，张量是一个多维数组，可以是一维、二维、三维或更高维的数组。点积是一种张量运算，用于将两个张量的对应元素相乘并累加得到一个标量结果。
np.tensordot函数可以通过指定两个张量的轴来进行点积运算。它接受三个参数：两个张量和一个整数或整数序列，用于指定点积运算的轴。
该函数的语法如下：
np.tensordot(a, b, axes)其中，a和b分别表示要进行点积运算的两个张量，axes表示指定的轴。如果axes是一个整数，则表示在a和b的最后一个维度上进行点积运算；如果axes是一个整数序列，则表示在a和b的指定维度上进行点积运算。
np.tensordot函数的返回值是两个张量的点积结果。
np.tensordot的优势在于它可以灵活地进行多维数组的点积运算，方便进行复杂的张量计算。它在科学计算、深度学习、机器学习等领域有广泛的应用。
在腾讯云的产品中，腾讯云提供了云服务器、云数据库、云存储、人工智能等相关产品，可以满足不同场景的需求。具体相关产品的介绍和链接地址可以参考腾讯云官方网站的文档。
参考链接：
相关·内容
1回答
平均张量积
、、
我还有一个与我的上一个问题( )有关的问题。在那里，我在计算中发现了一个错误。使用np.tensordot，我正在计算以下公式：
<..>应该显示平均值。在python代码中，它确实是这样的(ewp是一个向量，re是一个张量)：
q1 = numpy.tensordot(re, ewp, axes=(1, 0))
q2 = numpy.tensordot(q1, ewp, axes=(1, 0))
serc = q2 ** 2
或
serc = numpy.einsum('im, m -> i', numpy.einsum('ilm, l ->
浏览 2提问于2016-10-15得票数 1
回答已采纳
1回答
我有功能代码，但我想在两个方面提供帮助：
改进了numpy代码，使代码运行得更快(即不用于循环)
首先，我想问一下关于1号的问题。下面是我正在询问的代码片段：
import numpy as np
k = np.linspace(0,4.76*10,2400)
kx,ky = np.meshgrid(k, k)
rx = [0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4]
ry = [0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.1, 1.2]
tensx = np.tensordot(rx,kx, axes = 0)
tensy =
浏览 4提问于2022-07-30得票数 0
回答已采纳
假设我有两个3D数组A和B，形状分别为(3, 4, N)和(4, 3, N)。
我可以计算沿着第三个轴的切片之间的点积
with_einsum = np.eisum('ikl,kjl->ijl', A, B)
是否可以使用numpy.tensordot执行相同的操作？
浏览 0提问于2017-01-25得票数 1
回答已采纳
1回答
我有以下乘法例程：
import numpy as np
a = np.random.rand(3,3)
b = np.random.rand(3,50,50)
res = np.zeros((3, 50, 50))
for i in range(50):
for j in range(50):
res[:,i,j] = a @ b[:,i,j]
什么是einsum等价表达式？
诚挚的问候
浏览 10提问于2022-04-25得票数 0
回答已采纳
2回答
简化二次求和
、、、、
我试图使用numpy.einsum来简化代码中的循环。
目前，我的代码如下所示：
k = 100
m = 50
n = 10
A = np.arange(k*m*n).reshape(k, m, n)
B = np.arange(m*m).reshape(m, m)
T = np.zeros((n, n))
for ind in xrange(k):
T += np.dot(A[ind,:,:].T, np.dot(B, A[ind,:,:]))
我试图使用numpy.einsum作为这个循环的替代方案：
Tp = np.einsum('nij,njk->ik
浏览 0提问于2015-10-28得票数 4
回答已采纳
1回答
我想实现一个张量Tucker积，
(cube).Output：输入：B in (m, n)，C in shape (n, n, n) (n, n, n) Y in shape (m, m, m)，s.t.Y_ijk = ∑_{0≤a,b,c<n} B_ia * B_jb * B_kc * C_abc.
循环代码的原始代码：
def raw_tensor_product(B, C, i, j, k):
'''
@param B: (m, n)
@param C: (n, n, n)
@param i: index in range(0
浏览 4提问于2022-03-26得票数 -1
回答已采纳
1回答
Python中多张张量的有效约简
、、、、
我在Numpy中有四个多维张量( v[i,j,k]、a[i,s,l]、w[j,s,t,m]、x[k,t,n] )，并且我试图计算由以下所给出的张量z[l,m,n]：
z[l,m,n] = sum_{i,j,k,s,t} v[i,j,k] * a[i,s,l] * w[j,s,t,m] * x[k,t,n]
所有的张量都是相对较小的(比如总共32k元素)，但是我需要多次执行这个计算，所以我希望这个函数尽可能少的开销。
我试图像这样使用numpy.einsum实现它：
z = np.einsum('ijk,isl,jstm,ktn', v, a, w, x)
但速度很慢。我还尝试了
浏览 1提问于2016-03-07得票数 9
回答已采纳
1回答
我想知道是否有一种更快的方法/专用的NumPy函数来执行二维NumPy数组按元素方向的乘法，然后对所有元素进行求和。我目前使用np.sum(np.multiply(A, B))，其中A，B是等维m x n的NumPy数组。
浏览 4提问于2017-06-26得票数 13
回答已采纳
2回答
在python中，我有一个大小为(n,n,n)的三维数组T和一个大小为(n,k)的二维数组。
在线性代数中，由T定义并应用于W的多线性映射的代码为：
X3 = np.zeros((k,k,k))
for i in xrange(k):
for j in xrange(k):
for t in xrange(k):
for l in xrange(n):
for m in xrange(n)
for h in xrange(n):
浏览 7提问于2016-07-17得票数 2
1回答
围绕原点的旋转是一个矩阵乘积，可以用numpy的点函数来完成， import numpy as np
points = np.random.rand(100,3) # 100 X, Y, Z tuples. shape = (100,3)
rotation = np.identity(3) # null rotation for example
out = np.empty(points.shape)
for idx, point in enumerate(points):
out[idx,:] = np.dot(rotation, point) 这涉及到一个for循环，或者n
浏览 12提问于2019-01-31得票数 2
回答已采纳
1回答
我正在自学如何使用Python3(用于此特定任务的NumPy)进行彩色图像处理。
我有一个3d数组image，表示图像的每个像素的RGB值，因此它的形状是(高度，宽度，3)。在每个像素上，我想要生成新的RGB值，这是在给定像素处原始RGB值的一些线性组合。我将通过将每个像素上的RGB矢量乘以W，一个3x3的权重矩阵来实现这一点。
我可以使用嵌套的for循环来实现这一点，但速度很慢：
newRGB = np.zeros((height,width,3)) # make empty array to update with RGB values
for i in range(height):
浏览 3提问于2014-10-26得票数 2
回答已采纳
1回答
我有以下操作：
import numpy as np
x = np.random.rand(3,5,5)
w = np.random.rand(5,5)
y=np.zeros((3,5,5))
for i in range(3):
y[i] = np.dot(w.T,np.dot(x[i],w))
它对应于伪表达式y[m,i,j] = sum( w[k,i] * x[m,k,l] * w[l,j], axes=[k,l]或等效于w.T、x、w广播公司在x第一维上的点积。
我如何用numpy的广播规则来实现它呢？
提前谢谢。
浏览 2提问于2017-08-16得票数 1
回答已采纳
我对numpy并不熟悉，所以我在可视化numpy.tensordot()函数的工作时遇到了一些问题。根据tensordot的文档，轴在参数中传递，其中axes=0或1表示正常矩阵乘法，而axes=2表示收缩。
有人能解释一下乘法如何处理给定的例子吗？
例1：a=[1,1] b=[2,2] for axes=0,1为什么要为axes=2抛出一个错误？
例2：a=[[1,1],[1,1]] b=[[2,2],[2,2]] for axes=0,1,2
浏览 2提问于2018-08-23得票数 4
回答已采纳
1回答
Python张量积
、、、
我有以下问题。出于性能原因，我使用numpy.tensordot，因此我的值存储在张量和向量中。我的一个计算结果如下：
<w_j>是w_j的期望值，<sigma_i>是sigma_i的期望值。(也许我现在应该调用is sigma，因为它与standart偏差无关)现在为了进一步的计算，我还需要方差。对于get方差，我需要计算：
现在，当我用numpy.tensordot将第一个公式实现到python中时，我真的很高兴它起作用了，因为这是非常抽象的，而且我不习惯张量。代码看起来是这样的：
erc = numpy.tensordot(numpy.tensor
浏览 1提问于2016-10-14得票数 3
回答已采纳
3回答
我有两个数组。一个是n，p，另一个是d，p，r。我希望我的输出是d，n by r，在构造下面的张量B时，可以很容易地实现这个输出。但是，我想在没有这个循环的情况下这样做。
import numpy
X = numpy.array([[1,2,3],[3,4,5],[5,6,7],[7,8,9]]) # n x p
betas = numpy.array([[[1,2],[1,2],[1,2]], [[5,6],[5,6],[5,6]]]) # d x p x r
print X.shape
print betas.shape
B = numpy.zeros((betas.shape[0]
浏览 0提问于2018-01-29得票数 1
回答已采纳
1回答
我有两个不同维度的矩阵，我想用einsum numpy将它们相乘: C(24，79)和D(1，1，24，1)。我想得到维数为(1，1，79，1)的矩阵。
我试着用两种方法使它们成倍增长：
tmp = np.einsum('px, klpj ->klxj', C, D)
tmp = np.einsum('xp, klpj ->klxj', C, D)
我得到了不同的结果。为什么？将这些矩阵相乘的正确方法是什么？
浏览 2提问于2016-12-14得票数 1
1回答
如何将矩阵中每一行的点积向量化？
、、、、
如果我有一个矩阵A，我想得到A的点积，每一行B。
import numpy as np
a = np.array([[1.0, 2.0],
[3.0, 4.0]])
b = np.array([[1.0, 1.0],
[2.0, 2.0],
[3.0, 3.0]])
如果目标是手动完成(或者在循环中)：
c = np.array([np.dot(a, b[0])])
c = np.append(c, [np.dot(a, b[1])], axis=0)
c = np.append(c, [np.dot(a,
浏览 0提问于2017-03-03得票数 3
回答已采纳
2回答
假设我有两个矩阵B和M，我想执行以下语句：
B += 3*M
我反复执行这个指令，所以我不想每次矩阵3*M (3可能会改变，我只做标量矩阵积)构建。这是一个使这个计算“就位”的numpy函数吗？
更准确地说，我有一个标量as列表和一个矩阵Ms列表，我想执行这两个操作数的“点积”(这实际上不是一个，因为两个操作数是不同的类型)，也就是说：
sum(a*M for a, M in zip(as, Ms))
np.dot函数除了.
浏览 5提问于2016-09-13得票数 2
回答已采纳
2回答
我有两个numpy数组：
一个名为ti (70L )的一维数组，元素叫做ti。
一个名为I的三维数组，形状为(70L，1024L，1024L)，每个元素都称为Ii。因此，Ii是尺寸的(1024升，1024升)
我想沿着第一个维度制作两个数组的乘积，即：
tI = t1*I1,t2*I2,...,tN*IN
例如，再次获得一个新的维数数组(70L、1024L、1024L)，然后沿第一维取和，以获得维数数组(1024L，1024L)：
tsum = t1*I1 + t2*I2 + ... +tN*IN
就目前而言，我对以下工作感到满意：
tI = np.asarray([t[i]*
浏览 3提问于2016-03-22得票数 4
回答已采纳
1回答
在PyKeops package中，没有可用于矩阵-矩阵乘法的公式。相反，他们实现了类似于numpy.tensordot的东西。我有两个大小为m x n和n x n的矩阵A,B。有没有办法用numpy.tensordot复制A @ B？ import numpy as np
m,n = 10, 20
A = np.random.random((m,n))
B = np.random.random((n,n))
result1 = A @ B
result2 = np.tensordot(A,B,(1,1))
print(result1 == result2)
# ===========
浏览 13提问于2021-01-29得票数 0
回答已采纳
1回答
我如何用爱因斯坦符号写出下面的点积？
import numpy as np
LHS = np.ones((5,20,2))
RHS = np.ones((20,2))
np.sum([
np.dot(LHS[:,:,0], RHS[:,0]),
np.dot(LHS[:,:,1], RHS[:,1]),
], axis=0)
浏览 5提问于2019-08-07得票数 4
回答已采纳
2回答
在一篇研究论文中，作者在两个(3*3)矩阵A和B之间引入了一个外积，从而得到了C。
C(i, j) = sum(k=1..3, l=1..3, m=1..3, n=1..3) eps(i,k,l)*eps(j,m,n)*A(k,m)*B(l,n)
其中eps(a, b, c)是。
我想知道如何在Numpy中向量化这样的数学操作符，而不是天真地实现6个嵌套循环(用于i, j, k, l, m, n)。
浏览 2提问于2017-01-23得票数 4
回答已采纳
2回答
将2D和1D数组相乘NumPy
、、、、
我对python和numpy有些陌生，所以也许你们中的一些人可以在这里帮助我。
我有一个名为z的一维数组，以及一些名为X0、Y0和SLM的二维矩阵。
我想创建一个3D数组( 2D矩阵的堆栈)，通过执行此操作，尝试避免for循环：
for index in range(len(z)):
3D_array[index] = SLM * np.exp( z[index] * (X0+Y0) )
到目前为止，我已经尝试过：
3D_array = SLM[np.newaxis, :] * np.exp( z[:, np.newaxis, np.newaxis] * (X0+Y0))
这是正确的，
浏览 0提问于2020-10-14得票数 0
2回答
沿第三轴的点积
、、、
我正在尝试使用tensordot在numpy中获取张量点积，但我不确定应该如何重塑我的数组来实现计算。(总的来说，我对张量的数学仍然是个新手。)
我有过
arr = np.array([[[1, 1, 1],
[0, 0, 0],
[2, 2, 2]],
[[0, 0, 0],
[4, 4, 4],
[0, 0, 0]]])
w = [1, 1, 1]
我想沿着axis=2做一个点积，这样我就有了一个矩阵
array([[3, 0,
浏览 2提问于2016-03-16得票数 15
回答已采纳
给出两个numpy.array的a和b，
c = numpy.outer(a, b)
返回一个二维数组，其中c[i, j] == a[i] * b[j]。现在，假设a具有k维数。
哪个操作返回维数c的数组k+1，其中c[..., j] == a * b[j]
此外，让b具有l维度。
哪个操作返回维数c的数组k+1，其中c[..., i1, i2, i3] == a * b[i1, i2, i3]
浏览 6提问于2017-03-15得票数 6
回答已采纳
1回答
numpy阵列上的多维矩阵乘法
、、、、
我在python中实现了一个神经网络，作为反向传播的一部分，我需要乘以一个三维矩阵，称为A，维(200, 100, 1)，由一个2D矩阵，称为W，维(100, 200)，结果应该有维(200, 200, 1)。
A是误差向量，W是权矩阵，乘积用来计算前一层的更新。
我试着用matrix_multiply(from numpy.core.umath_tests)来解决它，我试着把W整形成(100,200,1)，然后乘以，但是这会抛出
ValueError: matrix_multiply: Input operand 1 has a mismatch in its core dimension
浏览 7提问于2017-02-11得票数 2
回答已采纳
2回答
高维Python矩阵乘法
、、、、
我试图在numpy中寻找一个矩阵运算，它将加快以下计算的速度。
我有两个三维矩阵A和B。第一个维度表示示例，它们都有n_examples示例。我想要实现的是在A和B中标出每个例子，并对结果进行求和：
import numpy as np
n_examples = 10
A = np.random.randn(n_examples, 20,30)
B = np.random.randn(n_examples, 30,5)
sum = np.zeros([20,5])
for i in range(len(A)):
sum += np.dot(A[i],B[i])
浏览 4提问于2014-05-10得票数 3
回答已采纳
3回答
我有两个numpy数组，一个是形状(2, 5, 10)，另一个是形状(2, 5, 10, 10)。我想要的乘法是[[x1[i][j] * x2[i][j] for j in range(5)] for i in range(2)]，它按预期工作，但是速度很慢，我想直接x1 * x2乘法，但是numpy不喜欢那样。有没有一种numpy方法可以在给定轴上进行乘法？ 我已经尝试过numpy.multiply，因为它显示'axis‘是ufunc 'multiply’的无效关键字 x1 = np.arange(100).reshape((2, 5, 10))
x2 = np.arang
浏览 9提问于2019-07-04得票数 1
回答已采纳
1回答
嗨，Stack溢出社区，
我有一个形状为4x4x701的3D numpy数组Rp，其中701 4x4切片中的每一个在不同的时间点代表一定的数量。我正试图有效地将Givens旋转矩阵Q及其Hermitian transpose QH应用于701片中的每一个，目前正在迭代地这样做，如下所示：
for idx in np.arange(Rp.shape[-1]):
Rp[[j,k],:,idx] = np.dot(Q, Rp[[j,k],:,idx])
Rp[:,[j,k],idx] = np.dot(Rp[:,[j,k],idx], QH)
但是必须有一种方法来避免迭代(对于num
浏览 0提问于2018-09-12得票数 0
回答已采纳
1回答
我试图加快我的代码，以执行一些数值计算，在这里，我需要乘3个矩阵与一个数组。问题的结构如下：
数组的形状为(N，10)
第一个矩阵沿阵列的动态维数为常数，形状为(10，10)。
另外两个矩阵沿阵列的第一维变化，具有(N，10，10)形状。
计算结果应该是带有(N，shape)的数组。
我已经实现了一个使用for循环的解决方案，但是我希望有一个更好的性能，所以我尝试使用numpy函数。我尝试过使用numpy.tensordot，但是当将动态矩阵与数组相乘时，我得到了(N，10，N)的形状，而不是(N，10)。
我的for循环如下：
res = np.zeros(temp_
浏览 3提问于2016-12-06得票数 2
回答已采纳
2回答
我有一个N-by-M数组，在每个条目中，我需要执行一些NumPy操作，并将结果放在那里。
现在，我用一个双循环的天真方式来做这件事：
import numpy as np
N = 10
M = 11
K = 100
result = np.zeros((N, M))
is_relevant = np.random.rand(N, M, K) > 0.5
weight = np.random.rand(3, 3, K)
values1 = np.random.rand(3, 3, K)
values2 = np.random.rand(3, 3, K)
for i in range
浏览 0提问于2019-05-17得票数 2
回答已采纳
1回答
我已经编译了numpy 1.6.2，并使用MKL希望有一个更好的性能。目前，我有一个严重依赖于np.einsum()的代码，而且我被告知einsum对MKL不好，因为几乎没有向量化。=(所以我想用np.dot()和切片重新编写我的一些代码，以便能够提高一些多核速度。我非常喜欢np.einsum()的简单性，并且可读性很好。总之，例如，我有一个多维矩阵乘法的形式：
np.einsum('mi,mnijqk->njqk',A,B)
那么，如何在np.dot()高效的MKL操作中转换像这样的东西，或者其他3,4和5维数组乘法呢？
我将发布更多信息:我正在计算这个等式：
浏览 1提问于2014-05-14得票数 6
回答已采纳
我有两个矩阵，5x4和3x2。我想从他们那里得到一个5x3矩阵。
>>>theta_ic = np.random.randint(5,size=(5,4))
>>>psi_tr = np.random.randint(5,size=(3,2))
我可以通过以下方式完成此操作
>>>np.einsum('ij,kl->ik',theta_ic,psi_tr).shape
(5,3)
但是我不知道用numpy.tensordot怎么做我试过了
>>>np.tensordot(theta_ic,psi_t
浏览 1提问于2017-05-07得票数 1
4回答
我有一个形状为(8,9)的稀疏矩阵和另一个形状为(9，12，17)的数组。我想把它们相乘，这样我就得到了一个大小为(8,12,17)的矩阵/数组，其中(8,9)矩阵只有效地乘以了第一维。我必须使用Kronecker产品才能做到这一点吗?或者在numpy中有一种简单的方法吗？
浏览 26提问于2016-07-29得票数 0
2回答
带einsum的交叉积
、、、、
我试图尽可能快地计算3x1向量对的交叉积。这
n = 10000
a = np.random.rand(n, 3)
b = np.random.rand(n, 3)
numpy.cross(a, b)
给出了正确的答案，但在的激励下，我认为einsum会帮我找到某个地方。我发现这两个
eijk = np.zeros((3, 3, 3))
eijk[0, 1, 2] = eijk[1, 2, 0] = eijk[2, 0, 1] = 1
eijk[0, 2, 1] = eijk[2, 1, 0] = eijk[1, 0, 2] = -1
np.einsum('ijk,aj,ak->
浏览 10提问于2016-09-23得票数 3
回答已采纳
1回答
对于R、G、B通道，我有一个640x480 RGB图像，其形状为(480,640，3) -3，我想在的每个像素上，根据以下内容转换RGB值：
# for each pixel
for i in range(img.shape[0]):
for j in range(img.shape[1]):
# set the new RGB value at that pixel to
# (new RGB vector) = (const matrix A) * (old RGB vector) + (const vecto
浏览 1提问于2020-10-04得票数 0
1回答
如何以更直接的方式做标记为# <----的行？
在程序中，x的每一行都是一个点的坐标，rot_mat[0]和rot_mat[1]是两个旋转矩阵。该程序按每个旋转矩阵旋转x。
改变每个旋转矩阵和坐标之间的乘法顺序是很好的，如果这会让事情变得更简单的话。我想让x的每一行或结果表示一个点的坐标。
结果应该与检查结果匹配。
程序：
# Rotation of coordinates of 4 points by
# each of the 2 rotation matrices.
import numpy as np
from scipy.stats import special_ortho_
浏览 3提问于2017-12-20得票数 3
回答已采纳
2回答
我想在python中优化以下代码：
for imode in N.arange(3*natom): #Loop on perturbation (6 for 2 atoms)
for ikpt in N.arange(nkpt):
for iband in N.arange(nband):
for iatom1 in N.arange(natom):
for iatom2 in N.arange(natom):
for idir1 in N.arange(0,3):
for idir2 in N.ara
浏览 0提问于2013-06-29得票数 2
回答已采纳
1回答
我在试着理解这件事。我的输入矩阵是(60,4)，权重矩阵是(4，2)。乘法可以很容易地完成(从数学的角度来看，最后的矩阵是(60,2))。但是Numpy显示了一个我无法解释的错误。
self.output = np.dot (inputs, self.weights) + self.biases
ValueError: operands could not be broadcast together with shapes (60,4) (4,2)
浏览 10提问于2021-12-08得票数 0
1回答
我正在尝试使用Numpy在Python中实现一个卷积层。输入是形状[N, H, W, C]的4维数组，其中：
N：批次大小
H：图像的高度
W：图像宽度
C：频道数
卷积滤波器也是形状[F, F, Cin, Cout]的四维数组，其中
F：方形滤波器的高度和宽度
Cin：输入通道数(Cin = C)
Cout：输出通道数
假设沿所有轴移动一步，并且没有填充，输出应该是形状[N, H - F + 1, W - F + 1, Cout]的4维数组。
我的代码如下：
import numpy as np
def conv2d(image, filter)
浏览 0提问于2019-05-10得票数 0
回答已采纳
考虑两个多维数组，其中每个数组中的第一个轴表示不同的样本，例如，两个数组在这个轴上具有相同的维度，我们希望沿着这个维度在这些数组之间应用np.tensordot。
也就是说，我们希望实现以下目标：
import numpy as np
a = np.random.normal(size=(10,2,4,5))
b = np.random.normal(size=(10,2))
out = np.zeros((10,4,5))
for i in range(10):
out[i] = np.tensordot(b[i],a[i],axes=1)
但是使用numpy操作/索引。
是否有一
浏览 0提问于2021-06-18得票数 1
回答已采纳
1回答
假设我有两个数组V和Q，其中V是(i, j, j)，Q是(j, j)。现在，我希望计算Q与V的每个“行”的点积，并将结果保存为一个(i, j, j)大小的矩阵。使用for循环很容易做到这一点，只需在i上迭代，比如
import numpy as np
v = np.random.normal(size=(100, 5, 5))
q = np.random.normal(size=(5, 5))
output = np.zeros_like(v)
for i in range(v.shape[0]):
output[i] = q.dot(v[i])
然而，这对于我的需求来说太慢了，我
浏览 1提问于2016-09-12得票数 1
回答已采纳
2回答
这是一个简单的问题，但我对所涉及的大小感到困惑。
使用NumPy，我有一个三维数组，shape = (10,100,100).
(我认为它是一个由10个“矩阵”组成的np.ndarray，每个矩阵的形状为100×100，即
arr1 = [M1 M2 M3....M10]
其中M1.shape = (100,100), M2.shape = (100,100),...
我还有第二个数据数组，名为"arrB"，即arrB.shaped (100,)。我的目标是用这些numpy数组(即(arrB.T)*arr1*(arrB) )进行矩阵乘法，得到一个整数。使用numpy数组，此操作
浏览 2提问于2015-06-30得票数 0
回答已采纳
1回答
我正在卷积一个形状为nLambda，nX，nY的3D数据立方体和一个形状为nLambda,3的过滤器。我设法让它在这种情况下工作，但我需要在大量保存为nt，nLambda，nX，nY的立方体上重复这个过程。我想扩展我必须处理的代码，但我总是弄乱平铺。有人知道怎么做吗？ 我当前的程序做的是： datacube.shape = [21,100,100]
filters.shape = [21,3]
data_collapsed.shape = [100,100,3] 我想让它这么做 datacube.shape = [10,21,100
浏览 27提问于2019-05-16得票数 3
回答已采纳
我目前正在研究一个耦合HMM的Python实现，它涉及元素级乘法，点积和维数(50，50，40，40，40，40，40，40)和维数ndarray (40,40,40,40)的和。也就是说，非常大..。第二次辐射或多或少是稀疏的，大约有70%的零。
到目前为止，我一直在使用numpy.einsum，它给了我相当慢的结果(算法运行大约需要3h )。现在的问题是，我需要为我的HMM优化一些参数，这意味着我必须至少运行10000次，因此我需要增加至少1,000倍的速度，这样才能使事情变得合理。
我一直在四处寻找用Python进行大型数组操作的最佳方法，现在我对我所读到的内容感到非常困惑。所以我有几个
浏览 1提问于2016-11-07得票数 1
回答已采纳
1回答
我的目标是高效地计算以下嵌套循环，
Ab = np.random.randn(1000, 100)
Tb = np.zeros((100, 100, 100))
for i in range(d):
for j in range(d):
for k in range(d):
Tb[i, j, k] = np.sum(Ab[:, i] * Ab[:, j] * Ab[:, k])
我找到了一种更快的方法来执行嵌套循环，只对组合进行循环：
for i,j,k in itertools.combinations_with_replacemen
浏览 0提问于2017-12-03得票数 1
回答已采纳
我正在尝试在c++中复制numpy.tensordot。numpy文档中的示例显示了我可以使用的嵌套循环，但是如果不使用 c = np.tensordot(a,b, axes=([1,0],[0,1])) 我想做的是： c = np.tensordot(a,b, axes=([1,2],[0,1])) 在python中，新的嵌套循环会是什么样子？在c++中有没有更简单/更快的方法来完成这个操作呢？现在，我在c++中使用与std：：vector相同的嵌套"for“循环。我见过一些可能有帮助的库，但我尝试只使用c++标准库。 下面是numpy示例和文档链接：https://numpy.o
浏览 21提问于2020-12-18得票数 1
回答已采纳
1回答
我对numpy.dot的产品有一些疑问。
我定义一个矩阵6x6，如下所示：
C=np.zeros((6,6))
C[0,0], C[1,1], C[2,2] = 129.5, 129.5, 129.5
C[3,3], C[4,4], C[5,5] = 25, 25, 25
C[0,1], C[0,2] = 82, 82
C[1,0], C[1,2] = 82, 82
C[2,0], C[2,1] = 82, 82
然后，我使用多维数组将其重新转换为4阶张量
def long2short(m, n):
"""
Given two indices m and
浏览 2提问于2013-07-17得票数 5
回答已采纳
我需要在NumPy中实现以下行为：
a = [1, 2, 3]
b = [[1, 0],
[0, 1]]
c = f(a, b)
> c = [[[1, 0],
[0, 1]],
[[2, 0],
[0, 2]],
[[3, 0],
[0, 3]]]
我可以用np.outer(a, b.flatten()).reshape(a.shape + b.shape)实现这一点，但这并不明显，需要一个注释才能清楚地说明代码的意图。有没有提供这种行为的内置函数？
浏览 0提问于2018-01-31得票数 2
回答已采纳
2回答
具有numpy的多个高阶矩阵
、、、、
我制造了这个玩具问题，反映了我更大的问题：
import numpy as np
ind = np.ones((3,2,4)) # shape=(3L, 2L, 4L)
dist = np.array([[0.1,0.3],[1,2],[0,1]]) # shape=(3L, 2L)
ans = np.array([np.dot(dist[i],ind[i]) for i in xrange(dist.shape[0])]) # shape=(3L, 4L)
print ans
""" prints:
[[ 0.4 0.4 0.4 0.4]
[
浏览 6提问于2015-06-13得票数 12
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
