广播#

参见

numpy.broadcast

术语 broadcasting 描述了 NumPy 在算术运算期间如何处理具有不同形状的数组. 在某些约束条件下,较小的数组会在较大的数组上"广播",以便它们具有兼容的形状. Broadcasting 提供了一种向量化数组运算的方法,从而使循环发生在 C 而不是 Python 中. 这样做不会不必要地复制数据,并且通常可以实现高效的算法实现. 但是,在某些情况下,广播不是一个好主意,因为它会导致内存使用效率低下,从而减慢计算速度.

NumPy 的运算通常以逐个元素为基础,在数组对上进行.在最简单的情况下,两个数组必须具有完全相同的形状,如下例所示:

>>> import numpy as np
>>> a = np.array([1.0, 2.0, 3.0])
>>> b = np.array([2.0, 2.0, 2.0])
>>> a * b
array([2.,  4.,  6.])

当数组的形状满足某些约束时,NumPy 的广播规则放宽了此约束.最简单的广播示例是当一个数组和一个标量值在一个运算中组合时:

>>> import numpy as np
>>> a = np.array([1.0, 2.0, 3.0])
>>> b = 2.0
>>> a * b
array([2.,  4.,  6.])

结果等同于前面的示例,其中 b 是一个数组.我们可以认为标量 b 在算术运算期间被拉伸成与 a 具有相同形状的数组. b 中的新元素(如 图 1 所示)只是原始标量的副本.拉伸类比只是概念性的. NumPy 足够智能,可以使用原始标量值,而无需实际复制,从而使广播运算尽可能地节省内存和计算.

标量被广播以匹配它所乘的 1-d 数组的形状.

图 1#

在最简单的广播示例中,标量 b 被拉伸以成为与 a 相同形状的数组,因此形状与逐个元素相乘兼容.

第二个示例中的代码比第一个示例中的代码更有效,因为广播在乘法期间移动的内存更少( b 是标量而不是数组).

通用广播规则#

在对两个数组进行运算时,NumPy 会逐个元素地比较它们的形状.它从尾随(即最右边)维度开始,然后向左进行.当以下情况时,两个维度兼容:

  1. 它们相等,或者

  2. 其中一个是 1.

如果未满足这些条件,则会引发 ValueError: operands could not be broadcast together 异常,表明数组具有不兼容的形状.

输入数组不需要具有相同的维度数.结果数组将具有与具有最大维度数的输入数组相同的维度数,其中每个维度的大小是输入数组中相应维度的最大大小.请注意,缺少的维度假定大小为 1.

例如,如果您有一个 256x256x3 的 RGB 值数组,并且您想按不同的值缩放图像中的每种颜色,您可以将图像乘以一个具有 3 个值的一维数组.根据广播规则对齐这些数组的尾轴大小,表明它们是兼容的:

Image  (3d array): 256 x 256 x 3
Scale  (1d array):             3
Result (3d array): 256 x 256 x 3

当比较的维度之一为一时,将使用另一个维度.换句话说,大小为 1 的维度会被拉伸或"复制"以匹配另一个维度.

在以下示例中, A 和 B 数组都具有长度为 1 的轴,这些轴在广播操作期间扩展为更大的尺寸:

A      (4d array):  8 x 1 x 6 x 1
B      (3d array):      7 x 1 x 5
Result (4d array):  8 x 7 x 6 x 5

可广播数组#

如果上述规则产生有效结果,则一组数组被称为"可广播"到相同的形状.

例如,如果 a.shape 是 (5,1), b.shape 是 (1,6), c.shape 是 (6,) 且 d.shape 是 () 使得 d 是标量,则 a,b,c 和 d 都可以广播到维度 (5,6);并且

  • a 的行为类似于 (5,6) 数组,其中 a[:,0] 广播到其他列,

  • b 的行为类似于 (5,6) 数组,其中 b[0,:] 广播到其他行,

  • c 的行为类似于 (1,6) 数组,因此像 (5,6) 数组一样,其中 c[:] 广播到每一行,最后,

  • d 的行为类似于 (5,6) 数组,其中单个值被重复.

以下是一些更多示例:

A      (2d array):  5 x 4
B      (1d array):      1
Result (2d array):  5 x 4

A      (2d array):  5 x 4
B      (1d array):      4
Result (2d array):  5 x 4

A      (3d array):  15 x 3 x 5
B      (3d array):  15 x 1 x 5
Result (3d array):  15 x 3 x 5

A      (3d array):  15 x 3 x 5
B      (2d array):       3 x 5
Result (3d array):  15 x 3 x 5

A      (3d array):  15 x 3 x 5
B      (2d array):       3 x 1
Result (3d array):  15 x 3 x 5

以下是一些不广播的形状示例:

A      (1d array):  3
B      (1d array):  4 # trailing dimensions do not match

A      (2d array):      2 x 1
B      (3d array):  8 x 4 x 3 # second from last dimensions mismatched

当将 1-d 数组添加到 2-d 数组时进行广播的示例:

>>> import numpy as np
>>> a = np.array([[ 0.0,  0.0,  0.0],
...               [10.0, 10.0, 10.0],
...               [20.0, 20.0, 20.0],
...               [30.0, 30.0, 30.0]])
>>> b = np.array([1.0, 2.0, 3.0])
>>> a + b
array([[  1.,   2.,   3.],
        [11.,  12.,  13.],
        [21.,  22.,  23.],
        [31.,  32.,  33.]])
>>> b = np.array([1.0, 2.0, 3.0, 4.0])
>>> a + b
Traceback (most recent call last):
ValueError: operands could not be broadcast together with shapes (4,3) (4,)

如 图 2 所示, b 被添加到 a 的每一行.在 图 3 中,由于形状不兼容,引发了一个异常.

形状为 (3) 的 1-d 数组被拉伸以匹配 它所添加到的形状为 (4, 3) 的 2-d 数组,结果是形状为 (4, 3) 的 2-d 数组.

图 2#

如果一维数组元素的数量与二维数组的列数匹配,则添加到二维数组的一维数组会导致广播.

形状为 (4, 3) 的二维数组和形状为 (4) 的一维数组上的巨大交叉线表明它们由于形状不匹配而无法广播,因此不会产生任何结果.

图 3#

当数组的尾部维度不相等时,广播会失败,因为不可能将第一个数组的行中的值与第二个数组的元素对齐以进行逐元素加法.

广播提供了一种方便的方法来获取两个数组的外积(或任何其他外部操作).以下示例展示了两个一维数组的外部加法运算:

>>> import numpy as np
>>> a = np.array([0.0, 10.0, 20.0, 30.0])
>>> b = np.array([1.0, 2.0, 3.0])
>>> a[:, np.newaxis] + b
array([[ 1.,   2.,   3.],
       [11.,  12.,  13.],
       [21.,  22.,  23.],
       [31.,  32.,  33.]])
一个形状为 (4, 1) 的二维数组和一个形状为 (3) 的一维数组被 拉伸以匹配它们的形状,并产生一个形状为 (4, 3) 的结果数组.

图 4#

在某些情况下,广播会拉伸两个数组,从而形成一个比任何一个初始数组都大的输出数组.

这里, newaxis 索引运算符在 a 中插入一个新轴,使其成为一个二维的 4x1 数组.将 4x1 数组与形状为 (3,) 的 b 组合,产生一个 4x3 数组.

一个实际的例子:矢量量化#

广播在实际问题中经常出现.一个典型的例子发生在信息论,分类和其他相关领域中使用的矢量量化 (VQ) 算法中.VQ 中的基本操作是在一组点(在 VQ 术语中称为 codes )中找到最接近给定点(称为 observation )的点.在下面显示的非常简单的二维情况下, observation 中的值描述了要分类的运动员的体重和身高. codes 代表不同类型的运动员. [1] 找到最近的点需要计算 observation 和每个代码之间的距离.最短的距离提供最佳匹配.在此示例中, codes[0] 是最接近的类别,表明该运动员很可能是篮球运动员.

>>> from numpy import array, argmin, sqrt, sum
>>> observation = array([111.0, 188.0])
>>> codes = array([[102.0, 203.0],
...                [132.0, 193.0],
...                [45.0, 155.0],
...                [57.0, 173.0]])
>>> diff = codes - observation    # the broadcast happens here
>>> dist = sqrt(sum(diff**2,axis=-1))
>>> argmin(dist)
0

在这个例子中, observation 数组被拉伸以匹配 codes 数组的形状:

Observation      (1d array):      2
Codes            (2d array):  4 x 2
Diff             (2d array):  4 x 2
一个身高与体重的图表,显示了一个女性 体操运动员,马拉松运动员,篮球运动员,橄榄球 截锋和待分类的运动员的数据.最短距离 是在篮球运动员和待分类运动员之间发现的.

图 5#

矢量量化的基本操作是计算待分类对象(深色方块)和多个已知代码(灰色圆圈)之间的距离.在这种简单的情况下,代码代表单个类别.更复杂的情况是每个类别使用多个代码.

通常,大量的 observations (可能从数据库中读取)与一组 codes 进行比较.考虑以下场景:

Observation      (2d array):      10 x 3
Codes            (3d array):   5 x 1 x 3
Diff             (3d array):  5 x 10 x 3

三维数组 diff 是广播的结果,而不是计算的必要条件.大型数据集将生成一个大型中间数组,这在计算上效率低下.相反,如果使用 Python 循环围绕上面二维示例中的代码单独计算每个观察值,则会使用一个更小的数组.

广播是一种强大的工具,用于编写简短且通常直观的代码,这些代码可以在 C 中非常有效地进行计算.但是,在某些情况下,广播会为一个特定的算法使用不必要的大量内存.在这些情况下,最好在 Python 中编写算法的外部循环.这也可能会生成更易于阅读的代码,因为使用广播的算法往往会随着广播中维度的增加而变得更难以解释.

脚注

On this page