I denne øvelse lærer du, hvordan du bruger funktionen NumPy argmax() til at finde indekset for det maksimale element i arrays.
NumPy er et kraftfuldt bibliotek til videnskabelig databehandling i Python; det giver N-dimensionelle arrays, der er mere effektive end Python-lister. En af de almindelige handlinger, du vil udføre, når du arbejder med NumPy-arrays, er at finde den maksimale værdi i arrayet. Det kan dog være, at du nogle gange ønsker at finde det indeks, hvor den maksimale værdi forekommer.
Argmax()-funktionen hjælper dig med at finde indekset for maksimum i både endimensionelle og flerdimensionale arrays. Lad os fortsætte for at lære, hvordan det virker.
Indholdsfortegnelse
Sådan finder du indekset for det maksimale element i et NumPy-array
For at følge med i denne tutorial skal du have Python og NumPy installeret. Du kan kode med ved at starte en Python REPL eller starte en Jupyter notesbog.
Lad os først importere NumPy under det sædvanlige alias np.
import numpy as np
Du kan bruge funktionen NumPy max() til at få den maksimale værdi i et array (valgfrit langs en bestemt akse).
array_1 = np.array([1,5,7,2,10,9,8,4]) print(np.max(array_1)) # Output 10
I dette tilfælde returnerer np.max(array_1) 10, hvilket er korrekt.
Antag, at du gerne vil finde det indeks, hvor den maksimale værdi forekommer i arrayet. Du kan tage følgende to-trins tilgang:
I array_1 forekommer den maksimale værdi på 10 ved indeks 4 efter nul-indeksering. Det første element er ved indeks 0; det andet element er ved indeks 1, og så videre.
For at finde det indeks, hvor maksimum forekommer, kan du bruge NumPy where()-funktionen. np.where(condition) returnerer en matrix af alle indekser, hvor betingelsen er Sand.
Du bliver nødt til at trykke ind i arrayet og få adgang til elementet ved det første indeks. For at finde ud af, hvor den maksimale værdi forekommer, sætter vi betingelsen til array_1==10; husk, at 10 er den maksimale værdi i array_1.
print(int(np.where(array_1==10)[0])) # Output 4
Vi har brugt np.where() med kun betingelsen, men dette er ikke den anbefalede metode til at bruge denne funktion.
📑 Bemærk: NumPy where() Funktion:
np.where(betingelse,x,y) returnerer:
– Elementer fra x, når betingelsen er Sand, og
– Elementer fra y, når betingelsen er falsk.
Ved at sammenkæde funktionerne np.max() og np.where() kan vi derfor finde det maksimale element efterfulgt af indekset, hvor det forekommer.
I stedet for ovenstående to-trins proces kan du bruge funktionen NumPy argmax() til at få indekset for det maksimale element i arrayet.
Syntaks for NumPy argmax()-funktionen
Den generelle syntaks for at bruge funktionen NumPy argmax() er som følger:
np.argmax(array,axis,out) # we've imported numpy under the alias np
I ovenstående syntaks:
- array er et hvilket som helst gyldigt NumPy-array.
- akse er en valgfri parameter. Når du arbejder med flerdimensionelle arrays, kan du bruge akseparameteren til at finde indekset for maksimum langs en bestemt akse.
- ud er en anden valgfri parameter. Du kan indstille out-parameteren til et NumPy-array for at gemme outputtet af argmax()-funktionen.
Bemærk: Fra NumPy version 1.22.0 er der en ekstra keepdims-parameter. Når vi angiver akseparameteren i funktionskaldet argmax(), reduceres arrayet langs denne akse. Men indstilling af keepdims-parameteren til True sikrer, at det returnerede output har samme form som input-arrayet.
Brug af NumPy argmax() til at finde indekset for det maksimale element
#1. Lad os bruge funktionen NumPy argmax() til at finde indekset for det maksimale element i array_1.
array_1 = np.array([1,5,7,2,10,9,8,4]) print(np.argmax(array_1)) # Output 4
Argmax()-funktionen returnerer 4, hvilket er korrekt! ✅
#2. Hvis vi omdefinerer array_1 sådan, at10 forekommer to gange, returnerer funktionen argmax() kun indekset for den første forekomst.
array_1 = np.array([1,5,7,2,10,10,8,4]) print(np.argmax(array_1)) # Output 4
For resten af eksemplerne bruger vi elementerne i array_1, vi definerede i eksempel #1.
Brug af NumPy argmax() til at finde indekset for det maksimale element i et 2D-array
Lad os omforme NumPy-arrayet array_1 til et todimensionelt array med to rækker og fire kolonner.
array_2 = array_1.reshape(2,4) print(array_2) # Output [[ 1 5 7 2] [10 9 8 4]]
For en todimensional matrix angiver akse 0 rækkerne, og akse 1 angiver kolonnerne. NumPy-arrays følger nul-indeksering. Så indeksene for rækkerne og kolonnerne for NumPy array array_2 er som følger:
Lad os nu kalde funktionen argmax() på det todimensionelle array, array_2.
print(np.argmax(array_2)) # Output 4
Selvom vi kaldte argmax() på det to-dimensionelle array, returnerer det stadig 4. Dette er identisk med outputtet for det en-dimensionelle array, array_1 fra forrige afsnit.
Hvorfor sker dette? 🤔
Dette skyldes, at vi ikke har angivet nogen værdi for akseparameteren. Når denne akseparameter ikke er indstillet, returnerer funktionen argmax() som standard indekset for det maksimale element langs det fladtrykte array.
Hvad er et fladt array? Hvis der er et N-dimensionelt array med form d1 x d2 x … x dN, hvor d1, d2, op til dN er størrelserne af arrayet langs de N dimensioner, så er det fladtrykte array et langt endimensionelt array af størrelse d1 * d2 * … * dN.
For at kontrollere, hvordan det fladtrykte array ser ud for array_2, kan du kalde flatten()-metoden, som vist nedenfor:
array_2.flatten() # Output array([ 1, 5, 7, 2, 10, 9, 8, 4])
Indeks for det maksimale element langs rækkerne (akse = 0)
Lad os fortsætte med at finde indekset for det maksimale element langs rækkerne (akse = 0).
np.argmax(array_2,axis=0) # Output array([1, 1, 1, 1])
Dette output kan være lidt svært at forstå, men vi vil forstå, hvordan det fungerer.
Vi har sat akseparameteren til nul (akse = 0), da vi gerne vil finde indekset for det maksimale element langs rækkerne. Derfor returnerer funktionen argmax() rækkenummeret, hvori det maksimale element forekommer – for hver af de tre kolonner.
Lad os visualisere dette for bedre forståelse.
Fra ovenstående diagram og argmax() output har vi følgende:
- For den første kolonne ved indeks 0 forekommer den maksimale værdi 10 i den anden række, ved indeks = 1.
- For den anden kolonne ved indeks 1 forekommer den maksimale værdi 9 i anden række, ved indeks = 1.
- For tredje og fjerde kolonne ved indeks 2 og 3 forekommer de maksimale værdier 8 og 4 begge i anden række, ved indeks = 1.
Det er netop derfor, vi har output-arrayet([1, 1, 1, 1]), fordi det maksimale element langs rækkerne forekommer i den anden række (for alle kolonner).
Indeks for det maksimale element langs søjlerne (akse = 1)
Lad os derefter bruge funktionen argmax() til at finde indekset for det maksimale element langs kolonnerne.
Kør følgende kodestykke og observer outputtet.
np.argmax(array_2,axis=1)
array([2, 0])
Kan du parse outputtet?
Vi har sat akse = 1 for at beregne indekset for det maksimale element langs søjlerne.
Argmax()-funktionen returnerer for hver række kolonnenummeret, hvori den maksimale værdi forekommer.
Her er en visuel forklaring:
Fra ovenstående diagram og argmax() output har vi følgende:
- For den første række ved indeks 0 forekommer den maksimale værdi 7 i den tredje kolonne, ved indeks = 2.
- For den anden række ved indeks 1 forekommer den maksimale værdi 10 i den første kolonne, ved indeks = 0.
Jeg håber, du nu forstår, hvad outputtet, array([2, 0]) midler.
Brug af den valgfrie ud-parameter i NumPy argmax()
Du kan bruge den valgfrie ud-parameter i funktionen NumPy argmax() til at gemme outputtet i et NumPy-array.
Lad os initialisere et array af nuller for at gemme outputtet fra det forrige argmax() funktionskald – for at finde indekset for maksimum langs kolonnerne (akse= 1).
out_arr = np.zeros((2,)) print(out_arr) [0. 0.]
Lad os nu gense eksemplet med at finde indekset for det maksimale element langs kolonnerne (akse = 1) og sætte ud til out_arr, som vi har defineret ovenfor.
np.argmax(array_2,axis=1,out=out_arr)
Vi ser, at Python-fortolkeren kaster en TypeError, da out_arr blev initialiseret til et array af 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 indstiller ud-parameteren til output-arrayet, er det derfor vigtigt at sikre, at output-arrayet er af den korrekte form og datatype. Da array-indekser altid er heltal, bør vi sætte parameteren dtype til int, når vi definerer output-arrayet.
out_arr = np.zeros((2,),dtype=int) print(out_arr) # Output [0 0]
Vi kan nu gå videre og kalde funktionen argmax() med både akse- og ud-parametrene, og denne gang kører den uden fejl.
np.argmax(array_2,axis=1,out=out_arr)
Outputtet af funktionen argmax() kan nu tilgås i arrayet out_arr.
print(out_arr) # Output [2 0]
Konklusion
Jeg håber, at denne vejledning hjalp dig med at forstå, hvordan du bruger NumPy argmax()-funktionen. Du kan køre kodeeksemplerne i en Jupyter notesbog.
Lad os gennemgå, hvad vi har lært.
- Funktionen NumPy argmax() returnerer indekset for det maksimale element i en matrix. Hvis det maksimale element forekommer mere end én gang i et array a, returnerer np.argmax(a) indekset for den første forekomst af elementet.
- Når du arbejder med flerdimensionelle arrays, kan du bruge den valgfrie akseparameter til at få indekset for det maksimale element langs en bestemt akse. For eksempel i en todimensional matrix: ved at indstille akse = 0 og akse = 1, kan du få indekset for det maksimale element langs henholdsvis rækkerne og kolonnerne.
- Hvis du vil gemme den returnerede værdi i et andet array, kan du indstille den valgfrie ud-parameter til output-arrayet. Output-arrayet skal dog være af kompatibel form og datatype.
Tjek derefter den dybdegående vejledning om Python-sæt.