一维雷达的有效放网

Question

用data将fencepost重塑为numpy的最有效方法是什么？

data      = np.array([1, 2, 3, 4, 5])                                                             
fencepost = np.array([[1, 2], [2, 3], [3, 4], [4, 5]])

Answer 1

只要以不同的方式看待相同的数据，您就可以获得相同的结果：

>>> from numpy.lib.stride_tricks import as_strided
>>> fencepost = as_strided(data, shape=(data.shape[0]-1, 2),
                           strides=(data.strides[0],)*2)
>>> fencepost
array([[1, 2],
       [2, 3],
       [3, 4],
       [4, 5]])

没有数据被复制，所以，特别是对于非常大的数组，这将是最快的。如果您确实需要一个单独的副本，您只需执行fencepost = fencepost.copy()并让numpy在内部处理所有事情：

In [11]: data = np.arange(10000000)

In [12]: %timeit as_strided(data, shape=(data.shape[0]-1, 2),
...                         strides=(data.strides[0],)*2)
100000 loops, best of 3: 12.2 us per loop

In [13]: %timeit as_strided(data, shape=(data.shape[0]-1, 2),
...                         strides=(data.strides[0],)*2).copy()
10 loops, best of 3: 183 ms per loop

Answer 2

这并不是真正的重塑，因为第二个数组有不同数量的元素。如果第一个数组具有N个元素(在本例中为N=5)，则第二个数组具有2N-2 (在本例中为8)。

因此，您必须创建一个新的数组并相应地填充它。解决这一问题有两种方法。可以逐列或逐行填充。哪个更有效率取决于..。好吧，让我们看看！

在这里，我使用了三个不同数组大小的来自IPython的%timeit：

import numpy as np
from numba import jit

data      = np.array([1, 2, 3, 4, 5])                                                             
#fencepost = np.array([[1, 2], [2, 3], [3, 4], [4, 5]])

def fp1(data):
    f = np.zeros((data.shape[0]-1,2))

    for i in range(data.shape[0]-1):
        f[i] = data[i:i+2]

    return f

def fp2(data):
    f = np.zeros((data.shape[0]-1,2))

    f[:,0] = data[:-1]
    f[:,1] = data[1:]

    return f

%timeit fp1(data)
%timeit fp2(data)

data2 = np.array(range(100000))
%timeit fp1(data2)
%timeit fp2(data2)

data3 = np.array(range(10000000))
%timeit fp1(data3)
%timeit fp2(data3)

在我的计算机上，对小数组进行逐行处理的效率略高一些，但快速地逐列执行则要好得多(因此，fp2是有效的答案)：

100000 loops, best of 3: 13 µs per loop
100000 loops, best of 3: 14.4 µs per loop
1 loops, best of 3: 203 ms per loop
1000 loops, best of 3: 1.09 ms per loop
1 loops, best of 3: 20.7 s per loop
1 loops, best of 3: 253 ms per loop

本质上，fp2更快，因为它只有2个numpy操作，而fp1是一个循环，需要对numpy进行多次调用。对于小型数组，对numpy的5个调用的开销可以忽略不计。