numpy.lib.stride_tricks.sliding_window_view#

lib.stride_tricks.sliding_window_view(x, window_shape, ось=None, *, subok=False, доступный для записи=False)[источник]#

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

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

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

Параметры:
xarray_like

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

window_shapeint или кортеж int

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

осьint или кортеж int, опционально

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

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

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

доступный для записиbool, необязательно

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

Возвращает:
представлениеndarray

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

Смотрите также

lib.stride_tricks.as_strided

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

broadcast_to

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

Примечания

Предупреждение

Эта функция создает представления с перекрывающейся памятью. Когда writeable=True, запись в представление изменит исходный массив и может повлиять на несколько позиций представления. См. примеры ниже и это руководство о разнице между копиями и представлениями.

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

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

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

Примеры

>>> import numpy as np
>>> 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.])

Два примера ниже демонстрируют эффект writeable=True.

Создание представления с настройками по умолчанию writeable=False и затем запись в него вызывает ошибку.

>>> v = sliding_window_view(x, 3)
>>> v[0,1] = 10
Traceback (most recent call last):
...
ValueError: assignment destination is read-only

Создание представления с writeable=True и затем запись в него изменяет исходный массив и несколько позиций представления.

>>> x = np.arange(6)  # reset x for the second example
>>> v = sliding_window_view(x, 3, writeable=True)
>>> v[0,1] = 10
>>> x
array([ 0, 10,  2,  3,  4,  5])
>>> v
array([[ 0, 10,  2],
       [10,  2,  3],
       [ 2,  3,  4],
       [ 3,  4,  5]])

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

На этой странице