如何理解外行人的坎坷步伐？

Posted 2021-04-26

我目前正在经历numpy，并且有一个名为“strides”的numpy主题。我明白它是什么。但它是如何工作的？我没有在网上找到任何有用的信息。任何人都可以让我以外行的方式理解吗？

答案

numpy数组的实际数据存储在称为数据缓冲区的同类且连续的内存块中。有关更多信息，请参阅NumPy internals。使用（默认）row-major顺序，2D数组如下所示：

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

例如：

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

这个2D数组有两个方向，axis-0（垂直向下跨行运行）和axis-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)  

这是另一个示例，显示2D数组的水平方向（轴-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]为4字节，而a[0, 0] -> a[0, 1]为4字节，a[0, 0] -> a[1, 0]为12字节。

最后但并非最不重要的是，NumPy允许创建现有数组的视图，可以选择修改步幅和形状，请参阅stride tricks。例如：

>>> 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

另一答案

只是为了给@AndyK添加一个很好的答案，我从Numpy MedKit那里学到了很多优点。他们在那里显示使用问题如下：

给定输入：

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]]])

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

shape - 沿每个轴的阵列尺寸。

strides - 必须跳过的内存字节数，以便沿某个维度进入下一个项目。

>>> 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个字节（每个4个字节的5个元素），每个元素占用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中使用它。

希望能帮助到你！