NumPy多维数组乘法深度解析：理解元素级与点积运算

本文深入探讨numpy数组乘法的两种主要形式：元素级乘法（`*`运算符）和点积运算（`np.dot()`或`np.matmul()`）。我们将通过具体示例，详细解释它们的工作原理、广播机制以及数组形状对结果的影响，并提供选择正确乘法操作的专业指南，帮助读者避免常见混淆，高效处理多维数组计算。

在NumPy中进行数组乘法时，理解所使用的运算符或函数至关重要，因为不同的操作符执行的是不同的数学运算。最常见的混淆点在于元素级乘法（element-wise multiplication）和点积（dot product）或矩阵乘法（matrix multiplication）。

1. NumPy数组乘法的基本类型

NumPy提供了两种主要的数组乘法方式：

• 元素级乘法 (Element-wise Multiplication)：使用标准的乘法运算符 *。这种操作会逐个元素地将两个数组中对应位置的元素相乘。如果两个数组的形状不完全匹配，NumPy会尝试使用广播（broadcasting）机制来使它们兼容。
• 点积/矩阵乘法 (Dot Product / Matrix Multiplication)：使用 np.dot() 函数或 np.matmul() 函数（或 @ 运算符，Python 3.5+）。这些函数执行的是线性代数中的点积或矩阵乘法运算，要求参与运算的数组（或矩阵）满足特定的维度匹配规则。

2. 元素级乘法 (*) 的行为解析

当使用 * 运算符对NumPy数组进行乘法时，NumPy会尝试执行元素级乘法。这意味着它会尝试将第一个数组的每个元素与其在第二个数组中对应的元素相乘。

示例分析： 考虑以下两个数组：

import numpy as np

a = np.array([1, 2, 3])  # 形状 (3,)
b = np.array([[1]])      # 形状 (1, 1)

当执行 a * b 时，NumPy会应用其广播规则：

1. a 的形状是 (3,)，可以被视为 (1, 3) 进行广播。
2. b 的形状是 (1, 1)。
3. 为了进行元素级乘法，NumPy会扩展 a 的维度，使其与 b 的行数匹配，同时扩展 b 的列数使其与 a 匹配。
   • a (1, 3) 与 b (1, 1) 广播后，b 会被扩展成 [[1, 1, 1]] (1, 3)。
4. 然后，进行元素级乘法： [[1, 2, 3]] * [[1, 1, 1]] 结果是 [[1*1, 2*1, 3*1]]，即 [[1, 2, 3]]。

import numpy as np

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

result_element_wise = a * b
print(f"a 的形状: {a.shape}")
print(f"b 的形状: {b.shape}")
print(f"a * b 的结果:\n{result_element_wise}")
print(f"a * b 结果的形状: {result_element_wise.shape}")

输出:

MarsX

AI驱动快速构建App，低代码无代码开发，改变软件开发的游戏规则

159

查看详情

a 的形状: (3,)
b 的形状: (1, 1)
a * b 的结果:
[[1 2 3]]
a * b 结果的形状: (1, 3)

这正是原始问题中观察到的结果。

3. 点积运算 (np.dot() / np.matmul()) 的行为解析

如果你期望的结果是 [[1],[2],[3]]，这通常意味着你想要执行一种矩阵乘法或点积运算，其中 a 被视为一个列向量，与 b 中的元素相乘。

为了实现这种类型的运算，我们需要确保数组的形状符合点积或矩阵乘法的要求。对于 np.dot(A, B)，要求 A 的最后一维与 B 的倒数第二维（即行数）匹配。

在我们的例子中，期望 [[1],[2],[3]] 表明 a 应该被视为一个 (3, 1) 的列向量，而 b 是一个 (1, 1) 的矩阵。

调整数组形状以进行点积： 首先，我们需要将 a 从 (3,) 的一维数组重塑（reshape）为 (3, 1) 的二维列向量。

import numpy as np

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

# 将 a 重塑为 (3, 1) 的列向量
a_reshaped = a.reshape(3, 1)

print(f"重塑后的 a 的形状: {a_reshaped.shape}")

# 执行点积
result_dot_product = np.dot(a_reshaped, b)
print(f"np.dot(a_reshaped, b) 的结果:\n{result_dot_product}")
print(f"np.dot(a_reshaped, b) 结果的形状: {result_dot_product.shape}")

输出:

重塑后的 a 的形状: (3, 1)
np.dot(a_reshaped, b) 的结果:
[[1]
 [2]
 [3]]
np.dot(a_reshaped, b) 结果的形状: (3, 1)

这正是你所期望的结果。

关于 np.matmul() 和 @ 运算符：np.matmul() 和 @ 运算符是Python 3.5+中引入的，专门用于矩阵乘法。它们与 np.dot() 在处理一维数组和高维数组时略有不同，但对于二维矩阵，它们的行为是相同的。

# 使用 np.matmul()
result_matmul = np.matmul(a_reshaped, b)
print(f"np.matmul(a_reshaped, b) 的结果:\n{result_matmul}")

# 使用 @ 运算符
result_at_operator = a_reshaped @ b
print(f"a_reshaped @ b 的结果:\n{result_at_operator}")

输出将与 np.dot() 的结果相同。

4. 关键差异与选择指南

• *`` 运算符 (元素级乘法)**：

  • 执行逐元素的乘法。
  • 遵循NumPy的广播规则。
  • 适用于希望对两个数组的对应元素进行操作的场景（例如，图像处理中的像素点亮度调整，或两个数据集对应特征的乘积）。
  • 不适用于线性代数中的矩阵乘法或点积。

• np.dot() / np.matmul() / @ 运算符 (点积/矩阵乘法)：

  • 执行线性代数中的点积或矩阵乘法。
  • 要求参与运算的数组维度兼容（例如，第一个数组的列数必须等于第二个数组的行数）。
  • 适用于需要进行矩阵运算的场景（例如，神经网络中的权重更新，线性回归中的特征变换）。
  • np.matmul() 和 @ 运算符在处理高维数组（N-D arrays）时，会将最后两个维度视为矩阵，并对它们执行矩阵乘法，而 np.dot() 行为更通用，可以用于标量点积、向量点积、矩阵乘法等。对于二维数组，三者行为一致。

特殊情况警示： 在某些非常特定的情况下（如本例中 a_reshaped 是 (3,1) 而 b 是 (1,1)），即使使用 a_reshaped * b 进行元素级乘法，结果也可能与 np.dot(a_reshaped, b) 相同。这是因为 b 是一个单元素矩阵，广播后会将 b 扩展为 [[1],[1],[1]]，然后进行元素级乘法，碰巧与点积结果一致。

# 在重塑 a 之后，尝试元素级乘法
a_reshaped = np.array([1, 2, 3]).reshape(3, 1)
b = np.array([[1]])

# 此时 a_reshaped 的形状是 (3, 1)，b 的形状是 (1, 1)
# 广播规则会把 b 扩展成 (3, 1) 的 [[1],[1],[1]]
result_coincident = a_reshaped * b
print(f"a_reshaped * b (巧合) 的结果:\n{result_coincident}")

输出:

a_reshaped * b (巧合) 的结果:
[[1]
 [2]
 [3]]

然而，强烈建议不要依赖这种巧合！ 如果你意图进行点积或矩阵乘法，请始终使用 np.dot()、np.matmul() 或 @ 运算符，以保证代码的清晰性、正确性和可维护性，避免因数组形状稍有变化而导致意外结果。

总结与最佳实践

理解NumPy中 * 运算符和 np.dot()/np.matmul() 函数之间的区别是高效使用NumPy的关键。

• 当你需要逐元素操作时，使用 * 运算符。
• 当你需要执行线性代数中的点积或矩阵乘法时，使用 np.dot()、np.matmul() 或 @ 运算符。
• 始终关注数组的形状。使用 .shape 属性检查数组的维度，并在必要时使用 .reshape()、.T (转置) 或 np.newaxis 来调整数组以满足运算要求。
• 避免依赖元素级乘法在特定情况下可能与点积产生相同结果的巧合，这会使代码难以理解和维护。

通过遵循这些原则，你可以更准确、更有效地利用NumPy进行复杂的数值计算。

以上就是NumPy多维数组乘法深度解析：理解元素级与点积运算的详细内容，更多请关注php中文网其它相关文章！