Pandas & NumPy Academy · Pelajaran

Menyelesaikan Sistem Linear

Selesaikan Ax=b menggunakan np.linalg.solve, lalu bandingkan dengan pendekatan naif berupa perkalian dengan invers untuk memahami stabilitas numerik.

Menyelesaikan Sistem Linear adalah pelajaran Pandas & NumPy Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Pandas & NumPy Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

Apa Itu Sistem Linear?

Sistem persamaan linear dapat ditulis dalam bentuk matriks sebagai Ax = b, dengan A sebagai matriks koefisien, x sebagai vektor peubah yang tidak diketahui, dan b sebagai vektor ruas kanan. Misalnya, dua persamaan dengan dua peubah yang tidak diketahui dapat dinyatakan sebagai persamaan matriks 2×2. Menyelesaikan sistem berarti mencari x sehingga A dikalikan dengan x sama dengan b. np.linalg.solve(A, b) milik NumPy menanganinya secara efisien dan akurat.

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 Invers?

Secara matematis, solusi untuk Ax = b adalah x = A⁻¹b. Namun, menghitung np.linalg.inv(A) @ b lebih lambat dan kurang akurat daripada langsung memanggil np.linalg.solve(A, b). solve() secara internal menggunakan dekomposisi LU, yang memerlukan lebih sedikit operasi dan mengakumulasi lebih sedikit kesalahan titik mengambang. Aturan praktisnya: jika Anda mencari x dalam Ax=b, selalu gunakan solve, jangan pernah gunakan 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 accurate

Persyaratan untuk solve()

np.linalg.solve(A, b) mengharuskan A berbentuk persegi dan tidak singular. Jika A singular (determinan bernilai nol), fungsi tersebut menghasilkan np.linalg.LinAlgError: Singular matrix. A bersifat singular ketika baris-barisnya bergantung secara linear—misalnya, satu persamaan hanyalah kelipatan dari persamaan lainnya. Selalu periksa bahwa sistem Anda terumuskan dengan baik sebelum memanggil solve. Jika A bukan matriks persegi, gunakan 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)

Dekomposisi LU di Balik Layar

np.linalg.solve secara internal menerapkan dekomposisi LU: metode ini memfaktorkan A menjadi matriks segitiga bawah L dan matriks segitiga atas U sehingga A = LU. Penyelesaian kemudian menjadi dua penyelesaian segitiga yang lebih sederhana (substitusi maju dan mundur), yang jauh lebih efisien daripada mengulangi eliminasi Gaussian dari awal. Algoritma yang sama digunakan oleh MATLAB, Fortran LAPACK, dan hampir setiap pustaka komputasi ilmiah.

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 Beberapa Ruas Kanan

np.linalg.solve(A, B) dapat menangani matriks B dengan beberapa kolom, serta menyelesaikan masing-masing kolom secara bersamaan. Jika B memiliki bentuk (n, k), hasil X memiliki bentuk (n, k)

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

`Kuadrat Terkecil dengan np.linalg.lstsq()`

Ketika sistem terlalu ditentukan (jumlah persamaan lebih banyak daripada peubah yang tidak diketahui), tidak ada solusi tepat. np.linalg.lstsq(A, b) mencari x yang meminimalkan jumlah kuadrat residual ||Ax - b||²—persis seperti yang dihitung oleh regresi linear. Fungsi ini mengembalikan solusi x, residual, peringkat, dan nilai singular. Argumen rcond=None menonaktifkan peringatan penghentian dukungan dan menetapkan batas untuk memperlakukan nilai singular sebagai nol.

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)

`Menerapkan solve() dalam Regresi Linear`

Persamaan normal kuadrat terkecil biasa adalah A.T @ A @ x = A.T @ b, yaitu sistem persegi yang dapat diselesaikan dengan np.linalg.solve. Hasilnya sama dengan lstsq ketika A.T @ A terkondisi dengan baik. Dalam praktiknya, lstsq lebih disukai karena menggunakan SVD dan tetap stabil ketika kolom-kolom hampir kolinear, tetapi persamaan normal membantu Anda memahami matematika di balik 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))

`Memeriksa Bilangan Kondisi`

Sebelum menyelesaikan sistem, sebaiknya periksa bilangan kondisi dengan np.linalg.cond(A). Bilangan kondisi yang mendekati 1 berarti sistem terkondisi dengan baik dan solusinya dapat diandalkan. Bilangan kondisi yang sangat besar (misalnya, 1e12) berarti matriks hampir singular: perubahan kecil pada b menghasilkan perubahan besar pada x, dan solusi mungkin tidak andal secara numerik. Dalam kasus tersebut, pertimbangkan regularisasi (regresi ridge) atau gunakan pemecah yang lebih tangguh.

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: Kapan Tidak Menggunakan linalg`

Untuk sistem yang sangat besar ketika A sebagian besar berisi entri nol (sebuah matriks jarang), menyimpan matriks penuh memboroskan memori dan menggunakan np.linalg.solve padat berlangsung lambat. SciPy menyediakan scipy.sparse dan scipy.sparse.linalg.spsolve yang memanfaatkan sifat jarang untuk sistem besar seperti model elemen hingga atau masalah jaringan. Memahami kapan matriks Anda bersifat jarang merupakan pertimbangan penting untuk kinerja dalam komputasi ilmiah.

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)

`Menafsirkan Vektor Solusi`

Setelah Anda mendapatkan vektor solusi x dari np.linalg.solve(A, b), selalu verifikasikan hasilnya dengan menghitung A @ x dan membandingkannya dengan b menggunakan np.allclose(A @ x, b). Dalam aritmetika titik mengambang, Anda hampir tidak pernah mendapatkan kesamaan yang persis — allclose memeriksa kesamaan dalam toleransi kecil. Residual ||Ax - b|| seharusnya mendekati epsilon mesin dikalikan skala masalah untuk 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 Pipeline Pembelajaran Mesin`

Penyelesai linear digunakan di berbagai bagian pembelajaran mesin: regresi linear menyelesaikan persamaan normal, proses Gaussian menyelesaikan sistem matriks kernel, dan filter Kalman menyelesaikan persamaan pembaruan keadaan. Dengan memahami np.linalg.solve dan lstsq, Anda dapat mengimplementasikan algoritme-algoritme ini dari awal dan men-debug-nya ketika hasilnya tidak sesuai harapan. Modul aljabar linear NumPy menyediakan alat numerik yang sama dengan yang digunakan dalam pustaka ilmiah produksi.

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

`Pemeriksaan Singkat`

Uji pemahaman Anda tentang konsep Analisis Data dari pelajaran ini.

`Rangkuman Pelajaran`

Dalam pelajaran ini Anda mempelajari bahwa: np.linalg.solve(A, b) menyelesaikan sistem linear persegi secara efisien menggunakan dekomposisi LU, np.linalg.lstsq() menemukan solusi kuadrat terkecil untuk sistem yang memiliki lebih banyak persamaan daripada peubah, dan bilangan kondisi mengukur kestabilan numerik — nilai besar memperingatkan adanya matriks yang hampir singular. Selanjutnya kita akan membahas nilai eigen dan SVD, yang menjadi dasar PCA dan banyak algoritme pembelajaran mesin.

`Pertanyaan yang Sering Diajukan`

`Apakah pelajaran “Menyelesaikan Sistem Linear” gratis?`

Ya — teks lengkap “Menyelesaikan Sistem Linear” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Pandas & NumPy Academy, upgrade ke CoddyKit PRO. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

`Apa yang akan aku pelajari di “Menyelesaikan Sistem Linear”?`

Selesaikan Ax=b menggunakan np.linalg.solve, lalu bandingkan dengan pendekatan naif berupa perkalian dengan invers untuk memahami stabilitas numerik. Kamu berlatih Pandas & NumPy Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

`Apakah aku perlu pengalaman untuk memulai Pandas & NumPy Academy?`

Tidak diperlukan pengalaman sebelumnya. Pandas & NumPy Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

`Berapa lama pelajaran “Menyelesaikan Sistem Linear” memakan waktu?`

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

`Bisakah aku menulis dan menjalankan kode dalam pelajaran Pandas & NumPy Academy ini?`

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

← SebelumnyaDeterminan, Invers, dan TransposSelanjutnya →Gambaran Umum Nilai Eigen dan SVD

`Semua pelajaran dalam kursus ini`

Perkalian Matriks dengan np.matmul dan @
Determinan, Invers, dan Transpos
Menyelesaikan Sistem Linear
Gambaran Umum Nilai Eigen dan SVD

← Kembali ke Pandas & NumPy Academy