np.将 ND 张量/数组与一维数组连接起来

我有两个数组a和b

a.shape
(5, 4, 3)
array([[[ 0.        ,  0.        ,  0.        ],
        [ 0.        ,  0.        ,  0.        ],
        [ 0.        ,  0.        ,  0.        ],
        [ 0.10772717,  0.604584  ,  0.41664413]],

       [[ 0.        ,  0.        ,  0.        ],
        [ 0.        ,  0.        ,  0.        ],
        [ 0.10772717,  0.604584  ,  0.41664413],
        [ 0.95879616,  0.85575133,  0.46135877]],

       [[ 0.        ,  0.        ,  0.        ],
        [ 0.10772717,  0.604584  ,  0.41664413],
        [ 0.95879616,  0.85575133,  0.46135877],
        [ 0.70442301,  0.74126523,  0.88965603]],

       [[ 0.10772717,  0.604584  ,  0.41664413],
        [ 0.95879616,  0.85575133,  0.46135877],
        [ 0.70442301,  0.74126523,  0.88965603],
        [ 0.8039435 ,  0.62802183,  0.58885027]],

       [[ 0.95879616,  0.85575133,  0.46135877],
        [ 0.70442301,  0.74126523,  0.88965603],
        [ 0.8039435 ,  0.62802183,  0.58885027],
        [ 0.95848603,  0.72429311,  0.71461332]]])

and b

array([ 0.79212707,  0.66629398,  0.58676553], dtype=float32)
b.shape
(3,)

我想获取数组

ab.shape
(5,5,3)

我做如下 第一的

b = b.reshape(1,1,3)

then

b=np.concatenate((b, b,b, b, b), axis = 0)

And

ab=np.concatenate((a, b), axis = 1)
ab.shape
(5, 5, 3)

我得到了正确的结果，但不是很方便，尤其是在步骤上

b=np.concatenate((b, b,b, b, b), axis = 0)

当我必须多次输入时（真实数据集有很多维度）。有没有更快的方法可以得到这个结果？

简单的广播b to 3D然后沿着第二个轴连接 -

b3D = np.broadcast_to(b,(a.shape[0],1,len(b)))
out = np.concatenate((a,b3D),axis=1)

The broadcasting与np.broadcast_to并不实际复制或制作副本，而只是一个复制视图，然后在下一步中，我们进行串联以即时进行复制。

标杆管理

我们正在比较np.repeat来自 @cᴏʟᴅsᴘᴇᴇᴅ 解决方案的版本反对np.broadcast_to一 本节重点关注性能。基于广播的在第二步中进行复制和串联，作为合并命令可以这么说，同时np.repeatversion 进行复制，然后在两个单独的步骤中连接。

整个方法的计时：

情况1 ：a = (500,400,300) and b = (300,)

In [321]: a = np.random.rand(500,400,300)

In [322]: b = np.random.rand(300)

In [323]: %%timeit
     ...: b3D = b.reshape(1, 1, -1).repeat(a.shape[0], axis=0)
     ...: r = np.concatenate((a, b3D), axis=1)
10 loops, best of 3: 72.1 ms per loop

In [325]: %%timeit
     ...: b3D = np.broadcast_to(b,(a.shape[0],1,len(b)))
     ...: out = np.concatenate((a,b3D),axis=1)
10 loops, best of 3: 72.5 ms per loop

对于较小的输入形状，请致电np.broadcast_to需要的时间比np.repeat鉴于设置广播所需的工作显然更加复杂，如下所示：

In [360]: a = np.random.rand(5,4,3)

In [361]: b = np.random.rand(3)

In [366]: %timeit np.broadcast_to(b,(a.shape[0],1,len(b)))
100000 loops, best of 3: 3.12 µs per loop

In [367]: %timeit b.reshape(1, 1, -1).repeat(a.shape[0], axis=0)
1000000 loops, best of 3: 957 ns per loop

但是，无论输入的形状如何，广播部分都将具有恒定的时间，即这3 u-sec部分将停留在该标记附近。对方的时间安排：b.reshape(1, 1, -1).repeat(a.shape[0], axis=0)取决于输入形状。因此，让我们更深入地研究一下这两种方法的串联步骤如何公平/行为。

深层发掘

尝试深入挖掘以了解串联部分消耗了多少：

In [353]: a = np.random.rand(500,400,300)

In [354]: b = np.random.rand(300)

In [355]: b3D = np.broadcast_to(b,(a.shape[0],1,len(b)))

In [356]: %timeit np.concatenate((a,b3D),axis=1)
10 loops, best of 3: 72 ms per loop

In [357]: b3D = b.reshape(1, 1, -1).repeat(a.shape[0], axis=0)

In [358]: %timeit np.concatenate((a,b3D),axis=1)
10 loops, best of 3: 72 ms per loop

结论：看起来并没有太大不同。

现在，让我们尝试一个需要复制的情况b是一个更大的数字并且b元素数量也非常多。

In [344]: a = np.random.rand(10000, 10, 1000)

In [345]: b = np.random.rand(1000)

In [346]: b3D = np.broadcast_to(b,(a.shape[0],1,len(b)))

In [347]: %timeit np.concatenate((a,b3D),axis=1)
10 loops, best of 3: 130 ms per loop

In [348]: b3D = b.reshape(1, 1, -1).repeat(a.shape[0], axis=0)

In [349]: %timeit np.concatenate((a,b3D),axis=1)
10 loops, best of 3: 141 ms per loop

结论：看起来像是合并的连接+复制np.broadcast_to这里做得好一些。

我们来尝试一下原来的情况(5,4,3) shape :

In [360]: a = np.random.rand(5,4,3)

In [361]: b = np.random.rand(3)

In [362]: b3D = np.broadcast_to(b,(a.shape[0],1,len(b)))

In [363]: %timeit np.concatenate((a,b3D),axis=1)
1000000 loops, best of 3: 948 ns per loop

In [364]: b3D = b.reshape(1, 1, -1).repeat(a.shape[0], axis=0)

In [365]: %timeit np.concatenate((a,b3D),axis=1)
1000000 loops, best of 3: 950 ns per loop

结论：同样，没有太大不同。

所以，最终的结论是，如果里面有很多元素b如果第一个轴a也是一个很大的数字（因为复制数就是那个），np.broadcast_to将是一个不错的选择，否则np.repeat基于版本很好地处理了其他情况。