Pandas & NumPy Academy · Lektion

Überblick über Eigenwerte und SVD

Berechnen Sie Eigenwerte und Eigenvektoren mit np.linalg.eig und verstehen Sie, wie SVD die Dimensionsreduktion mit PCA ermöglicht.

Lektion 4 von 413 Schritte

Überblick über Eigenwerte und SVD ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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 Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Eigenwerte und Eigenvektoren?

Ein Eigenvektor einer quadratischen Matrix A ist ein von null verschiedener Vektor v mit der Eigenschaft A @ v = lambda * v – die Multiplikation mit A skaliert v lediglich, ändert aber nicht seine Richtung. Der Skalar lambda wird als der zu v gehörende Eigenwert bezeichnet. Eigenwerte zeigen die intrinsischen „Streckfaktoren“ einer linearen Transformation: Ein Eigenwert von 2 bedeutet, dass die Matrix Längen in Richtung des Eigenvektors verdoppelt; ein negativer Eigenwert kehrt die Richtung um.

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)

Eigenwerte mit np.linalg.eig() berechnen

np.linalg.eig(A) gibt ein Tupel (eigenvalues, eigenvectors) zurück. Die Eigenwerte sind in einem 1-D-Array enthalten; die Eigenvektoren befinden sich in einem 2-D-Array, wobei jede Spalte einen Eigenvektor enthält. Bei reellen symmetrischen Matrizen (etwa Kovarianzmatrizen) sind die Eigenwerte immer reell und die Eigenvektoren orthogonal. Verwenden Sie für symmetrische Matrizen np.linalg.eigh(A), da diese Funktion schneller ist und garantiert reelle Ergebnisse liefert.

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

Eigenwerte und Eigenschaften von Matrizen

Eigenwerte enthalten wichtige Informationen über die Eigenschaften einer Matrix. Die Determinante entspricht dem Produkt aller Eigenwerte: det(A) = product(eigenvalues). Die Spur (die Summe der Diagonalelemente) entspricht der Summe der Eigenwerte: trace(A) = sum(eigenvalues). Eine Matrix ist genau dann positiv definit (alle Eigenwerte > 0), wenn alle Eigenwerte positiv sind – eine entscheidende Eigenschaft gültiger Kovarianzmatrizen und konvexer Optimierungsprobleme.

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

Überblick über die Singulärwertzerlegung (SVD)

Die Singulärwertzerlegung (SVD) zerlegt jede Matrix A (nicht nur quadratische) in der Form A = U @ S @ V.T, wobei U und V orthogonale Matrizen sind und S eine Diagonalmatrix mit nichtnegativen Singulärwerten auf der Diagonale ist. Die SVD ist die allgemeinste und numerisch stabilste Matrixfaktorisierung. Sie bildet die Grundlage für PCA, Bildkompression, Empfehlungssysteme und die Berechnung der Pseudoinversen. np.linalg.svd(A) gibt U, s (die 1-D-Singulärwerte) und Vh (die transponierte Matrix V) zurück.

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ärwerte und Matrizenrang

Die Singulärwerte (die Diagonalelemente von S) sind immer nichtnegativ und werden üblicherweise in absteigender Reihenfolge aufgeführt. Die Anzahl der von null verschiedenen Singulärwerte entspricht dem Rang der Matrix. Nahezu null große Singulärwerte weisen auf eine nahezu lineare Abhängigkeit zwischen Zeilen oder Spalten hin. Der größte Singulärwert entspricht der Spektralnorm der Matrix, und das Verhältnis zwischen dem größten und dem kleinsten von null verschiedenen Singulärwert ist die Konditionszahl zur Messung der numerischen Stabilität.

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 und PCA: Der Zusammenhang

Die Hauptkomponentenanalyse (PCA) lässt sich direkt mithilfe der SVD implementieren. Nachdem Sie Ihre Datenmatrix X zentriert haben (indem Sie die Spaltenmittelwerte abziehen), sind die rechten Singulärvektoren in Vh die Hauptkomponenten, und die quadrierten Singulärwerte (geteilt durch n-1) sind die erklärten Varianzen. Sklearns PCA verwendet genau diesen Ansatz. Wenn Sie diesen Zusammenhang verstehen, können Sie PCA zur Dimensionsreduktion von Grund auf implementieren oder an Ihre Anforderungen anpassen.

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)

Niedrigrangige Approximation mit SVD

Die SVD ermöglicht eine niedrigrangige Matrixapproximation: Behalten Sie nur die k größten Singulärwerte und -vektoren und rekonstruieren Sie daraus eine Approximation der ursprünglichen Matrix. Dies bildet die Grundlage für Bildkompression und kollaboratives Filtern bei Empfehlungen. Die abgeschnittene SVD U[:, :k] @ np.diag(s[:k]) @ Vh[:k, :] liefert im Sinne der kleinsten Quadrate die beste Approximation vom Rang k (Satz von Eckart und Young).

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

Eigenzerlegung vs. SVD: Wann verwendet man welche?

Verwenden Sie die Eigenzerlegung (np.linalg.eig oder eigh), wenn Sie eine quadratische symmetrische Matrix haben und ihre Hauptachsen verstehen möchten – beispielsweise die Kovarianzmatrix bei PCA oder Markov-Übergangsmatrizen. Verwenden Sie die SVD (np.linalg.svd), wenn Ihre Matrix rechteckig ist oder Sie maximale numerische Stabilität benötigen. Die SVD existiert immer; bei nichtsymmetrischen Matrizen kann die Eigenzerlegung komplexe Zahlen liefern.

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)

Spektralsatz für symmetrische Matrizen

Der Spektralsatz besagt, dass sich jede reelle symmetrische Matrix A in der Form A = Q @ diag(eigenvalues) @ Q.T zerlegen lässt, wobei Q orthogonal ist (Q.T = Q⁻¹). Das bedeutet, dass symmetrische Matrizen immer mit reellen Eigenwerten und orthogonalen Eigenvektoren diagonalisierbar sind. Kovarianzmatrizen, Kernelmatrizen in SVMs und die Hesse-Matrix bei der Optimierung sind allesamt symmetrisch, wodurch dieser Satz in der Theorie des Machine Learnings universell einsetzbar ist.

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

Praxis: Potenziteration für den betragsmäßig größten Eigenwert

Wenn Sie nur den größten Eigenwert und seinen Eigenvektor benötigen, ist die Potenziteration wesentlich effizienter, als alle Eigenwerte zu berechnen. Beginnen Sie mit einem zufälligen Vektor, multiplizieren Sie ihn wiederholt mit A und normieren Sie ihn. So konvergiert er zum dominanten Eigenvektor. Auf diese Weise funktionierte auch Googles ursprünglicher PageRank-Algorithmus. Mit NumPy besteht jede Iteration aus einer einzigen Matrix-Vektor-Multiplikation mit @.

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

np.linalg.svd in realen Pipelines verwenden

In einer realen Datenpipeline wird die SVD zur Rauschunterdrückung und Datenkompression eingesetzt. Nachdem Sie die SVD an den Trainingsdaten angepasst haben, behalten Sie nur die ersten k Komponenten bei, die 95 % der Varianz erfassen. Dadurch wird die Dimensionalität neuer Daten reduziert, bevor Sie sie einem Klassifikator oder Regressor zuführen. Das beschleunigt das Training und verbessert häufig die Generalisierbarkeit, da verrauschte Dimensionen entfernt werden. Passen Sie die SVD immer nur an den Trainingsdaten an und wenden Sie dieselbe Transformation auf die Testdaten an.

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)

Schnelltest

Testen Sie Ihr Verständnis der in dieser Lektion behandelten Konzepte der Datenanalyse.

Lektionszusammenfassung

In dieser Lektion haben Sie gelernt: np.linalg.eig()/eigh() berechnen Eigenwerte und Eigenvektoren, die die intrinsischen Streckrichtungen einer Matrix sichtbar machen, np.linalg.svd() zerlegt jede Matrix in U, Singulärwerte und Vh und ermöglicht dadurch PCA sowie niederrangige Approximationen, und Singulärwerte quantifizieren die von jeder Komponente erfasste Varianz und bestimmen den Rang der Matrix. Als Nächstes beschäftigen wir uns mit der Verarbeitung großer Datensätze, indem wir CSV-Dateien blockweise einlesen.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
30
Lektionen
120

Häufig gestellte Fragen

Ist die Lektion „Überblick über Eigenwerte und SVD“ kostenlos?

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

Was lerne ich in „Überblick über Eigenwerte und SVD“?

Berechnen Sie Eigenwerte und Eigenvektoren mit np.linalg.eig und verstehen Sie, wie SVD die Dimensionsreduktion mit PCA ermöglicht. Du übst Pandas & NumPy 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 Pandas & NumPy Academy zu starten?

Keine Vorkenntnisse erforderlich. Pandas & NumPy 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 4 von 4.

Wie lange dauert die Lektion „Überblick über Eigenwerte und SVD“?

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 Pandas & NumPy Academy-Lektion Code schreiben und ausführen?

Ja. Jede Pandas & NumPy 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 mit np.matmul und @
  2. Determinanten, Inversen und Transponierte
  3. Lineare Gleichungssysteme lösen
  4. Überblick über Eigenwerte und SVD
← Zurück zu Pandas & NumPy Academy