Скользящее окно формы M-by-N numpy.ndarray

In [1]: import numpy as np

In [2]: a = np.array([[00,01], [10,11], [20,21], [30,31], [40,41], [50,51]])

In [3]: w = np.hstack((a[:-2],a[1:-1],a[2:]))

In [4]: w
Out[4]: 
array([[ 0,  1, 10, 11, 20, 21],
       [10, 11, 20, 21, 30, 31],
       [20, 21, 30, 31, 40, 41],
       [30, 31, 40, 41, 50, 51]])

Вы можете написать это как функцию так:

def window_stack(a, stepsize=1, width=3):
    n = a.shape[0]
    return np.hstack( a[i:1+n+i-width:stepsize] for i in range(0,width) )

На самом деле это не зависит от формы исходного массива, пока a.ndim = 2. Обратите внимание, что я никогда не использую ни одну из длин в интерактивной версии. Второе измерение формы не имеет значения; каждая строка может быть сколь угодно длинной. Благодаря предложению @Jaime вы можете сделать это, вообще не проверяя форму:

def window_stack(a, stepsize=1, width=3):
    return np.hstack( a[i:1+i-width or None:stepsize] for i in range(0,width) )

Вы можете сделать векторизованное скользящее окно в numpy, используя причудливую индексацию.

>>> import numpy as np

>>> a = np.array([[00,01], [10,11], [20,21], [30,31], [40,41], [50,51]])

>>> a
array([[ 0,  1],
       [10, 11],
       [20, 21],                      #define our 2d numpy array
       [30, 31],
       [40, 41],
       [50, 51]])

>>> a = a.flatten()

>>> a
array([ 0,  1, 10, 11, 20, 21, 30, 31, 40, 41, 50, 51])    #flattened numpy array

>>> indexer = np.arange(6)[None, :] + 2*np.arange(4)[:, None]

>>> indexer
array([[ 0,  1,  2,  3,  4,  5],
       [ 2,  3,  4,  5,  6,  7],            #sliding window indices
       [ 4,  5,  6,  7,  8,  9],
       [ 6,  7,  8,  9, 10, 11]])

>>> a[indexer]
array([[ 0,  1, 10, 11, 20, 21],
       [10, 11, 20, 21, 30, 31],            #values of a over sliding window
       [20, 21, 30, 31, 40, 41],
       [30, 31, 40, 41, 50, 51]])

>>> np.sum(a[indexer], axis=1)
array([ 63, 123, 183, 243])         #sum of values in 'a' under the sliding window.

Объяснение того, что делает этот код.

np.arange(6)[None, :] создает вектор-строку от 0 до 6, а np.arange(4)[:, None] создает вектор-столбец от 0 до 4. Это приводит к матрице 4x6, где каждая строка (шесть из них) представляет окно, а количество строк (четыре из них) представляет собой количество окон. Число, кратное 2, заставляет скользящее окно перемещаться на 2 единицы за раз, что необходимо для перемещения по каждому кортежу. Используя нарезку массива numpy, вы можете передать скользящее окно в сглаженный массив numpy и выполнять на них агрегаты, такие как сумма.

Одно решение

np.lib.stride_tricks.as_strided(a, shape=(4,6), strides=(8,4)).

Использование шагов интуитивно понятно, когда вы начинаете думать с точки зрения указателей/адресов.

Метод as_strided() имеет 3 аргумента.

1. данные
2. форма
3. успехи

data — это массив, с которым мы будем работать.

Чтобы использовать as_strided() для реализации функций скользящего окна, мы должны заранее вычислить форму вывода. В вопросе (4,6) - это форма вывода. Если размеры неверны, мы в конечном итоге читаем мусорные значения. Это потому, что мы обращаемся к данным, перемещая указатель на пару байтов (в зависимости от типа данных).

Определение правильного значения strides необходимо для получения ожидаемых результатов. Перед вычислением шагов узнайте, сколько памяти занимает каждый элемент, используя arr.strides[-1]. В этом примере память, занимаемая одним элементом, составляет 4 байта. Массивы Numpy создаются в основном в виде строк. Первый элемент следующей строки находится рядом с последним элементом текущей строки.

Ex:

0 , 1 | 10, 11 | ...

10 рядом с 1.

Представьте себе двумерный массив, преобразованный в одномерный (это допустимо, поскольку данные хранятся в формате строк). Первый элемент каждой строки в выходных данных является нечетным индексированным элементом в массиве 1D.

0, 10, 20, 30, ..

Следовательно, количество шагов в памяти, которое нам нужно сделать, чтобы перейти от 0 к 10, от 10 к 20 и так далее, равно 2 * mem size of element. Каждая строка имеет шаг 2 * 4bytes = 8. Для данной строки в выходных данных все элементы находятся рядом друг с другом в нашем воображаемом одномерном массиве. Чтобы получить следующий элемент в строке, просто сделайте один шаг, равный размеру элемента. Значение шага столбца составляет 4 байта.

Следовательно, strides=(8,4)

Альтернативное объяснение: вывод имеет вид (4,6). Шаг столбца 4. Таким образом, элементы первой строки начинаются с индекса 0 и состоят из 6 элементов, отстоящих друг от друга на 4 байта. После того, как первая строка собрана, вторая строка начинается в 8 байтах от начала текущей строки. Третья строка начинается в 8 байтах от начальной точки второй строки и так далее.

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

Понимание короткого списка возможно с помощью more_itertools.windowed^1:

Дано

import numpy as np
import more_itertools as mit


a = [["00","01"],
     ["10","11"],
     ["20","21"],
     ["30","31"],
     ["40","41"],
     ["50","51"]]

b = np.array(a)

Код

np.array([list(mit.flatten(w)) for w in mit.windowed(a, n=3)])

or

np.array([[i for item in w for i in item] for w in mit.windowed(a, n=3)])

or

np.array(list(mit.windowed(b.ravel(), n=6)))

Вывод

array([['00', '01', '10', '11', '20', '21'],
       ['10', '11', '20', '21', '30', '31'],
       ['20', '21', '30', '31', '40', '41'],
       ['30', '31', '40', '41', '50', '51']], 
      dtype='<U2')

Скользящие окна размером n=3 создаются и сглаживаются. Обратите внимание, что размер шага по умолчанию равен more_itertools.windowed(..., step=1).

Производительность

В качестве массива принятый ответ является самым быстрым.

%timeit np.hstack((a[:-2], a[1:-1], a[2:]))
# 37.5 µs ± 1.88 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit np.hstack((b[:-2], b[1:-1], b[2:]))
# 12.9 µs ± 166 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit np.array([list(mit.flatten(w)) for w in mit.windowed(a, n=3)])
# 23.2 µs ± 1.73 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit np.array([[i for item in w for i in item] for w in mit.windowed(a, n=3)])
# 21.2 µs ± 999 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%timeit np.array(list(mit.windowed(b.ravel(), n=6)))
# 43.4 µs ± 374 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

^{_{Сторонняя библиотека, реализующая рецепты itertool и множество полезных инструментов.}}

Начиная с Numpy 1.20, используя новый sliding_window_view, чтобы скользить/прокручивать окна элементов и основываться на той же идее, что и user42541 answer, мы можем сделать:

import numpy as np
from numpy.lib.stride_tricks import sliding_window_view

# values = np.array([[0,1], [10,11], [20,21], [30,31], [40,41], [50,51]])
sliding_window_view(values.flatten(), window_shape = 2*3)[::2]
# array([[ 0,  1, 10, 11, 20, 21],
#        [10, 11, 20, 21, 30, 31],
#        [20, 21, 30, 31, 40, 41],
#        [30, 31, 40, 41, 50, 51]])

где 2 — размер подмассивов, а 3 — размер окна.

Детали промежуточных шагов:

# values = np.array([[0,1], [10,11], [20,21], [30,31], [40,41], [50,51]])

# Flatten the array (concatenate sub-arrays):
values.flatten()
# array([ 0,  1, 10, 11, 20, 21, 30, 31, 40, 41, 50, 51])

# Slide through windows of size 2*3=6:
sliding_window_view(values.flatten(), 2*3)
# array([[ 0,  1, 10, 11, 20, 21],
#        [ 1, 10, 11, 20, 21, 30],
#        [10, 11, 20, 21, 30, 31],
#        [11, 20, 21, 30, 31, 40],
#        [20, 21, 30, 31, 40, 41],
#        [21, 30, 31, 40, 41, 50],
#        [30, 31, 40, 41, 50, 51]])

# Only keep even rows (1 row in 2 - if sub-arrays have a size of x, then replace 2 with x):
sliding_window_view(values.flatten(), 2*3)[::2]
# array([[ 0,  1, 10, 11, 20, 21],
#        [10, 11, 20, 21, 30, 31],
#        [20, 21, 30, 31, 40, 41],
#        [30, 31, 40, 41, 50, 51]])

Начиная с версии NumPy 1.20.0 это можно сделать с помощью

np.lib.stride_tricks.sliding_window_view(arr, winsize)

Пример:

>>> arr = np.arange(0, 9).reshape((3, 3))
>>> np.lib.stride_tricks.sliding_window_view(arr, (2, 2))

array([[[[0, 1],
         [3, 4]],

        [[1, 2],
         [4, 5]]],


       [[[3, 4],
         [6, 7]],

        [[4, 5],
         [7, 8]]]])

Подробнее об этом можно прочитать здесь.

Вот однострочный с использованием Numpy ›= v1.17

rowsJoined = 3

splits = np.vstack(np.split(x,np.array([[i, i + rowsJoined] for i in range(x.shape[0] - (rowsJoined - 1))]).reshape(-1))).reshape(-1, rowsJoined * x.shape[1]) 

Контрольная работа

x = np.array([[00,1],
              [10,11],
              [20,21],
              [30,31],
              [40,41],
              [50,51]])

Результат

[[ 0  1 10 11 20 21]
 [10 11 20 21 30 31]
 [20 21 30 31 40 41]
 [30 31 40 41 50 51]]

Проверка производительности на большом массиве

import numpy as np
import time

x = np.array(range(1000)).reshape(-1, 2)
rowsJoined = 3

all_t = 0.
for i in range(1000):
    start_ = time.time()
    np.vstack(
        numpy.split(x,np.array([[i, i + rowsJoined] for i in range(x.shape[0] - (rowsJoined - 1))])
                    .reshape(-1))).reshape(-1, rowsJoined * x.shape[1])
    all_t += time.time() - start_

print('Average Time of 1000 Iterations on Array of Shape '
      '1000 x 2 is: {} Seconds.'.format(all_t/1000.))

Результат производительности

Average Time of 1000 Iterations on Array of Shape 1000 x 2 is: 0.0016909 Seconds.

Это чистая реализация Python:

def sliding_window(arr, window=3):
    i = iter(arr)
    a = []
    for e in range(0, window): a.append(next(i))
    yield a
    for e in i:
        a = a[1:] + [e]
        yield a

Пример:

# flatten array
flatten = lambda l: [item for sublist in l for item in sublist]

a = [[0,1], [10,11], [20,21], [30,31], [40,41], [50,51]]
w = sliding_window(a, width=3)
print( list(map(flatten,w)) )

[[0, 1, 10, 11, 20, 21], [10, 11, 20, 21, 30, 31], [20, 21, 30, 31, 40, 41], [30, 31, 40, 41, 50, 51]]

Эталон

import timeit
def benchmark():
  a = [[0,1], [10,11], [20,21], [30,31], [40,41], [50,51]]
  sliding_window(a, width=3)

times = timeit.Timer(benchmark).repeat(3, number=1000)
time_taken = min(times) / 1000
print(time_taken)

1.0944640007437556e-06