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 или кортеж из int

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

axisint или кортеж из int, необязательно

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

subokbool, необязательно

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

writeablebool, необязательно

Когда 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.])

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