python - 使用 Numpy 在元组列表之间进行外部减法

Question

注意:我并不是在寻找有关如何使用np.subtract.outer的语法，而是试图解决我在执行过程中遇到的一个非常具体的问题其应用。

我有一个元组列表 -

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

我正在尝试在此列表(元组)的每个元素之间实现完整的矢量化减法。我可以使用 itertools 进行迭代来完成此操作，如下所示，期望 5x5x2 作为 -

#My attempt with iteration (producing expected results)

np.array([np.array(i[0])-np.array(i[1]) for i in itertools.product(a, a)]).reshape(5,5,2)

#RESULT (5x5x2) 
array([[[ 0,  0],
        [-1,  0],
        [-1, -1],
        [-2,  0],
        [-2, -2]],

       [[ 1,  0],
        [ 0,  0],
        [ 0, -1],
        [-1,  0],
        [-1, -2]],

       [[ 1,  1],
        [ 0,  1],
        [ 0,  0],
        [-1,  1],
        [-1, -1]],

       [[ 2,  0],
        [ 1,  0],
        [ 1, -1],
        [ 0,  0],
        [ 0, -2]],

       [[ 2,  2],
        [ 1,  2],
        [ 1,  1],
        [ 0,  2],
        [ 0,  0]]])

但是，当使用np.subtract.outer()时。我最终得到一个形状为 5x2x5x2 的数组，如下所示 -

#My attempt with vectorization (producing unexpected results)

np.subtract.outer(a,a) #5x2x5x2

array([[[[ 0,  0],  #This matrix is same as ....
         [-1,  0],
         [-1, -1],
         [-2,  0],
         [-2, -2]],

        [[ 0,  0],  #This one...
         [-1,  0],
         [-1, -1],
         [-2,  0],
         [-2, -2]]],


       [[[ 1,  1],   #However, this ...
         [ 0,  1],
         [ 0,  0],
         [-1,  1],
         [-1, -1]],

        [[ 0,  0],  #And this, dont repeat! ..
         [-1,  0],
         [-1, -1],
         [-2,  0],
         [-2, -2]]],


       [[[ 1,  1],   #This ...
         [ 0,  1],
         [ 0,  0],
         [-1,  1],
         [-1, -1]],

        [[ 1,  1],   #And this do..
         [ 0,  1],
         [ 0,  0],
         [-1,  1],
         [-1, -1]]],


       [[[ 2,  2],
         [ 1,  2],
         [ 1,  1],
         [ 0,  2],
         [ 0,  0]],

        [[ 0,  0],
         [-1,  0],
         [-1, -1],
         [-2,  0],
         [-2, -2]]],


       [[[ 2,  2],
         [ 1,  2],
         [ 1,  1],
         [ 0,  2],
         [ 0,  0]],

        [[ 2,  2],
         [ 1,  2],
         [ 1,  1],
         [ 0,  2],
         [ 0,  0]]]])

经过检查，我发现某些矩阵实际上重复了两次，而对于其他矩阵，输出中的情况并非如此(如上所述)。

我的问题是 -

1. 为什么会发生这种重复？
2. 如何在此示例中正确使用 np.subtract.outer？
3. (或者，)如何将矩阵转换为期望的矩阵？ (5x2x5x2) -> (5x5x2)

注意:这只是一个玩具示例。原始元组列表很大并且是 float32。

Answer 1

无需使用outer。只需使用广播:

In [5]: a[:,None,:]-a[None,:,:]
Out[5]: 
array([[[ 0,  0],
        [-1,  0],
        [-1, -1],
        [-2,  0],
        [-2, -2]],

       [[ 1,  0],
        [ 0,  0],
        [ 0, -1],
        [-1,  0],
        [-1, -2]],

       [[ 1,  1],
        [ 0,  1],
        [ 0,  0],
        [-1,  1],
        [-1, -1]],

       [[ 2,  0],
        [ 1,  0],
        [ 1, -1],
        [ 0,  0],
        [ 0, -2]],

       [[ 2,  2],
        [ 1,  2],
        [ 1,  1],
        [ 0,  2],
        [ 0,  0]]])

a 是 (5,2)，使用 None 扩展，这 2 项是 (5,1,2) 和 (1,5,2)，它们一起组成(5,5,2)数组。

outer 可以通过以下方式使用:

np.subtract.outer(a,a)[:,np.arange(2),:,np.arange(2)].transpose(1,2,0)

从 (5,2,5,2) 中删除重复项并重新排序轴。但速度慢了 3 倍。