Numpy egenverdier

“Numpy egenverdier er funksjonen i Python -skriptet som lar oss beregne egenverdiene for en gitt matrise. Eigenverdier har et stort antall applikasjoner innen maskinlæring, datasett og kontrollsystemer. Disse verdiene definerer systemstabiliteten i kontrollsystemer, hjelper til. Numpy tilhører de tilgjengelige pakkene som er levert av Python for å håndtere forskjellige funksjoner som er relevante for ND-arrays og matriser. For å beregne egenverdiene for enhver ND-array, bruker vi den innebygde funksjonen som leveres av Numpy-pakken “Numpy. Lining () ”. Vi kan beregne egenvektorene for egenverdiene ved å bruke den samme formelen siden de henger sammen.”

Fremgangsmåte

Denne artikkelen inneholder alle detaljene for å implementere Numpy EigenValue -funksjonen i Python -skriptet. Artikkelen gir først en kort introduksjon til egenverdien og det numpy biblioteket, og deretter viser den metoden for implementering av denne funksjonen på de utmerkede eksemplene. For å jobbe med denne funksjonen, må vi laste ned Python -kompilatoren og installere og importere Numpy -pakkene.

Syntaks

Syntaksen for å kalle funksjonen til numpy egenverdi er ganske enkel og er gitt som følger:

$ numpy. Lining.eig ()

Denne funksjonen tar inn en hvilken som helst matrise eller ND-array som er firkantet i naturen og returnerer egenverdiene og egenvektorene for den matrisen. En flerdimensjonal matrise er kjent som Square Matrix, og denne matrisen representerer all informasjonen relatert til systemet eller datasettet. Nå som vi har lært om syntaks for denne funksjonssamtalen, så nå bør vi prøve å implementere denne funksjonen på de forskjellige eksemplene.

Eksempel nr. 01

For å beregne egenverdiene til et hvilket som helst system, bør vi kjenne til matrisen. Så vi vil hypotetisk definere en firkantet matrise eller 2D (todimensjonal) matrise siden matrisen og ND-arrayen er nesten den samme, men erklæringsmetoden deres varierer litt fra hverandre. For å opprette en ND-array eller matrise for systemet, vil vi først importere Numpy-biblioteket som "NP" slik at vi kan bruke dette navnet, hvor vi blir pålagt å ringe Numpy. Etter å ha importert Numpy, vil vi nå gå fremover og erklære og initialisere en 2D-matrise med verdiene eller dens elementer som “[2, 2], [4, 4]”. Denne erklæringen vil bli gjort ved å ringe “NP. Array () ”-metode, og så vil vi gi disse verdiene til denne funksjonen som parameter og vil lagre resultatene i en viss variabel“ a ”. Denne variabelen “A” har nå systemmatrisen lagret i den. Etter å ha initialisert 2D-array, vil vi nå beregne egenverdier og egenvektorer ved å kalle funksjonen "NP". Lining. eig (matrise) ”.Til denne funksjonen vil vi passere den nd-arrayen som vi allerede har opprettet, og den vil returnere de to parametrene en egenverdi, som vi vil lagre i variabelen som "egenverdi", og den andre parameteren ville være egenvektorer som da ville være da Lagret i variabelen, som "EVEC", og deretter vil vi vise disse to parametrene ved å kalle utskriftsfunksjonen som "Print (navn på parameteren)". Vi har beskrevet hele dette forklarte eksemplet i form av Python -koden i følgende figur, og nå vil vi prøve å utføre dette skriptet for å bekrefte om koden vår er bygget riktig eller ikke.

Importer numpy som NP
a = np.Array ([[2, 2],
[4, 4]])
Eigenvalue, EVEC = NP.Lining.eig (a)
print ("Eigen -verdiene: \ n",
egenverdi)
Print ("Egenvektorene: \ n",
EVEC)

Etter utførelsen av koden, for eksempel nummer 1, ble kodebyggingen opprettet med suksess, og koden kom tilbake og viste de to parametrene for systemets ND-array som "egenvektor" og "egenverdier" som kan sees i utdrag av utgangen.

Eksempel # 02

Det forrige eksemplet har tatt en firkantet matrise av ordren 2 × 2, som faktisk er 2-D-array. Så i dette eksemplet vil vi prøve å oppgradere konseptet et skritt videre og vil beregne egenverdiene for systemet som har systemmatrisen til rekkefølge 3 × 3. Til å begynne med dette eksemplet, vil vi lage et nytt prosjekt i Python -kompilatoren, og så vil vi importere de grunnleggende Python -bibliotekene og pakkene som vi trenger å jobbe med senere i prosjektet.

Vi vil installere Numpy -pakken fra Python -bibliotekene, og deretter fra disse installerte pakkene, vil vi importere Numpy som ordet “NP”. Nå vil vi bruke denne NP i stedet for numpy i koden. La oss gå videre og lage en tredimensjonal matrise for systemet. En tredimensjonal matrise består av tre rader og tre kolonner. Vi vil kalle funksjonen “NP. Array () ”og send elementene til matrisen i 3 × 3 -ordren som“ [2, 2, 3], [3, 2, 4], [5, 4, 6] ”. Når 3-D-arrayen er initialisert, vil vi prøve å finne egenverdiene for denne matrisen, og vi vil igjen kalle funksjonen slik vi har gjort i forrige eksempel som “NP.Lining.eig (matrise) ”. Til funksjonen vil vi passere matrisen, og den vil returnere egenverdiene og vektorene for systemets matrise.

Importer numpy som NP
Array = NP.Array ([[2, 2, 3],
[3, 2, 4],
[5, 4, 6]])
Eigenvalue, EVEC = NP.Lining.eig (matrise)
print ("Eigen -verdiene: \ n",
egenverdi)
Print ("Egenvektorene: \ n",
EVEC)

Figuren ovenfor representerer kodebiten til scenariet som vi nettopp har diskutert i det andre eksemplet på denne artikkelen i form av Python -skriptet. Vi kan ganske enkelt kopiere denne koden og prøve å kjøre den på kompilatorene våre og sjekke utdataene. Utgangen fra koden har returnert nøyaktig de to parametrene som er egenverdier og egenvektorer, i form av de komplekse tallene som vi ønsket å bli beregnet for systemets matrise, som var en firkantet matrise på 3 × 3 dimensjoner (3d-array).

Konklusjon

Vi vil oppsummere artikkelen ved nok en gang å gjennomgå trinnene vi har tatt i denne artikkelen. Vi har gitt en kort historie om begrepet egenverdier med numpy pakker. Så diskuterte vi syntaks for implementering av egenverdiene ved hjelp av Numpy-pakken, og til slutt forklarte vi og implementerte i detalj egenverdiene for ND-arrays eller systemmatriser.