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 раз медленнее, чем более специализированная версия.

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

Примеры

>>> from numpy.lib.stride_tricks import 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]])

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

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

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