Oversikt over egenverdier og SVD
Beregn egenverdier og egenvektorer med np.linalg.eig, og forstå hvordan SVD danner grunnlaget for dimensjonsreduksjon med PCA.
Oversikt over egenverdier og SVD er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Hva er egenverdier og egenvektorer?
En egenvektor til en kvadratisk matrise A er en vektor v som ikke er null, og som oppfyller A @ v = lambda * v – multiplikasjon med A skalerer bare v; retningen endres ikke. Skalaren lambda kalles egenverdien som hører til v. Egenverdier viser de iboende «strekkfaktorene» til en lineær transformasjon: En egenverdi på 2 betyr at matrisen dobler lengdene i egenvektorens retning, mens en negativ egenverdi snur retningen.
import numpy as np
A = np.array([[3.0, 1.0],
[0.0, 2.0]])
eigenvalues, eigenvectors = np.linalg.eig(A)
print('Eigenvalues:', eigenvalues)
print('Eigenvectors (columns):')
print(eigenvectors)Beregning av egenverdier med np.linalg.eig()
np.linalg.eig(A) returnerer en tuppel med (eigenvalues, eigenvectors). Egenverdiene er en endimensjonal tabell, mens egenvektorene er en todimensjonal tabell der hver kolonne er en egenvektor. For reelle symmetriske matriser (som kovariansmatriser) er egenverdiene alltid reelle, og egenvektorene er ortogonale – bruk np.linalg.eigh(A) for symmetriske matriser, siden den er raskere og garantert å returnere reelle resultater.
import numpy as np
# Symmetric matrix -> use eigh for efficiency and real eigenvalues
A = np.array([[4.0, 2.0],
[2.0, 3.0]])
vals, vecs = np.linalg.eigh(A)
print('Eigenvalues (real):', vals)
print('Eigenvectors (orthonormal columns):')
print(vecs)
# Verify: A @ v = lambda * v for each eigenvector
for i in range(len(vals)):
lhs = A @ vecs[:, i]
rhs = vals[i] * vecs[:, i]
print(f'v{i} check:', np.allclose(lhs, rhs))Egenverdier og matriseegenskaper
Egenverdier inneholder viktige egenskaper ved matriser. Determinanten er lik produktet av alle egenverdiene: det(A) = product(eigenvalues). Sporet (summen av diagonalelementene) er lik summen av egenverdiene: trace(A) = sum(eigenvalues). En matrise er positivt definit (alle egenverdier > 0) bare når alle egenverdiene er positive – en avgjørende egenskap for gyldige kovariansmatriser og konvekse optimaliseringsproblemer.
import numpy as np
A = np.array([[4.0, 2.0],
[2.0, 3.0]])
vals, _ = np.linalg.eigh(A)
print('Eigenvalues:', vals)
print('Product (should = det):', np.prod(vals))
print('np.linalg.det:', np.linalg.det(A))
print('Sum (should = trace):', np.sum(vals))
print('np.trace:', np.trace(A))
print('Positive definite:', np.all(vals > 0))Oversikt over singulærverdidekomponering (SVD)
Singulærverdidekomponering (SVD) dekomponerer enhver matrise A (ikke bare kvadratiske matriser) som A = U @ S @ V.T, der U og V er ortogonale matriser, og S er diagonal med ikke-negative singulærverdier på diagonalen. SVD er den mest generelle og numerisk stabile faktoriseringen av matriser. Den danner grunnlaget for PCA, bildekomprimering, anbefalingssystemer og beregning av pseudoinversen. np.linalg.svd(A) returnerer U, s (endimensjonale singulærverdier) og Vh (V transponert).
import numpy as np
A = np.array([[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0]])
U, s, Vh = np.linalg.svd(A, full_matrices=False)
print('U shape:', U.shape)
print('s (singular values):', s)
print('Vh shape:', Vh.shape)
# Reconstruct A
A_reconstructed = U @ np.diag(s) @ Vh
print('Reconstruction correct:', np.allclose(A, A_reconstructed))Singulærverdier og matriserang
Singulærverdiene (diagonalen i S) er alltid ikke-negative og listes vanligvis i synkende rekkefølge. Antallet singulærverdier som ikke er null, er lik matrisens rang. Singulærverdier nær null indikerer nesten-lineær avhengighet mellom rader eller kolonner. Den største singulærverdien gir matrisens spektralnorm, og forholdet mellom den største og den minste ikke-null-singulærverdien er kondisjonstallet som brukes til å måle numerisk stabilitet.
import numpy as np
# Full-rank matrix
A = np.random.rand(5, 3)
U, s, Vh = np.linalg.svd(A, full_matrices=False)
print('Singular values:', np.round(s, 4))
print('Rank (non-zero sv):', np.linalg.matrix_rank(A))
print('Condition number:', s[0] / s[-1])
# Rank-deficient matrix
B = np.array([[1.0, 2.0], [2.0, 4.0], [3.0, 6.0]])
_, sb, _ = np.linalg.svd(B, full_matrices=False)
print('Rank-deficient sv:', np.round(sb, 8))SVD og PCA: sammenhengen
Hovedkomponentanalyse (PCA) kan implementeres direkte ved hjelp av SVD. Når De har sentrert datamatrisen X (ved å trekke fra kolonnemidlene), er de høyre singulærvektorene i Vh hovedkomponentene, og kvadratet av singulærverdiene (delt på n-1) er den forklarte variansen. Sklearns PCA bruker nøyaktig denne fremgangsmåten. Når De forstår denne sammenhengen, kan De implementere eller tilpasse PCA fra grunnen av for dimensjonsreduksjon.
import numpy as np
np.random.seed(0)
X = np.random.randn(100, 4)
# Center the data
X_centered = X - X.mean(axis=0)
# SVD-based PCA
U, s, Vh = np.linalg.svd(X_centered, full_matrices=False)
# Variance explained by each component
var_explained = (s ** 2) / (X.shape[0] - 1)
total_var = var_explained.sum()
print('Variance explained ratio:', np.round(var_explained / total_var, 3))
# Project onto top 2 principal components
X_pca = X_centered @ Vh[:2].T
print('Reduced shape:', X_pca.shape)Lavrangsapproksimering med SVD
SVD muliggjør lavrangsapproksimering av matriser: behold bare de k største singulærverdiene og singulærvektorene, og rekonstruer en approksimasjon av den opprinnelige matrisen. Dette er grunnlaget for bildekomprimering og kollaborativ filtrering i anbefalingssystemer. Den trunkerte SVD-en U[:, :k] @ np.diag(s[:k]) @ Vh[:k, :] gir den beste approksimasjonen med rang k i minste-kvadraters forstand (Eckart-Young-teoremet).
import numpy as np
np.random.seed(1)
A = np.random.rand(20, 15)
U, s, Vh = np.linalg.svd(A, full_matrices=False)
# Rank-3 approximation
k = 3
A_approx = U[:, :k] @ np.diag(s[:k]) @ Vh[:k, :]
error = np.linalg.norm(A - A_approx, 'fro')
total = np.linalg.norm(A, 'fro')
print(f'Approximation error: {error/total:.3f} (fraction of total)')
print(f'Top-3 singular values capture {(s[:3]**2).sum()/(s**2).sum():.1%} of variance')Egenverdidekomponering kontra SVD: når skal De bruke hva?
Bruk egendekomponering (np.linalg.eig eller eigh) når De har en kvadratisk, symmetrisk matrise og vil forstå dens hovedakser – for eksempel kovariansmatrisen i PCA eller Markov-overgangsmatriser. Bruk SVD (np.linalg.svd) når matrisen er rektangulær, eller når De trenger maksimal numerisk stabilitet. SVD eksisterer alltid, mens egendekomponering kan gi komplekse tall for ikke-symmetriske matriser.
import numpy as np
# Non-symmetric matrix: eigenvalues may be complex
A = np.array([[0.0, -1.0],
[1.0, 0.0]])
vals, _ = np.linalg.eig(A)
print('Eigenvalues (complex for rotation):', vals)
# SVD always gives real singular values
_, s, _ = np.linalg.svd(A)
print('Singular values (always real):', s)Spektralteoremet for symmetriske matriser
Spektralteoremet sier at enhver reell, symmetrisk matrise A kan dekomponeres som A = Q @ diag(eigenvalues) @ Q.T, der Q er ortogonal (Q.T = Q⁻¹). Dette betyr at symmetriske matriser alltid kan diagonaliseres med reelle egenverdier og ortogonale egenvektorer. Kovariansmatriser, kjernematriser i SVM-er og Hessian-matrisen i optimalisering er alle symmetriske, noe som gjør dette teoremet svært nyttig i teorien for maskinlæring.
import numpy as np
A = np.array([[5.0, 2.0, 1.0],
[2.0, 3.0, 0.0],
[1.0, 0.0, 4.0]])
vals, Q = np.linalg.eigh(A)
print('Eigenvalues:', np.round(vals, 4))
# Reconstruct A = Q @ diag(vals) @ Q.T
A_reconstructed = Q @ np.diag(vals) @ Q.T
print('Reconstruction correct:', np.allclose(A, A_reconstructed))
print('Q is orthogonal:', np.allclose(Q.T @ Q, np.eye(3)))Praktisk: potensiterasjon for den dominerende egenverdien
Når De bare trenger den største egenverdien og den tilhørende egenvektoren, er potensiterasjon langt mer effektivt enn å beregne alle egenverdiene. Start med en tilfeldig vektor, multipliser gjentatte ganger med A og normaliser, så konvergerer metoden mot den dominerende egenvektoren. Slik fungerte Googles opprinnelige PageRank-algoritme. NumPy gjør hver iterasjon til én matrise-vektor-multiplikasjon med @.
import numpy as np
A = np.array([[4.0, 1.0, 2.0],
[1.0, 3.0, 0.0],
[2.0, 0.0, 2.0]])
v = np.random.rand(3)
for _ in range(50):
v = A @ v
v = v / np.linalg.norm(v)
eigenvalue_approx = v @ A @ v
print('Dominant eigenvector:', np.round(v, 4))
print('Approx eigenvalue:', round(eigenvalue_approx, 4))
# Verify with eigh
vals, vecs = np.linalg.eigh(A)
print('True max eigenvalue:', round(vals[-1], 4))Bruk av np.linalg.svd i reelle pipelines
I en reell datapipeline brukes SVD til støyreduksjon og datakomprimering. Når De har tilpasset SVD til treningsdataene, beholder De bare de k øverste komponentene som fanger opp 95 % av variansen. Dette reduserer dimensjonaliteten til nye data før de mates inn i en klassifikator eller regressor, noe som gjør treningen raskere og ofte forbedrer generaliseringen ved å fjerne støyende dimensjoner. Tilpass alltid SVD bare til treningsdataene, og bruk den samme transformasjonen på testdataene.
import numpy as np
np.random.seed(7)
X_train = np.random.randn(200, 50)
X_test = np.random.randn(40, 50)
# Fit on training data
X_mean = X_train.mean(axis=0)
X_centered = X_train - X_mean
U, s, Vh = np.linalg.svd(X_centered, full_matrices=False)
# Choose k to capture 90% variance
cumvar = np.cumsum(s**2) / (s**2).sum()
k = np.searchsorted(cumvar, 0.9) + 1
print(f'Components to capture 90% variance: {k}')
# Transform test data using the same Vh
X_test_reduced = (X_test - X_mean) @ Vh[:k].T
print('Reduced test shape:', X_test_reduced.shape)Hurtigsjekk
Test forståelsen Deres av konseptene innen dataanalyse fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De at np.linalg.eig()/eigh() beregner egenverdier og egenvektorer som viser en matrises iboende strekkretninger, at np.linalg.svd() dekomponerer enhver matrise i U, singulærverdier og Vh, noe som muliggjør PCA og lavrangsapproksimering, og at singulærverdier kvantifiserer variansen som hver komponent fanger opp, og bestemmer matrisens rang. Deretter skal vi se på håndtering av store datasett ved å strømme CSV-filer i biter.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Oversikt over egenverdier og SVD» gratis?
Ja – hele teksten i «Oversikt over egenverdier og SVD» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Oversikt over egenverdier og SVD»?
Beregn egenverdier og egenvektorer med np.linalg.eig, og forstå hvordan SVD danner grunnlaget for dimensjonsreduksjon med PCA. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?
Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.
Hvor lang tid tar leksjonen «Oversikt over egenverdier og SVD»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?
Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Matrise-multiplikasjon med np.matmul og @
- Determinanter, inverse matriser og transponering
- Løsning av lineære systemer
- Oversikt over egenverdier og SVD