Pandas & NumPy Academy · Lektion

Determinanter, inverser och transponering

Beräkna matrisdeterminanter med np.linalg.det, inverser med np.linalg.inv och transponeringar med .T.

Lektion 2 av 413 steg

Determinanter, inverser och transponering är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Pandas & NumPy Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Transponeringen av en matris

Transponeringen av en matris vänder den över sin diagonal: rader blir kolumner och kolumner blir rader. Om A har formen (m, n) har A.T formen (n, m). Transponeringar förekommer överallt inom linjär algebra: vid beräkning av kovariansmatriser, implementering av gradientbackpropagering och konvertering mellan konventioner för radvektorer och kolumnvektorer. NumPy hämtar transponeringen med attributet .T – ingen kopia skapas, utan det är endast en vy med omordnade steg.

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)

Transponering i praktiken

Ett vanligt mönster är att beräkna A.T @ A, vilket ger en symmetrisk kvadratisk matris som förekommer i minsta-kvadratregression, PCA och normalekvationer. Om A har formen (n, p) har A.T @ A formen (p, p). Resultatet är alltid symmetriskt eftersom (A.T @ A)[i,j] == (A.T @ A)[j,i]. Många numeriska lösare utnyttjar denna egenskap för att bli effektivare.

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

Determinanten: vad den betyder

Determinanten för en kvadratisk matris är ett skalärt värde som beskriver geometrisk information: den mäter faktorn som matrisen skalar areor (i 2D) eller volymer (i högre dimensioner) med. En determinant på noll betyder att matrisen är singulär – den pressar ihop rummet till ett underrum med lägre dimension och saknar invers. En determinant som inte är noll garanterar att matrisen är inverterbar. NumPy beräknar den med 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

Beräkna inversen med np.linalg.inv()

Inversen till en matris A, skriven A⁻¹, uppfyller A @ A⁻¹ = I, där I är identitetsmatrisen. Inverser finns endast för kvadratiska, icke-singulära matriser. np.linalg.inv(A) beräknar inversen numeriskt. I praktiken bör Ni sällan beräkna inverser explicit eftersom det är numeriskt instabilt; använd i stället np.linalg.solve() för ekvationssystem. Men det är viktigt att förstå inverser begreppsmässigt.

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

Numerisk instabilitet vid direkt invertering

Att beräkna inversen till en matris och sedan multiplicera introducerar flyttalsfel som ackumuleras. Att till exempel lösa A_inv @ b är mindre exakt än att direkt anropa np.linalg.solve(A, b). En välkonditionerad matris (med en determinant långt från noll) är mindre känslig för dessa fel. Konditionstalet (np.linalg.cond(A)) kvantifierar hur nära en matris är att vara singulär – höga konditionstal signalerar numeriska problem.

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

Ortogonala matriser och deras transponeringar

En särskild klass av matriser är ortogonala matriser, där A.T @ A = I. Det innebär att transponeringen ÄR inversen, vilket gör ortogonala matriser mycket enkla att invertera. Rotationsmatriser och Q-faktorn i QR-faktorisering är ortogonala. Kolumnerna i en ortogonal matris bildar en ortonormal bas – varje kolumn har längden ett och är vinkelrät mot alla andra kolumner.

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

Pseudoinversen för icke-kvadratiska matriser

En vanlig invers finns endast för kvadratiska matriser, men Moore–Penrose-pseudoinversen generaliserar invertering till godtyckliga matriser. np.linalg.pinv(A) beräknar den med SVD. Den utgör grunden för minsta-kvadratlösningen till överbestämda system (fler ekvationer än obekanta), vilket är exakt det som linjär regression löser. Om A är kvadratisk och inverterbar är pinv(A) lika med 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)

Determinantens tecken och volymskalning

Determinantens tecken anger om transformationen bevarar eller vänder orienteringen. En positiv determinant innebär att orienteringen bevaras (som vid en rotation), medan en negativ determinant innebär att orienteringen vänds (som vid en spegling). Absolutbeloppet anger volymskalningsfaktorn. För en 2×2-matris [[a,b],[c,d]] gäller det = a*d - b*c. NumPy hanterar kvadratiska matriser av godtycklig storlek effektivt.

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

Använda np.linalg.slogdet() för stabilitet

För stora matriser kan determinanten bli oändlig eller underflyta till noll även när matrisen inte är singulär. np.linalg.slogdet(A) returnerar (sign, log_abs_det) – tecknet och den naturliga logaritmen av determinantens absolutbelopp – vilket undviker numeriskt overflow. Detta används ofta i probabilistiska modeller (gaussiska sannolikhetsmodeller), där man arbetar i logaritmrymden för att hålla talen hanterbara.

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

Praktiskt: lösa 2×2 för hand jämfört med NumPy

För en 2×2-matris [[a, b], [c, d]] är inversen (1/det) * [[d, -b], [-c, a]], där det = ad - bc. Om Ni kan denna formel blir det lättare att kontrollera NumPys resultat. För allt större än så är det opraktiskt att beräkna inversen analytiskt – det är precis därför vi använder np.linalg.inv(). Verifiera alltid numeriska resultat med 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)))

Kombinera transponering och invers i beräkningsflöden

Ett vanligt mönster inom linjär algebra kombinerar transponering och invers: (A.T @ A)⁻¹ @ A.T ger den projektionsmatris som används i vanlig minsta-kvadratmetod. I NumPy kan detta skrivas som np.linalg.inv(A.T @ A) @ A.T, men även här är np.linalg.lstsq numeriskt att föredra. Om Ni känner till det underliggande mönstret blir det lättare att förstå vad lösaren gör och att felsöka problem när matriser är nära singulära.

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

Snabbtest

Testa Er förståelse av begreppen inom dataanalys från den här lektionen.

Sammanfattning av lektionen

I den här lektionen har Ni lärt Er att A.T är transponeringen som byter plats på rader och kolumner, att np.linalg.inv() beräknar matrisinversen men sällan bör användas direkt (använd helst solve eller lstsq) och att np.linalg.det() returnerar determinanten, som är noll för singulära matriser. Härnäst utforskar vi hur man löser linjära system direkt med np.linalg.solve.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”Determinanter, inverser och transponering” gratis?

Ja – hela texten till ”Determinanter, inverser och transponering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Pandas & NumPy Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Determinanter, inverser och transponering”?

Beräkna matrisdeterminanter med np.linalg.det, inverser med np.linalg.inv och transponeringar med .T. Ni övar på Pandas & NumPy Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Pandas & NumPy Academy?

Du behöver inga förkunskaper. Utbildningen i Pandas & NumPy Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Determinanter, inverser och transponering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Pandas & NumPy Academy-lektionen?

Ja. Varje Pandas & NumPy Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Matris multiplikation med np.matmul och @
  2. Determinanter, inverser och transponering
  3. Lösning av linjära ekvationssystem
  4. Översikt över egenvärden och SVD
← Tillbaka till Pandas & NumPy Academy