np.dot 3x3 与 N 1x3 阵列

Question

我有一个包含 N 个 1x3 数组的 ndarray，我想用 3x3 矩阵执行点乘。我似乎无法找到一种有效的方法来做到这一点，因为所有 multi_dot 和 tensordot 等方法似乎都递归地求和或乘以每个操作的结果。我只是想以与应用标量相同的方式应用点乘。我可以使用 for 循环或列表推导来做到这一点，但它对我的应用程序来说太慢了。

N = np.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9], ...])
m = np.asarray([[10, 20, 30], [40, 50, 60], [70, 80, 90]])

我想执行类似这样的操作，但没有任何 python 循环：

np.asarray([np.dot(m, a) for a in N])

所以它只返回[m * N[0], m * N[1], m * N[2], ...]

最有效的方法是什么？有没有办法做到这一点，如果 N 只是一个 1x3 矩阵，它只会输出与 np.dot(m, N) 相同的结果？

Answer 1

试试这个：

import numpy as np
N = np.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 2, 3], [4, 5, 6]])
m = np.asarray([[10, 20, 30], [40, 50, 60], [70, 80, 90]])
re0 = np.asarray([np.dot(m, a) for a in N])  # original
re1 = np.dot(m, N.T).T  # efficient
print("result0:\n{}".format(re0))
print("result1:\n{}".format(re1))
print("Is result0 == result1? {}".format(np.array_equal(re0, re1)))

输出：

result0:
[[ 140  320  500]
 [ 320  770 1220]
 [ 500 1220 1940]
 [ 140  320  500]
 [ 320  770 1220]]
result1:
[[ 140  320  500]
 [ 320  770 1220]
 [ 500 1220 1940]
 [ 140  320  500]
 [ 320  770 1220]]
Is result0 == result1? True

时间成本：

import timeit
setup = '''
import numpy as np
N = np.random.random((1, 3))
m = np.asarray([[10, 20, 30], [40, 50, 60], [70, 80, 790]])
'''

>> timeit.timeit("np.asarray([np.dot(m, a) for a in N])", setup=setup, number=100000)
0.295798063278
>> timeit.timeit("np.dot(m, N.T).T", setup=setup, number=100000)
0.10135102272
# N = np.random.random((10, 3))
>> timeit.timeit("np.asarray([np.dot(m, a) for a in N])", setup=setup, number=100000)
1.7417007659969386
>> timeit.timeit("np.dot(m, N.T).T", setup=setup, number=100000)
0.1587108800013084
# N = np.random.random((100, 3))
>> timeit.timeit("np.asarray([np.dot(m, a) for a in N])", setup=setup, number=100000)
11.6454949379
>> timeit.timeit("np.dot(m, N.T).T", setup=setup, number=100000)
0.180465936661

Answer 2

首先，关于您的最后一个问题。 (3,) N 和 (1,3) 之间有区别：

In [171]: np.dot(m,[1,2,3])
Out[171]: array([140, 320, 500])       # (3,) result

In [172]: np.dot(m,[[1,2,3]])
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-172-e8006b318a32> in <module>()
----> 1 np.dot(m,[[1,2,3]])

ValueError: shapes (3,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)

您的迭代版本产生 (1,3) 结果：

In [174]: np.array([np.dot(m,a) for a in [[1,2,3]]])
Out[174]: array([[140, 320, 500]])

将N 设为 (4,3) 数组（这有助于保持 N 的第一个暗淡不同）：

In [176]: N = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10,11,12]])
In [177]: N.shape
Out[177]: (4, 3)
In [178]: np.array([np.dot(m,a) for a in N])
Out[178]: 
array([[ 140,  320,  500],
       [ 320,  770, 1220],
       [ 500, 1220, 1940],
       [ 680, 1670, 2660]])

结果是 (4,3)。

一个简单的dot 不起作用（与 (1,3) 情况相同）：

In [179]: np.dot(m,N)
...
ValueError: shapes (3,3) and (4,3) not aligned: 3 (dim 1) != 4 (dim 0)
In [180]: np.dot(m,N.T)     # (3,3) dot with (3,4) -> (3,4)
Out[180]: 
array([[ 140,  320,  500,  680],
       [ 320,  770, 1220, 1670],
       [ 500, 1220, 1940, 2660]])

所以这需要另一个转置来匹配你的迭代结果。

einsum 的显式索引也可以处理这些转置：

In [181]: np.einsum('ij,kj->ki',m,N)
Out[181]: 
array([[ 140,  320,  500],
       [ 320,  770, 1220],
       [ 500, 1220, 1940],
       [ 680, 1670, 2660]])

也适用于 (1,3) 情况（但不适用于 (3,) 情况）：

In [182]: np.einsum('ij,kj->ki',m,[[1,2,3]])
Out[182]: array([[140, 320, 500]])

matmul、@ 也用于计算重复点 - 如果输入是 3d（或可广播）：

In [184]: (m@N[:,:,None]).shape
Out[184]: (4, 3, 1)
In [185]: (m@N[:,:,None])[:,:,0]     # to squeeze out that last dimension
Out[185]: 
array([[ 140,  320,  500],
       [ 320,  770, 1220],
       [ 500, 1220, 1940],
       [ 680, 1670, 2660]])

dot 和 matmul 描述 1、2 和 3d 输入会发生什么。可能需要一些时间和实验来了解正在发生的事情。基本规则是A的最后一个，B的第二个到最后。

您的 N 实际上是 (n,3)、n (3,) 数组。这是 4 (1,3) 数组的样子：

In [186]: N1 = N[:,None,:]
In [187]: N1.shape
Out[187]: (4, 1, 3)
In [188]: N1
Out[188]: 
array([[[ 1,  2,  3]],

       [[ 4,  5,  6]],

       [[ 7,  8,  9]],

       [[10, 11, 12]]])

和之前的点一样 (4,1,3) 点 (3,3).T -> (4,1,3) -> (4,3)

In [190]: N1.dot(m.T).squeeze()
Out[190]: 
array([[ 140,  320,  500],
       [ 320,  770, 1220],
       [ 500, 1220, 1940],
       [ 680, 1670, 2660]])

其中 n 个：

In [191]: np.array([np.dot(a,m.T).squeeze() for a in N1])
Out[191]: 
array([[ 140,  320,  500],
       [ 320,  770, 1220],
       [ 500, 1220, 1940],
       [ 680, 1670, 2660]])