外行人怎样理解 numpy strides？

问题描述：

我目前正在研究 numpy，numpy 中有一个名为“strides”的主题。我明白它是什么。但它是如何工作的？我在网上找不到任何有用的信息。有人能用通俗易懂的语言让我理解吗？

解决方案 1：

numpy 数组的实际数据存储在称为数据缓冲区的同构且连续的内存块中。有关更多信息，请参阅NumPy 内部结构。使用（默认）行主序，二维数组如下所示：

为了将多维数组的索引 i、j、k、... 映射到数据缓冲区中的位置（偏移量，以字节为单位），NumPy 使用strides的概念。Strides 是内存中沿数组的每个方向/维度从一个项目跳到下一个项目所要跳过的字节数。换句话说，它是每个维度上连续项目之间的字节间隔。

例如：

>>> a = np.arange(1,10).reshape(3,3)
>>> a
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

这个二维数组有两个方向，轴 0（垂直向下跨行）和轴 1（水平跨列），每个项目的大小为：

>>> a.itemsize  # in bytes
4  

因此，要从a[0, 0] -> a[0, 1]（沿第 0 行水平移动，从第 0 列到第 1 列）开始，数据缓冲区中的字节步长为 4。对于 等也是一样。a[0, 1] -> a[0, 2]这a[1, 0] -> a[1, 1]意味着水平方向（轴 1）的步幅数为 4 个字节。

但是，要从 开始a[0, 0] -> a[1, 0]（沿第 0 列垂直移动，从第 0 行到第 1 行），您需要先遍历第 0 行上的所有剩余项以到达第 1 行，然后穿过第 1 行到达项a[1, 0]，即a[0, 0] -> a[0, 1] -> a[0, 2] -> a[1, 0]。因此，垂直方向（轴 0）的步幅数为 3*4 = 12 个字节。请注意，从 开始a[0, 2] -> a[1, 0]，并且通常从第 i 行的最后一项到第 (i+1) 行的第一项，也是 4 个字节，因为数组a是按行主序存储的。

这就是为什么

>>> a.strides  # (strides[0], strides[1])
(12, 4)  

下面是另一个示例，显示二维数组在水平方向（轴 1）上的步幅strides[1]不一定等于项目大小（例如，按列主序排列的数组）：

>>> b = np.array([[1, 4, 7],
                  [2, 5, 8],
                  [3, 6, 9]]).T
>>> b
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

>>> b.strides
(4, 12)

这strides[1]是项目大小的倍数。尽管数组b看起来与数组相同a，但它是不同的数组：内部b存储为|1|4|7|2|5|8|3|6|9|（因为转置不会影响数据缓冲区，只会交换步长和形状），而存储a为|1|2|3|4|5|6|7|8|9|。使它们看起来相似的是不同的步长。也就是说，的字节步长b[0, 0] -> b[0, 1]为 3*4=12 字节b[0, 0] -> b[1, 0]，而 为 为a[0, 0] -> a[0, 1]4 字节，而 为 为a[0, 0] -> a[1, 0]12 字节。

最后但同样重要的一点是，NumPy 允许创建现有数组的视图，并可以选择修改步幅和形状，请参阅步幅技巧。例如：

>>> np.lib.stride_tricks.as_strided(a, shape=a.shape[::-1], strides=a.strides[::-1])
array([[1, 4, 7],
       [2, 5, 8],
       [3, 6, 9]])

这相当于转置数组a。

让我补充一下，但不必太详细，甚至可以定义不是项目大小倍数的步幅。以下是示例：

>>> a = np.lib.stride_tricks.as_strided(np.array([1, 512, 0, 3], dtype=np.int16), 
                                        shape=(3,), strides=(3,))
>>> a
array([1, 2, 3], dtype=int16)

>>> a.strides[0]
3

>>> a.itemsize
2

解决方案 2：

为了补充@AndyK 的精彩回答，我从Numpy MedKit了解了 numpy strides 。他们在那里展示了问题的用法，如下所示：

给定输入：

x = np.arange(20).reshape([4, 5])
>>> x
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

预期产出：

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

       [[  5,  6,  7,  8,  9],
        [ 10, 11, 12, 13, 14]],

       [[ 10, 11, 12, 13, 14],
        [ 15, 16, 17, 18, 19]]])

为此，我们需要了解以下术语：

形状- 数组沿每个轴的尺寸。

步幅- 沿某个维度前进到下一个项目必须跳过的内存字节数。

>>> x.strides
(20, 4)

>>> np.int32().itemsize
4

现在，如果我们看一下预期输出：

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

       [[  5,  6,  7,  8,  9],
        [ 10, 11, 12, 13, 14]],

       [[ 10, 11, 12, 13, 14],
        [ 15, 16, 17, 18, 19]]])

我们需要操纵数组形状和步幅。输出形状必须是 (3, 2, 5)，即 3 个项目，每个项目包含两行 (m == 2)，每行有 5 个元素。

步幅需要从 (20, 4) 更改为 (20, 20, 4)。新输出数组中的每个项目都从新行开始，每行由 20 个字节组成（5 个元素，每个元素 4 个字节），每个元素占用 4 个字节（int32）。

所以：

>>> from numpy.lib import stride_tricks
>>> stride_tricks.as_strided(x, shape=(3, 2, 5),
                                strides=(20, 20, 4))
...
array([[[  0,  1,  2,  3,  4],
        [  5,  6,  7,  8,  9]],

       [[  5,  6,  7,  8,  9],
        [ 10, 11, 12, 13, 14]],

       [[ 10, 11, 12, 13, 14],
        [ 15, 16, 17, 18, 19]]])

另一种方法是：

>>> d = dict(x.__array_interface__)
>>> d['shape'] = (3, 2, 5)
>>> s['strides'] = (20, 20, 4)

>>> class Arr:
...     __array_interface__ = d
...     base = x

>>> np.array(Arr())
array([[[  0,  1,  2,  3,  4],
        [  5,  6,  7,  8,  9]],

       [[  5,  6,  7,  8,  9],
        [ 10, 11, 12, 13, 14]],

       [[ 10, 11, 12, 13, 14],
        [ 15, 16, 17, 18, 19]]])

我经常使用此方法代替numpy.hstack或numpy.vstack，相信我，计算速度更快。

笔记：

当使用此技巧使用非常大的数组时，计算精确的步幅并不那么简单。我通常会创建一个numpy.zeroes所需形状的数组，然后使用来获取步幅array.strides，并在函数中使用它stride_tricks.as_strided。

希望有帮助！

解决方案 3：

我改编了 @Rick M. 提供的工作，以解决我的问题，即移动任意形状的 numpy 数组的窗口切片。代码如下：

def sliding_window_slicing(a, no_items, item_type=0):
    """This method perfoms sliding window slicing of numpy arrays

    Parameters
    ----------
    a : numpy
        An array to be slided in subarrays
    no_items : int
        Number of sliced arrays or elements in sliced arrays
    item_type: int
        Indicates if no_items is number of sliced arrays (item_type=0) or
        number of elements in sliced array (item_type=1), by default 0

    Return
    ------
    numpy
        Sliced numpy array
    """
    if item_type == 0:
        no_slices = no_items
        no_elements = len(a) + 1 - no_slices
        if no_elements <=0:
            raise ValueError('Sliding slicing not possible, no_items is larger than ' + str(len(a)))
    else:
        no_elements = no_items                
        no_slices = len(a) - no_elements + 1
        if no_slices <=0:
            raise ValueError('Sliding slicing not possible, no_items is larger than ' + str(len(a)))

    subarray_shape = a.shape[1:]
    shape_cfg = (no_slices, no_elements) + subarray_shape
    strides_cfg = (a.strides[0],) + a.strides
    as_strided = np.lib.stride_tricks.as_strided #shorthand
    return as_strided(a, shape=shape_cfg, strides=strides_cfg)

此方法自动计算步幅，并适用于任意维度的numpy数组：

一维数组 - 通过多个切片进行切片

In [11]: a                                                                                                                                                     
Out[11]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [12]: sliding_window_slicing(a, 5, item_type=0)                                                                                                                          
Out[12]: 
array([[0, 1, 2, 3, 4, 5],
       [1, 2, 3, 4, 5, 6],
       [2, 3, 4, 5, 6, 7],
       [3, 4, 5, 6, 7, 8],
       [4, 5, 6, 7, 8, 9]])

一维数组 - 通过每个切片的元素数量进行切片

In [13]: sliding_window_slicing(a, 5, item_type=1)                                                                                                             
Out[13]: 
array([[0, 1, 2, 3, 4],
       [1, 2, 3, 4, 5],
       [2, 3, 4, 5, 6],
       [3, 4, 5, 6, 7],
       [4, 5, 6, 7, 8],
       [5, 6, 7, 8, 9]])

二维数组 - 通过多个切片进行切片

In [16]: a = np.arange(10).reshape([5,2])                                                                                                                      

In [17]: a                                                                                                                                                     
Out[17]: 
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])

In [18]: sliding_window_slicing(a, 2, item_type=0)                                                                                                             
Out[18]: 
array([[[0, 1],
        [2, 3],
        [4, 5],
        [6, 7]],

       [[2, 3],
        [4, 5],
        [6, 7],
        [8, 9]]])

二维数组 - 通过每个切片中的元素数量进行切片

In [19]: sliding_window_slicing(a, 2, item_type=1)                                                                                                             
Out[19]: 
array([[[0, 1],
        [2, 3]],

       [[2, 3],
        [4, 5]],

       [[4, 5],
        [6, 7]],

       [[6, 7],
        [8, 9]]])