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的循环。对于小型数组，5次调用numpy的开销可以忽略不计。

1D nararray的高效fenceposting

2 个答案: