Numpy как найти индекс максимального элемента

Функция Numpy argmax() возвращает индексы максимального элемента массива на определенной оси.

np.argmax() — это встроенная функция Numpy, которая используется в Python для получения индексов максимального элемента из массива (одномерный массив) или любой строки или столбца (многомерный массив) любого заданного массива.

Синтаксис

Параметры

Функция np.argmax() принимает в качестве параметра три аргумента:

1. arr: массив, из которого мы хотим получить индексы максимального элемента.
2. axis: по умолчанию это None. Но для многомерного массива, если мы собираемся найти индекс любого максимума элемента по строкам или по столбцам, мы должны указать ось = 1 или ось = 0 соответственно.
3. out: это необязательный параметр. Это обеспечивает возможность вставки вывода в массив с соответствующей формой и типом.

Возвращаемое значение

Функция Python NumPy argmax() возвращает массив той же формы, что и заданный массив, содержащий индексы максимальных элементов.

Нахождение индекса максимального элемента из одномерного массива

См. следующий код.

Выход:

Объяснение.

В этой программе мы сначала объявили массив с некоторыми случайными числами, заданными пользователем. Затем мы напечатали форму (размер) массива.

Затем мы вызвали argmax(), чтобы получить индекс максимального элемента массива. Мы видим, что максимальный элемент этого массива равен 14, что находится в позиции 1, поэтому выход равен 1.

Нахождение индексов максимальных элементов многомерного массива

Выход:

Объяснение.

В приведенной выше программе мы сначала объявили матрицу размера 4 × 3, и вы также можете увидеть форму матрицы, которая равна(4,3). Затем мы вызвали argmax(), чтобы получить вывод о различных случаях.

В первом случае мы передали arr и axis=1, что возвращает массив размера 4, содержащий индексы всех максимальных элементов из каждой строки. Во втором случае мы передали arr и axis=0 , что возвращает массив размера 3.

Создание массива с помощью np.arange() и последующее использование    np. argmax()

Давайте воспользуемся функцией numpy arange(), чтобы создать двумерный массив и найти индекс максимального значения массива.

Выход:

Несколько вхождений максимальных значений

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

См. следующий код.

Выход:

В приведенном выше примере максимальное значение равно 21, но оно встречается в массиве два раза. Таким образом, он вернет индекс первого вхождения. В нашем случае индекс равен 0.

Найдем максимальное значение по заданной оси.

См. следующий код.

Выход:

В приведенном выше коде мы проверяем максимальный элемент вместе с осью x. Наш вывод — [0, 1, 1], что означает 21 > 18, поэтому он возвращает 0, потому что индекс 21 равен 0. Тогда 11 < 21 означает, что возвращен индекс 21, что равно 1. Тогда 10 < 19, что означает, что вернулся индекс 19, который равен 1.

For multidimensional arrays you can use the axis keyword in order to apply the partitioning along the expected axis.

# For a 2D array
indices = np.argpartition(arr, -N, axis=1)[:, -N:]

And for grabbing the items:

x = arr.shape[0]
arr[np.repeat(np.arange(x), N), indices.ravel()].reshape(x, N)

But note that this won’t return a sorted result. In that case you can use np.argsort() along the intended axis:

indices = np.argsort(arr, axis=1)[:, -N:]

# Result
x = arr.shape[0]
arr[np.repeat(np.arange(x), N), indices.ravel()].reshape(x, N)

Here is an example:

In [42]: a = np.random.randint(0, 20, (10, 10))

In [44]: a
Out[44]:
array([[ 7, 11, 12,  0,  2,  3,  4, 10,  6, 10],
       [16, 16,  4,  3, 18,  5, 10,  4, 14,  9],
       [ 2,  9, 15, 12, 18,  3, 13, 11,  5, 10],
       [14,  0,  9, 11,  1,  4,  9, 19, 18, 12],
       [ 0, 10,  5, 15,  9, 18,  5,  2, 16, 19],
       [14, 19,  3, 11, 13, 11, 13, 11,  1, 14],
       [ 7, 15, 18,  6,  5, 13,  1,  7,  9, 19],
       [11, 17, 11, 16, 14,  3, 16,  1, 12, 19],
       [ 2,  4, 14,  8,  6,  9, 14,  9,  1,  5],
       [ 1, 10, 15,  0,  1,  9, 18,  2,  2, 12]])

In [45]: np.argpartition(a, np.argmin(a, axis=0))[:, 1:] # 1 is because the first item is the minimum one.
Out[45]:
array([[4, 5, 6, 8, 0, 7, 9, 1, 2],
       [2, 7, 5, 9, 6, 8, 1, 0, 4],
       [5, 8, 1, 9, 7, 3, 6, 2, 4],
       [4, 5, 2, 6, 3, 9, 0, 8, 7],
       [7, 2, 6, 4, 1, 3, 8, 5, 9],
       [2, 3, 5, 7, 6, 4, 0, 9, 1],
       [4, 3, 0, 7, 8, 5, 1, 2, 9],
       [5, 2, 0, 8, 4, 6, 3, 1, 9],
       [0, 1, 9, 4, 3, 7, 5, 2, 6],
       [0, 4, 7, 8, 5, 1, 9, 2, 6]])

In [46]: np.argpartition(a, np.argmin(a, axis=0))[:, -3:]
Out[46]:
array([[9, 1, 2],
       [1, 0, 4],
       [6, 2, 4],
       [0, 8, 7],
       [8, 5, 9],
       [0, 9, 1],
       [1, 2, 9],
       [3, 1, 9],
       [5, 2, 6],
       [9, 2, 6]])

In [89]: a[np.repeat(np.arange(x), 3), ind.ravel()].reshape(x, 3)
Out[89]:
array([[10, 11, 12],
       [16, 16, 18],
       [13, 15, 18],
       [14, 18, 19],
       [16, 18, 19],
       [14, 14, 19],
       [15, 18, 19],
       [16, 17, 19],
       [ 9, 14, 14],
       [12, 15, 18]])

В этом руководстве вы узнаете, как использовать функцию NumPy argmax() для поиска индекса максимального элемента в массивах.

NumPy — мощная библиотека для научных вычислений на Python; он предоставляет N-мерные массивы, которые более эффективны, чем списки Python. Одной из распространенных операций, которую вы будете выполнять при работе с массивами NumPy, является поиск максимального значения в массиве. Однако иногда вам может понадобиться найти индекс, при котором происходит максимальное значение.

Функция argmax() помогает найти индекс максимума как в одномерных, так и в многомерных массивах. Давайте продолжим изучать, как это работает.

Чтобы следовать этому руководству, вам необходимо установить Python и NumPy. Вы можете кодировать, запустив Python REPL или запустив блокнот Jupyter.

Во-первых, давайте импортируем NumPy под обычным псевдонимом np.

import numpy as np

Вы можете использовать функцию NumPy max(), чтобы получить максимальное значение в массиве (необязательно вдоль определенной оси).

array_1 = np.array([1,5,7,2,10,9,8,4])
print(np.max(array_1))

# Output
10

В этом случае np.max(array_1) возвращает 10, что правильно.

Предположим, вы хотите найти индекс, при котором в массиве встречается максимальное значение. Вы можете использовать следующий двухэтапный подход:

Найдите максимальный элемент.

Найдите индекс максимального элемента.

В array_1 максимальное значение 10 встречается в индексе 4 после нулевой индексации. Первый элемент имеет индекс 0; второй элемент имеет индекс 1 и так далее.

Чтобы найти индекс, при котором происходит максимум, вы можете использовать функцию NumPy where(). np.where(условие) возвращает массив всех индексов, где условие истинно.

Вам нужно будет подключиться к массиву и получить доступ к элементу по первому индексу. Чтобы найти, где находится максимальное значение, мы устанавливаем условие в array_1==10; напомним, что 10 — это максимальное значение в array_1.

print(int(np.where(array_1==10)[0]))

# Output
4

Мы использовали np.where() только с условием, но это не рекомендуемый метод для использования этой функции.

📑 Примечание: функция NumPy where():
np.where(условие,x,y) возвращает:

– Элементы из x, когда условие истинно, и
– Элементы из y, когда условие имеет значение False.

Следовательно, объединяя функции np.max() и np.where(), мы можем найти максимальный элемент, за которым следует индекс, по которому он встречается.

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

Синтаксис функции NumPy argmax()

Общий синтаксис для использования функции NumPy argmax() выглядит следующим образом:

np.argmax(array,axis,out)
# we've imported numpy under the alias np

В приведенном выше синтаксисе:

• array — любой допустимый массив NumPy.
• ось является необязательным параметром. При работе с многомерными массивами вы можете использовать параметр оси, чтобы найти индекс максимума по определенной оси.
• out — еще один необязательный параметр. Вы можете установить параметр out в массив NumPy для хранения вывода функции argmax().

Примечание. В NumPy версии 1.22.0 появился дополнительный параметр keepdims. Когда мы указываем параметр оси в вызове функции argmax(), массив уменьшается вдоль этой оси. Но установка для параметра keepdims значения True гарантирует, что возвращаемый результат имеет ту же форму, что и входной массив.

Использование NumPy argmax() для поиска индекса максимального элемента

№1. Давайте воспользуемся функцией NumPy argmax(), чтобы найти индекс максимального элемента в array_1.

array_1 = np.array([1,5,7,2,10,9,8,4])
print(np.argmax(array_1))

# Output
4

Функция argmax() возвращает 4, и это правильно! ✅

№ 2. Если мы переопределим array_1 таким образом, что 10 встречается дважды, функция argmax() вернет только индекс первого вхождения.

array_1 = np.array([1,5,7,2,10,10,8,4])
print(np.argmax(array_1))

# Output
4

В остальных примерах мы будем использовать элементы array_1, которые мы определили в примере №1.

Использование NumPy argmax() для поиска индекса максимального элемента в 2D-массиве

Давайте изменим массив NumPy array_1 в двумерный массив с двумя строками и четырьмя столбцами.

array_2 = array_1.reshape(2,4)
print(array_2)

# Output
[[ 1  5  7  2]
 [10  9  8  4]]

Для двумерного массива ось 0 обозначает строки, а ось 1 — столбцы. Массивы NumPy следуют нулевой индексации. Таким образом, индексы строк и столбцов для массива NumPy array_2 следующие:

Теперь давайте вызовем функцию argmax() для двумерного массива array_2.

print(np.argmax(array_2))

# Output
4

Несмотря на то, что мы вызвали argmax() для двумерного массива, он по-прежнему возвращает 4. Это идентично выходным данным для одномерного массива array_1 из предыдущего раздела.

Почему это происходит? 🤔

Это потому, что мы не указали никакого значения для параметра оси. Если этот параметр оси не установлен, по умолчанию функция argmax() возвращает индекс максимального элемента в сглаженном массиве.

Что такое плоский массив? Если имеется N-мерный массив вида d1 x d2 x … x dN, где d1, d2, to dN — размеры массива по N измерениям, то сплющенный массив представляет собой длинный одномерный массив размера д1*д2*…*дН.

Чтобы проверить, как выглядит сглаженный массив для array_2, вы можете вызвать метод flatten(), как показано ниже:

array_2.flatten()

# Output
array([ 1,  5,  7,  2, 10,  9,  8,  4])

Индекс максимального элемента вдоль строк (ось = 0)

Перейдем к поиску индекса максимального элемента по строкам (ось = 0).

np.argmax(array_2,axis=0)

# Output
array([1, 1, 1, 1])

Этот вывод может быть немного сложным для понимания, но мы поймем, как он работает.

Мы установили параметр оси равным нулю (ось = 0), так как мы хотели бы найти индекс максимального элемента по строкам. Поэтому функция argmax() возвращает номер строки, в которой встречается максимальный элемент, — для каждого из трех столбцов.

Давайте визуализируем это для лучшего понимания.

Из приведенной выше диаграммы и вывода argmax() мы имеем следующее:

• Для первого столбца с индексом 0 максимальное значение 10 встречается во второй строке с индексом = 1.
• Для второго столбца с индексом 1 максимальное значение 9 встречается во второй строке с индексом = 1.
• Для третьего и четвертого столбцов с индексами 2 и 3 максимальные значения 8 и 4 встречаются во второй строке с индексом = 1.

Именно поэтому у нас есть выходной массив ([1, 1, 1, 1]), так как максимальный элемент по строкам приходится на вторую строку (для всех столбцов).

Индекс максимального элемента вдоль столбцов (ось = 1)

Далее воспользуемся функцией argmax(), чтобы найти индекс максимального элемента по столбцам.

Запустите следующий фрагмент кода и посмотрите на результат.

np.argmax(array_2,axis=1)

array([2, 0])

Можете ли вы разобрать вывод?

Мы установили ось = 1, чтобы вычислить индекс максимального элемента по столбцам.

Функция argmax() возвращает для каждой строки номер столбца, в котором встречается максимальное значение.

Вот визуальное объяснение:

Из приведенной выше диаграммы и вывода argmax() мы имеем следующее:

• Для первой строки с индексом 0 максимальное значение 7 встречается в третьем столбце с индексом = 2.
• Для второй строки с индексом 1 максимальное значение 10 встречается в первом столбце с индексом = 0.

Надеюсь, теперь вы понимаете, что такое вывод, массив([2, 0]) означает.

Использование необязательного параметра вывода в NumPy argmax()

Вы можете использовать необязательный параметр out the в функции NumPy argmax() для сохранения вывода в массиве NumPy.

Давайте инициализируем массив нулей для хранения вывода предыдущего вызова функции argmax() — для нахождения индекса максимума по столбцам (ось = 1).

out_arr = np.zeros((2,))
print(out_arr)
[0. 0.]

Теперь давайте вернемся к примеру поиска индекса максимального элемента по столбцам (ось = 1) и установим значение out равным out_arr, которое мы определили выше.

np.argmax(array_2,axis=1,out=out_arr)

Мы видим, что интерпретатор Python выдает TypeError, так как out_arr по умолчанию был инициализирован массивом с плавающей запятой.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py in _wrapfunc(obj, method, *args, **kwds)
     56     try:
---> 57         return bound(*args, **kwds)
     58     except TypeError:

TypeError: Cannot cast array data from dtype('float64') to dtype('int64') according to the rule 'safe'

Поэтому при установке параметра out для выходного массива важно убедиться, что выходной массив имеет правильную форму и тип данных. Поскольку индексы массива всегда являются целыми числами, мы должны установить для параметра dtype значение int при определении выходного массива.

out_arr = np.zeros((2,),dtype=int)
print(out_arr)

# Output
[0 0]

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

np.argmax(array_2,axis=1,out=out_arr)

Выходные данные функции argmax() теперь доступны в массиве out_arr.

print(out_arr)
# Output
[2 0]

Вывод

Я надеюсь, что это руководство помогло вам понять, как использовать функцию NumPy argmax(). Вы можете запустить примеры кода в блокноте Jupyter.

Давайте повторим то, что мы узнали.

• Функция NumPy argmax() возвращает индекс максимального элемента в массиве. Если максимальный элемент встречается в массиве a более одного раза, то np.argmax(a) возвращает индекс первого вхождения элемента.
• При работе с многомерными массивами вы можете использовать необязательный параметр оси, чтобы получить индекс максимального элемента по определенной оси. Например, в двумерном массиве: задав ось = 0 и ось = 1, можно получить индекс максимального элемента по строкам и столбцам соответственно.
• Если вы хотите сохранить возвращаемое значение в другом массиве, вы можете установить необязательный параметр out для выходного массива. Однако выходной массив должен иметь совместимую форму и тип данных.

Затем ознакомьтесь с подробным руководством по наборам Python.