Wartości własne i wektory własne
Oblicz rozkłady własne za pomocą eigen() i interpretuj wyniki.
Wartości własne i wektory własne to bezpłatna lekcja R Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.
Czym są wartości własne?
Wektor własny v macierzy A to niezerowy wektor, który po pomnożeniu przez A zmienia tylko swoją skalę, a nie kierunek: Av = λv. Skalar λ to wartość własna. Wartości własne i wektory własne ujawniają charakterystyczne kierunki rozciągania macierzy.
# Intuition: A simple scaling matrix
A <- matrix(c(3, 0,
0, 2), nrow = 2, byrow = TRUE)
# The eigenvectors are the standard basis vectors
# A * c(1,0) = 3 * c(1,0) -> eigenvalue 3
# A * c(0,1) = 2 * c(0,1) -> eigenvalue 2
v1 <- c(1, 0)
A %*% v1 # c(3, 0) = 3 * v1
v2 <- c(0, 1)
A %*% v2 # c(0, 2) = 2 * v2
cat('Eigenvalues of a diagonal matrix are its diagonal entries')eigen(): obliczanie wartości własnych
eigen(A) zwraca listę zawierającą $values (wartości własne posortowane według malejącego modułu) oraz $vectors (macierz wektorów własnych zapisanych jako kolumny). Wektory własne są normalizowane do długości jednostkowej.
A <- matrix(c(4, 1,
2, 3), nrow = 2, byrow = TRUE)
# Compute eigendecomposition
eig <- eigen(A)
# Eigenvalues
eig$values
# [1] 5 2 (descending order)
# Eigenvectors (columns)
eig$vectors
# [,1] [,2]
# [1,] 0.7071068 -0.4472136
# [2,] 0.7071068 0.8944272
cat('Each column is one eigenvector (unit length)')Weryfikacja Av = lambda * v
Aby przeprowadzić weryfikację, sprawdź, czy A %*% v - lambda * v jest w praktyce równe zero. Ze względu na arytmetykę zmiennoprzecinkową użyj max(abs(...)) i sprawdź, czy wynik jest bliski epsilonowi maszynowemu, zamiast testować dokładną równość.
A <- matrix(c(4, 1,
2, 3), nrow = 2, byrow = TRUE)
eig <- eigen(A)
lambda1 <- eig$values[1] # 5
v1 <- eig$vectors[, 1]
# Verify: Av - lambda*v should be ~0
residual <- A %*% v1 - lambda1 * v1
max(abs(residual)) # ~ 1e-16
# Check all eigenpairs at once
# A V = V diag(lambda) where V = eigenvectors matrix
V <- eig$vectors
Lambda <- diag(eig$values)
err <- A %*% V - V %*% Lambda
max(abs(err)) # near zeroMacierze symetryczne: rzeczywiste wartości własne
Macierze symetryczne (A = t(A)) zawsze mają rzeczywiste wartości własne i ortogonalne wektory własne. Wynika to z twierdzenia spektralnego — ma ono podstawowe znaczenie w statystyce, ponieważ macierze kowariancji są symetryczne i dodatnio półokreślone.
# Symmetric matrix
S <- matrix(c(4, 2, 2,
2, 3, 1,
2, 1, 5), nrow = 3, byrow = TRUE)
# All symmetric: A = t(A)
all.equal(S, t(S)) # TRUE
# Eigenvalues are real
eig <- eigen(S)
eig$values # All real numbers
Im(eig$values) # All zero
# Eigenvectors are orthogonal: V'V = I
V <- eig$vectors
round(t(V) %*% V, 10) # Identity matrix
cat('Symmetric -> real eigenvalues, orthogonal eigenvectors')Macierze niesymetryczne: zespolone wartości własne
Macierze niesymetryczne mogą mieć zespolone wartości własne (w parach sprzężonych). R zwraca je jako liczby zespolone. Część rzeczywista odpowiada za wzrost lub zanik, a część urojona — za obrót lub oscylacje.
# Rotation-like matrix -> complex eigenvalues
A <- matrix(c(0, -1,
1, 0), nrow = 2, byrow = TRUE)
# This is a 90-degree rotation matrix
eig <- eigen(A)
eig$values
# [1] 0+1i 0-1i (pure imaginary!)
# Real part: zero -> neither grows nor decays
Re(eig$values) # 0 0
# Imaginary part: indicates rotation
Im(eig$values) # 1 -1
# Another example: stable spiral
B <- matrix(c(-1, -2,
2, -1), nrow = 2, byrow = TRUE)
eigen(B)$values # -1 +/- 2iRozkład według wartości własnych A = VLV^-1
Macierz A, którą można diagonalizować, można zapisać jako A = V Λ V⁻¹, gdzie V jest macierzą wektorów własnych, a Λ = diag(eigenvalues). Rozkład ten umożliwia obliczanie potęg macierzy: A^n = V Λ^n V⁻¹.
A <- matrix(c(4, 1,
2, 3), nrow = 2, byrow = TRUE)
eig <- eigen(A)
V <- eig$vectors
Lambda <- diag(eig$values)
# Reconstruct A = V %*% Lambda %*% solve(V)
A_reconstructed <- V %*% Lambda %*% solve(V)
all.equal(A, A_reconstructed) # TRUE
# Matrix power A^3 using eigendecomposition
A_cubed_eig <- V %*% diag(eig$values^3) %*% solve(V)
A_cubed_direct <- A %*% A %*% A
all.equal(Re(A_cubed_eig), A_cubed_direct) # TRUEKoncepcja PCA za pomocą wartości własnych macierzy kowariancji
Analiza głównych składowych (PCA) wykorzystuje rozkład według wartości własnych macierzy kowariancji. Wektory własne wyznaczają kierunki największej wariancji (główne składowe), a wartości własne określają wariancję wzdłuż każdego z tych kierunków.
set.seed(42)
# Correlated 2D data
x1 <- rnorm(100)
x2 <- 0.8 * x1 + 0.6 * rnorm(100)
X <- cbind(x1, x2)
# Covariance matrix
C <- cov(X)
print(round(C, 3))
# Eigendecomposition of covariance matrix
eig <- eigen(C)
cat('Eigenvalues (variance explained):\n')
print(eig$values)
cat('PC1 direction:\n')
print(eig$vectors[, 1])
# Variance explained by PC1
prop_var <- eig$values[1] / sum(eig$values)
cat('PC1 explains:', round(100 * prop_var, 1), '%')Promień spektralny
Promień spektralny ρ(A) = max|λᵢ| to największa wartość własna pod względem modułu. Określa stabilność algorytmów iteracyjnych: jeśli ρ < 1, iteracje są zbieżne, a jeśli ρ > 1 — rozbieżne.
spectral_radius <- function(A) {
max(Mod(eigen(A)$values))
}
# Convergent matrix: spectral radius < 1
A_conv <- matrix(c(0.5, 0.2,
0.1, 0.3), nrow = 2, byrow = TRUE)
spectral_radius(A_conv) # < 1 -> iterations converge
# Divergent matrix: spectral radius > 1
A_div <- matrix(c(2, 0.5,
0.3, 1.5), nrow = 2, byrow = TRUE)
spectral_radius(A_div) # > 1 -> iterations diverge
# For positive definite A, spectral radius = max eigenvalue
cat('Spectral radius determines iterative stability')Wyznacznik i ślad za pomocą wartości własnych
Wyznacznik jest równy iloczynowi wartości własnych, a ślad — ich sumie. Zależności te łączą własności algebraiczne z wartościami własnymi i umożliwiają kontrolę poprawności wyników funkcji eigen().
A <- matrix(c(5, 2,
1, 4), nrow = 2, byrow = TRUE)
eig_vals <- eigen(A)$values
# det(A) = product of eigenvalues
det(A)
prod(eig_vals) # Same!
# trace = sum of eigenvalues
sum(diag(A))
sum(eig_vals) # Same!
# For numeric precision, use Re() on complex
A2 <- matrix(c(3, -1, 2, 5), nrow = 2, byrow = TRUE)
ev <- eigen(A2)$values
all.equal(det(A2), prod(Re(ev)), tolerance = 1e-10)
all.equal(sum(diag(A2)), sum(Re(ev)), tolerance = 1e-10)Macierze dodatnio określone
Macierz symetryczna jest dodatnio określona (PD), jeśli wszystkie jej wartości własne są dodatnie. Macierze kowariancji są dodatnio półokreślone (ich wartości własne są ≥ 0). Macierze PD są odwracalne i mają rozkład Cholesky’ego.
# Check positive definiteness
is_positive_definite <- function(A) {
# Symmetric check
if (!isTRUE(all.equal(A, t(A)))) return(FALSE)
all(eigen(A)$values > 0)
}
# Positive definite covariance matrix
S <- matrix(c(4, 2,
2, 3), nrow = 2, byrow = TRUE)
is_positive_definite(S) # TRUE
eigen(S)$values # Both positive
# Not PD (one negative eigenvalue)
Q <- matrix(c(1, 3,
3, 2), nrow = 2, byrow = TRUE)
is_positive_definite(Q) # FALSE
eigen(Q)$values # One negativeIteracja potęgowa dla dominującej wartości własnej
W przypadku dużych macierzy obliczenie wszystkich wartości własnych jest kosztowne. Iteracja potęgowa wyznacza największą wartość własną w sposób iteracyjny — jest podstawą algorytmu PageRank firmy Google. Należy wielokrotnie mnożyć przez A, a następnie normalizować wynik.
# Power iteration: finds dominant eigenvalue
power_iteration <- function(A, tol = 1e-10, max_iter = 1000) {
n <- nrow(A)
v <- rnorm(n); v <- v / sqrt(sum(v^2)) # random unit vector
lambda_old <- 0
for (i in seq_len(max_iter)) {
w <- A %*% v
lambda <- max(abs(w))
v <- w / lambda
if (abs(lambda - lambda_old) < tol) break
lambda_old <- lambda
}
list(value = lambda, vector = v)
}
A <- matrix(c(4, 1, 2, 3), nrow = 2, byrow = TRUE)
result <- power_iteration(A)
result$value # Should be ~5 (dominant eigenvalue)
eigen(A)$values[1] # CompareSzybkie sprawdzenie
Sprawdź swoją znajomość wartości własnych i wektorów własnych w R.
Podsumowanie: wartości własne i wektory własne
Najważniejsze informacje: eigen(A) zwraca $values i $vectors. Weryfikuj wynik za pomocą A %*% v - lambda*v ≈ 0. Macierze symetryczne mają rzeczywiste wartości własne i ortogonalne wektory własne. Macierze niesymetryczne mogą mieć zespolone wartości własne. det(A) = iloczyn wartości własnych, a ślad = ich suma. PCA wykonuje rozkład macierzy kowariancji. Macierz dodatnio określona ↔ wszystkie wartości własne > 0.
A <- matrix(c(6, 2, 2, 3), nrow = 2)
eig <- eigen(A)
# Key eigen operations:
eig$values # eigenvalues
eig$vectors # eigenvectors (columns)
# Verify Av = lambda*v
v1 <- eig$vectors[, 1]
max(abs(A %*% v1 - eig$values[1] * v1)) # ~0
# Properties
all.equal(det(A), prod(eig$values)) # TRUE
all.equal(sum(diag(A)), sum(eig$values)) # TRUE
# Reconstruct A = V Lambda V^{-1}
V <- eig$vectors
all.equal(A, Re(V %*% diag(eig$values) %*% solve(V)))Często zadawane pytania
Czy lekcja „Wartości własne i wektory własne” jest bezpłatna?
Tak — pełny tekst „Wartości własne i wektory własne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Wartości własne i wektory własne”?
Oblicz rozkłady własne za pomocą eigen() i interpretuj wyniki. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć R Academy?
Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Wartości własne i wektory własne”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?
Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Mnożenie macierzy i wyznaczniki
- Rozwiązywanie układów równań liniowych za pomocą solve()
- Wartości własne i wektory własne
- Rozkłady SVD, QR i Cholesky’ego