Bỏ qua tới nội dung chính

Trước khi có tính toán khoa học

Tính toán khoa học: những con số đáng tin khi không có đáp án chính xác

Vì sao người học khoa học máy tính cần tính toán khoa học: số dấu phẩy động, tìm nghiệm, điều kiện và ổn định, Runge–Kutta, ma trận thưa — và bắt đầu từ đâu.

Ban biên tập OpenER

Cập nhật 18/11/2026 · 20 phút đọc · CC BY 4.0

Hồi đi học, bấm √2 trên máy tính cầm tay, màn hình hiện 1,414213562. Con số thật có vô hạn chữ số và không bao giờ lặp lại, nên chiếc máy không thể có đáp án "đúng" — nó chỉ có một đáp án gần đúng. Câu hỏi đáng hỏi là: gần tới đâu, và dựa vào đâu mà tin?

Với √2, câu hỏi nghe như chuyện vặt. Nhưng phần lớn những con số quan trọng mà máy tính làm ra đều thuộc loại này: đường đi dự kiến của một cơn bão, độ võng của cây cầu khi đoàn xe tải chạy qua, tham số của một mô hình AI. Không bài nào có công thức cho đáp án chính xác; máy làm hàng tỷ phép tính, phép nào cũng làm tròn một chút. Tính toán khoa học (scientific computing) là môn học về cách tính ra những con số như vậy cho nhanh, và quan trọng hơn, cho đáng tin: biết chúng sai bao nhiêu, và sai số có bị khuếch đại thành vô nghĩa hay không.

Trước khi có tính toán khoa học

Tính gần đúng là việc rất cũ: một tấm đất sét của người Babylon, gần bốn nghìn năm tuổi, đã ghi √2 đúng tới khoảng sáu chữ số; bài Vật lý kể những bước sau đó, từ Euler tới ENIAC. Thời tính tay, người tính thấy từng con số và nhận ra ngay khi có gì bất thường.

Máy tính điện tử mang tới một nỗi lo mới: mỗi giây hàng nghìn phép tính, phép nào cũng làm tròn, và không ai đứng nhìn. Năm 1943, nhà thống kê Harold Hotelling ước lượng rằng khi giải hệ phương trình bằng khử Gauss, sai số làm tròn có thể tăng theo hàm mũ với số ẩn. Nếu ông đúng, máy tính sẽ vô dụng với chính những bài toán lớn mà người ta xây nó để giải.

Câu trả lời đến từng bước:

  1. Phân tích sai số chặt chẽ — 1947. John von Neumann và Herman Goldstine công bố một bài gần tám mươi trang, lần theo từng phép làm tròn khi nghịch đảo một ma trận lớn, và chỉ ra rằng với một lớp ma trận quan trọng, sai số vẫn trong tầm kiểm soát. Goldstine về sau gọi đó là bài báo hiện đại đầu tiên của giải tích số. Năm 1948, Alan Turing đặt tên cho đại lượng đo độ nhạy của một hệ phương trình: số điều kiện (condition number).
  2. Đổi câu hỏi — Wilkinson, thập niên 1950–1960. James Wilkinson, người từng làm cùng Turing ở Phòng thí nghiệm Vật lý Quốc gia Anh, thôi hỏi "đáp án của máy cách đáp án thật bao xa?" mà hỏi "đáp án này có phải đáp án đúng của một bài toán rất gần bài đã cho không?". Cách nhìn đó, phân tích sai số ngược (backward error analysis), cho thấy khử Gauss có chọn trụ an toàn hơn nhiều so với nỗi lo của Hotelling. Wilkinson nhận giải Turing năm 1970.
  3. Thư viện dùng chung — thập niên 1970–1990. Các chuyên gia viết bộ giải một lần, thử trên nhiều loại máy, rồi phát miễn phí: EISPACK cho trị riêng, LINPACK (1979) cho hệ phương trình, BLAS cho các phép toán vector và ma trận cơ bản, rồi LAPACK (1992) thay cho cả hai thư viện đầu. Phụ lục sách hướng dẫn LINPACK năm 1979 có một bảng thời gian giải hệ 100 ẩn trên 23 loại máy — mầm của bài đo mà danh sách siêu máy tính TOP500 dùng tới hôm nay, chuyện của bài Tính toán song song.
  4. Một luật làm tròn chung — IEEE 754, 1985. Trước đó, mỗi hãng máy có định dạng số thực và cách làm tròn riêng. Cùng một chương trình, hai máy cho hai đáp án; có máy còn cho x − y = 0 dù x khác y. Người thiết kế chính của chuẩn là William Kahan; chip Intel 8087 (1980) đã làm theo bản nháp. Chuẩn IEEE 754 hứa một điều đơn giản mà mạnh: cộng, trừ, nhân, chia và khai căn luôn cho ra đúng số máy gần đáp án thật nhất. Kahan nhận giải Turing năm 1989.

Đặt cạnh nhau:

Trước đó
Có tính toán khoa học
Con số máy in ra
Tin hay không tùy cảm giác
Kèm ước lượng sai số: biết bao nhiêu chữ số đáng tin
Khi kết quả sai
Không biết lỗi tại bài toán hay tại cách giải
Số điều kiện đo bài toán, độ ổn định đo thuật toán
Giải hệ 1.000 ẩn
Mỗi nơi tự viết, tự mắc lỗi
Gọi LAPACK, code đã thử mấy chục năm
Cùng chương trình, hai máy
Có thể ra hai đáp án
Mỗi phép tính cơ bản làm tròn theo cùng một luật; chia cho 0 ra inf thay vì làm máy dừng

Thế giới "mỗi số chỉ vài chữ số đáng tin" đang quay lại ở một nơi bất ngờ: chip AI. Để nhanh và đỡ tốn bộ nhớ, mô hình học sâu được huấn luyện bằng số 16 bit, thậm chí 8 bit. Số float16 chỉ giữ khoảng ba chữ số có nghĩa:

python
import struct

def f16(x):                              # làm tròn x về số thực 16 bit (float16)
    return struct.unpack("e", struct.pack("e", x))[0]

dem = 0.0
for _ in range(10_000):                  # cộng 1, mười nghìn lần
    dem = f16(dem + 1)
print(dem)                               # 2048.0

Tới 2048, hai số 16 bit liền nhau cách nhau 2, nên 2048 + 1 bị làm tròn về 2048 và bộ đếm đứng yên mãi. Vì vậy thư viện học sâu cộng dồn bằng số 32 bit, và nhân hàm mất mát lên trước khi tính gradient cho số nhỏ khỏi chìm về 0.

Môn này trả lời câu hỏi gì

Tính toán khoa học trả lời câu hỏi: làm sao để một cỗ máy chỉ có hữu hạn chữ số giải được các bài toán của toán học liên tục — phương trình, ma trận khổng lồ, phương trình vi phân — và biết đáp án gần đúng tới đâu? Với mỗi bài toán, môn học dạy đặt ba câu hỏi:

  1. Bài toán nhạy tới đâu? Dữ liệu xê dịch một chút mà đáp án đổi hẳn thì không thuật toán nào cứu được.
  2. Thuật toán có khuếch đại sai số không? Cùng một bài toán, cách tính này giữ được 15 chữ số, cách kia chỉ còn 1.
  3. Tốn bao nhiêu? Thêm một chữ số đúng phải trả bao nhiêu bước tính, bao nhiêu bộ nhớ.

Ở nhiều trường kỹ thuật Việt Nam, môn gần nhất với chủ đề này mang tên Phương pháp tính. Lộ trình xếp nó vào nhóm Thuật toán, vì mỗi phương pháp số là một thuật toán — chỉ có câu hỏi "đúng hay sai?" được thay bằng "sai bao nhiêu?".

Người học khoa học máy tính phần lớn sẽ gọi NumPy, SciPy, PyTorch chứ không tự viết bộ giải. Nhưng thư viện không biết bài toán của bạn nhạy tới đâu. Khi mô hình ra nan, khi mô phỏng "nổ", khi hai máy cho hai đáp án, người học môn này biết tìm lỗi ở đâu.

Năm ý tưởng cốt lõi

1. Số của máy: cây thước có vạch không đều

Kiểu float của Python — số dấu phẩy động (floating point) 64 bit theo IEEE 754 — giữ khoảng 16 chữ số có nghĩa. Hãy hình dung một cây thước có vạch dày đặc quanh số 0 và thưa dần khi số lớn lên, nhưng khoảng cách tương đối giữa hai vạch liền nhau luôn cỡ 10⁻¹⁶. Mỗi phép tính ra một số thật, rồi máy dịch nó về vạch gần nhất.

python
import math

for x in (1.0, 1000.0, 1e16):
    print(f"gần {x:g}: hai số máy liền nhau cách nhau {math.ulp(x):.3g}")
print((1e16 + 1) + 1, 1e16 + (1 + 1))   # cùng ba số, hai thứ tự cộng

day = [1.0] + [1e-16] * 1_000_000        # tổng đúng là 1,0000000001

tong = 0.0
for x in day:                            # cộng lần lượt
    tong += x
print(tong)

tong, bu = 0.0, 0.0                      # cộng có bù (Kahan, 1965)
for x in day:
    y = x - bu                           # trả lại phần bị làm tròn mất ở lần trước
    t = tong + y
    bu = (t - tong) - y                  # phần của y không lọt được vào tổng
    tong = t
print(tong, math.fsum(day))
text
gần 1: hai số máy liền nhau cách nhau 2.22e-16
gần 1000: hai số máy liền nhau cách nhau 1.14e-13
gần 1e+16: hai số máy liền nhau cách nhau 2
1e+16 1.0000000000000002e+16
1.0
1.0000000001 1.0000000001

Gần 10¹⁶, hai vạch cách nhau 2, nên cộng thêm 1 là rơi vào khe và bị làm tròn về chỗ cũ: cộng 1 hai lần riêng rẽ thì mất cả hai, cộng 1 + 1 trước thì giữ được. Phép cộng trên máy không có tính kết hợp, và một triệu số nhỏ cộng lần lượt thì mất sạch (bài Giải tích gặp cùng chuyện này ở đạo hàm số). Vòng lặp thứ hai là cộng có bù (compensated summation) của Kahan: một biến phụ giữ phần vừa bị làm tròn mất rồi trả lại ở lần cộng sau. (Từ Python 3.12, hàm sum có sẵn cũng cộng có bù, nên phải tự viết vòng lặp mới thấy cách cộng ngây thơ.)

Hai hệ quả cho người viết phần mềm:

  • Tái lập (reproducibility): cộng song song trên nhiều nhân hay trên GPU, thứ tự cộng mỗi lần một khác, nên hai lần chạy có thể lệch ở mấy chữ số cuối. Cờ biên dịch -ffast-math cho phép đổi thứ tự phép tính — và có thể xóa luôn biến bu, vì về mặt đại số nó bằng 0.
  • Kiểm thử: đừng so hai số thực bằng ==; so với một dung sai chọn từ phân tích sai số, như math.isclose(a, b, rel_tol=1e-9).

2. Tìm nghiệm: chắc chắn hay nhanh

Nhiều phương trình không có công thức nghiệm, kể cả bài rất đời thường như tìm lãi suất thật của một khoản mua trả góp. Ta lấy một bài có sẵn đáp án để đo: nghiệm dương của x² − 2 = 0, tức √2 ở đầu bài. Hai cách:

  • Chia đôi (bisection): f(1) < 0 < f(2), nên nghiệm nằm trong đoạn [1, 2]. Thử điểm giữa, giữ nửa đoạn còn chứa nghiệm, lặp lại — như trò đoán số "lớn hơn hay nhỏ hơn".
  • Phương pháp Newton (Newton's method): thay đường cong bằng tiếp tuyến tại điểm đang đứng, rồi nhảy tới chỗ tiếp tuyến cắt trục hoành. Với x² − 2, bước nhảy là x ← x − (x² − 2)/(2x) — đúng cách khai căn mà Heron ở Alexandria đã mô tả từ thế kỷ I.
python
import math

def f(x):                                # nghiệm dương của x² − 2 = 0 là √2
    return x * x - 2

a, b, buoc = 1.0, 2.0, 0                 # chia đôi: f(1) < 0 < f(2), nghiệm nằm giữa
while b - a > 1e-15:
    m = (a + b) / 2
    if f(m) < 0:
        a = m                            # nghiệm ở nửa phải
    else:
        b = m                            # nghiệm ở nửa trái
    buoc += 1
print(f"chia đôi: {buoc} bước, {a:.15f}")

x = 1.0                                  # Newton: đi theo tiếp tuyến tới chỗ nó cắt trục hoành
for buoc in range(1, 6):
    x = x - f(x) / (2 * x)               # 2x là đạo hàm của x² − 2
    print(f"Newton bước {buoc}: {x:.15f}, sai {abs(x - math.sqrt(2)):.1e}")
text
chia đôi: 50 bước, 1.414213562373095
Newton bước 1: 1.500000000000000, sai 8.6e-02
Newton bước 2: 1.416666666666667, sai 2.5e-03
Newton bước 3: 1.414215686274510, sai 2.1e-06
Newton bước 4: 1.414213562374690, sai 1.6e-12
Newton bước 5: 1.414213562373095, sai 0.0e+00

Chia đôi mỗi bước thêm đúng một bit — khoảng 3,3 bước cho một chữ số thập phân — nên mất 50 bước. Newton chỉ cần 5: số chữ số đúng gấp đôi sau mỗi bước, 1 → 3 → 6 → 12 → 16. Đó là hội tụ bậc hai (quadratic convergence), thấy ngay ở số mũ của cột sai số: −3, −6, −12.

Cái giá của Newton: phải biết đạo hàm và phải xuất phát đủ gần nghiệm, không thì tiếp tuyến có thể ném nó đi xa mãi; chia đôi chậm nhưng không bao giờ lạc. Bộ giải thật như phương pháp Brent (Brent's method) — hàm brentq của SciPy — ghép chia đôi với những bước nhảy nhanh kiểu Newton mà không cần đạo hàm: đi nhanh khi được, lùi về chia đôi khi cần — giữ cả bảo đảm lẫn tốc độ.

3. Bài toán nhạy và thuật toán ẩu

Hai người đứng cạnh nhau trên bờ, cùng ngắm một chiếc thuyền ngoài khơi để xác định vị trí của nó. Hai tia ngắm gần như song song, nên một người lệch tay một chút là giao điểm chạy đi rất xa. Lỗi không nằm ở thước đo hay cách tính, mà ở chính bài toán: bài toán điều kiện xấu (ill-conditioned).

python
from fractions import Fraction as F      # phân số chính xác: không có phép làm tròn nào
import math

def giai(a, b, c, d, e, f):              # ax + by = e và cx + dy = f, theo quy tắc Cramer
    det = a * d - b * c
    return (e * d - b * f) / det, (a * f - c * e) / det

# hai đường thẳng gần song song: x + y = 2 và x + 1,0001y = 2,0001
print(*giai(1, 1, 1, F("1.0001"), 2, F("2.0001")))
print(*giai(1, 1, 1, F("1.0001"), 2, F("2.0002")))   # vế phải đổi 0,0001

b, c = -1e8, 1.0                         # x² − 100.000.000x + 1 = 0
can = math.sqrt(b * b - 4 * c)
lon = (-b + can) / 2                     # nghiệm lớn: cộng hai số cùng dấu, không sao
print((-b - can) / 2)                    # nghiệm nhỏ theo công thức sách giáo khoa
print(c / lon)                           # nghiệm nhỏ theo Vi-ét: tích hai nghiệm bằng c
text
1 1
0 2
7.450580596923828e-09
1e-08

Hai dòng đầu tính bằng phân số chính xác: vế phải đổi 0,0001 — chưa tới một phần hai mươi nghìn — mà nghiệm nhảy từ (1, 1) sang (0, 2). Số điều kiện của hệ này khoảng 40.000: sai số ở dữ liệu có thể bị phóng to chừng ấy lần, tức mất khoảng bốn, năm chữ số. Máy tính không gây ra chuyện này và cũng không chữa được; nó chỉ có thể báo cho bạn, như hàm numpy.linalg.cond.

Hai dòng sau là chuyện ngược lại: bài toán ổn mà thuật toán ẩu. Phương trình x² − 100.000.000x + 1 = 0 có một nghiệm rất nhỏ, gần 10⁻⁸, không hề nhạy với dữ liệu. Nhưng công thức nghiệm sách giáo khoa lấy 100.000.000 trừ đi căn của biệt thức, một số gần bằng nó: phép trừ xóa gần hết 16 chữ số chung, và kết quả sai tới 25%. Đó là triệt tiêu nghiêm trọng (catastrophic cancellation). Viết lại theo định lý Vi-ét — nghiệm nhỏ bằng c chia cho nghiệm lớn — thì không còn phép trừ nào, và kết quả đúng tới chữ số cuối.

Ghép hai nửa lại thành quy tắc quan trọng nhất của môn học, đi ra từ cách nhìn của Wilkinson:

sai số tương đối của đáp án ≲ số điều kiện của bài toán × sai số ngược của thuật toán.

Một thuật toán ổn định ngược (backward stable) — như khử Gauss có chọn trụ trong bài Đại số tuyến tính — giữ thừa số thứ hai ở cỡ 10⁻¹⁶; phần còn lại là chuyện của bài toán. Bài Tối ưu hóa gặp số điều kiện ở dạng khác, trong hạ gradient.

4. Phương trình vi phân: chọn đúng bộ giải

Một ly cà phê phin vừa pha, 90 °C, để trong phòng 30 °C. Định luật làm nguội Newton (Newton's law of cooling) nói tốc độ nguội tỷ lệ với độ chênh so với nhiệt độ phòng: dT/dt = −k(T − 30). Bài này có nghiệm chính xác, nên đo được sai số của từng cách giải.

Bài Vật lý đã dùng phương pháp Euler (Euler method): nếm độ dốc ở đầu bước rồi đi thẳng theo nó. Runge–Kutta bậc 4 (RK4), từ công trình của Carl Runge (1895) và Martin Kutta (1901), nếm độ dốc ở bốn chỗ trong bước rồi lấy trung bình có trọng số:

python
import math

he_so, phong, T0 = 0.05, 30, 90          # tốc độ nguội (mỗi phút), nhiệt độ phòng, ly cà phê lúc pha (°C)

def doc(T):                              # định luật làm nguội Newton: dT/dt = −k(T − T_phòng)
    return -he_so * (T - phong)

def euler(T, h):                         # một lần nếm độ dốc, ở đầu bước
    return T + h * doc(T)

def rk4(T, h):                           # Runge–Kutta bậc 4: nếm độ dốc ở bốn chỗ trong bước
    k1 = doc(T)
    k2 = doc(T + h / 2 * k1)
    k3 = doc(T + h / 2 * k2)
    k4 = doc(T + h * k3)
    return T + h / 6 * (k1 + 2 * k2 + 2 * k3 + k4)

dung = phong + (T0 - phong) * math.exp(-he_so * 20)    # nghiệm chính xác sau 20 phút
print(f"chính xác: {dung:.4f} °C")
for cach, so_buoc in [(euler, 4), (euler, 40), (euler, 400), (rk4, 4), (rk4, 8)]:
    T, h = T0, 20 / so_buoc
    for _ in range(so_buoc):
        T = cach(T, h)
    print(f"{cach.__name__:5} {so_buoc:3} bước: {T:.4f} °C, sai {abs(T - dung):.1e}")
text
chính xác: 52.0728 °C
euler   4 bước: 48.9844 °C, sai 3.1e+00
euler  40 bước: 51.7939 °C, sai 2.8e-01
euler 400 bước: 52.0451 °C, sai 2.8e-02
rk4     4 bước: 52.0737 °C, sai 8.9e-04
rk4     8 bước: 52.0728 °C, sai 5.0e-05

Mỗi bước RK4 tốn gấp bốn lần Euler, nhưng RK4 bốn bước (16 lần tính độ dốc) sai chưa tới một phần nghìn độ, còn Euler 400 bước vẫn sai gần ba phần trăm độ. Lý do là bậc chính xác (order of accuracy): tăng số bước 10 lần, sai số Euler giảm 10 lần — bậc 1; tăng số bước 2 lần, sai số RK4 giảm khoảng 18 lần, gần 2⁴ = 16 — bậc 4.

Bảng đó cũng là cách kiểm thử code số đáng tin nhất: giải một bài có nghiệm chính xác, nhân đôi số bước, xem sai số có giảm đúng 2ᵖ lần như lý thuyết hứa không. Một hàm RK4 gõ nhầm một hệ số vẫn ra những con số trông rất hợp lý, nhưng sai số chỉ giảm 2 hay 4 lần — phép thử này lộ ra ngay.

Chọn bộ giải còn một chuyện nữa: ổn định. Thử Euler với bước 50 phút: nhiệt độ thành −60 °C, rồi 165 °C, rồi −172,5 °C — ly cà phê vừa đóng băng vừa sôi. Ở bài này, Euler chỉ ổn định khi bước ngắn hơn 2/k, tức 40 phút. Nhiều hệ thật có những thành phần nhanh chậm chênh nhau hàng triệu lần — phản ứng hóa học có chất sinh ra rồi mất đi trong một phần triệu giây bên cạnh chất biến đổi trong nhiều giờ. Phương trình như vậy gọi là cứng (stiff), tên do Curtiss và Hirschfelder đặt năm 1952. Thành phần nhanh buộc phương pháp hiện (explicit) như Euler hay RK4 đi những bước tí hon suốt cả quãng, dù nó đã tắt từ lâu; phương pháp ẩn (implicit) giải thêm một phương trình mỗi bước nhưng được đi bước dài. Vì vậy scipy.integrate.solve_ivp có tham số method: mặc định "RK45" là một Runge–Kutta tự ước lượng sai số và tự chỉnh bước; bài toán cứng thì chọn "BDF" hay "Radau".

5. Cấu trúc: đừng tính những số 0

Muốn biết nhiệt độ ổn định trong một thanh kim loại được đốt nóng đều dọc thân, hai đầu giữ ở 0 °C, ta chia thanh thành một triệu điểm, mỗi điểm một ẩn. Ma trận của hệ có 10¹² ô, nhưng mỗi hàng chỉ có ba ô khác 0, vì nhiệt độ ở một điểm chỉ dính tới hai điểm kề. Đó là ma trận thưa (sparse matrix), ở đây còn gọn hơn: mọi số khác 0 nằm trên ba đường chéo.

python
import time

def nhiet_do_thanh(n):
    # thanh dài 1 m đốt nóng đều, hai đầu giữ 0 °C; chia thành n điểm cách đều.
    # Mỗi điểm chỉ dính tới hai điểm kề: −u[i−1] + 2u[i] − u[i+1] = h²
    h2 = (1 / (n + 1)) ** 2
    c, d = [0.0] * n, [0.0] * n
    c[0], d[0] = -0.5, h2 / 2
    for i in range(1, n):                # khử xuôi: mỗi hàng chỉ cần hàng ngay trên nó
        m = 2 + c[i - 1]
        c[i], d[i] = -1 / m, (h2 + d[i - 1]) / m
    u = [0.0] * n
    u[-1] = d[-1]
    for i in range(n - 2, -1, -1):       # thế ngược từ cuối thanh về đầu
        u[i] = d[i] - c[i] * u[i + 1]
    return u

n = 999_999
bat_dau = time.perf_counter()
u = nhiet_do_thanh(n)
print(f"giữa thanh: {u[n // 2]:.9f} (đúng: 0.125), mất {time.perf_counter() - bat_dau:.1f} giây")
print(f"nếu lưu cả ma trận: {n * n * 8 / 1e12:.0f} TB; khử Gauss thường: {n**3 / 3:.0e} phép tính")
text
giữa thanh: 0.125000075 (đúng: 0.125), mất 1.1 giây
nếu lưu cả ma trận: 8 TB; khử Gauss thường: 3e+17 phép tính

Khử Gauss trên ma trận đầy đủ cần cỡ n³/3 phép tính, và trước hết cần 8 TB bộ nhớ chỉ để chứa ma trận. Dùng cấu trúc ba đường chéo thì cùng phép khử ấy chỉ còn vài triệu phép tính, ít hơn hàng chục tỷ lần: Python thuần, vốn chậm, xong trong khoảng một giây. Thuật toán không đổi; chỉ là không tính những số 0. (Phần lệch ở chữ số thứ tám là sai số làm tròn, bị số điều kiện cỡ 4 × 10¹¹ của ma trận phóng to — đúng quy tắc ở ý thứ ba.)

Một bài học đi kèm: đừng tính ma trận nghịch đảo để giải hệ — nghịch đảo của ma trận thưa ở trên kín đặc, lại 8 TB.

Bài toán hai, ba chiều — gió trên một vùng, ứng suất trong thân cầu — cũng thưa nhưng khó hơn, vì khử Gauss lấp dần các ô 0. Ở đó người ta dùng phương pháp lặp (iterative method) như gradient liên hợp (conjugate gradient) của Hestenes và Stiefel (1952), chỉ cần nhân ma trận với vector — việc ma trận thưa làm rất rẻ. Ý chung của cả môn: thuật toán nhanh nhất là thuật toán dùng được cấu trúc của bài toán.

Tính toán khoa học nằm ở đâu trong chồng tầng

Trong chồng tầng của bài Từ electron đến ứng dụng, tính toán khoa học là một cột chạy dọc từ phần cứng lên ứng dụng:

  • Phần cứng: bộ tính dấu phẩy động trong mỗi nhân xử lý làm tròn đúng luật IEEE 754; GPU và chip AI thêm các định dạng 16 và 8 bit — xem bài Kiến trúc máy tính.
  • Thư viện lõi: BLAS tinh chỉnh riêng cho từng dòng chip (OpenBLAS, Intel MKL…), LAPACK và các bộ giải ma trận thưa dựng trên nó.
  • Thư viện khoa học: NumPy, SciPy, MATLAB, Julia, R đều gọi BLAS và LAPACK ở bên dưới.
  • Ứng dụng: mô phỏng, dự báo, đồ họa, học máy. Bài toán quá lớn cho một máy thì chia cho hàng nghìn máy — việc của tính toán song song.

Đưa lên

Những con số gần đúng kèm lời hứa về độ chính xác — bộ giải phương trình, hệ tuyến tính, trị riêng, phương trình vi phân mà người dùng chỉ cần đặt dung sai rồi gọi.

Giấu đi

Chọn trụ, chỉnh độ dài bước, thứ tự cộng, từng lần làm tròn. Cái giá: đáp án của một bài toán điều kiện xấu vẫn được in đủ 16 chữ số, chữ số nào trông cũng chắc chắn như nhau.

Học trước và học sau

· 6 môn

Giải tích

Calculus

Đạo hàm, chuỗi Taylor, phương trình vi phân — những thứ môn này tìm cách tính gần đúng trên máy. Nên học trước.

Xem chủ đề trên OpenER: Calculus

Đại số tuyến tính

Linear Algebra

Một nửa môn tính toán khoa học là đại số tuyến tính chạy trên máy. Nên học trước.

Xem chủ đề trên OpenER: Linear Algebra

Lập trình

Programming

Python ở mức viết được hàm và vòng lặp, rồi làm quen NumPy. Nên học trước.

Xem chủ đề trên OpenER: Programming

Tối ưu hóa

Optimization

Phương pháp Newton nhiều chiều, số điều kiện của hàm mục tiêu — họ hàng gần của tìm nghiệm. Học song song hoặc sau.

Xem chủ đề trên OpenER: Optimization

Tính toán song song

Parallel Computing

Khi một mô phỏng cần hàng nghìn bộ xử lý: chia lưới, chia ma trận, giữ kết quả tái lập được. Học sau.

Xem chủ đề trên OpenER: Parallel Computing

Đồ họa máy tính

Computer Graphics

Vải, nước, khói trên màn hình là phương trình vi phân giải cho kịp từng khung hình. Học sau.

Xem chủ đề trên OpenER: Computer Graphics

Ứng dụng thật và nghề nghiệp

  • Dự báo thời tiết và khí hậu: mô hình giải các phương trình của khí quyển trên một lưới phủ cả Trái Đất, chạy nhiều lần mỗi ngày.
  • Kỹ thuật: mô phỏng va chạm ô tô, khí động học, ứng suất trong cầu bằng phương pháp phần tử hữu hạn (finite element method) trước khi làm mẫu thật.
  • Y tế: ảnh chụp cắt lớp (CT) được dựng lại từ hàng nghìn phép đo tia X bằng thuật toán số.
  • Tài chính định lượng: định giá quyền chọn bằng phương trình đạo hàm riêng hay mô phỏng Monte Carlo — xem bài Xác suất và thống kê.
  • Thư viện học máy: người viết lõi của PyTorch, JAX sống hằng ngày với tràn số và độ chính xác 16 bit.

Các nghề liên quan: kỹ sư phần mềm nghiên cứu (research software engineer), kỹ sư mô phỏng, kỹ sư tính toán hiệu năng cao (HPC), chuyên viên định lượng, và kỹ sư tối ưu thư viện số ở các hãng chip.

Học xong làm được gì, bắt đầu từ đâu

Sau môn này bạn có thể:

  • nhận ra những phép tính làm mất chữ số, và viết lại công thức để tránh;
  • phân biệt bài toán điều kiện xấu với thuật toán không ổn định;
  • giải phương trình phi tuyến, hệ tuyến tính, bình phương tối thiểu, trị riêng, phương trình vi phân, và chọn đúng hàm thư viện cho từng bài;
  • đo bậc hội tụ bằng thực nghiệm để kiểm thử code số của mình, và khai thác cấu trúc thưa của bài toán.

Nên biết trước: giải tích một biến (đạo hàm, chuỗi Taylor), đại số tuyến tính (hệ phương trình, ma trận), và Python.

Bắt đầu trên OpenER: trang chủ đề Scientific Computing có hướng dẫn học sáu bước, từ số dấu phẩy động tới phương trình vi phân, với sách chính Python Programming and Numerical Methods của nhóm tác giả ở UC Berkeley — đọc miễn phí, mỗi phương pháp có code Python. Các khóa đã chọn lọc nằm ở chủ đề Giải tích số của lộ trình Toán học, dùng chung môn học: khóa chính là Numerical Analysis của IIT Bombay trên NPTEL, có video và lập trình Python, cùng các khóa thay thế và nâng cao của MIT và HKUST.

Lời khuyên: mỗi phương pháp, tự viết một lần, so với thư viện, rồi vẽ sai số theo độ dài bước trên thang log — độ dốc của đường thẳng chính là bậc hội tụ. Khi đường đó gãy và cong lên ở cuối, bạn đã chạm tới sàn làm tròn của máy, và hiểu vì sao cả môn học xoay quanh nó.

Tài liệu tham khảo

  • Qingkai Kong, Timmy Siauw, Alexandre M. Bayen — Python Programming and Numerical Methods: A Guide for Engineers and Scientists, Academic Press, 2020; có bản đọc miễn phí trên trang của UC Berkeley.
  • Lloyd N. Trefethen, David Bau III — Numerical Linear Algebra, SIAM, 1997.
  • Richard L. Burden, J. Douglas Faires — Numerical Analysis, Cengage.
  • Nicholas J. Higham — Accuracy and Stability of Numerical Algorithms, SIAM, ấn bản thứ hai, 2002.
  • MIT 18.330 Introduction to Numerical Analysis (Spring 2012) và MIT 18.335J Introduction to Numerical Methods (Spring 2019) — tài liệu mở trên MIT OpenCourseWare.
  • IEEE — IEEE Standard for Floating-Point Arithmetic (IEEE 754-2019).
  • John von Neumann, Herman H. Goldstine — "Numerical Inverting of Matrices of High Order", Bulletin of the American Mathematical Society, 1947.

Ban biên tập OpenER, “Tính toán khoa học: những con số đáng tin khi không có đáp án chính xác”, OpenER, 2026. Phát hành theo CC BY 4.0: được chia sẻ, chỉnh sửa, kể cả thương mại, miễn ghi công tác giả và dẫn link bài gốc.