0Pricing
R Academy · Lektion

Eigenwerte und Eigenvektoren

Berechnen Sie Eigenwertzerlegungen mit eigen() und interpretieren Sie die Ergebnisse

Eigenwerte und Eigenvektoren ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Eigenwerte?

Ein Eigenvektor v der Matrix A ist ein von null verschiedener Vektor, der bei der Multiplikation mit A nur skaliert, sich aber nicht dreht: Av = λv. Der Skalar λ ist der Eigenwert. Eigenvektoren und Eigenwerte zeigen die charakteristischen Streckungsrichtungen einer Matrix.

# 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(): Eigenwerte berechnen

eigen(A) gibt eine Liste mit $values (nach abnehmendem Betrag sortierte Eigenwerte) und $vectors (Matrix der Eigenvektoren als Spalten) zurück. Die Eigenvektoren sind auf die Länge eins normiert.

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)')

Av = lambda * v überprüfen

Überprüfen Sie, ob A %*% v - lambda * v im Wesentlichen null ist. Verwenden Sie aufgrund der Gleitkommaarithmetik max(abs(...)) und prüfen Sie, ob der Wert nahe an der Maschinenpräzision liegt, statt auf exakte Gleichheit zu testen.

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 zero

Symmetrische Matrizen: Reelle Eigenwerte

Symmetrische Matrizen (A = t(A)) haben immer reelle Eigenwerte und orthogonale Eigenvektoren. Dies ist der Spektralsatz — er ist in der Statistik von zentraler Bedeutung, da Kovarianzmatrizen symmetrisch positiv semidefinit sind.

# 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')

Nicht symmetrische Matrizen: Komplexe Eigenwerte

Nicht symmetrische Matrizen können komplexe Eigenwerte haben (komplex konjugierte Paare). R gibt sie als komplexe Zahlen zurück. Der Realteil bestimmt Wachstum oder Abklingen, der Imaginärteil Drehung oder Schwingung.

# 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 +/- 2i

Eigenwertzerlegung A = VLV^-1

Eine diagonalisierbare Matrix A lässt sich als A = V Λ V⁻¹ schreiben, wobei V die Eigenvektormatrix und Λ = diag(eigenvalues) ist. Diese Zerlegung ermöglicht die Berechnung von Matrixpotenzen: 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)  # TRUE

PCA-Konzept anhand von Kovarianz-Eigenwerten

Die Hauptkomponentenanalyse (PCA) verwendet die Eigenwertzerlegung der Kovarianzmatrix. Die Eigenvektoren geben die Richtungen maximaler Varianz (Hauptkomponenten) an; die Eigenwerte geben die Varianz in den jeweiligen Richtungen an.

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), '%')

Spektralradius

Der Spektralradius ρ(A) = max|λᵢ| ist der betragsmäßig größte Eigenwert. Er bestimmt die Stabilität iterativer Algorithmen: Für ρ < 1 konvergieren die Iterationen, für ρ > 1 divergieren sie.

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')

Determinante und Spur anhand von Eigenwerten

Die Determinante ist gleich dem Produkt der Eigenwerte, die Spur gleich ihrer Summe. Diese Beziehungen verknüpfen algebraische Eigenschaften mit Eigenwerten und bieten Plausibilitätsprüfungen für Ihre Ergebnisse von 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)

Positiv definite Matrizen

Eine symmetrische Matrix ist positiv definit (PD), wenn alle Eigenwerte positiv sind. Kovarianzmatrizen sind positiv semidefinit (Eigenwerte ≥ 0). Positiv definite Matrizen sind invertierbar und besitzen Cholesky-Zerlegungen.

# 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 negative

Potenziteration für den dominanten Eigenwert

Bei großen Matrizen ist die Berechnung aller Eigenwerte aufwendig. Die Potenziteration findet iterativ den größten Eigenwert — sie bildet die Grundlage des PageRank-Algorithmus von Google. Multiplizieren Sie wiederholt mit A und normieren Sie anschließend.

# 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]  # Compare

Kurzer Test

Testen Sie Ihr Verständnis von Eigenwerten und Eigenvektoren in R.

Zusammenfassung: Eigenwerte und Eigenvektoren

Wichtigste Erkenntnisse: eigen(A) gibt $values und $vectors zurück. Überprüfen Sie mit A %*% v - lambda*v ≈ 0. Symmetrische Matrizen haben reelle Eigenwerte und orthogonale Eigenvektoren. Nicht symmetrische Matrizen können komplexe Eigenwerte besitzen. det(A) = Produkt der Eigenwerte; Spur = Summe. PCA zerlegt die Kovarianzmatrix. Positiv definit ↔ alle Eigenwerte > 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)))

Häufig gestellte Fragen

Ist die Lektion „Eigenwerte und Eigenvektoren“ kostenlos?

Ja — der vollständige Text von „Eigenwerte und Eigenvektoren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Eigenwerte und Eigenvektoren“?

Berechnen Sie Eigenwertzerlegungen mit eigen() und interpretieren Sie die Ergebnisse Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Eigenwerte und Eigenvektoren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Matrixmultiplikation und Determinanten
  2. Lineare Gleichungssysteme mit solve() lösen
  3. Eigenwerte und Eigenvektoren
  4. SVD-, QR- und Cholesky-Zerlegungen
← Zurück zu R Academy