I den här handledningen kommer du att lära dig hur du använder funktionen NumPy argmax() för att hitta indexet för det maximala elementet i arrayer.
NumPy är ett kraftfullt bibliotek för vetenskaplig beräkning i Python; det ger N-dimensionella arrayer som är mer presterande än Python-listor. En av de vanliga operationerna du kommer att utföra när du arbetar med NumPy-arrayer är att hitta det maximala värdet i arrayen. Emellertid kanske du ibland vill hitta indexet där det maximala värdet inträffar.
Argmax()-funktionen hjälper dig att hitta indexet för maximum i både endimensionella och flerdimensionella arrayer. Låt oss fortsätta för att lära oss hur det fungerar.
Innehållsförteckning
Hur man hittar indexet för maximalt element i en NumPy-array
För att följa med i denna handledning måste du ha Python och NumPy installerade. Du kan koda med genom att starta en Python REPL eller starta en Jupyter-anteckningsbok.
Låt oss först importera NumPy under det vanliga aliaset np.
import numpy as np
Du kan använda funktionen NumPy max() för att få det maximala värdet i en array (valfritt längs en specifik axel).
array_1 = np.array([1,5,7,2,10,9,8,4]) print(np.max(array_1)) # Output 10
I det här fallet returnerar np.max(array_1) 10, vilket är korrekt.
Anta att du vill hitta indexet där det maximala värdet förekommer i arrayen. Du kan ta följande tvåstegsmetod:
I array_1 inträffar det maximala värdet på 10 vid index 4, efter nollindexering. Det första elementet är vid index 0; det andra elementet är vid index 1, och så vidare.
För att hitta indexet vid vilket maximum inträffar kan du använda NumPy where()-funktionen. np.where(condition) returnerar en matris med alla index där villkoret är sant.
Du måste knacka in i arrayen och komma åt objektet vid det första indexet. För att hitta var det maximala värdet förekommer sätter vi villkoret till array_1==10; kom ihåg att 10 är det maximala värdet i array_1.
print(int(np.where(array_1==10)[0])) # Output 4
Vi har använt np.where() med endast villkoret, men detta är inte den rekommenderade metoden för att använda den här funktionen.
📑 Obs: NumPy where() Funktion:
np.where(condition,x,y) returnerar:
– Element från x när villkoret är sant, och
– Element från y när villkoret är Falskt.
Genom att koppla ihop funktionerna np.max() och np.where() kan vi därför hitta det maximala elementet, följt av indexet där det förekommer.
Istället för ovanstående tvåstegsprocess kan du använda funktionen NumPy argmax() för att få indexet för det maximala elementet i arrayen.
Syntax för NumPy argmax()-funktionen
Den allmänna syntaxen för att använda NumPy argmax()-funktionen är som följer:
np.argmax(array,axis,out) # we've imported numpy under the alias np
I ovanstående syntax:
- array är vilken giltig NumPy-array som helst.
- axel är en valfri parameter. När du arbetar med flerdimensionella arrayer kan du använda axelparametern för att hitta indexet för maximum längs en specifik axel.
- ut är en annan valfri parameter. Du kan ställa in parametern ut till en NumPy-matris för att lagra utdata från funktionen argmax().
Notera: Från NumPy version 1.22.0 finns det ytterligare en keepdims-parameter. När vi anger axelparametern i funktionsanropet argmax() reduceras arrayen längs den axeln. Men att ställa in keepdims-parametern till True säkerställer att den returnerade utgången har samma form som inmatningsmatrisen.
Använda NumPy argmax() för att hitta indexet för det maximala elementet
#1. Låt oss använda funktionen NumPy argmax() för att hitta indexet för det maximala elementet i array_1.
array_1 = np.array([1,5,7,2,10,9,8,4]) print(np.argmax(array_1)) # Output 4
Argmax()-funktionen returnerar 4, vilket är korrekt! ✅
#2. Om vi omdefinierar array_1 så att10 inträffar två gånger, returnerar funktionen argmax() endast indexet för den första förekomsten.
array_1 = np.array([1,5,7,2,10,10,8,4]) print(np.argmax(array_1)) # Output 4
För resten av exemplen kommer vi att använda elementen i array_1 som vi definierade i exempel #1.
Använda NumPy argmax() för att hitta indexet för det maximala elementet i en 2D-array
Låt oss omforma NumPy-arrayen array_1 till en tvådimensionell array med två rader och fyra kolumner.
array_2 = array_1.reshape(2,4) print(array_2) # Output [[ 1 5 7 2] [10 9 8 4]]
För en tvådimensionell matris anger axel 0 raderna och axel 1 anger kolumnerna. NumPy-matriser följer nollindexering. Så indexen för raderna och kolumnerna för NumPy array array_2 är som följer:
Låt oss nu kalla funktionen argmax() på den tvådimensionella arrayen array_2.
print(np.argmax(array_2)) # Output 4
Även om vi anropade argmax() på den tvådimensionella arrayen, returnerar den fortfarande 4. Detta är identisk med utdata för den endimensionella arrayen, array_1 från föregående avsnitt.
Varför händer detta? 🤔
Detta beror på att vi inte har angett något värde för axelparametern. När denna axelparameter inte är inställd returnerar funktionen argmax() som standard indexet för det maximala elementet längs den tillplattade arrayen.
Vad är en tillplattad array? Om det finns en N-dimensionell array med formen d1 x d2 x … x dN, där d1, d2, upp till dN är storleken på arrayen längs de N dimensionerna, så är den tillplattade arrayen en lång endimensionell array av storlek d1 * d2 * … * dN.
För att kontrollera hur den tillplattade arrayen ser ut för array_2, kan du anropa flatten()-metoden, som visas nedan:
array_2.flatten() # Output array([ 1, 5, 7, 2, 10, 9, 8, 4])
Index för det maximala elementet längs raderna (axel = 0)
Låt oss fortsätta för att hitta indexet för det maximala elementet längs raderna (axel = 0).
np.argmax(array_2,axis=0) # Output array([1, 1, 1, 1])
Det här resultatet kan vara lite svårt att förstå, men vi kommer att förstå hur det fungerar.
Vi har satt axelparametern till noll (axel = 0), eftersom vi vill hitta indexet för det maximala elementet längs raderna. Därför returnerar funktionen argmax() radnumret där det maximala elementet förekommer – för var och en av de tre kolumnerna.
Låt oss visualisera detta för bättre förståelse.
Från diagrammet ovan och argmax()-utgången har vi följande:
- För den första kolumnen vid index 0, uppträder maxvärdet 10 i den andra raden, vid index = 1.
- För den andra kolumnen vid index 1 förekommer maxvärdet 9 i den andra raden, vid index = 1.
- För den tredje och fjärde kolumnen vid index 2 och 3 förekommer maxvärdena 8 och 4 båda i den andra raden, vid index = 1.
Det är just därför vi har utgångsmatrisen([1, 1, 1, 1]) eftersom det maximala elementet längs raderna förekommer i den andra raden (för alla kolumner).
Index för det maximala elementet längs kolumnerna (axel = 1)
Låt oss sedan använda funktionen argmax() för att hitta indexet för det maximala elementet längs kolumnerna.
Kör följande kodavsnitt och observera resultatet.
np.argmax(array_2,axis=1)
array([2, 0])
Kan du analysera utgången?
Vi har satt axel = 1 för att beräkna indexet för det maximala elementet längs kolumnerna.
Funktionen argmax() returnerar, för varje rad, kolumnnumret där det maximala värdet förekommer.
Här är en visuell förklaring:
Från diagrammet ovan och argmax()-utgången har vi följande:
- För den första raden vid index 0, förekommer maxvärdet 7 i den tredje kolumnen, vid index = 2.
- För den andra raden vid index 1, uppträder maxvärdet 10 i den första kolumnen, vid index = 0.
Jag hoppas att du nu förstår vad resultatet, array([2, 0]) betyder att.
Använda den valfria ut-parametern i NumPy argmax()
Du kan använda den valfria parametern ut i funktionen NumPy argmax() för att lagra utdata i en NumPy-array.
Låt oss initiera en matris med nollor för att lagra utdata från det föregående funktionsanropet argmax() – för att hitta indexet för maximum längs kolumnerna (axel= 1).
out_arr = np.zeros((2,)) print(out_arr) [0. 0.]
Låt oss nu återgå till exemplet med att hitta indexet för det maximala elementet längs kolumnerna (axel = 1) och sätta ut till out_arr som vi har definierat ovan.
np.argmax(array_2,axis=1,out=out_arr)
Vi ser att Python-tolken kastar ett TypeError, eftersom out_arr initialiserades till en array av float som standard.
---------------------------------------------------------------------------
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'
När du ställer in parametern ut till utmatrisen är det därför viktigt att se till att utmatrisen är av rätt form och datatyp. Eftersom matrisindex alltid är heltal bör vi ställa in parametern dtype till int när vi definierar utmatrisen.
out_arr = np.zeros((2,),dtype=int) print(out_arr) # Output [0 0]
Vi kan nu gå vidare och anropa argmax()-funktionen med både axel- och utparametrarna, och den här gången körs den utan fel.
np.argmax(array_2,axis=1,out=out_arr)
Utdata från funktionen argmax() kan nu nås i arrayen out_arr.
print(out_arr) # Output [2 0]
Slutsats
Jag hoppas att den här handledningen hjälpte dig att förstå hur du använder NumPy argmax()-funktionen. Du kan köra kodexemplen i en Jupyter-anteckningsbok.
Låt oss granska vad vi har lärt oss.
- Funktionen NumPy argmax() returnerar indexet för det maximala elementet i en array. Om det maximala elementet förekommer mer än en gång i en array a, returnerar np.argmax(a) indexet för den första förekomsten av elementet.
- När du arbetar med flerdimensionella arrayer kan du använda den valfria axelparametern för att få indexet för det maximala elementet längs en viss axel. Till exempel, i en tvådimensionell array: genom att ställa in axel = 0 och axel = 1 kan du få indexet för det maximala elementet längs raderna respektive kolumnerna.
- Om du vill lagra det returnerade värdet i en annan matris kan du ställa in den valfria ut-parametern till utmatrisen. Utdatamatrisen bör dock vara av kompatibel form och datatyp.
Kolla sedan in den djupgående guiden om Python-set.