Разрезание массива NumPy 2d или как извлечь подматрицу mxm из массива nxn (n> m)?

Question

Я хочу нарезать массив NumPy nxn. Я хочу извлечь произвольный выбор из m строк и столбцов этого массива (т. Е. Без какого-либо шаблона в количестве строк / столбцов), сделав его новым массивом mxm. Для этого примера допустим, что массив 4x4, и я хочу извлечь из него массив 2x2.

Вот наш массив:

from numpy import *
x = range(16)
x = reshape(x,(4,4))

print x
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

Строка и столбцы для удаления совпадают. Самый простой случай - это когда я хочу извлечь подматрицу 2x2, которая находится в начале или в конце, то есть:

In [33]: x[0:2,0:2]
Out[33]: 
array([[0, 1],
       [4, 5]])

In [34]: x[2:,2:]
Out[34]: 
array([[10, 11],
       [14, 15]])

Но что, если мне нужно удалить еще одну смесь строк / столбцов? Что если мне нужно удалить первую и третью строки / строки, извлекая таким образом подматрицу [[5,7],[13,15]]? Может быть любая композиция строк / строк. Я где-то читал, что мне просто нужно проиндексировать мой массив, используя массивы / списки индексов для строк и столбцов, но это, похоже, не работает:

In [35]: x[[1,3],[1,3]]
Out[35]: array([ 5, 15])

Я нашел один способ, а именно:

    In [61]: x[[1,3]][:,[1,3]]
Out[61]: 
array([[ 5,  7],
       [13, 15]])

Первая проблема в том, что она едва читаема, хотя я могу жить с этим. Если у кого-то есть лучшее решение, я, конечно, хотел бы услышать его.

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

Answer 1

Чтобы ответить на этот вопрос, мы должны посмотреть, как работает индексирование многомерного массива в Numpy.Давайте сначала скажем, что у вас есть массив x из вашего вопроса.Буфер, назначенный на x, будет содержать 16 возрастающих целых чисел от 0 до 15. Если вы обращаетесь к одному элементу, скажем, x[i,j], NumPy должен выяснить расположение в памяти этого элемента относительно начала буфера.Это делается путем вычисления i*x.shape[1]+j (и умножения на размер типа int для получения фактического смещения памяти).

Если вы извлекаете подмассив с помощью базового среза, например y = x[0:2,0:2], результирующий объект будетподелиться базовым буфером с x.Но что произойдет, если вы получите y[i,j]?NumPy не может использовать i*y.shape[1]+j для вычисления смещения в массиве, поскольку данные, принадлежащие y, не являются последовательными в памяти.

NumPy решает эту проблему, вводя шагов .При вычислении смещения памяти для доступа к x[i,j] фактически вычисляется i*x.strides[0]+j*x.strides[1] (и это уже включает в себя коэффициент для размера целого):

x.strides
(16, 4)

Когда y извлекается каквыше, NumPy не создает новый буфер, но создает новый объект массива, ссылающийся на тот же буфер (в противном случае y будет просто равен x.) Новый объект массива будет иметьдругой формы, чем x и, возможно, другое начальное смещение в буфере, но будет делить шаги с x (в данном случае, по крайней мере):

y.shape
(2,2)
y.strides
(16, 4)

Таким образом, вычисляя смещениеy[i,j] даст правильный результат.

Но что NumPy должен сделать для чего-то вроде z=x[[1,3]]?Механизм шагов не позволит правильно индексировать, если исходный буфер используется для z.Теоретически NumPy может добавить более сложный механизм, чем пошаговые, но это сделает доступ к элементу относительно дорогим, что каким-то образом бросает вызов всей идее массива.Кроме того, представление больше не будет действительно легким объектом.

Это подробно описано в документации NumPy по индексированию .

О, и я почти забыло вашем актуальном вопросе: Вот как заставить индексирование работать с несколькими списками так, как ожидается:

x[[[1],[3]],[1,3]]

Это потому, что массивы индекса транслируются в общую форму.Конечно, для этого конкретного примера вы также можете обойтись с базовой нарезкой:

x[1::2, 1::2]

Answer 2

Как упомянул Свен, x[[[0],[2]],[1,3]] вернет 0 и 2 строки, которые соответствуют столбцам 1 и 3, а x[[0,2],[1,3]] вернет значения x [0,1] и x [2,3] в массиве ,

Для первого примера, который я привел, есть полезная функция numpy.ix_. Вы можете сделать то же самое, что и мой первый пример с x[numpy.ix_([0,2],[1,3])]. Это может избавить вас от необходимости вводить все эти дополнительные скобки.

Answer 3

Я не думаю, что x[[1,3]][:,[1,3]] трудно читаем.Если вы хотите получить более четкое представление о своих намерениях, вы можете сделать следующее:

a[[1,3],:][:,[1,3]]

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

Например, на ваших входах 33 и 34, хотя вы получаете массив 2x2, шаг равен 4. Таким образом, когда вы индексируете следующую строку, указатель перемещается кправильная позиция в памяти.

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

Answer 4

Если вы хотите пропустить все остальные строки и все остальные столбцы, то вы можете сделать это с помощью базовой нарезки:

In [49]: x=np.arange(16).reshape((4,4))
In [50]: x[1:4:2,1:4:2]
Out[50]: 
array([[ 5,  7],
       [13, 15]])

Это возвращает представление, а не копию вашего массива.

In [51]: y=x[1:4:2,1:4:2]

In [52]: y[0,0]=100

In [53]: x   # <---- Notice x[1,1] has changed
Out[53]: 
array([[  0,   1,   2,   3],
       [  4, 100,   6,   7],
       [  8,   9,  10,  11],
       [ 12,  13,  14,  15]])

, в то время как z=x[(1,3),:][:,(1,3)] использует расширенное индексирование и, следовательно, возвращает копию:

In [58]: x=np.arange(16).reshape((4,4))
In [59]: z=x[(1,3),:][:,(1,3)]

In [60]: z
Out[60]: 
array([[ 5,  7],
       [13, 15]])

In [61]: z[0,0]=0

Обратите внимание, что x не изменяется:

In [62]: x
Out[62]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

Если вы хотите выбрать произвольноестроки и столбцы, то вы не можете использовать базовую нарезку.Вам придется использовать расширенное индексирование, используя что-то вроде x[rows,:][:,columns], где rows и columns - последовательности.Это, конечно, даст вам копию, а не вид вашего исходного массива.Это, как и следовало ожидать, поскольку массивный массив использует непрерывную память (с постоянными шагами), и не было бы никакого способа генерировать представление с произвольными строками и столбцами (так как для этого потребовались бы непостоянные шаги).

Answer 5

С помощью numpy вы можете передать срез для каждого компонента индекса - так, ваш приведенный выше пример x[0:2,0:2] работает.

Если вы просто хотите равномерно пропустить столбцы или строки, вы можете передать срезы с тремя компонентами (то есть start, stop, step).

Опять же, для вашего примера выше:

>>> x[1:4:2, 1:4:2]
array([[ 5,  7],
       [13, 15]])

Что по сути: срез в первом измерении, начиная с индекса 1, останавливается, когда индекс равен 4 или больше, и добавляет 2 к индексу в каждом проходе.То же самое для второго измерения.Опять же: это работает только для постоянных шагов.

Синтаксис, который вам нужно сделать, чтобы сделать что-то совсем другое - на самом деле x[[1,3]][:,[1,3]] создает новый массив, включающий только строки 1 и 3 из исходного массива (сделано счасть x[[1,3]]), а затем повторно нарежьте это - создав третий массив - включая только столбцы 1 и 3 предыдущего массива.

Answer 6

У меня есть подобный вопрос здесь: Запись в под-массиве ndarray наиболее питонским способом. Python 2 .

Следуя решению предыдущего поста для вашего случая, решение выглядит так:

columns_to_keep = [1,3] 
rows_to_keep = [1,3]

Использование ix _:

x[np.ix_(rows_to_keep, columns_to_keep)] 

Что такое:

array([[ 5,  7],
       [13, 15]])

Answer 7

Я не уверен, насколько это эффективно, но вы можете использовать range (), чтобы разрезать обе оси

 x=np.arange(16).reshape((4,4))
 x[range(1,3), :][:,range(1,3)]