В настоящее время я прохожу через numpy, и в numpy есть тема, которая называется "шаги". Я понимаю, что это. Но как это работает? Я не нашел никакой полезной информации в Интернете. Может ли кто-нибудь дать мне понять с точки зрения непрофессионала?
Как понять обалденные шаги для дилетанта?
Ответ 1
Фактические данные массива Numpy хранятся в однородном и непрерывном блоке памяти, называемом буфером данных. Для получения дополнительной информации см. Внутренности NumPy. Используя (по умолчанию) основной порядок строк, 2D-массив выглядит следующим образом:
Чтобы отобразить индексы i, j, k,... многомерного массива на позиции в буфере данных (смещение в байтах), NumPy использует понятие шагов. Шагов - это количество байтов, которые нужно перепрыгнуть в памяти, чтобы перейти от одного элемента к следующему элементу по каждому направлению/измерению массива. Другими словами, это разделение байтов между последовательными элементами для каждого измерения.
Например:
>>> a = np.arange(1,10).reshape(3,3)
>>> a
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Этот двумерный массив имеет два направления: оси-0 (проходящие вертикально вниз по рядам) и ось-1 (проходящие горизонтально между столбцами), причем каждый элемент имеет размер:
>>> a.itemsize # in bytes
4
Таким образом, чтобы перейти от a[0, 0] → a[0, 1]
(двигаясь горизонтально вдоль 0-й строки, от 0-го столбца до 1-го столбца), шаг байта в буфере данных равен 4. То же самое для a[0, 1] → a[0, 2]
, a[1, 0] → a[1, 1]
и т.д. Это означает, что количество шагов для горизонтального направления (ось-1) составляет 4 байта.
Однако, чтобы перейти от a[0, 0] → a[1, 0]
(двигаясь по вертикали вдоль 0-го столбца, от 0-й строки к 1-й строке), вам необходимо сначала пройти все оставшиеся элементы в 0-й строке. чтобы добраться до 1-й строки, а затем пройти через 1-ю строку, чтобы добраться до элемента a[1, 0]
, то есть a[0, 0] → a[0, 1] → a[0, 2] → a[1, 0]
. Поэтому число шагов для вертикального направления (ось-0) составляет 3 * 4 = 12 байтов. Обратите внимание, что переход от a[0, 2] → a[1, 0]
, и в целом от последнего элемента строки я -th к первому элементу строки (i + 1) -th, равен также 4 байта, потому что массив a
хранится в главном порядке строк.
Вот почему
>>> a.strides # (strides[0], strides[1])
(12, 4)
Вот еще один пример, показывающий, что шаги в горизонтальном направлении (ось-1), strides[1]
, двумерного массива необязательно равны размеру элемента (например, массив с основным порядком столбцов):
>>> b = np.array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]]).T
>>> b
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> b.strides
(4, 12)
Здесь strides[1]
кратен размеру предмета. Хотя массив b
выглядит идентично массиву a
, он представляет собой другой массив: внутри b
хранится как |1|4|7|2|5|8|3|6|9|
(потому что транспонирование не влияет на буфер данных, а только меняет шаги и форму), тогда как a
as |1|2|3|4|5|6|7|8|9|
, Что делает их похожими, так это разные шаги. То есть шаг байта для b[0, 0] → b[0, 1]
составляет 3 * 4 = 12 байт, а для b[0, 0] → b[1, 0]
- 4 байта, тогда как для a[0, 0] → a[0, 1]
- 4 байта, а для a[0, 0] → a[1, 0]
- 12 байтов.
И последнее, но не менее важное: NumPy позволяет создавать виды существующих массивов с возможностью изменения шагов и формы, см. Трюки с шагами. Например:
>>> np.lib.stride_tricks.as_strided(a, shape=a.shape[::-1], strides=a.strides[::-1])
array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]])
что эквивалентно транспонированию массива a
.
Позвольте мне добавить, но не вдаваясь в подробности, что можно даже определить шаги, которые не кратны размеру предмета. Вот пример:
>>> a = np.lib.stride_tricks.as_strided(np.array([1, 512, 0, 3], dtype=np.int16),
shape=(3,), strides=(3,))
>>> a
array([1, 2, 3], dtype=int16)
>>> a.strides[0]
3
>>> a.itemsize
2
Ответ 2
Просто чтобы добавить отличный ответ от @AndyK, я узнал о больших успехах от Numpy MedKit. Там они показывают использование с проблемой следующим образом:
С учетом ввода:
x = np.arange(20).reshape([4, 5])
>>> x
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19]])
Ожидаемый результат:
array([[[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9]],
[[ 5, 6, 7, 8, 9],
[ 10, 11, 12, 13, 14]],
[[ 10, 11, 12, 13, 14],
[ 15, 16, 17, 18, 19]]])
Для этого нам нужно знать следующие термины:
shape - Размеры массива вдоль каждой оси.
шагов - количество байтов памяти, которые необходимо пропустить, чтобы перейти к следующему элементу в определенном измерении.
>>> x.strides
(20, 4)
>>> np.int32().itemsize
4
Теперь, если мы посмотрим на ожидаемый результат:
array([[[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9]],
[[ 5, 6, 7, 8, 9],
[ 10, 11, 12, 13, 14]],
[[ 10, 11, 12, 13, 14],
[ 15, 16, 17, 18, 19]]])
Нам нужно манипулировать формой массива и шагами. Выходная форма должна быть (3, 2, 5), то есть 3 элемента, каждый из которых содержит две строки (m == 2), а каждая строка имеет 5 элементов.
Шаг должен быть изменен с (20, 4) на (20, 20, 4). Каждый элемент в новом выходном массиве начинается с новой строки, каждая строка состоит из 20 байтов (5 элементов по 4 байта в каждом), а каждый элемент занимает 4 байта (int32).
Итак:
>>> from numpy.lib import stride_tricks
>>> stride_tricks.as_strided(x, shape=(3, 2, 5),
strides=(20, 20, 4))
...
array([[[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9]],
[[ 5, 6, 7, 8, 9],
[ 10, 11, 12, 13, 14]],
[[ 10, 11, 12, 13, 14],
[ 15, 16, 17, 18, 19]]])
Альтернативой будет:
>>> d = dict(x.__array_interface__)
>>> d['shape'] = (3, 2, 5)
>>> s['strides'] = (20, 20, 4)
>>> class Arr:
... __array_interface__ = d
... base = x
>>> np.array(Arr())
array([[[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9]],
[[ 5, 6, 7, 8, 9],
[ 10, 11, 12, 13, 14]],
[[ 10, 11, 12, 13, 14],
[ 15, 16, 17, 18, 19]]])
Я очень часто использую этот метод вместо numpy.hstack или numpy.vstack и доверяю мне, в вычислительном отношении это намного быстрее.
Примечание:
При использовании очень больших массивов с этим трюком вычисление точных шагов не так тривиально. Я обычно делаю массив numpy.zeroes
желаемой формы и получаю шаги, используя array.strides
, и использую это в функции stride_tricks.as_strided
.
Надеюсь, это поможет!