Pandas & NumPy Academy · Lektion

Determinanten, Inversen und Transponierte

Berechnen Sie Matrixdeterminanten mit np.linalg.det, Inversen mit np.linalg.inv und transponierte Matrizen mit .T.

Lektion 2 von 413 Schritte

Determinanten, Inversen und Transponierte ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Die Transponierte einer Matrix

Die Transponierte einer Matrix ist ihre Spiegelung an der Diagonalen: Zeilen werden zu Spalten und Spalten werden zu Zeilen. Wenn A die Form (m, n) hat, besitzt A.T die Form (n, m). Transponierte treten in der linearen Algebra überall auf: bei der Berechnung von Kovarianzmatrizen, bei der Implementierung des Gradienten-Backpropagation-Verfahrens und bei der Umwandlung zwischen Konventionen für Zeilen- und Spaltenvektoren. NumPy greift über das Attribut .T auf die Transponierte zu – dabei wird keine Kopie erstellt, sondern lediglich eine Sicht mit neu angeordneten Strides verwendet.

import numpy as np

A = np.array([[1, 2, 3],
              [4, 5, 6]])
print('A shape:', A.shape)       # (2, 3)
print('A.T shape:', A.T.shape)   # (3, 2)
print(A.T)

Die Transponierte in der Praxis

Ein häufig verwendetes Muster ist die Berechnung von A.T @ A. Sie erzeugt eine symmetrische quadratische Matrix, die bei der Least-Squares-Regression, der PCA und den Normalgleichungen auftritt. Wenn A die Form (n, p) hat, besitzt A.T @ A die Form (p, p). Das Ergebnis ist immer symmetrisch, weil (A.T @ A)[i,j] == (A.T @ A)[j,i] gilt. Viele numerische Löser nutzen diese Eigenschaft zur Effizienzsteigerung.

import numpy as np

A = np.array([[1.0, 2.0],
              [3.0, 4.0],
              [5.0, 6.0]])  # shape (3, 2)

ATA = A.T @ A   # shape (2, 2), symmetric
print('A.T @ A:')
print(ATA)
print('Is symmetric:', np.allclose(ATA, ATA.T))

Die Determinante: Ihre Bedeutung

Die Determinante einer quadratischen Matrix ist ein skalarer Wert, der geometrische Informationen enthält: Sie misst den Faktor, um den die Matrix Flächen (in 2D) oder Volumen (in höheren Dimensionen) skaliert. Eine Determinante von null bedeutet, dass die Matrix singulär ist – sie bildet den Raum auf einen Unterraum geringerer Dimension ab und besitzt keine Inverse. Eine von null verschiedene Determinante garantiert, dass die Matrix invertierbar ist. NumPy berechnet sie mit np.linalg.det().

import numpy as np

# Non-singular matrix
A = np.array([[3.0, 1.0],
              [2.0, 4.0]])
print('det(A):', np.linalg.det(A))   # 3*4 - 1*2 = 10

# Singular matrix (row 2 = 2 * row 1)
B = np.array([[1.0, 2.0],
              [2.0, 4.0]])
print('det(B):', np.linalg.det(B))   # ~0

Die Inverse mit np.linalg.inv() berechnen

Die Inverse einer Matrix A, geschrieben als A⁻¹, erfüllt A @ A⁻¹ = I, wobei I die Einheitsmatrix ist. Inversen existieren nur für quadratische, nicht singuläre Matrizen. np.linalg.inv(A) berechnet die Inverse numerisch. In der Praxis sollten Sie Inversen nur selten explizit berechnen, da dies numerisch instabil ist. Verwenden Sie stattdessen für Gleichungssysteme bevorzugt np.linalg.solve(). Das konzeptionelle Verständnis von Inversen ist jedoch unverzichtbar.

import numpy as np

A = np.array([[3.0, 1.0],
              [2.0, 4.0]])

A_inv = np.linalg.inv(A)
print('Inverse:')
print(A_inv)

# Verify: A @ A_inv should be identity
I = A @ A_inv
print('A @ A_inv (should be I):')
print(np.round(I, 10))

Numerische Instabilität bei direkter Invertierung

Wenn Sie die Inverse einer Matrix berechnen und anschließend eine Multiplikation durchführen, summieren sich Gleitkommafehler. Beispielsweise ist das Lösen mit A_inv @ b weniger genau als der direkte Aufruf von np.linalg.solve(A, b). Eine gut konditionierte Matrix (deren Determinante weit von null entfernt ist) reagiert weniger empfindlich auf diese Fehler. Die Konditionszahl (np.linalg.cond(A)) quantifiziert, wie nahe eine Matrix an der Singularität liegt – hohe Konditionszahlen weisen auf numerische Probleme hin.

import numpy as np

A = np.array([[1.0, 2.0],
              [1.0001, 2.0]])
print('Condition number:', np.linalg.cond(A))
# Very high condition number -> near-singular, unstable inversion

b = np.array([3.0, 3.0001])
# Prefer solve over inv @ b
print('Solution via solve:', np.linalg.solve(A, b))

Orthogonale Matrizen und ihre Transponierten

Eine besondere Matrixklasse sind orthogonale Matrizen, für die A.T @ A = I gilt. Das bedeutet, dass die Transponierte zugleich die Inverse IST, wodurch sich orthogonale Matrizen äußerst effizient invertieren lassen. Rotationsmatrizen und der Q-Faktor der QR-Zerlegung sind orthogonal. Die Spalten einer orthogonalen Matrix bilden eine Orthonormalbasis – jede Spalte hat die Länge eins und steht senkrecht auf allen anderen Spalten.

import numpy as np

# 90-degree rotation matrix is orthogonal
theta = np.pi / 2
R = np.array([[np.cos(theta), -np.sin(theta)],
              [np.sin(theta),  np.cos(theta)]])

print('R.T @ R (should be identity):')
print(np.round(R.T @ R, 10))
print('Is orthogonal:', np.allclose(R.T @ R, np.eye(2)))

Die Pseudoinverse für nicht quadratische Matrizen

Eine reguläre Inverse existiert nur für quadratische Matrizen, aber die Moore-Penrose-Pseudoinverse erweitert das Konzept der Invertierung auf beliebige Matrizen. np.linalg.pinv(A) berechnet sie mithilfe der SVD. Sie bildet die Grundlage der Least-Squares-Lösung überbestimmter Gleichungssysteme (mehr Gleichungen als Unbekannte) – genau das Problem, das die lineare Regression löst. Wenn A quadratisch und invertierbar ist, entspricht pinv(A) inv(A).

import numpy as np

# Over-determined system: 3 equations, 2 unknowns
A = np.array([[1.0, 1.0],
              [1.0, 2.0],
              [1.0, 3.0]])
b = np.array([2.0, 3.0, 5.0])

# Least-squares solution using pseudo-inverse
x = np.linalg.pinv(A) @ b
print('Best-fit solution:', x)
# Or use lstsq directly
x2, _, _, _ = np.linalg.lstsq(A, b, rcond=None)
print('lstsq solution:', x2)

Vorzeichen der Determinante und Volumenskalierung

Das Vorzeichen der Determinante gibt an, ob die Transformation die Orientierung beibehält oder umkehrt. Eine positive Determinante bedeutet, dass die Orientierung erhalten bleibt (wie bei einer Rotation); eine negative Determinante bedeutet, dass die Orientierung gespiegelt wird (wie bei einer Spiegelung). Der Betrag gibt den Skalierungsfaktor für das Volumen an. Für eine 2×2-Matrix [[a,b],[c,d]] gilt det = a*d - b*c. NumPy verarbeitet quadratische Matrizen beliebiger Größe effizient.

import numpy as np

# Identity: det = 1 (no scaling, no flip)
I = np.eye(3)
print('det(I):', np.linalg.det(I))    # 1.0

# Scaling by 2 in all directions: det = 8 = 2^3
S = 2 * np.eye(3)
print('det(2I):', np.linalg.det(S))   # 8.0

# Reflection: det = -1
F = np.array([[-1.0, 0.0],
              [ 0.0, 1.0]])
print('det(reflection):', np.linalg.det(F))

np.linalg.slogdet() für mehr Stabilität verwenden

Bei großen Matrizen kann die Determinante überlaufen oder zu null unterlaufen, obwohl die Matrix nicht singulär ist. np.linalg.slogdet(A) gibt (sign, log_abs_det) zurück – das Vorzeichen und den natürlichen Logarithmus des Betrags der Determinante – und verhindert dadurch numerische Überläufe. Dies wird häufig in probabilistischen Modellen (etwa bei Gaußschen Likelihoods) verwendet, in denen Sie im Logarithmusraum arbeiten, damit die Zahlen handhabbar bleiben.

import numpy as np

A = np.random.rand(100, 100)

# Direct det might underflow for large matrices
sign, logdet = np.linalg.slogdet(A)
print('Sign:', sign)
print('Log|det|:', logdet)
print('Actual det (may be ~0 due to float):', np.linalg.det(A))
print('Reconstructed |det|:', np.exp(logdet))

Praxis: 2×2-Matrizen von Hand und mit NumPy lösen

Für eine 2×2-Matrix [[a, b], [c, d]] lautet die Inverse (1/det) * [[d, -b], [-c, a]], wobei det = ad - bc gilt. Wenn Sie diese Formel kennen, können Sie das Ergebnis von NumPy stichprobenartig überprüfen. Für größere Matrizen ist die analytische Berechnung der Inversen unpraktisch – genau deshalb verwenden wir np.linalg.inv(). Überprüfen Sie numerische Ergebnisse immer mit np.allclose(A @ A_inv, np.eye(n)).

import numpy as np

a, b, c, d = 3.0, 1.0, 2.0, 4.0
A = np.array([[a, b], [c, d]])
det = a*d - b*c

# Manual inverse
A_inv_manual = (1/det) * np.array([[d, -b], [-c, a]])
print('Manual inv:')
print(A_inv_manual)

# NumPy inverse
print('np.linalg.inv:')
print(np.linalg.inv(A))
print('Match:', np.allclose(A_inv_manual, np.linalg.inv(A)))

Transponierte und Inverse in Pipelines kombinieren

Ein häufiges Muster in der linearen Algebra kombiniert Transponierung und Invertierung: Die Berechnung von (A.T @ A)⁻¹ @ A.T ergibt die Projektionsmatrix, die bei der gewöhnlichen Least-Squares-Methode verwendet wird. In NumPy lässt sich dies als np.linalg.inv(A.T @ A) @ A.T schreiben, aber auch hier ist np.linalg.lstsq numerisch vorzuziehen. Wenn Sie das zugrunde liegende Muster kennen, verstehen Sie besser, was der Solver tut, und können Probleme bei nahezu singulären Matrizen leichter beheben.

import numpy as np

# Design matrix for simple linear regression (with bias)
X = np.column_stack([np.ones(5), np.array([1., 2., 3., 4., 5.])])
y = np.array([2.1, 3.9, 6.2, 8.1, 9.8])

# OLS via normal equations: beta = (X.T @ X)^-1 @ X.T @ y
beta = np.linalg.inv(X.T @ X) @ X.T @ y
print('Coefficients (intercept, slope):', np.round(beta, 3))

# Verify with lstsq
beta2, _, _, _ = np.linalg.lstsq(X, y, rcond=None)
print('lstsq result:', np.round(beta2, 3))

Schnelltest

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

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: A.T ist die Transponierte, die Zeilen und Spalten vertauscht, np.linalg.inv() berechnet die Matrixinverse, sollte aber nur selten direkt verwendet werden (bevorzugen Sie solve oder lstsq), und np.linalg.det() gibt die Determinante zurück, die bei singulären Matrizen null ist. Als Nächstes betrachten wir das direkte Lösen linearer Gleichungssysteme mit np.linalg.solve.

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 „Determinanten, Inversen und Transponierte“ kostenlos?

Ja — der vollständige Text von „Determinanten, Inversen und Transponierte“ 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 „Determinanten, Inversen und Transponierte“?

Berechnen Sie Matrixdeterminanten mit np.linalg.det, Inversen mit np.linalg.inv und transponierte Matrizen mit .T. 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 2 von 4.

Wie lange dauert die Lektion „Determinanten, Inversen und Transponierte“?

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