Python 矩阵数组的元素有效乘法

假设

array_1

和

array_2

是两个大小相同的矩阵数组。这两个数组的元素（它们的元素的乘法定义得很好）是否有向量化的方式来相乘

虚拟代码：

def mat_multiply(array_1,array_2):
    size=np.shape(array_1)[0]

    result=np.array([])
    for i in range(size):
        result=np.append(result,np.dot(array_1[i],array_2[i]),axis=0)
    return np.reshape(result,(size,2))

输入示例：

a=[[[1,2],[3,4]],[[1,2],[3,4]]]
b=[[1,3],[4,5]]

输出：

[[  7.  15.]
 [ 14.  32.]]

---

与第一句相反，

a

和

b

的大小不一样。但让我们关注你的例子

因此，您需要-2个点积，每行

a

和

b

np.array([np.dot(x,y) for x,y in zip(a,b)])

或者避免附加

X = np.zeros((2,2))
for i in range(2):
    X[i,...] = np.dot(a[i],b[i])

dot

产品可用

einsum

（矩阵索引符号）表示为

因此，下一步是索引第一个维度：

np.einsum('kij,kj->ki',a,b)

我对

einsum

非常熟悉，但仍然需要一些尝试和错误来确定您想要什么。现在问题已经清楚了，我可以用其他几种方法来计算

A, B = np.array(a), np.array(b)    
np.multiply(A,B[:,np.newaxis,:]).sum(axis=2)
(A*B[:,None,:]).sum(2)
np.dot(A,B.T)[0,...]
np.tensordot(b,a,(-1,-1))[:,0,:]

我发现使用不同大小的阵列很有帮助。例如，如果

A

是

（2,3,4）

和

B

（2,4）

，则点和必须在最后一个维度上更为明显

---

另一个numpy迭代工具是

np.nditer

<代码>einsum使用此选项（在C中）。

避免

[…，0]

步骤需要更精细的设置

C = np.zeros((2,2))
it = np.nditer([A, B, C],flags=['external_loop','reduce_ok'],
    op_axes=[[0,1,2], [0,-1,1], [0,1,-1]],
    op_flags=[['readonly'],['readonly'],['readwrite']])
for x,y,w in it:
    w[...] = np.dot(x,y)
    # w[...] += x*y 
print C
# array([[  7.,  15.],[ 14.,  32.]])

---

与第一句相反，

a

和

b

的大小不一样。但让我们关注你的例子

因此，您需要-2个点积，每行

a

和

b

np.array([np.dot(x,y) for x,y in zip(a,b)])

或者避免附加

X = np.zeros((2,2))
for i in range(2):
    X[i,...] = np.dot(a[i],b[i])

dot

产品可用

einsum

（矩阵索引符号）表示为

因此，下一步是索引第一个维度：

np.einsum('kij,kj->ki',a,b)

我对

einsum

非常熟悉，但仍然需要一些尝试和错误来确定您想要什么。现在问题已经清楚了，我可以用其他几种方法来计算

A, B = np.array(a), np.array(b)    
np.multiply(A,B[:,np.newaxis,:]).sum(axis=2)
(A*B[:,None,:]).sum(2)
np.dot(A,B.T)[0,...]
np.tensordot(b,a,(-1,-1))[:,0,:]

我发现使用不同大小的阵列很有帮助。例如，如果

A

是

（2,3,4）

和

B

（2,4）

，则点和必须在最后一个维度上更为明显

---

另一个numpy迭代工具是

np.nditer

<代码>einsum使用此选项（在C中）。

避免

[…，0]

步骤需要更精细的设置

C = np.zeros((2,2))
it = np.nditer([A, B, C],flags=['external_loop','reduce_ok'],
    op_axes=[[0,1,2], [0,-1,1], [0,1,-1]],
    op_flags=[['readonly'],['readonly'],['readwrite']])
for x,y,w in it:
    w[...] = np.dot(x,y)
    # w[...] += x*y 
print C
# array([[  7.,  15.],[ 14.,  32.]])

---

@hpaulj在其广泛而全面的选项列表中还遗漏了一个选项：

>>> a = np.array(a)
>>> b = np.array(b)
>>> from numpy.core.umath_tests import matrix_multiply
>>> matrix_multiply.signature
'(m,n),(n,p)->(m,p)'
>>> matrix_multiply(a, b[..., np.newaxis])
array([[[ 7],
        [15]],

       [[14],
        [32]]])
>>> matrix_multiply(a, b[..., np.newaxis]).shape
(2L, 2L, 1L)
>>> np.squeeze(matrix_multiply(a, b[..., np.newaxis]), axis=-1)
array([[ 7, 15],
       [14, 32]])

matrix\u multiply

的好处在于，作为一个gufunc，它不仅适用于一维矩阵数组，还适用于可广播数组。例如，如果不将第一个矩阵与第一个向量相乘，将第二个矩阵与第二个向量相乘，而是希望计算所有可能的乘法，则可以简单地执行以下操作：

>>> a = np.arange(8).reshape(2, 2, 2) # to have different matrices
>>> np.squeeze(matrix_multiply(a[...,np.newaxis, :, :],
...                            b[..., np.newaxis]), axis=-1)
array([[[ 3, 11],
        [ 5, 23]],

       [[19, 27],
        [41, 59]]])

---

@hpaulj在其广泛而全面的选项列表中还遗漏了一个选项：

>>> a = np.array(a)
>>> b = np.array(b)
>>> from numpy.core.umath_tests import matrix_multiply
>>> matrix_multiply.signature
'(m,n),(n,p)->(m,p)'
>>> matrix_multiply(a, b[..., np.newaxis])
array([[[ 7],
        [15]],

       [[14],
        [32]]])
>>> matrix_multiply(a, b[..., np.newaxis]).shape
(2L, 2L, 1L)
>>> np.squeeze(matrix_multiply(a, b[..., np.newaxis]), axis=-1)
array([[ 7, 15],
       [14, 32]])

matrix\u multiply

的好处在于，作为一个gufunc，它不仅适用于一维矩阵数组，还适用于可广播数组。例如，如果不将第一个矩阵与第一个向量相乘，将第二个矩阵与第二个向量相乘，而是希望计算所有可能的乘法，则可以简单地执行以下操作：

>>> a = np.arange(8).reshape(2, 2, 2) # to have different matrices
>>> np.squeeze(matrix_multiply(a[...,np.newaxis, :, :],
...                            b[..., np.newaxis]), axis=-1)
array([[[ 3, 11],
        [ 5, 23]],

       [[19, 27],
        [41, 59]]])

---

@lucemia，我在那里找不到任何相关的东西。@lucemia，我在那里找不到任何相关的东西。谢谢。投票！但是它们是一样大的！a由两个矩阵组成：[[1,2]，[3,4]]和[[1,2]，[3,4]]。b由两个矩阵组成：[1,3]和[4,5]。我认为您可以将

np.einsum'调用中的
k
替换为

…`并使其适用于矩阵和向量的可广播数组，而不仅仅是一维数组。Naji-您的

a

和

b

是列表列表

A

是一个3d阵列，

B

2d。如果你想矢量化操作，你需要考虑这些高维数组。否则你就只能在低维数组上迭代了。@hpaulj，我理解你的意思。你提到我说

a

nd

b

大小相同是错误的。重点是，我是从数学的角度讲的，a和b的大小相同，因为它们包含相同大小的矩阵。我期望得到的是这些数组中元素（数组中的每个矩阵）之间的元素相乘（只要成对元素之间的相乘在数学上定义得很好）。我唯一想澄清的是，我所说的不是数据结构，而是矩阵的数学k-图。

numpy

文档中使用的一个概念是

兼容形状

，谢谢。投票！但是它们是一样大的！a由两个矩阵组成：[[1,2]，[3,4]]和[[1,2]，[3,4]]。b由两个矩阵组成：[1,3]和[4,5]。我认为您可以将

np.einsum'调用中的
k
替换为

…`并使其适用于矩阵和向量的可广播数组，而不仅仅是一维数组。Naji-您的

a

和

b

是列表列表

A

是一个3d阵列，

B

2d。如果你想矢量化操作，你需要考虑这些高维数组。否则你就只能在低维数组上迭代了。@hpaulj，我理解你的意思。你提到我说

a

nd

b

大小相同是错误的。重点是，我是从数学的角度讲的，a和b的大小相同，因为它们包含相同大小的矩阵。我期望得到的是这些数组中元素（数组中的每个矩阵）之间的元素相乘（只要成对元素之间的相乘在数学上定义得很好）。我唯一想澄清的是，我不是在说什么