Penyelesaian Numerik untuk AI: Gunakan solve Tanpa Invers Eksplisit

Sebuah langkah kalibrasi AI mungkin perlu memulihkan dua parameter yang tidak diketahui dari dua respons terukur. Persamaannya cukup kecil untuk ditulis di papan tulis, tetapi kode produksi tetap harus menentukan cara menyelesaikannya dan cara memeriksa jawabannya. Vektor yang tampak masuk akal bukan bukti bahwa data menentukannya secara andal.

Pelajaran ini mengembangkan keputusan tersebut dengan NumPy. Anda akan menyelesaikan sistem linear persegi, membandingkan numpy.linalg.solve dengan jalur invers eksplisit, menghitung residual, mengukur pengondisian, dan mengenali batas singular ketika estimasi parameter unik tidak ada.

Hasil belajar: Gunakan numpy.linalg.solve dan jelaskan mengapa inversi eksplisit biasanya dihindari.

Pelajaran 22: Transformasi identitas dan invers menunjukkan makna invers secara matematis. Pelajaran 24: Bentuk eselon baris mengungkap struktur menunjukkan bagaimana pivot dan variabel bebas mengungkap apa yang dapat ditentukan oleh sebuah sistem. Di sini, kita menghubungkan aljabar eksak itu dengan komputasi berpresisi hingga. Situs pendamping resmi Mathematics for Machine Learning menempatkan pekerjaan ini di Bagian 2.3 dari PDF buku; skenario kalibrasi, angka, kode, visual, dan asesmen di bawah ini adalah karya orisinal.

Sistem linear adalah kontrak pemulihan parameter

Tuliskan vektor parameter yang tidak diketahui sebagai

x = \begin{bmatrix}x_1\\x_2\end{bmatrix}\in\mathbb{R}^2.

Vektor ini memiliki dua koordinat, sehingga setiap baris matriks koefisien $A$ harus memuat dua koefisien. Jika dua pengamatan menghasilkan vektor ruas kanan $b$ , sistem pemulihan parameter berbentuk

A x=b, \qquad A\in\mathbb{R}^{2\times 2}, \quad b\in\mathbb{R}^{2}, \quad x\in\mathbb{R}^{2}.

Untuk kepala kalibrasi kecil, $x_1$ bisa menjadi skala yang diterapkan pada satu sinyal dan $x_2$ menjadi koreksi mirip offset yang diterapkan pada sinyal lain. Secara lebih umum, notasi yang sama menggambarkan lapisan linear kecil, koreksi sensor, atau submasalah pemulihan parameter di dalam pipeline AI yang lebih besar. Baris-baris $A$ adalah pola koefisien yang diamati; $b$ berisi respons yang seharusnya dihasilkan oleh pola tersebut.

Jika $A$ persegi dan invertibel, aljabar dari pelajaran sebelumnya memberi

x=A^{-1}b.

Identitas itu berguna untuk penalaran. Identitas itu tidak berarti program harus terlebih dahulu membangun $A^{-1}$ setiap kali membutuhkan $x$ .

Contoh kerja: pulihkan dua parameter kalibrasi

Pertimbangkan sistem yang sengaja dibuat kecil berikut

A=\begin{bmatrix}3&1\\1&2\end{bmatrix}, \qquad b=\begin{bmatrix}8\\1\end{bmatrix}.

Kedua persamaannya adalah

3x_1+x_2=8, \qquad x_1+2x_2=1.

Selesaikan dengan substitusi sebelum meminta NumPy melakukan pekerjaan yang sama. Persamaan pertama memberi $x_2=8-3x_1$ . Substitusikan ungkapan itu ke persamaan kedua:

x_1+2(8-3x_1)=1 \Longrightarrow -5x_1=-15 \Longrightarrow x_1=3.

Kemudian $x_2=8-3(3)=-1$ , sehingga

x=\begin{bmatrix}3\\-1\end{bmatrix}.

Periksa kedua persamaan asli, bukan hanya persamaan yang sudah diubah susunannya:

A x = \begin{bmatrix}3&1\\1&2\end{bmatrix} \begin{bmatrix}3\\-1\end{bmatrix} = \begin{bmatrix}8\\1\end{bmatrix}=b.

Perhitungan yang sama dalam NumPy

import numpy as np

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

x_solve = np.linalg.solve(A, b)
x_inverse = np.linalg.inv(A) @ b

print(x_solve)
print(x_inverse)
print(np.linalg.norm(A @ x_solve - b))
print(np.linalg.norm(A @ x_inverse - b))

Pada runtime NumPy 2.3.5 yang disertakan, keluaran yang telah diverifikasi adalah:

[ 3. -1.]
[ 3. -1.]
2.220446049250313e-16
9.155133597044475e-16

Nilai kecil yang bukan nol itu adalah norma residual floating-point. Dalam aritmetika eksak, kedua residual bernilai nol dan kedua metode merepresentasikan jawaban matematis yang sama. Perbedaan kecil pada digit terakhir mengingatkan kita untuk membandingkan hasil floating-point dengan toleransi, bukan dengan kesetaraan eksak.

Mengapa `solve` biasanya merupakan langkah antara yang tepat

Ekspresi matematis langsung $A^{-1}b$ menyembunyikan dua tugas komputasi yang berbeda:

Jalur	Apa yang dihitung	Mengapa penting untuk satu ruas kanan
`np.linalg.solve(A, b)`	Memfaktorkan $A$ dan menerapkan faktor-faktornya pada $b$	Hanya menghitung vektor yang diminta.
`np.linalg.inv(A) @ b`	Membangun setiap kolom $A^{-1}$ , lalu mengalikannya dengan $b$	Menghitung informasi jauh lebih banyak daripada yang diperlukan satu penyelesaian ini.

Untuk satu ruas kanan, solve menghindari materialisasi seluruh invers. Untuk beberapa ruas kanan yang disimpan sebagai kolom-kolom $B$ , gunakan np.linalg.solve(A, B) sehingga matriks koefisien yang sama dapat difaktorkan sekali sementara semua solusi yang diminta dihitung. Simpan invers hanya jika aplikasi memang membutuhkan invers itu sendiri; invers bukan pengganti default untuk solve.

Dokumentasi NumPy saat ini untuk solve menyatakan bahwa matriks koefisien harus persegi dan berpangkat penuh, serta mendokumentasikan bahwa rutin tersebut menggunakan implementasi LAPACK _gesv. Dokumentasi inv juga memperingatkan bahwa matriks yang terkondisi buruk dapat menghasilkan keluaran tidak akurat meskipun inversi tidak memunculkan galat. Karena itu, pilihan implementasi dan diagnosis perlu berada dalam model mental yang sama.

Perbedaan runtime bergantung pada perangkat keras dan pustaka, sehingga bukan benchmark yang portabel. Sebagai ilustrasi, pengujian di host penulisan berikut menggunakan matriks acak tetap berukuran $64\times64$ , lima pengulangan waktu, dan dua puluh pemanggilan per pengulangan:

from timeit import repeat

rng = np.random.default_rng(7)
A_timing = rng.normal(size=(64, 64)) + 64 * np.eye(64)
b_timing = rng.normal(size=64)

solve_time = min(
    repeat(lambda: np.linalg.solve(A_timing, b_timing), repeat=5, number=20)
) / 20
inverse_time = min(
    repeat(lambda: np.linalg.inv(A_timing) @ b_timing, repeat=5, number=20)
) / 20

print(solve_time * 1e6, inverse_time * 1e6, inverse_time / solve_time)

Run yang telah diverifikasi mencetak kira-kira 15.2 µs, 52.2 µs, dan 3.43× untuk waktu solve, waktu jalur invers, dan rasionya. Anggap angka-angka itu sebagai bentuk perbandingan yang dapat direproduksi, bukan janji performa: alasan algoritmis untuk memilih solve adalah karena ia menghindari penghitungan matriks yang tidak digunakan, dan pustaka BLAS atau ukuran matriks yang berbeda dapat mengubah rasio tersebut.

Residual adalah pemeriksaan kecocokan, bukan sertifikat kepercayaan

Untuk contoh kerja, hitung residual dari jalur langsung:

r=b-A\hat{x} = \begin{bmatrix}8\\1\end{bmatrix} - \begin{bmatrix}8\\1\end{bmatrix} = \begin{bmatrix}0\\0\end{bmatrix}.

Program floating-point melaporkan norma mendekati $10^{-15}$ , bukan tepat nol. Itu merupakan bukti kuat bahwa vektor yang dikembalikan cocok dengan $b$ ini. Namun, bayangkan koefisien atau respons berasal dari pengukuran sensor yang dibulatkan. Solver dapat menemukan vektor yang sangat cocok dengan nilai yang telah dibulatkan itu, tetapi vektor tersebut tetap dapat berubah besar ketika pengukuran diubah dalam batas ketidakpastiannya.

Pengondisian mengukur sensitivitas

Bilangan kondisi membandingkan seberapa besar matriks dapat memperkuat perubahan input relatif. Untuk matriks invertibel dan norma-2,

\kappa_2(A)=\lVert A\rVert_2,\lVert A^{-1}\rVert_2 =\frac{\sigma_{\max}(A)}{\sigma_{\min}(A)},

dengan $\sigma_{\max}$ dan $\sigma_{\min}$ adalah nilai singular terbesar dan terkecil. Bilangan kondisi yang mendekati $1$ menunjukkan arah yang seimbang. Nilai besar berarti perubahan kecil tertentu pada input dapat menyebabkan perubahan relatif yang jauh lebih besar pada solusi. Jika nilai singular terkecil adalah nol, matriksnya singular dan bilangan kondisinya tak terhingga.

Untuk ruas kanan yang terganggu, batas yang berguna berbentuk

\frac{\lVert\delta x\rVert}{\lVert x\rVert} \lesssim \kappa(A)\frac{\lVert\delta b\rVert}{\lVert b\rVert},

dengan asumsi-asumsi umum untuk sistem nonsingular. Ketaksamaan ini adalah peringatan tentang kemungkinan penguatan, bukan janji bahwa setiap gangguan akan mencapai kasus terburuk.

Sekarang gunakan baris-baris yang hampir bergantung:

B=\begin{bmatrix}1&1\\1&1.0001\end{bmatrix}, \qquad x_{\text{true}}=\begin{bmatrix}2\\-1\end{bmatrix}, \qquad b=B x_{\text{true}}=\begin{bmatrix}1\\0.9999\end{bmatrix}.

Baris kedua hampir merupakan salinan baris pertama. Dengan $b$ persis seperti yang ditampilkan, solve memulihkan $[2,-1]$ . Ubah hanya respons kedua sebesar $10^{-6}$ , lalu solve lagi. NumPy melaporkan

condition number: 40002.000074915224
original solution: [ 2. -1.]
perturbed solution: [ 1.99 -0.99]
relative input change: 7.071421374297804e-07
relative solution change: 0.006324555320519327
perturbed residual norm: 0.0

Input berubah sekitar $7.1\times10^{-7}$ secara relatif, sedangkan vektor parameter berubah sekitar $6.3\times10^{-3}$ secara relatif. Itu kira-kira sensitivitas sebesar bilangan kondisi empat orde magnitudo. Solusi yang terganggu tetap memiliki residual nol untuk data yang terganggu: ia menyelesaikan persamaan baru dengan benar, tetapi data tersebut tidak mengidentifikasi vektor parameter yang stabil.

Peta stabilitas statis

Residual kecil dapat menyembunyikan solusi yang sensitif

Residual memeriksa persamaan yang sudah diselesaikan. Bilangan kondisi memperingatkan seberapa jauh solusi dapat berubah ketika data masukan berubah.

Ketiga kasus dapat menghasilkan residual kecil untuk ruas kanan yang diberikan. Kondisi matriks menentukan apakah kecocokan itu juga merupakan estimasi parameter yang dapat dipercaya.

Kuantitas persis yang diwakili dalam peta stabilitas
Kasus	Bilangan kondisi	Perubahan masukan relatif → perubahan solusi	Residual dan interpretasi
Kondisi baik	2.62	1.2 × 10⁻⁷ → 2.0 × 10⁻⁷	Residual sekitar 10⁻¹⁵; kedua jalur sepakat untuk contoh berkondisi baik ini.
Kondisi buruk	4.0002 × 10⁴	7.1 × 10⁻⁷ → 6.3 × 10⁻³	Residual 0 untuk data yang terganggu, tetapi perubahan masukan 7,1 × 10⁻⁷ menggeser x sebesar 6,3 × 10⁻³.
Singular	∞	Tidak berlaku	κ₂(A) tak terhingga; solve dan inverse menghasilkan galat matriks singular, bukan jawaban unik.

Baca kedua diagnosis bersama-sama: residual bertanya “apakah x ini cocok dengan b?”; kondisi bertanya “seberapa jauh x berubah jika b atau A sedikit berbeda?”

Visual tersebut memisahkan kedua pertanyaan. Residual bertanya apakah kandidat cocok dengan persamaan yang sedang ada di memori. Bilangan kondisi bertanya apakah perubahan kecil pada persamaan dapat menggeser kandidat itu. Sistem kalibrasi AI membutuhkan kedua jawaban.

Kasus batas: singular berarti “tidak ada penyelesaian unik”

Pertimbangkan

C=\begin{bmatrix}1&2\\2&4\end{bmatrix}.

Baris kedua adalah dua kali baris pertama, sehingga rank $C$ adalah $1$ , bukan $2$ . Dengan $b=[3,6]^\mathsf{T}$ , persamaannya konsisten tetapi memiliki tak terhingga banyak solusi: setiap $(x_1,x_2)$ yang memenuhi $x_1+2x_2=3$ dapat digunakan. Dengan $b=[3,7]^\mathsf{T}$ , persamaannya tidak konsisten karena persamaan kedua meminta ruas kiri dua kali ruas kiri pertama tetapi memberikan ruas kanan yang berbeda.

Tidak satu pun situasi tersebut memiliki vektor unik untuk dikembalikan oleh np.linalg.solve. Pada runtime yang disertakan, np.linalg.solve(C, [3, 6]) dan np.linalg.inv(C) sama-sama memunculkan numpy.linalg.LinAlgError: Singular matrix. Dokumentasi NumPy solve menetapkan syarat rank penuh dan menunjuk ke numpy.linalg.lstsq ketika solusi kuadrat terkecil sesuai untuk masalah non-persegi atau rank-deficient. Itu adalah pertanyaan yang berbeda dari menyelesaikan sistem persegi yang invertibel, jadi jangan diam-diam mengganti satu metode dengan metode lain.

Alur kerja NumPy yang disiplin untuk sistem AI

Untuk submasalah pemulihan parameter kecil, alur kerja yang dapat dipertanggungjawabkan adalah:

Periksa kontraknya. Pastikan dimensi $A$ , $b$ , dan vektor parameter yang dimaksud sesuai.
Selesaikan secara langsung. Gunakan np.linalg.solve(A, b) untuk sistem persegi berpangkat penuh; gunakan metode yang dirancang untuk kuadrat terkecil jika masalahnya tidak teridentifikasi dengan baik.
Ukur residual. Hitung np.linalg.norm(A @ x - b) dan bandingkan dengan skala $b$ , bukan hanya dengan ambang absolut sembarang.
Periksa pengondisian. Hitung np.linalg.cond(A) dan bandingkan sensitivitas yang mungkin terjadi dengan presisi pengukuran serta jumlah digit yang akan digunakan di tahap berikutnya.
Anggap kegagalan sebagai informasi. Galat singular, bilangan kondisi yang sangat besar, atau residual yang besar relatif terhadap $b$ harus memicu penyelidikan terhadap data, fitur, penskalaan, atau desain model.

Dalam tugas kalibrasi atau pemulihan parameter, alur kerja ini mengubah vektor bobot menjadi hasil yang dapat diaudit. Residual kecil dapat mendukung klaim bahwa implementasi menyelesaikan persamaan yang diberikan. Bilangan kondisi sedang dan pemeriksaan perturbasi memberi bukti bahwa persamaan tersebut cukup kuat mengikat parameter untuk penggunaan yang dimaksud. Tidak satu pun diagnosis membuktikan bahwa sistem AI yang lebih luas akurat; keduanya menjawab pertanyaan implementasi yang lebih sempit dan dapat diuji.

Pelajaran berikutnya meninggalkan algoritme numerik sejenak dan menanyakan operasi aljabar mana yang valid pada sistem bilangan yang digunakan tensor AI umum. Untuk sekarang, ingat aturan praktisnya: selesaikan sistem yang ada, periksa residual yang diperoleh, dan tanyakan melalui pengondisian apakah sistem yang berdekatan akan menceritakan kisah parameter yang berbeda.