Numpy中数组的广播机制总结

逃离我推掉我的手 2022-12-27 14:20 262阅读 0赞

Numpy中的对于数组间的算术运算采用“元素一 一对应”的计算机制,因而一般要求两个数组的形状相同才能进行数组间的算术运算,但是在某些情况中，Numpy中允许符合一定规则的不同形状的数组进行算术运算。广播的核心规则如下:

*  两数组的后缘维度轴长度相同(满足低维数组和高维数组的某一内层元素形状相同，低维数组才能被拓展成和高维数组一样的形状)
 *  两数组的后缘维度中有任意个长度是1或缺失
 *  输出数组的形状是输入数组形状的各个维度上的最大值

上面的规则可能看起来比较难懂，简单来说就是低维数组要想被拓展成和高维数组一样的形状，从后往前比较时两数组时，低维数组的所有维度要么等于高维数组的对应维度，要么该维度大小值为1或缺失,数组广播将会在维度为1或缺失的维度方向上进行。举例说明如下:

下面是一些广播的例子:

举例1：

In:

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

Out:

\[ 3  6  9 12\]

标量和数组的乘积运算即是数组广播的最简单的一个例子,上诉过程中标量b被“虚拟”地扩展为数组\[3,3,3,3\]然后才和数组a\[1,2,3,4\]进行乘法运算，以满足Numpy中两数组间“元素一 一对应”的运算规则。

举例2:

In:

a = np.array([[1,2,3,4],
                  [5,6,7,8],
                  [9,10,11,12],
                  [13,14,15,16]])
    
    b = np.array([1,2,3,4])
    print(a.shape)
    print(b.shape)
    print(a+b)
    print((a+b).shape)

Out:  
a.shape:  (4, 4)  
b.shape:  (4,)  
运算结果为:  
 \[\[ 2  4  6  8\]  
 \[ 6  8 10 12\]  
 \[10 12 14 16\]  
 \[14 16 18 20\]\]  
(a+b).shape:  (4, 4)

上诉一维数组和二维数组的加法运算中，b数组其实和a数组在第0维上的一个内层元素形状相同，因而b数组可以被"虚拟"地拓展为一个4x4的二维数组，相当于被"纵向拉长了"，然后再和a数组进行加法运算。

更多例子:  
In：

a = np.ones((3,4,2))
    b = np.ones((4,2))
    
    print("a:\n",a)
    print("b:\n",b)
    print("a.shape: ",a.shape)
    print('b.shape: ',b.shape)
    print("a+b\n",a+b)
    print("(a+b).shape: ",(a+b).shape)

Out:

a:  
 \[\[\[1. 1.\]  
  \[1. 1.\]  
  \[1. 1.\]  
  \[1. 1.\]\]

\[\[1. 1.\]  
  \[1. 1.\]  
  \[1. 1.\]  
  \[1. 1.\]\]

\[\[1. 1.\]  
  \[1. 1.\]  
  \[1. 1.\]  
  \[1. 1.\]\]\]  
b:  
 \[\[1. 1.\]  
 \[1. 1.\]  
 \[1. 1.\]  
 \[1. 1.\]\]  
a.shape:  (3, 4, 2)  
b.shape:  (4, 2)  
a+b  
 \[\[\[2. 2.\]  
  \[2. 2.\]  
  \[2. 2.\]  
  \[2. 2.\]\]

\[\[2. 2.\]  
  \[2. 2.\]  
  \[2. 2.\]  
  \[2. 2.\]\]

\[\[2. 2.\]  
  \[2. 2.\]  
  \[2. 2.\]  
  \[2. 2.\]\]\]  
(a+b).shape:  (3, 4, 2)

上诉例子中，数组b(4,2)实际上是数组a(3,4,2)中的一个第0维度上的一个元素,满足"两数组的后缘维度轴长度相同(满足低维数组和高维数组的某一内层元素形状相同，低维数组才能被拓展成和高维数组一样的形状)"规则，因而b数组能被“虚拟”地拓展成为(3,4,2)的形状，完成和数组a的加法运算。

In:

a = np.ones((3,2,1,4,2))
    b = np.ones((1,3,4,1))
    
    print("a.shape: ",a.shape)
    print('b.shape: ',b.shape)
    print("(a+b).shape: ",(a+b).shape)

Out:

a.shape:  (3, 2, 1, 4, 2)  
b.shape:  (1, 3, 4, 1)  
(a+b).shape:  (3, 2, 3, 4, 2)

上述例子中，从后往前依次比较a、b数组的维度发现，要么对应相等，要么为1,满足广播的条件因而能进行算术运算。结果数组的各维度取决于输入数组的各维度的最大值。

不满足广播规则的一些例子:

In:

a = np.ones((2,3,4))
    b = np.ones((4,4))
    
    print(a)
    print(b)
    print("a.shape: ",a.shape)
    print('b.shape: ',b.shape)
    print("(a+b).shape: ",(a+b).shape)

Out:

\[\[\[1. 1. 1. 1.\]  
  \[1. 1. 1. 1.\]  
  \[1. 1. 1. 1.\]\]

\[\[1. 1. 1. 1.\]  
  \[1. 1. 1. 1.\]  
  \[1. 1. 1. 1.\]\]\]

\[\[1. 1. 1. 1.\]  
 \[1. 1. 1. 1.\]  
 \[1. 1. 1. 1.\]  
 \[1. 1. 1. 1.\]\]  
a.shape:  (2, 3, 4)  
b.shape:  (4, 4)

Traceback (most recent call last):  
ValueError: operands could not be broadcast together with shapes (2,3,4) (4,4)

上述例子中，b数组的形状为(4,4)不是a数组的任意维度上的一个元素，且从后往前比较时，对应维度大小不同且不等于1，因而不符合广播规则,不能进行广播后完成运算。

**总结：**Numpy中数组的广播规则其实就是一句话，要么低维数组和高维数组的某一内层元素形状相同，要么从后往前依次比较两数组的维度时，维度大小对应相等或为1。