numpy.lib.stride_tricks.sliding_window_view

lib.stride_tricks.sliding_window_view(x, window_shape, axis=None, *, subok=False, writeable=False) [source]

Создание представления скользящего окна над массивом с заданной формой окна.

Также известна как свёртывание или скользящее окно, окно перемещается по всем измерениям массива и извлекает подмножества массива во всех положениях окна.

Новая в версии 1.20.0.

Параметры

xarray_like

Массив, для которого создаётся представление скользящего окна.

window_shapeint or tuple of int

Размер окна над каждой осью, участвующей в скользящем окне. Если axis отсутствует, он должен иметь такую же длину, как и количество измерений входного массива. Целые числа i обрабатываются так, как будто они являются кортежем (i,).

axisint or tuple of int, optional

Ось или оси, вдоль которых применяется скользящее окно. По умолчанию скользящее окно применяется ко всем осям и window_shape[i] будет ссылаться на ось i массива x. Если axis задан как tuple of int, window_shape[i] будет ссылаться на ось axis[i] массива x. Целые числа i обрабатываются так, как будто они являются кортежем (i,).

subokbool, optional

Если True, подклассы будут проходить без изменений, иначе возвращаемый массив будет принудительно преобразован в массив базового класса (по умолчанию).

writeablebool, optional

Если True, разрешается запись в возвращаемое представление. По умолчанию False, так как это следует использовать с осторожностью: возвращаемое представление содержит одно и то же местоположение в памяти несколько раз, поэтому запись в одно место приведёт к изменениям в других.

Возвращаемое значение

viewndarray

Представление скользящего окна массива. Размерности скользящего окна вставляются в конец, а исходные размерности обрезаются по мере необходимости, в зависимости от размера скользящего окна. То есть view.shape = x_shape_trimmed + window_shape, где x_shape_trimmed - x.shape с каждым элементом, уменьшенным на одно меньше, чем соответствующий размер окна.

См. также

lib.stride_tricks.as_strided

Процедура более низкого уровня и менее безопасная для создания произвольных представлений из настраиваемой формы и шагов.

broadcast_to

распространить массив на заданную форму.

Примечания

Для многих приложений использование представления скользящего окна может быть удобным, но потенциально очень медленным. Часто существуют специализированные решения, например:

• scipy.signal.fftconvolve
• функции фильтрации в scipy.ndimage
• функции скользящего окна, предоставляемые bottleneck.

Приблизительно подход со скользящим окном с размером входных данных N и размером окна W будет масштабироваться как O(N*W), где часто специальный алгоритм может достичь O(N). Это означает, что вариант скользящего окна для размера окна 100 может быть в 100 раз медленнее, чем более специализированная версия.

Тем не менее, для небольших размеров окон, когда нет специального алгоритма, или как инструмент для прототипирования и разработки, эта функция может быть хорошим решением.

Примеры

>>> x = np.arange(6)
>>> x.shape
(6,)
>>> v = sliding_window_view(x, 3)
>>> v.shape
(4, 3)
>>> v
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]])

Это также работает в более высоких измерениях, например:

>>> i, j = np.ogrid[:3, :4]
>>> x = 10*i + j
>>> x.shape
(3, 4)
>>> x
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23]])
>>> shape = (2,2)
>>> v = sliding_window_view(x, shape)
>>> v.shape
(2, 3, 2, 2)
>>> v
array([[[[ 0,  1],
         [10, 11]],
        [[ 1,  2],
         [11, 12]],
        [[ 2,  3],
         [12, 13]]],
       [[[10, 11],
         [20, 21]],
        [[11, 12],
         [21, 22]],
        [[12, 13],
         [22, 23]]]])

Ось может быть задана явно:

>>> v = sliding_window_view(x, 3, 0)
>>> v.shape
(1, 4, 3)
>>> v
array([[[ 0, 10, 20],
        [ 1, 11, 21],
        [ 2, 12, 22],
        [ 3, 13, 23]]])

Одна и та же ось может использоваться несколько раз. В этом случае каждое использование уменьшает соответствующее исходное измерение:

>>> v = sliding_window_view(x, (2, 3), (1, 1))
>>> v.shape
(3, 1, 2, 3)
>>> v
array([[[[ 0,  1,  2],
         [ 1,  2,  3]]],
       [[[10, 11, 12],
         [11, 12, 13]]],
       [[[20, 21, 22],
         [21, 22, 23]]]])

В сочетании с пошаговым слайсингом (::step), это можно использовать для получения представлений скользящего окна, которые пропускают элементы:

>>> x = np.arange(7)
>>> sliding_window_view(x, 5)[:, ::2]
array([[0, 2, 4],
       [1, 3, 5],
       [2, 4, 6]])

или представления, которые перемещаются на несколько элементов

>>> x = np.arange(7)
>>> sliding_window_view(x, 3)[::2, :]
array([[0, 1, 2],
       [2, 3, 4],
       [4, 5, 6]])

Распространённое применение sliding_window_view — вычисление текущих статистических данных. Самый простой пример — среднее скользящее окно:

>>> x = np.arange(6)
>>> x.shape
(6,)
>>> v = sliding_window_view(x, 3)
>>> v.shape
(4, 3)
>>> v
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]])
>>> moving_average = v.mean(axis=-1)
>>> moving_average
array([1., 2., 3., 4.])

Обратите внимание, что подход со скользящим окном часто не является оптимальным (см. раздел «Примечания»).