0Pricing
Pandas & NumPy Academy · บทเรียน

การแก้ระบบสมการเชิงเส้น

แก้ Ax=b ด้วย np.linalg.solve และเปรียบเทียบกับวิธีคูณด้วยเมทริกซ์ผกผันแบบตรงไปตรงมาในด้านเสถียรภาพเชิงตัวเลข

การแก้ระบบสมการเชิงเส้น เป็นบทเรียน Pandas & NumPy Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Pandas & NumPy Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Pandas & NumPy Academy มีบทเรียนทั้งหมด 4 บทเรียน

ระบบสมการเชิงเส้นคืออะไร

ระบบสมการเชิงเส้นสามารถเขียนในรูปเมทริกซ์ได้เป็น Ax = b โดย A คือเมทริกซ์สัมประสิทธิ์ x คือเวกเตอร์ของตัวไม่ทราบค่า และ b คือเวกเตอร์ด้านขวามือ ตัวอย่างเช่น สมการสองสมการที่มีตัวไม่ทราบค่าสองตัวสามารถเขียนเป็นสมการเมทริกซ์ 2×2 ได้ การแก้ระบบหมายถึงการหา x ที่ทำให้ A คูณด้วย x เท่ากับ b np.linalg.solve(A, b) ของ NumPy จัดการงานนี้ได้อย่างมีประสิทธิภาพและแม่นยำ

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

เหตุใดจึงไม่ใช้เมทริกซ์ผกผัน

ในทางคณิตศาสตร์ คำตอบของ Ax = b คือ x = A⁻¹b แต่การคำนวณ np.linalg.inv(A) @ b ช้ากว่าและแม่นยำน้อยกว่าการเรียก np.linalg.solve(A, b) โดยตรง solve() ใช้การแยก LU ภายใน ซึ่งต้องดำเนินการน้อยกว่าและทำให้ข้อผิดพลาดเลขจุดลอยตัวสะสมน้อยกว่า หลักทั่วไปคือ หากคุณกำลังแก้หา x ใน Ax=b ให้ใช้ solve เสมอ และอย่าใช้ 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

ข้อกำหนดสำหรับ solve()

np.linalg.solve(A, b) กำหนดให้ A เป็นเมทริกซ์จัตุรัสและไม่เป็นเอกฐาน หาก A เป็นเอกฐาน (ดีเทอร์มิแนนต์เป็นศูนย์) ฟังก์ชันจะส่งข้อผิดพลาด np.linalg.LinAlgError: Singular matrix A เป็นเอกฐานเมื่อแถวต่าง ๆ พึ่งพากันเชิงเส้น เช่น สมการหนึ่งเป็นเพียงผลคูณค่าคงที่ของอีกสมการหนึ่ง ควรตรวจสอบเสมอว่าระบบของคุณมีรูปแบบปัญหาที่เหมาะสมก่อนเรียกใช้ solve หาก A ไม่ใช่เมทริกซ์จัตุรัส ให้ใช้ 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 เบื้องหลังการทำงาน

np.linalg.solve ใช้การแยก LU ภายใน โดยแยกตัวประกอบ A เป็นเมทริกซ์สามเหลี่ยมล่าง L และเมทริกซ์สามเหลี่ยมบน U ซึ่งเป็นไปตาม A = LU จากนั้นการแก้สมการจะกลายเป็นการแก้ระบบสามเหลี่ยมที่ง่ายกว่าสองขั้นตอน (การแทนค่าล่วงหน้าและการแทนค่าถอยหลัง) ซึ่งมีประสิทธิภาพมากกว่าการกำจัดแบบเกาส์ที่ทำซ้ำตั้งแต่ต้นมาก อัลกอริทึมนี้เป็นแบบเดียวกับที่ใช้ใน MATLAB, Fortran LAPACK และไลบรารีการคำนวณทางวิทยาศาสตร์แทบทุกแห่ง

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

การแก้ระบบที่มีด้านขวามือหลายชุด

np.linalg.solve(A, B) สามารถจัดการเมทริกซ์ B ที่มีหลายคอลัมน์ โดยแก้หาคำตอบของแต่ละคอลัมน์พร้อมกัน หาก B มีรูปร่าง (n, k) ผลลัพธ์ X จะมีรูปร่าง (n, k) โดยแต่ละคอลัมน์ของ X คือคำตอบสำหรับคอลัมน์ที่สอดคล้องกันของ B วิธีนี้มีประโยชน์ในการจำลองทางฟิสิกส์และการเรียนรู้ของเครื่อง ซึ่งต้องแก้เมทริกซ์สัมประสิทธิ์เดิมกับด้านขวามือหลายชุด

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

กำลังสองน้อยที่สุดด้วย np.linalg.lstsq()

เมื่อระบบมีสมการมากเกินไป (มีสมการมากกว่าตัวไม่ทราบค่า) จะไม่มีคำตอบที่ตรงพอดี np.linalg.lstsq(A, b) จะหา x ที่ทำให้ผลรวมกำลังสองของเศษเหลือน้อยที่สุด ||Ax - b||² ซึ่งตรงกับสิ่งที่การถดถอยเชิงเส้นคำนวณพอดี ฟังก์ชันนี้คืนค่าคำตอบ x, เศษเหลือ, อันดับ และค่ singular ฟังก์ชัน rcond=None จะระงับคำเตือนเรื่องการเลิกใช้งานและกำหนดจุดตัดสำหรับถือว่าค่า singular เป็นศูนย์

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)

การใช้ solve() ในการถดถอยเชิงเส้น

สมการปกติของกำลังสองน้อยที่สุดแบบธรรมดาคือ A.T @ A @ x = A.T @ b ซึ่งเป็นระบบจัตุรัสที่แก้ได้ด้วย np.linalg.solve วิธีนี้ให้ผลลัพธ์เดียวกับ lstsq เมื่อ A.T @ A มีสภาพดี ในทางปฏิบัติ ควรใช้ lstsq มากกว่า เพราะใช้ SVD และมีเสถียรภาพแม้คอลัมน์เกือบจะอยู่ในแนวเดียวกัน แต่สมการปกติช่วยให้คุณเข้าใจคณิตศาสตร์เบื้องหลังการถดถอย

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

การตรวจสอบจำนวนสภาพ

ก่อนแก้ระบบ ควรตรวจสอบจำนวนสภาพด้วย np.linalg.cond(A) จำนวนสภาพที่ใกล้ 1 หมายถึงระบบมีสภาพดีและคำตอบน่าเชื่อถือ จำนวนสภาพที่ใหญ่มาก (เช่น 1e12) หมายความว่าเมทริกซ์เกือบเป็นเอกฐาน การเปลี่ยนแปลงเล็กน้อยใน b จะทำให้ x เปลี่ยนแปลงอย่างมาก และคำตอบอาจไม่น่าเชื่อถือในเชิงตัวเลข ในกรณีนี้ ให้พิจารณาการทำให้เป็นระเบียบ (การถดถอยแบบ ridge) หรือใช้ตัวแก้ปัญหาที่มีความทนทานมากกว่า

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

ระบบเบาบาง: เมื่อใดไม่ควรใช้ linalg

สำหรับระบบขนาดใหญ่มากที่ A มีสมาชิกส่วนใหญ่เป็นศูนย์ (หรือเรียกว่าเมทริกซ์เบาบาง) การจัดเก็บเมทริกซ์เต็มจะสิ้นเปลืองหน่วยความจำ และการใช้ np.linalg.solve แบบหนาแน่นจะทำงานช้า SciPy มี scipy.sparse และ scipy.sparse.linalg.spsolve ซึ่งใช้ประโยชน์จากความเบาบางสำหรับระบบขนาดใหญ่มาก เช่น แบบจำลองไฟไนต์เอลิเมนต์หรือปัญหาเครือข่าย การเข้าใจว่าเมทริกซ์ของคุณเบาบางหรือไม่เป็นข้อพิจารณาด้านประสิทธิภาพที่สำคัญในการคำนวณทางวิทยาศาสตร์

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)

การตีความเวกเตอร์คำตอบ

เมื่อได้เวกเตอร์คำตอบ x จาก np.linalg.solve(A, b) แล้ว ควร ตรวจสอบคำตอบเสมอ โดยคำนวณ A @ x แล้วเปรียบเทียบกับ b ด้วย np.allclose(A @ x, b) ในการคำนวณแบบเลขทศนิยม คุณแทบจะไม่ได้ค่าที่เท่ากันทุกประการ — allclose จะตรวจสอบว่าค่าอยู่ภายในค่าความคลาดเคลื่อนที่ยอมรับได้ขนาดเล็กหรือไม่ ค่าคงเหลือ ||Ax - b|| ควรมีค่าใกล้เคียงกับเอปซิลอนของเครื่องคูณด้วยสเกลของปัญหา สำหรับระบบที่มีสภาวะเหมาะสม

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

การแก้ระบบในกระบวนการประมวลผลการเรียนรู้ของเครื่อง

ตัวแก้ระบบเชิงเส้นปรากฏอยู่ในงานการเรียนรู้ของเครื่องตลอดกระบวนการ ได้แก่ การถดถอยเชิงเส้นที่แก้สมการปกติ กระบวนการเกาส์เซียนที่แก้ระบบเมทริกซ์เคอร์เนล และ ตัวกรองคาลมานที่แก้สมการอัปเดตสถานะ เมื่อเข้าใจ np.linalg.solve และ lstsq แล้ว คุณจะสามารถนำอัลกอริทึมเหล่านี้ไปเขียนตั้งแต่ต้น และแก้ไขข้อผิดพลาดเมื่อผลลัพธ์ไม่เป็นไปตามที่คาดได้ โมดูล linalg ของ NumPy มอบเครื่องมือเชิงตัวเลขแบบเดียวกับที่ใช้ในไลบรารีวิทยาศาสตร์สำหรับงานจริง

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

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจแนวคิดการวิเคราะห์ข้อมูลจากบทเรียนนี้

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า np.linalg.solve(A, b) แก้ระบบสมการเชิงเส้นแบบจัตุรัสได้อย่างมีประสิทธิภาพโดยใช้การแยกเมทริกซ์แบบ LU, np.linalg.lstsq() หาคำตอบกำลังสองน้อยที่สุดสำหรับระบบที่มีสมการมากกว่าจำนวนตัวแปร และ จำนวนเงื่อนไขใช้วัดเสถียรภาพเชิงตัวเลข โดยค่าขนาดใหญ่เป็นสัญญาณเตือนว่าเมทริกซ์เกือบเอกฐาน บทถัดไป เราจะสำรวจค่าลักษณะเฉพาะและ SVD ซึ่งเป็นพื้นฐานของ PCA และอัลกอริทึมการเรียนรู้ของเครื่องจำนวนมาก

คำถามที่พบบ่อย

บทเรียน “การแก้ระบบสมการเชิงเส้น” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การแก้ระบบสมการเชิงเส้น” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Pandas & NumPy Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Pandas & NumPy Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การแก้ระบบสมการเชิงเส้น”

แก้ Ax=b ด้วย np.linalg.solve และเปรียบเทียบกับวิธีคูณด้วยเมทริกซ์ผกผันแบบตรงไปตรงมาในด้านเสถียรภาพเชิงตัวเลข คุณปฏิบัติ Pandas & NumPy Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Pandas & NumPy Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Pandas & NumPy Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การแก้ระบบสมการเชิงเส้น” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Pandas & NumPy Academy นี้ได้ไหม

ได้ บทเรียน Pandas & NumPy Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การคูณเมทริกซ์ด้วย np.matmul และ @
  2. ดีเทอร์มิแนนต์ เมทริกซ์ผกผัน และทรานสโพส
  3. การแก้ระบบสมการเชิงเส้น
  4. ภาพรวมค่าเฉพาะและ SVD
← กลับไปที่ Pandas & NumPy Academy