Использование Numpy stride_tricks для получения неперекрывающихся блоков массива

Я пытаюсь использовать numpy.lib.stride_tricks.as_strided для итерации по неперекрывающимся блокам массива, но у меня возникают проблемы с поиском документации параметров, поэтому я смог получить только перекрывающиеся блоки.

Например, у меня есть массив 4x5, из которого я хотел бы получить 4 блока 2x2. Я в порядке с лишними клетками на правом и нижнем крае, исключаемом.

Пока что мой код:

import sys
import numpy as np

a = np.array([
[1,2,3,4,5],
[6,7,8,9,10],
[11,12,13,14,15],
[16,17,18,19,20],
])

sz = a.itemsize
h,w = a.shape
bh,bw = 2,2

shape = (h/bh, w/bw, bh, bw)
strides = (w*sz, sz, w*sz, sz)
blocks = np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)

print blocks[0][0]
assert blocks[0][0].tolist() == [[1, 2], [6,7]]
print blocks[0][1]
assert blocks[0][1].tolist() == [[3,4], [8,9]]
print blocks[1][0]
assert blocks[1][0].tolist() == [[11, 12], [16, 17]]

Форма полученного массива блоков кажется правильной, но последние два утверждения терпят неудачу, возможно, из-за того, что мои параметры формы или шагов неверны. Какие значения для них я должен установить, чтобы получить неперекрывающиеся блоки?

Источник

3 ответа

Решение
import numpy as np
n=4
m=5
a = np.arange(1,n*m+1).reshape(n,m)
print(a)
# [[ 1  2  3  4  5]
#  [ 6  7  8  9 10]
#  [11 12 13 14 15]
#  [16 17 18 19 20]]
sz = a.itemsize
h,w = a.shape
bh,bw = 2,2
shape = (h/bh, w/bw, bh, bw)
print(shape)
# (2, 2, 2, 2)

strides = sz*np.array([w*bh,bw,w,1])
print(strides)
# [40  8 20  4]

blocks=np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
print(blocks)
# [[[[ 1  2]
#    [ 6  7]]
#   [[ 3  4]
#    [ 8  9]]]
#  [[[11 12]
#    [16 17]]
#   [[13 14]
#    [18 19]]]]

Начиная с 1 в a (т.е. blocks[0,0,0,0]), чтобы добраться до 2 (т.е. blocks[0,0,0,1]) находится на расстоянии одного пункта. Поскольку (на моей машине) a.itemsize 4 байта, шаг 1*4 = 4. Это дает нам последнее значение в strides = (10,2,5,1)*a.itemsize = (40,8,20,4),

Начиная с 1 опять же, чтобы добраться до 6 (т.е. blocks[0,0,1,0]) 5 (т.е. w) элементов, поэтому шаг равен 5*4 = 20. Это составляет значение от второго до последнего в strides,

Начиная с 1 еще раз, чтобы добраться до 3 (т.е. blocks[0,1,0,0]) 2 (т.е. bw) элементов, поэтому шаг 2*4 = 8. Это составляет второе значение в strides,

Наконец, начиная с 1, чтобы добраться до 11 (т.е. blocks[1,0,0,0]) составляет 10 (т.е. w*bh) предметов нет, поэтому шаг 10*4 = 40. Так strides = (40,8,20,4),

Источник

Используя в качестве примера ответ @unutbu, я написал функцию, которая реализует этот трюковый метод для любого массива ND. Смотрите ниже ссылку на источник.

>>> a = numpy.arange(1,21).reshape(4,5)

>>> print a
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]

>>> blocks = blockwise_view(a, blockshape=(2,2), require_aligned_blocks=False)

>>> print blocks
[[[[ 1 2]
   [ 6 7]]

  [[ 3 4]
   [ 8 9]]]


 [[[11 12]
   [16 17]]

  [[13 14]
   [18 19]]]]

[ blockwise_view.py ] [ test_blockwise_view.py ]

Источник

http://scikit-image.org/ имеет функцию с именем view_as_blocks() это делает почти то, что вам нужно. Единственная проблема в том, что у него есть дополнительный assert это запрещает ваш вариант использования, так как ваши блоки не делятся равномерно в форме массива. Но в вашем случае assert в этом нет необходимости, так что вы можете скопировать исходный код функции и безопасно удалить надоедливую самоутверждение.

Источник
Другие вопросы по тегам