作者：Minkyung Kang

译者：知源觅流

原文链接：
https://github.com/mkang32/python-basics/blob/master/numpy/dot_vs_multiply_vs_matmul_vs_at.ipynb

3. NumPy数组有哪些可用的功能？

我们的目标是在 NumPy 中找到执行点积或矩阵乘法的最佳方法。我比较了三个不同类别中的五种不同选项：

1. 元素乘法（element-wise multiplication）：* 或 np.multiply 加上 np.sum
2. 点积：np.dot
3. 矩阵乘法：np.matmul, @

我们将根据向量/矩阵的维度来探讨不同的情况，并理解每种方法的优缺点（the pros and cons of each method）。要在接下来的部分中运行代码，我们首先需要导入 numpy。

import numpy as np

(1) 元素乘法：*和sum

首先，我们可以尝试将元素乘法作为基本方法来实现点积：将两个向量中的对应元素相乘，然后将所有输出值相加。这种方法的缺点是你需要分别进行乘法和加法运算，导致它比我们稍后将讨论的其他方法慢。

这是一个使用两个1-D数组计算点积的示例。

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

>>> a*b
array([ 4, 10, 18])

>>> sum(a*b)
32
>>> np.sum(a*b) #译者添加
32

让我们看看2-D数组矩阵乘法的示例。

c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([1, 1, 1])

>>> c*d
array([[1, 2, 3],
       [4, 5, 6]])

在这里，二维数组 c 的每一行都被视为矩阵的一个元素，并与第二个数组 d 进行逐元素相乘。如下所示。

如果我们想要的是矩阵乘法的话，结果应该是这样：

因此，为了得到想要的输出，你需要对初始输出应用 np.sum。请注意，你应该传递参数 axis=1，它会对同一行中的元素求和。否则，因为默认值是axis=None，它对数组中的所有元素求和（译者订）。(译者注：axis=0表示跨行（Y轴）的方向，axis=1表示跨列（X轴）的方向）

>>> np.sum(c*d, axis=1)
array([ 6, 15])

译者注：

你可能会问，为什么不用sum了呢？这是因为如果你继续用刚才用过的sum函数，就得不到想要的结果了。

>>> sum(c*d)

array([5, 7, 9])

此时，你可能被sum和np.sum绕晕了。从下面的简介可以看出，sum是Python内置的函数，用于求和，功能有限。np.sum是numpy提供的求和函数，功能相对强大。所以，一般建议用np.sum。

对sum的简介。

sum(iterable, /, start=0)

Return the sum of a 'start' value (default: 0) plus an iterable of numbers

对np.sum的简介。

sum(a, axis=None, dtype=None, out=None, keepdims=, initial=, where=)

Sum of array elements over a given axis.

(2) 元素乘法：np.multiply和sum

np.multiply 和 * 基本上是一样的。它是NumPy的元素乘法版本，而不是Python的本地运算符。你需要 sum 函数求和才能得到最终的标量输出。

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

>>> np.multiply(a, b)
array([ 4, 10, 18])

>>>  np.sum(np.multiply(a, b))
32

(3) 点积：np.dot

在Numpy中有一种更优雅和简单的方法来计算点积，它就是np.dot(a, b) 或 a.dot(b)。它可以同时处理元素乘法和求和。简单易用。

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

>>> np.dot(a, b)
32

然而，当它是一个更高维度的数组时，你需要小心。如果数组的维度为2-D或更高，请确保第一个数组的列数与第二个数组的行数相匹配。

a = np.array([[1, 2, 3]])  # shape (1, 3)
b = np.array([[4, 5, 6]])  # shape (1, 3)

>>> np.dot(a, b)  
# ValueError: shapes (1,3) and (1,3) not aligned: 3 (dim 1) != 1 (dim 0)

为了让上述示例运行，你需要转置第二个数组，以便形状对齐：(1, 3) x (3, 1)。请注意，这将返回形为(1, 1)的数组，这是一个2-D数组。

a = np.array([[1, 2, 3]])  # shape (1, 3)
b = np.array([[4, 5, 6]])  # shape (1, 3)

>>> np.dot(a, b.T)  
array([[32]])

如果第二个数组是形状为（3，）的1-D数组，那么输出的数组也会是1-D数组。

a = np.array([[1, 2, 3]])  # shape (1, 3)
b = np.array([4, 5, 6])  # shape (3, )

>>> np.dot(a, b)  
array([32])

还要注意输入数组的顺序。如果顺序相反，你会得到外积（outer product）而不是内积（inner product）（点积）。（译者注：一个行向量乘以一个列向量称作向量的内积，又叫作点积，结果是一个标量；一个列向量乘以一个行向量称作向量的外积，结果是一个矩阵）

a = np.array([[1, 2, 3]])  # shape (1, 3)
b = np.array([[4, 5, 6]])  # shape (1, 3)

>>> np.dot(a.T, b)  # (3, 1) x (1, 3) 
array([[ 4,  5,  6],
       [ 8, 10, 12],
       [12, 15, 18]])

那么np.dot方法也适用于2-D数组×2-D数组吗？现在让我们尝试一个2D x 2D的例子。

c = np.array([[1, 2, 3], [4, 5, 6]])  # shape (2, 3)
d = np.array([[1], [1], [1]])  # shape (3, 1)

>>> np.dot(c, d)
array([[ 6],
       [15]])

它起作用了！即使它被称为点积，根据其定义，这表示输入是1-D向量，输出是标量，但它对2-D或更高维度的矩阵也起作用，就像它是矩阵乘法一样。上面例子的计算过程如下所示。

*或np.multiply是不支持这样计算的，所以np.dot绝对是一个改进。那么，我们应该把np.dot用于所有的点积和矩阵乘法吗？

从技术上讲，可以，但并不推荐使用np.dot进行矩阵乘法，因为“点积”这个名称有特定的含义，可能会让读者感到困惑，尤其是数学家！

此外，对于高维矩阵（3-D或更高），不推荐使用 np.dot，因为它的行为与普通矩阵乘法不同。我们将在本文的后面部分讨论这个问题。

因此，np.dot 既适用于点积也适用于矩阵乘法，但仅建议用于点积。

(4) 矩阵乘法：np.matmul

下一个选项是 np.matmul。它专为矩阵乘法而设计，名字也是由此得来（MATrix MULtiplication）。尽管名称说的是矩阵乘法，但它也适用于 1-D 数组，就像 np.dot 一样。下面让我们尝试一下之前测试 np.dot 的例子。可以看出，对于1-D和2-D数组，np.matmul 与 np.dot 的功能是一样的。

# 1D array
a = np.array([1, 2, 3])  # shape (1, 3)
b = np.array([4, 5, 6])  # shape (1, 3)

>>> np.matmul(a, b)
32

# 2D array with values in 1 axis
a = np.array([[1, 2, 3]])  # shape (1, 3)
b = np.array([[4, 5, 6]])  # shape (1, 3)

>>> np.dot(a, b.T) 
array([[32]])

# 2D arrays
c = np.array([[1, 2, 3], [4, 5, 6]])  # shape (2, 3)
d = np.array([[1], [1], [1]])  # shape (3, 1)

>>> np.dot(c, d)
array([[ 6],
       [15]])

太好了！因此，这意味着np.dot和np.matmul都可以完美地用于点积和矩阵乘法。然而，正如我们之前所说，建议使用np.dot进行点积运算，使用np.matmul进行2-D或更高维度的矩阵乘法。

(5 ) 矩阵乘法：@

最后一个选项来了！@是自Python 3.5以来引入的新运算符，其名称来自mATrices。它基本上与 np.matmul 相同，并旨在执行矩阵乘法。但是，如果我们已经有了完美的 np.matmul，为什么还需要新的中缀运算符呢？

向stdlib添加新运算符的主要动机是矩阵乘法是一个非常常见的运算，它应该拥有自己的中缀运算符。例如，运算符 // 远不如矩阵乘法常见，但仍拥有自己的中缀。要了解此添加的背景，请查看PEP 465 （
https://www.python.org/dev/peps/pep-0465/）。

# 1D array
a = np.array([1, 2, 3])  # shape (1, 3)
b = np.array([4, 5, 6])  # shape (1, 3)

>>> a @ b  
32

# 2D array with values in 1 axis
a = np.array([[1, 2, 3]])  # shape (1, 3)
b = np.array([[4, 5, 6]])  # shape (1, 3)

>>> a @ b.T
array([[32]])

# 2D arrays
c = np.array([[1, 2, 3], [4, 5, 6]])  # shape: (2, 3)
d = np.array([[1], [1], [1]])  # shape: (3, 1)

>>> c @ d
array([[ 6],
       [15]])

因此，@ 的工作原理和 np.matmul 完全一样。但是在 np.matmul 和@ 之间应该使用哪一个呢？尽管这是你的偏好，但在代码中 @ 看起来比np.matmul 更干净。例如，如果你想对三个不同的矩阵 x，y，z 执行矩阵乘法。那么下面是不同的方式：

# `np.matmul` version
np.matmul(np.matmul(x, y), z)

# `@` version
x @ y @ z

如你所见，@ 操作符更为简洁、易读。然而，由于该操作符仅在Python 3.5及以上版本可用，如果你使用的是更早的Python版本，你必须使用np.matmul。

荟萃知识，滋养你我。