I denne opplæringen vil du lære hvordan du bruker NumPy argmax()-funksjonen for å finne indeksen til maksimumselementet i matriser.
NumPy er et kraftig bibliotek for vitenskapelig databehandling i Python; det gir N-dimensjonale arrays som er mer ytelsesdyktige enn Python-lister. En av de vanlige operasjonene du vil utføre når du arbeider med NumPy-matriser, er å finne maksimumsverdien i matrisen. Imidlertid vil du kanskje noen ganger finne indeksen der maksimumsverdien oppstår.
Argmax()-funksjonen hjelper deg med å finne indeksen til maksimum i både endimensjonale og flerdimensjonale matriser. La oss fortsette for å lære hvordan det fungerer.
Innholdsfortegnelse
Hvordan finne indeksen for maksimalt element i en NumPy-matrise
For å følge med på denne opplæringen, må du ha Python og NumPy installert. Du kan kode med ved å starte en Python REPL eller starte en Jupyter-notisbok.
Først, la oss importere NumPy under det vanlige aliaset np.
import numpy as np
Du kan bruke funksjonen NumPy max() for å få maksimalverdien i en matrise (valgfritt 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 tilfellet returnerer np.max(array_1) 10, som er riktig.
Anta at du vil finne indeksen der maksimumsverdien forekommer i matrisen. Du kan ta følgende to-trinns tilnærming:
I array_1 forekommer maksimalverdien på 10 ved indeks 4, etter nullindeksering. Det første elementet er ved indeks 0; det andre elementet er på indeks 1, og så videre.
For å finne indeksen der maksimum inntreffer, kan du bruke NumPy where()-funksjonen. np.where(condition) returnerer en matrise med alle indekser der betingelsen er sann.
Du må trykke inn i matrisen og få tilgang til elementet ved den første indeksen. For å finne hvor maksimumsverdien forekommer, setter vi betingelsen til array_1==10; husk at 10 er maksimumsverdien i array_1.
print(int(np.where(array_1==10)[0])) # Output 4
Vi har brukt np.where() med kun betingelsen, men dette er ikke den anbefalte metoden for å bruke denne funksjonen.
📑 Merk: NumPy where() funksjon:
np.where(betingelse,x,y) returnerer:
– Elementer fra x når betingelsen er Sann, og
– Elementer fra y når betingelsen er falsk.
Ved å lenke funksjonene np.max() og np.where() kan vi derfor finne maksimumselementet, etterfulgt av indeksen der det oppstår.
I stedet for den ovennevnte totrinnsprosessen, kan du bruke NumPy argmax()-funksjonen for å få indeksen til maksimumselementet i matrisen.
Syntaks for NumPy argmax()-funksjonen
Den generelle syntaksen for å bruke NumPy argmax()-funksjonen er som følger:
np.argmax(array,axis,out) # we've imported numpy under the alias np
I syntaksen ovenfor:
- array er en hvilken som helst gyldig NumPy array.
- akse er en valgfri parameter. Når du arbeider med flerdimensjonale matriser, kan du bruke akseparameteren til å finne indeksen for maksimum langs en bestemt akse.
- ut er en annen valgfri parameter. Du kan sette ut-parameteren til en NumPy-matrise for å lagre utdataene fra argmax()-funksjonen.
Merk: Fra NumPy versjon 1.22.0 er det en ekstra keepdims-parameter. Når vi spesifiserer akseparameteren i argmax() funksjonskallet, reduseres matrisen langs den aksen. Men å sette keepdims-parameteren til True sikrer at den returnerte utgangen har samme form som input-arrayen.
Bruke NumPy argmax() for å finne indeksen til det maksimale elementet
#1. La oss bruke funksjonen NumPy argmax() for å finne indeksen til maksimumselementet i array_1.
array_1 = np.array([1,5,7,2,10,9,8,4]) print(np.argmax(array_1)) # Output 4
Argmax()-funksjonen returnerer 4, som er riktig! ✅
#2. Hvis vi omdefinerer array_1 slik at10 forekommer to ganger, returnerer argmax()-funksjonen bare indeksen for den første forekomsten.
array_1 = np.array([1,5,7,2,10,10,8,4]) print(np.argmax(array_1)) # Output 4
For resten av eksemplene bruker vi elementene i array_1 vi definerte i eksempel #1.
Bruke NumPy argmax() for å finne indeksen til det maksimale elementet i en 2D-array
La oss omforme NumPy-matrisen array_1 til en todimensjonal matrise med to rader og fire kolonner.
array_2 = array_1.reshape(2,4) print(array_2) # Output [[ 1 5 7 2] [10 9 8 4]]
For en todimensjonal matrise angir akse 0 radene og akse 1 angir kolonnene. NumPy-matriser følger nullindeksering. Så indeksene til radene og kolonnene for NumPy array array_2 er som følger:
La oss nå kalle argmax()-funksjonen på den todimensjonale matrisen, array_2.
print(np.argmax(array_2)) # Output 4
Selv om vi kalte argmax() på den todimensjonale matrisen, returnerer den fortsatt 4. Dette er identisk med utgangen for den endimensjonale matrisen, matrise_1 fra forrige seksjon.
Hvorfor skjer dette? 🤔
Dette er fordi vi ikke har spesifisert noen verdi for akseparameteren. Når denne akseparameteren ikke er angitt, returnerer argmax()-funksjonen som standard indeksen til maksimumselementet langs den flate matrisen.
Hva er en flatet matrise? Hvis det er en N-dimensjonal matrise med form d1 x d2 x … x dN, der d1, d2, opp til dN er størrelsene på matrisen langs de N dimensjonene, så er den flate matrisen en lang endimensjonal matrise med størrelse d1 * d2 * … * dN.
For å sjekke hvordan den flattede matrisen ser ut for array_2, kan du kalle flatten()-metoden, som vist nedenfor:
array_2.flatten() # Output array([ 1, 5, 7, 2, 10, 9, 8, 4])
Indeks for maksimumselementet langs radene (akse = 0)
La oss fortsette med å finne indeksen til det maksimale elementet langs radene (akse = 0).
np.argmax(array_2,axis=0) # Output array([1, 1, 1, 1])
Denne utgangen kan være litt vanskelig å forstå, men vi vil forstå hvordan den fungerer.
Vi har satt akseparameteren til null (akse = 0), da vi ønsker å finne indeksen til maksimumselementet langs radene. Derfor returnerer argmax()-funksjonen radnummeret der maksimumselementet forekommer – for hver av de tre kolonnene.
La oss visualisere dette for bedre forståelse.
Fra diagrammet ovenfor og argmax()-utgangen har vi følgende:
- For den første kolonnen ved indeks 0, oppstår maksimalverdien 10 i den andre raden, ved indeks = 1.
- For den andre kolonnen ved indeks 1 forekommer maksimalverdien 9 i den andre raden, ved indeks = 1.
- For den tredje og fjerde kolonnen ved indeks 2 og 3, forekommer maksimumsverdiene 8 og 4 begge i den andre raden, ved indeks = 1.
Det er nettopp derfor vi har utgangsmatrisen([1, 1, 1, 1]) fordi det maksimale elementet langs radene forekommer i den andre raden (for alle kolonner).
Indeks for maksimumselementet langs kolonnene (akse = 1)
La oss deretter bruke argmax()-funksjonen for å finne indeksen til maksimumselementet langs kolonnene.
Kjør følgende kodebit og observer utdataene.
np.argmax(array_2,axis=1)
array([2, 0])
Kan du analysere utdataene?
Vi har satt akse = 1 for å beregne indeksen til det maksimale elementet langs kolonnene.
Argmax()-funksjonen returnerer, for hver rad, kolonnenummeret der maksimumsverdien forekommer.
Her er en visuell forklaring:
Fra diagrammet ovenfor og argmax()-utgangen har vi følgende:
- For den første raden ved indeks 0, oppstår maksimalverdien 7 i den tredje kolonnen, ved indeks = 2.
- For den andre raden ved indeks 1 forekommer maksimalverdien 10 i den første kolonnen, ved indeks = 0.
Jeg håper du nå forstår hva utgangen, array([2, 0]) midler.
Bruke den valgfrie ut-parameteren i NumPy argmax()
Du kan bruke den valgfrie ut-parameteren i NumPy argmax()-funksjonen for å lagre utdataene i en NumPy-matrise.
La oss initialisere en matrise med nuller for å lagre utdata fra forrige argmax() funksjonskall – for å finne indeksen til maksimum langs kolonnene (akse= 1).
out_arr = np.zeros((2,)) print(out_arr) [0. 0.]
La oss nå se på eksemplet med å finne indeksen til det maksimale elementet langs kolonnene (akse = 1) og sette ut til out_arr vi har definert ovenfor.
np.argmax(array_2,axis=1,out=out_arr)
Vi ser at Python-tolken kaster en TypeError, ettersom out_arr ble initialisert til en rekke flytere 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'
Derfor, når du setter ut-parameteren til utmatrisen, er det viktig å sikre at utmatrisen er av riktig form og datatype. Siden matriseindekser alltid er heltall, bør vi sette parameteren dtype til int når vi definerer utmatrisen.
out_arr = np.zeros((2,),dtype=int) print(out_arr) # Output [0 0]
Vi kan nå gå videre og kalle argmax()-funksjonen med både akse- og ut-parametere, og denne gangen kjører den uten feil.
np.argmax(array_2,axis=1,out=out_arr)
Utdataene fra argmax()-funksjonen kan nå nås i matrisen out_arr.
print(out_arr) # Output [2 0]
Konklusjon
Jeg håper denne opplæringen hjalp deg med å forstå hvordan du bruker NumPy argmax()-funksjonen. Du kan kjøre kodeeksemplene i en Jupyter-notisbok.
La oss gå gjennom det vi har lært.
- Funksjonen NumPy argmax() returnerer indeksen til maksimumselementet i en matrise. Hvis maksimumselementet forekommer mer enn én gang i en matrise a, returnerer np.argmax(a) indeksen for den første forekomsten av elementet.
- Når du arbeider med flerdimensjonale matriser, kan du bruke den valgfrie akseparameteren for å få indeksen til det maksimale elementet langs en bestemt akse. For eksempel, i en todimensjonal matrise: ved å sette akse = 0 og akse = 1, kan du få indeksen til det maksimale elementet langs henholdsvis radene og kolonnene.
- Hvis du vil lagre den returnerte verdien i en annen matrise, kan du sette den valgfrie ut-parameteren til utmatrisen. Utdatamatrisen bør imidlertid være av kompatibel form og datatype.
Deretter kan du sjekke ut den grundige veiledningen om Python-sett.