Python 如何正确使用numpy作为跨步（来自np.stride技巧）？

我正在尝试使用

numpy.stripped\u技巧

重塑numpy数组。这是我遵循的指南：

我的用例非常相似，不同之处在于我需要3的步幅

鉴于此阵列：

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

我想得到：

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

以下是我尝试过的：

import numpy as np

as_strided = np.lib.stride_tricks.as_strided
a = np.arange(1, 10)

as_strided(a, (len(a) - 2, 3), (3, 3))

array([[                 1,      2199023255552,             131072],
       [     2199023255552,             131072, 216172782113783808],
       [            131072, 216172782113783808,        12884901888],
       [216172782113783808,        12884901888,                768],
       [       12884901888,                768,   1125899906842624],
       [               768,   1125899906842624,           67108864],
       [  1125899906842624,           67108864,                  4]])

---

我很确定我已经效仿了T，但显然不是。我哪里做错了？

我不知道为什么你认为你需要3的步幅。您需要在

a

的一个元素和下一个元素之间以字节为单位的距离进行跨步，您可以使用

a.strips

：

as_strided(a, (len(a) - 2, 3), a.strides*2)

公认的答案（和讨论）是好的，但为了不想运行自己的测试用例的读者的利益，我将尝试说明发生了什么：

In [374]: a = np.arange(1,10)
In [375]: as_strided = np.lib.stride_tricks.as_strided

In [376]: a.shape
Out[376]: (9,)
In [377]: a.strides 
Out[377]: (4,)

对于连续的1d数组，

strips

是元素的大小，这里是4个字节，一个int32。要从一个元素转到下一个元素，它向前移动4个字节

OP尝试了什么：

In [380]: as_strided(a, shape=(7,3), strides=(3,3))
Out[380]: 
array([[        1,       512,    196608],
       [      512,    196608,  67108864],
       [   196608,  67108864,         4],
       [ 67108864,         4,      1280],
       [        4,      1280,    393216],
       [     1280,    393216, 117440512],
       [   393216, 117440512,         7]])

这是一个3字节的步进，跨越int32边界，并给出了大部分无法理解的数字。如果数据类型是bytes或uint8，则If可能更有意义

我们使用

a.strips*2

（元组复制）或

（4,4）

得到所需的数组：

In [381]: as_strided(a, shape=(7,3), strides=(4,4))
Out[381]: 
array([[1, 2, 3],
       [2, 3, 4],
       [3, 4, 5],
       [4, 5, 6],
       [5, 6, 7],
       [6, 7, 8],
       [7, 8, 9]])

列和行都是一步一个元素，导致一步移动窗口。我们还可以设置

shape=（3,7）

，3个windows7元素长

In [382]: _.strides
Out[382]: (4, 4)

将每个窗口的步幅更改为（8,4）步2个元素

In [383]: as_strided(a, shape=(7,3), strides=(8,4))
Out[383]: 
array([[          1,           2,           3],
       [          3,           4,           5],
       [          5,           6,           7],
       [          7,           8,           9],
       [          9,          25, -1316948568],
       [-1316948568,   184787224, -1420192452],
       [-1420192452,           0,           0]])

但是形状是关闭的，显示原始数据缓冲区末尾的字节。这可能很危险（我们不知道这些字节是否属于其他对象或数组）。使用这种大小的阵列，我们无法获得完整的两步窗口集

现在，为每一行（3*4,4）添加3个元素：

这与3x3重塑的形状和步幅相同

我们可以设置负步幅值和0值。事实上，沿具有正步长的维度进行负步长切片将产生负步长，而广播通过设置0步长工作：

In [399]: np.broadcast_to(a, (2,9))
Out[399]: 
array([[1, 2, 3, 4, 5, 6, 7, 8, 9],
       [1, 2, 3, 4, 5, 6, 7, 8, 9]])
In [400]: _.strides
Out[400]: (0, 4)

In [401]: a.reshape(3,3)[::-1,:]
Out[401]: 
array([[7, 8, 9],
       [4, 5, 6],
       [1, 2, 3]])
In [402]: _.strides
Out[402]: (-12, 4)

---

但是，负步长需要调整原始数组中的哪个元素是视图的第一个元素，而

as_stride

没有用于此的参数。

我尝试执行类似的操作，但遇到了相同的问题

在您的案例中，如本文所述，问题是：

当存储在内存中时，您没有考虑元素的大小（int32=4，可以使用.dtype.itemsize进行检查）

您没有适当地指定必须跳过的跨步数，在您的示例中也是4，因为您只跳过了一个元素

在此基础上，我为自己创建了一个函数，在该函数中，我使用n个元素的窗口计算给定数组的分段，并指定要重叠的元素数（由窗口-元素数到跳过）

我在这里分享它，以防其他人需要它，因为我花了一段时间才弄清楚stride_技巧是如何工作的：

def window_signal(signal, window, overlap):
    """ 
    Windowing function for data segmentation.

    Parameters:
    ------------
    signal: ndarray
            The signal to segment.
    window: int
            Window length, in samples.
    overlap: int
             Number of samples to overlap

    Returns: 
    --------
    nd-array 
            A copy of the signal array with shape (rows, window),
            where row = (N-window)//(window-overlap) + 1
    """
    N = signal.reshape(-1).shape[0] 
    if (window == overlap):
        rows = N//window
        overlap = 0
    else:
        rows = (N-window)//(window-overlap) + 1
        miss = (N-window)%(window-overlap)
        if(miss != 0):
            print('Windowing led to the loss of ', miss, ' samples.')
    item_size = signal.dtype.itemsize 
    strides = (window - overlap) * item_size
    return np.lib.stride_tricks.as_strided(signal, shape=(rows, window),
                                           strides=(strides, item_size))

根据您的代码，这种情况的解决方案是：

a，（len（a）-2,3，（4,4））

或者，使用功能窗口信号：

window\u信号（a、3、2）

两者都返回以下数组作为输出：

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

为什么你认为你需要3的步幅？@user2357112我不知道。。。根据给出的示例，我认为这就是我需要跨步的方式。看起来这个示例是对4字节整数的跨步进行硬编码，这不是一个好主意，因为在不同的操作系统上，它们的输入可能很容易是8字节的。我将对其进行编辑。
as_strip
允许您访问数组数据缓冲区之外的字节。它不会检查步幅和形状是否有效。小心使用。谢谢，这很简单。我真的不知道跨步是什么，我认为是3，因为在链接中，他们使用了4。我读了文档，但不太明白。它说的是当遍历数组时，每个维度要跨入一个字节元组。
@user2357112-是否需要添加一些解释？出于好奇，如果我想跨过两个
（[1,2,3]，[3,4,5]，…）
，我需要
a.strips*3
？@cᴏʟᴅsᴘᴇᴇᴅ: 我认为你误解了数组的步长。数组的步长告诉您在任何维中从一个数组元素移动到下一个数组元素需要在内存中移动多少字节。参见和@cᴏʟᴅsᴘᴇᴇᴅ: 
len（a）-5
看起来不正确-正确的表达式应该是带有
//2
的表达式。除此之外，它看起来像是你把事情搞定了。“对于一维数组，步长是元素的大小”-仅对于连续数组。假设连续性通常是个坏主意，除非你确切知道输入是如何产生的，或者你自己检查了连续性。太棒了。非常感谢你。信息量大，很有帮助。从提供的示例中，更容易识别此处的模式。至于负跨步，可能更容易直接通过，因此您可以提供
偏移量
以及
形状
和
跨步
。
array([[1, 2, 3],
   [2, 3, 4],
   [3, 4, 5],
   [4, 5, 6],
   [5, 6, 7],
   [6, 7, 8],
   [7, 8, 9]])