我正在尝试使用numpy.strided_tricks重塑一个numpy数组。这是我正在遵循的指南：https://stackoverflow.com/a/2487551/4909087
我的用例非常相似，区别在于我需要大步前进。
鉴于此数组：
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，但显然不是。我哪里错了？
答案 0 :(得分：4)
我不知道为什么你认为你需要步幅3.你需要跨越a的一个元素和下一个元素之间的距离，你可以使用a.strides：
as_strided(a, (len(a) - 2, 3), a.strides*2)
答案 1 :(得分：2)
接受的答案（和讨论）很好，但为了不想运行自己的测试用例的读者的利益，我将尝试说明发生了什么：<\ n / p>
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数组，strides是元素的大小，这里是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边界，并提供大多数不可理解的数字。如果dtype是字节或uint8可能更有意义。
而是使用a.strides*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个windows 7元素。
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]])
但是形状是关闭的，显示原始数据缓冲区末尾的字节数。这可能很危险（我们不知道这些字节是否属于某个其他对象或数组）。使用这个大小的阵列，我们无法获得一整套2步窗口。
现在每行（3 * 4,4）的步骤3元素：
In [384]: as_strided(a, shape=(3,3), strides=(12,4))
Out[384]:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [385]: a.reshape(3,3).strides
Out[385]: (12, 4)
这是一个相同的形状，并且与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_strided没有参数。
答案 2 :(得分：1)
我正在尝试执行类似的操作并遇到相同的问题。
对于您而言，如本comment所述，问题是：
我使自己成为基于此answer的函数，其中我使用n个元素的窗口并指定要重叠的元素数来计算给定数组的分段（由窗口给出） - number_of_elements_to_skip ）。
我在这里分享它是为了防止别人需要它，因为花了我一段时间才弄清楚stride_tricks的工作原理：
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))
根据您的代码，针对这种情况的解决方案是：
as_strided(a, (len(a) - 2, 3), (4, 4))
或者，使用函数window_signal：
window_signal(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]])