Løsning af lineære ligningssystemer
Løs Ax=b med np.linalg.solve, og sammenlign med den naive tilgang, hvor man multiplicerer med den inverse matrix, med fokus på numerisk stabilitet.
Løsning af lineære ligningssystemer er en gratis Pandas & NumPy Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Pandas & NumPy Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.
Hvad er et lineært system?
Et system af lineære ligninger kan skrives på matrixform som Ax = b, hvor A er koefficientmatricen, x er vektoren af ubekendte, og b er højresidevektoren. To ligninger med to ubekendte kan for eksempel udtrykkes som en 2×2-matriceligning. At løse systemet betyder at finde x, så A multipliceret med x er lig med b. NumPys np.linalg.solve(A, b) håndterer dette effektivt og nøjagtigt.
import numpy as np
# System: 2x + y = 5
# x + 3y = 10
A = np.array([[2.0, 1.0],
[1.0, 3.0]])
b = np.array([5.0, 10.0])
x = np.linalg.solve(A, b)
print('Solution x:', x)
print('Verify A @ x == b:', np.allclose(A @ x, b))Hvorfor ikke bruge den inverse matrix?
Matematisk er løsningen på Ax = b x = A⁻¹b. Men beregning af np.linalg.inv(A) @ b er langsommere og mindre nøjagtig end at kalde np.linalg.solve(A, b) direkte. solve() bruger LU-dekomponering internt, hvilket kræver færre operationer og ophober færre flydende-kommafejl. Tommelfingerreglen er: Hvis du løser for x i Ax=b, skal du altid bruge solve, aldrig inv.
import numpy as np
A = np.random.rand(100, 100)
b = np.random.rand(100)
# Avoid this pattern
x_inv = np.linalg.inv(A) @ b
# Prefer this
x_solve = np.linalg.solve(A, b)
print('Max difference:', np.max(np.abs(x_inv - x_solve)))
# solve is faster AND more accurateKrav til solve()
np.linalg.solve(A, b) kræver, at A er kvadratisk og ikke-singulær. Hvis A er singulær (determinanten er nul), udløser funktionen np.linalg.LinAlgError: Singular matrix. A er singulær, når rækkerne er lineært afhængige — for eksempel når en ligning blot er et multiplum af en anden. Kontrollér altid, at dit system er veldefineret, før du kalder solve. Hvis A ikke er kvadratisk, skal du i stedet bruge np.linalg.lstsq().
import numpy as np
# Well-posed system
A = np.array([[1.0, 2.0], [3.0, 4.0]])
b = np.array([5.0, 6.0])
print('Solution:', np.linalg.solve(A, b))
# Singular system (row 2 = 3 * row 1)
A_singular = np.array([[1.0, 2.0], [3.0, 6.0]])
try:
np.linalg.solve(A_singular, b)
except np.linalg.LinAlgError as e:
print('Error:', e)LU-dekomponering bag kulisserne
np.linalg.solve anvender internt LU-dekomponering: den faktoriserer A i en nedre trekantsmatrix L og en øvre trekantsmatrix U, så A = LU. Løsningen bliver derefter til to enklere trekantsløsninger (fremad- og bagudsubstitution), som er langt mere effektive end at gentage Gauss-elimination fra bunden. Det er den samme algoritme, som bruges af MATLAB, Fortran LAPACK og stort set alle biblioteker til videnskabelig databehandling.
import numpy as np
from scipy import linalg
A = np.array([[2.0, 1.0, -1.0],
[-3.0, -1.0, 2.0],
[-2.0, 1.0, 2.0]])
b = np.array([8.0, -11.0, -3.0])
# NumPy solve (uses LAPACK dgesv under the hood)
x = np.linalg.solve(A, b)
print('Solution:', x)
print('Check:', np.allclose(A @ x, b))Løsning med flere højresider
np.linalg.solve(A, B) kan håndtere en matrix B med flere søjler og løse for hver søjle samtidigt. Hvis B har dimensionen (n, k), har resultatet X dimensionen (n, k), hvor hver søjle i X er løsningen for den tilsvarende søjle i B. Dette er nyttigt i fysiksimuleringer og maskinlæring, hvor du skal løse med den samme koefficientmatrix og mange forskellige højresider.
import numpy as np
A = np.array([[3.0, 1.0],
[1.0, 2.0]])
# Three right-hand side vectors at once
B = np.array([[9.0, 3.0, 6.0],
[8.0, 4.0, 2.0]])
X = np.linalg.solve(A, B)
print('Solutions X shape:', X.shape) # (2, 3)
print('Verify A @ X == B:', np.allclose(A @ X, B))Mindste kvadrater med np.linalg.lstsq()
Når systemet er overbestemt (flere ligninger end ubekendte), findes der ingen eksakt løsning. np.linalg.lstsq(A, b) finder den x-værdi, der minimerer summen af de kvadrerede residualer ||Ax - b||² — det er netop det, lineær regression beregner. Den returnerer løsningen x, residualerne, rang og singulærværdierne. Argumentet rcond=None undertrykker en advarsel om forældelse og angiver grænsen for, hvornår singulærværdier behandles som nul.
import numpy as np
# Over-determined: 4 equations, 2 unknowns
A = np.array([[1.0, 1.0],
[1.0, 2.0],
[1.0, 3.0],
[1.0, 4.0]])
b = np.array([2.0, 2.5, 3.5, 4.5])
x, residuals, rank, sv = np.linalg.lstsq(A, b, rcond=None)
print('Least-squares solution:', x)
print('Residuals:', residuals)
print('Rank:', rank)Anvendelse af solve() i lineær regression
Normalligningerne for almindelig mindste-kvadraters regression er A.T @ A @ x = A.T @ b, hvilket er et kvadratisk system, der kan løses med np.linalg.solve. Det giver samme resultat som lstsq, når A.T @ A er velkonditioneret. I praksis foretrækkes lstsq, fordi den bruger SVD og er stabil, selv når søjlerne næsten er kollineære, men normalligningerne hjælper dig med at forstå matematikken bag regression.
import numpy as np
np.random.seed(0)
X = np.column_stack([np.ones(50), np.random.rand(50) * 10])
y = 3.0 + 2.0 * X[:, 1] + np.random.randn(50)
# Solve normal equations
coeffs = np.linalg.solve(X.T @ X, X.T @ y)
print('Intercept:', round(coeffs[0], 3))
print('Slope:', round(coeffs[1], 3))Kontrol af konditionstallet
Før du løser systemet, er det god praksis at kontrollere konditionstallet med np.linalg.cond(A). Et konditionstal tæt på 1 betyder, at systemet er velkonditioneret, og at løsningen er pålidelig. Et meget stort konditionstal (f.eks. 1e12) betyder, at matricen næsten er singulær: små ændringer i b giver store ændringer i x, og løsningen kan være numerisk upålidelig. I så fald kan du overveje regularisering (ridge-regression) eller at bruge en mere robust løsningsmetode.
import numpy as np
# Well-conditioned
A1 = np.array([[2.0, 1.0], [1.0, 3.0]])
print('Condition number (well):', np.linalg.cond(A1))
# Ill-conditioned (nearly linearly dependent rows)
A2 = np.array([[1.0, 1.0], [1.0, 1.0001]])
print('Condition number (ill):', np.linalg.cond(A2))Sparse systemer: hvornår linalg ikke skal bruges
For meget store systemer, hvor A hovedsageligt består af nulelementer (en sparsom matrix), spilder det hukommelse at gemme hele matricen, og den tætte np.linalg.solve er langsom. SciPy stiller scipy.sparse og scipy.sparse.linalg.spsolve til rådighed; de udnytter sparsiteten i store systemer som modeller med finitte elementer eller netværksproblemer. Det er vigtigt for ydeevnen i videnskabelig databehandling at forstå, hvornår din matrix er sparsom.
import numpy as np
# Dense solve is fine for small-to-medium systems
A = np.random.rand(200, 200)
b = np.random.rand(200)
x = np.linalg.solve(A, b)
print('Dense solve OK, solution shape:', x.shape)
# For large sparse systems, use scipy.sparse.linalg.spsolve instead
# from scipy.sparse.linalg import spsolve
# x = spsolve(A_sparse, b)Fortolkning af løsningsvektoren
Når du har løsningsvektoren x fra np.linalg.solve(A, b), skal du altid verificere den ved at beregne A @ x og sammenligne den med b ved hjælp af np.allclose(A @ x, b). Ved flydende kommaaritmetik får du sjældent en nøjagtig lighed — allclose kontrollerer, om værdierne ligger inden for en lille tolerance. Residualet ||Ax - b|| bør for et velkonditioneret system ligge tæt på maskinepsilon gange problemets skala.
import numpy as np
A = np.array([[4.0, 3.0, 2.0],
[1.0, 5.0, 3.0],
[2.0, 1.0, 6.0]])
b = np.array([10.0, 20.0, 15.0])
x = np.linalg.solve(A, b)
print('Solution:', np.round(x, 4))
# Residual check
residual = np.linalg.norm(A @ x - b)
print('Residual ||Ax - b||:', residual)
print('Valid:', np.allclose(A @ x, b))Løsning i maskinlæringsforløb
Lineære løsningsmetoder bruges overalt i maskinlæring: lineær regression løser normal-ligningerne, Gauss-processer løser systemer med kernelmatricer, og Kalman-filtre løser ligninger for tilstandsopdatering. Når du forstår np.linalg.solve og lstsq, kan du implementere disse algoritmer fra bunden og fejlfinde dem, når resultaterne er uventede. NumPys linalg-modul giver dig de samme numeriske værktøjer, som bruges i videnskabelige biblioteker til produktion.
import numpy as np
# Ridge regression: (X.T @ X + lambda * I) @ w = X.T @ y
np.random.seed(42)
X = np.random.rand(100, 5)
y = np.random.rand(100)
lambda_reg = 0.1
n_features = X.shape[1]
A = X.T @ X + lambda_reg * np.eye(n_features)
bvec = X.T @ y
w = np.linalg.solve(A, bvec)
print('Ridge regression weights:', np.round(w, 4))Hurtigt tjek
Test din forståelse af begreberne inden for dataanalyse fra denne lektion.
Opsummering af lektionen
I denne lektion har du lært, at np.linalg.solve(A, b) effektivt løser kvadratiske lineære systemer ved hjælp af LU-dekomponering, at np.linalg.lstsq() finder løsningen med mindste kvadrater for overbestemte systemer, og at konditionstallet måler den numeriske stabilitet — store værdier advarer om næsten-singulære matricer. Nu skal vi se på egenværdier og SVD, som danner grundlag for PCA og mange maskinlæringsalgoritmer.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Løsning af lineære ligningssystemer” gratis?
Ja — hele teksten til “Løsning af lineære ligningssystemer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Pandas & NumPy Academy-kurset, skal du opgradere til CoddyKit PRO. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Løsning af lineære ligningssystemer”?
Løs Ax=b med np.linalg.solve, og sammenlign med den naive tilgang, hvor man multiplicerer med den inverse matrix, med fokus på numerisk stabilitet. Du øver dig i Pandas & NumPy Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Pandas & NumPy Academy?
Der kræves ingen tidligere erfaring. Pandas & NumPy Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Løsning af lineære ligningssystemer”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Pandas & NumPy Academy-lektion?
Ja. Alle Pandas & NumPy Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Matrixmultiplikation med np.matmul og @
- Determinanter, inverse matricer og transponering
- Løsning af lineære ligningssystemer
- Overblik over egenværdier og SVD