python - 从一维数组构建高效的 Numpy 二维数组

Question

我有一个这样的数组:

A = array([1,2,3,4,5,6,7,8,9,10])

我正在尝试获取这样的数组:

B = array([[1,2,3],
          [2,3,4],
          [3,4,5],
          [4,5,6]])

每行(具有固定的任意宽度)移动一个。 A 的数组长 10k 条记录，我试图在 Numpy 中找到一种有效的方法。目前我正在使用 vstack 和一个很慢的 for 循环。有更快的方法吗？

编辑:

width = 3 # fixed arbitrary width
length = 10000 # length of A which I wish to use
B = A[0:length + 1]
for i in range (1, length):
    B = np.vstack((B, A[i, i + width + 1]))

Answer 1

实际上，有一种更有效的方法可以做到这一点...使用 vstack 等的缺点是您正在制作数组的副本。

顺便说一句，这实际上与@Paul 的答案相同，但我发布这个只是为了更详细地解释事情......

有一种方法可以只用 View 来做到这一点，这样没有内存被复制。

我是直接从 Erik Rigtorp's post to numpy-discussion 借来的，而后者又从 Keith Goodman 的 Bottleneck 那里借来了它。 (这非常有用!)。

基本技巧是直接操作strides of the array (对于一维数组):

import numpy as np

def rolling(a, window):
    shape = (a.size - window + 1, window)
    strides = (a.itemsize, a.itemsize)
    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)

a = np.arange(10)
print rolling(a, 3)

其中 a 是您的输入数组，而 window 是您想要的窗口长度(在您的情况下为 3)。

这会产生:

[[0 1 2]
 [1 2 3]
 [2 3 4]
 [3 4 5]
 [4 5 6]
 [5 6 7]
 [6 7 8]
 [7 8 9]]

但是，原始 a 和返回的数组之间绝对没有重复的内存。这意味着它比其他选项速度快并且可扩展性很多。

例如(使用 a = np.arange(100000) 和 window=3):

%timeit np.vstack([a[i:i-window] for i in xrange(window)]).T
1000 loops, best of 3: 256 us per loop

%timeit rolling(a, window)
100000 loops, best of 3: 12 us per loop

如果我们将其推广到沿 N 维数组的最后一个轴的“滚动窗口”，我们会得到 Erik Rigtorp 的“滚动窗口”函数:

import numpy as np

def rolling_window(a, window):
   """
   Make an ndarray with a rolling window of the last dimension

   Parameters
   ----------
   a : array_like
       Array to add rolling window to
   window : int
       Size of rolling window

   Returns
   -------
   Array that is a view of the original array with a added dimension
   of size w.

   Examples
   --------
   >>> x=np.arange(10).reshape((2,5))
   >>> rolling_window(x, 3)
   array([[[0, 1, 2], [1, 2, 3], [2, 3, 4]],
          [[5, 6, 7], [6, 7, 8], [7, 8, 9]]])

   Calculate rolling mean of last dimension:
   >>> np.mean(rolling_window(x, 3), -1)
   array([[ 1.,  2.,  3.],
          [ 6.,  7.,  8.]])

   """
   if window < 1:
       raise ValueError, "`window` must be at least 1."
   if window > a.shape[-1]:
       raise ValueError, "`window` is too long."
   shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
   strides = a.strides + (a.strides[-1],)
   return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)

那么，让我们看看这里发生了什么... 操作数组的strides 可能看起来有点神奇，但是一旦你了解了发生了什么，就完全没有了。 numpy 数组的步幅描述了沿给定轴递增一个值所必须采取的步骤的大小(以字节为单位)。所以，在 64 位 float 的一维数组的情况下，每一项的长度是 8 个字节，而 x.strides 是 (8,)。

x = np.arange(9)
print x.strides

现在，如果我们将其重新整形为 2D、3x3 数组，步幅将是 (3 * 8, 8)，因为我们必须跳过 24 个字节才能在第一步递增一个轴，8 个字节沿第二个轴递增一步。

y = x.reshape(3,3)
print y.strides

类似地，转置与反转数组的步幅相同:

print y
y.strides = y.strides[::-1]
print y

显然，数组的步长和数组的形状密切相关。如果我们改变一个，我们就必须相应地改变另一个，否则我们将无法对实际保存数组值的内存缓冲区进行有效描述。

因此，如果你想同时改变数组的形状和大小，你不能只通过设置x.strides和 x.shape，即使新的步幅和形状是兼容的。

这就是 numpy.lib.as_strided 的用武之地。它实际上是一个非常简单的函数，它只是同时设置数组的步幅和形状。

它会检查两者是否兼容，但不会检查旧步幅和新形状是否兼容，如果您独立设置两者，则会发生这种情况。 (它实际上是通过 numpy's __array_interface__ 实现的，它允许任意类将内存缓冲区描述为 numpy 数组。)

所以，我们所做的只是让一个项目沿一个轴前进(在 64 位数组的情况下为 8 个字节)，但 也仅沿另一个轴前进 8 个字节。

换句话说，如果“窗口”大小为 3，则数组的形状为 (whatever, 3)，而不是步进完整的 3 * x。 itemsize 对于第二个维度，它只前进一个项目，有效地使新数组的行成为原始数组的“移动窗口” View 。

(这也意味着 x.shape[0] * x.shape[1] 与新数组的 x.size 不同。)

无论如何，希望这能让事情变得更清楚..