Menyelesaikan Sistem Linear
Selesaikan Ax=b menggunakan np.linalg.solve dan bandingkan dengan pendekatan naif pendaraban dengan matriks songsang dari segi kestabilan berangka.
Menyelesaikan Sistem Linear ialah pelajaran Pandas & NumPy Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pandas & NumPy Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.
Apakah Sistem Linear?
Sistem persamaan linear boleh ditulis dalam bentuk matriks sebagai Ax = b, dengan A ialah matriks pekali, x ialah vektor pemboleh ubah tidak diketahui, dan b ialah vektor sebelah kanan. Sebagai contoh, dua persamaan dengan dua pemboleh ubah tidak diketahui boleh dinyatakan sebagai persamaan matriks 2×2. Menyelesaikan sistem bermaksud mencari x supaya A didarab dengan x sama dengan b. NumPy mengendalikan perkara ini dengan cekap dan tepat menggunakan np.linalg.solve(A, b).
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))Mengapa Tidak Menggunakan Matriks Songsang?
Dari segi matematik, penyelesaian bagi Ax = b ialah x = A⁻¹b. Namun, mengira np.linalg.inv(A) @ b lebih perlahan dan kurang tepat berbanding memanggil np.linalg.solve(A, b) secara terus. solve() menggunakan penguraian LU secara dalaman, yang memerlukan lebih sedikit operasi dan mengumpulkan kurang ralat titik apungan. Peraturan amnya: jika anda mencari x dalam Ax=b, sentiasa gunakan solve, bukan 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 accurateKeperluan untuk solve()
np.linalg.solve(A, b) memerlukan A berbentuk segi empat sama dan bukan singular. Jika A singular (penentu bernilai sifar), fungsi ini menghasilkan np.linalg.LinAlgError: Singular matrix. A adalah singular apabila baris-barisnya bergantung secara linear — contohnya, satu persamaan hanyalah gandaan persamaan yang lain. Sentiasa semak bahawa sistem anda dirumus dengan baik sebelum memanggil solve. Jika A bukan berbentuk segi empat sama, gunakan np.linalg.lstsq() sebagai ganti.
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)Penguraian LU di Sebalik Tabir
np.linalg.solve secara dalaman menggunakan penguraian LU: ia memfaktorkan A kepada matriks segi tiga bawah L dan matriks segi tiga atas U supaya A = LU. Penyelesaian kemudiannya menjadi dua penyelesaian segi tiga yang lebih mudah (penggantian ke hadapan dan ke belakang), yang jauh lebih cekap berbanding mengulangi penghapusan Gaussian dari awal. Algoritma yang sama digunakan oleh MATLAB, Fortran LAPACK dan hampir setiap pustaka pengkomputeran saintifik.
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))Menyelesaikan Pelbagai Sebelah Kanan
np.linalg.solve(A, B) boleh mengendalikan matriks B dengan berbilang lajur, lalu menyelesaikan setiap lajur secara serentak. Jika B mempunyai bentuk (n, k), hasil X mempunyai bentuk (n, k), dengan setiap lajur X ialah penyelesaian bagi lajur B yang sepadan. Ini berguna dalam simulasi fizik dan pembelajaran mesin apabila anda perlu menyelesaikan matriks pekali yang sama dengan banyak sebelah kanan yang berbeza.
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))Kuasa Dua Terkecil dengan np.linalg.lstsq()
Apabila sistem terlebih tentu (mempunyai lebih banyak persamaan daripada pemboleh ubah tidak diketahui), tiada penyelesaian tepat yang wujud. np.linalg.lstsq(A, b) mencari x yang meminimumkan jumlah kuasa dua baki ||Ax - b||² — inilah yang dikira oleh regresi linear. Ia mengembalikan penyelesaian x, baki, pangkat dan nilai singular. Argumen rcond=None menyekat amaran penamatan penggunaan dan menetapkan ambang untuk menganggap nilai singular sebagai sifar.
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)Menggunakan solve() dalam Regresi Linear
Persamaan normal bagi kuasa dua terkecil biasa ialah A.T @ A @ x = A.T @ b, iaitu sistem segi empat sama yang boleh diselesaikan dengan np.linalg.solve. Ini memberikan hasil yang sama seperti lstsq apabila A.T @ A terkondisi baik. Dalam amalan, lstsq lebih digemari kerana ia menggunakan SVD dan stabil walaupun lajur hampir kolinear, tetapi persamaan normal membantu anda memahami matematik di sebalik regresi.
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))Menyemak Nombor Keadaan
Sebelum menyelesaikan sistem, amalan yang baik ialah menyemak nombor keadaan menggunakan np.linalg.cond(A). Nombor keadaan yang hampir dengan 1 bermaksud sistem terkondisi baik dan penyelesaiannya boleh dipercayai. Nombor keadaan yang sangat besar (contohnya, 1e12) bermaksud matriks hampir singular: perubahan kecil pada b menghasilkan perubahan besar pada x, dan penyelesaian itu mungkin tidak boleh dipercayai dari segi berangka. Dalam keadaan ini, pertimbangkan regularisasi (regresi rabung) atau penggunaan penyelesai yang lebih kukuh.
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))Sistem Jarang: Bila Tidak Menggunakan linalg
Bagi sistem yang sangat besar dan A mempunyai kebanyakan entri bernilai sifar (iaitu matriks jarang), menyimpan keseluruhan matriks membazirkan memori dan menggunakan np.linalg.solve padat adalah perlahan. SciPy menyediakan scipy.sparse dan scipy.sparse.linalg.spsolve yang memanfaatkan sifat jarang untuk sistem besar seperti model unsur terhingga atau masalah rangkaian. Memahami bila matriks anda bersifat jarang ialah pertimbangan prestasi yang penting dalam pengkomputeran saintifik.
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)Mentafsir Vektor Penyelesaian
Setelah memperoleh vektor penyelesaian x daripada np.linalg.solve(A, b), sentiasa sahkan vektor itu dengan mengira A @ x dan membandingkannya dengan b menggunakan np.allclose(A @ x, b). Dalam aritmetik titik apung, kesamaan tepat jarang diperoleh — allclose membuat semakan dalam julat toleransi yang kecil. Baki ||Ax - b|| sepatutnya hampir dengan epsilon mesin yang didarab dengan skala masalah bagi sistem yang terkondisi dengan baik.
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))Penyelesaian dalam Saluran Paip Pembelajaran Mesin
Penyelesai linear digunakan di seluruh pembelajaran mesin: regresi linear menyelesaikan persamaan normal, proses Gaussian menyelesaikan sistem matriks kernel, dan penapis Kalman menyelesaikan persamaan kemas kini keadaan. Dengan memahami np.linalg.solve dan lstsq, anda boleh melaksanakan algoritma ini dari awal dan menyahpepijatnya apabila hasilnya tidak seperti yang dijangka. Modul linalg NumPy menyediakan alat berangka yang sama seperti yang digunakan dalam pustaka saintifik pengeluaran.
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))Semakan Pantas
Uji pemahaman anda tentang konsep Analisis Data daripada pelajaran ini.
Imbas Kembali Pelajaran
Dalam pelajaran ini, anda telah mempelajari bahawa: np.linalg.solve(A, b) menyelesaikan sistem linear segi empat sama dengan cekap menggunakan penguraian LU, np.linalg.lstsq() mencari penyelesaian kuasa dua terkecil untuk sistem yang terlebih tentu, dan nombor keadaan mengukur kestabilan berangka — nilai yang besar memberi amaran tentang matriks yang hampir singular. Seterusnya, kita akan meneroka nilai eigen dan SVD, yang menjadi asas kepada PCA serta banyak algoritma ML.
Pelajari Python dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Soalan Lazim
Adakah pelajaran “Menyelesaikan Sistem Linear” percuma?
Ya — teks penuh “Menyelesaikan Sistem Linear” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pandas & NumPy Academy, tingkat taraf kepada CoddyKit PRO. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Menyelesaikan Sistem Linear”?
Selesaikan Ax=b menggunakan np.linalg.solve dan bandingkan dengan pendekatan naif pendaraban dengan matriks songsang dari segi kestabilan berangka. Anda berlatih Pandas & NumPy Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Pandas & NumPy Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Pandas & NumPy Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.
Berapa lamakah pelajaran “Menyelesaikan Sistem Linear” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pandas & NumPy Academy ini?
Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Pendaraban Matriks dengan np.matmul dan @
- Determinan, Songsangan dan Transpos
- Menyelesaikan Sistem Linear
- Gambaran Keseluruhan Nilai Eigen dan SVD