Toán cho học máy: ba môn toán cùng làm việc trong một mô hình
Đại số tuyến tính, giải tích và xác suất ghép lại thế nào trong một mô hình học máy: hàm mất mát, lan truyền ngược, hợp lý cực đại, PCA — và học từ đâu.
Ban biên tập OpenER
Cập nhật 09/11/2026 · 20 phút đọc · CC BY 4.0
Năm nhất đại học, bạn qua ba môn toán: Giải tích, Đại số tuyến tính, Xác suất thống kê. Mỗi môn một quyển giáo trình, một kỳ thi, rồi cất lên giá. Hai năm sau, bạn mở ghi chú bài giảng của một khóa học máy và gặp một dòng như thế này:
θ ← θ − α · ∇J(θ), J(θ) = −(1/n) · Σ log p(yᵢ | xᵢ; θ)Trong một dòng có đủ cả ba môn. θ là một vector có khi hàng triệu con số — đại số tuyến tính. ∇ là gradient — giải tích. p(y | x; θ) và log là xác suất. Từng ký hiệu bạn đều đã học, nhưng chưa ai chỉ cho bạn vì sao chúng đứng cạnh nhau, và vì sao lại là log.
Toán cho học máy (mathematics for machine learning) là chủ đề trả lời đúng chỗ đó. Nó gần như không dạy toán mới, mà cho thấy ba môn cũ khớp vào nhau thế nào để một chương trình học được từ dữ liệu.
Trước khi có toán cho học máy
Các mảnh toán của chủ đề này có từ lâu trước khi có máy tính. Các nhà thiên văn đã phải "khớp" công thức quỹ đạo với số liệu đo — nhưng mỗi người một cách gộp số liệu, và hai người cùng một bộ số liệu có thể ra hai đáp án. Từng mảnh lần lượt xuất hiện:
- Bình phương tối thiểu (least squares) — Adrien-Marie Legendre công bố năm 1805, trong phụ lục của một cuốn sách về quỹ đạo sao chổi. Carl Friedrich Gauss công bố năm 1809 và nói mình đã dùng từ năm 1795; câu chuyện ông tìm lại tiểu hành tinh Ceres đã kể trong bài Đại số tuyến tính. Từ đây, "khớp nhất" có một định nghĩa chung mà ai tính cũng ra cùng một đáp án: tổng bình phương sai số nhỏ nhất. Gauss còn chỉ ra một điều ít được nhắc tới: nếu sai số đo có dạng hình chuông, nghiệm bình phương tối thiểu chính là bộ tham số có khả năng nhất — mầm của ý tưởng thứ tư trong bài này.
- Hợp lý cực đại (maximum likelihood) và PCA — đầu thế kỷ XX. Năm 1901, Karl Pearson tìm "đường thẳng và mặt phẳng khớp nhất" cho một đám điểm nhiều chiều — tiền thân của phân tích thành phần chính (principal component analysis — PCA), mà Harold Hotelling đặt tên năm 1933. Trong các bài báo từ 1912 tới 1922, Ronald Fisher biến ý của Gauss thành một phương pháp chung cho mọi mô hình xác suất: chọn tham số làm cho dữ liệu đã thấy có xác suất cao nhất.
- Máy tự tính đạo hàm — thập niên 1960 – 1970. Năm 1964, R. E. Wengert mô tả một chương trình tính đạo hàm cùng lúc với giá trị của hàm, qua từng phép tính nhỏ. Năm 1970, trong luận văn thạc sĩ ở Đại học Helsinki, Seppo Linnainmaa mô tả cách tính ngược từ kết quả về đầu vào, mà nay gọi là vi phân tự động chế độ ngược (reverse-mode automatic differentiation).
- Lan truyền ngược (backpropagation) cho mạng nơ-ron — Paul Werbos đề xuất dùng cách tính ngược ấy để huấn luyện mạng nơ-ron: ý tưởng có từ luận án tiến sĩ năm 1974, được viết rõ cho mạng nơ-ron trong một bài năm 1982. Bài báo năm 1986 của Rumelhart, Hinton và Williams — đã nhắc trong bài Học máy — làm nó phổ biến.
- Vi phân tự động thành thư viện — từ cuối thập niên 2000. Theano của Đại học Montréal, rồi TensorFlow và PyTorch giữa thập niên 2010: người nghiên cứu chỉ viết cách tính xuôi của mô hình, thư viện tự lo phần đạo hàm.
Trước bước cuối, mỗi mô hình mới đi kèm vài trang đạo hàm viết tay: tính trên giấy, chép thành code, rồi kiểm tra bằng cách nhích từng tham số xem kết quả đổi bao nhiêu. Sai một dấu trừ, chương trình không báo lỗi gì — mô hình chỉ học chậm hoặc học sai, có khi mất nhiều ngày mới tìm ra.
Đặt cạnh nhau:
Khớp bằng mắt, đạo hàm bằng tay | Ba môn toán ghép lại, máy tự tính đạo hàm | |
|---|---|---|
"Khớp nhất" nghĩa là gì | Mỗi người một cách, chọn tay vài quan sát đáng tin | Một tiêu chí rõ ràng: bình phương tối thiểu, hợp lý cực đại |
Chọn cách đo "sai" | Theo thói quen | Suy ra từ giả định về nhiễu trong dữ liệu |
Đạo hàm của mô hình | Tính trên giấy, mỗi mô hình mới tính lại, dễ sai một dấu | Viết cách tính xuôi, thư viện tự tính ngược |
Dữ liệu nhiều chiều | Xử lý từng cột, từng ví dụ | Cả lô dữ liệu là một ma trận, một phép nhân trên GPU |
Cỡ mô hình huấn luyện được | Vài tham số, có công thức giải thẳng | Hàng tỷ tham số, không cần công thức |
Ngay trong học máy hôm nay vẫn còn một góc sống như thời trước: siêu tham số (hyperparameter) — tốc độ học, số tầng của mạng, số ví dụ trong một lô (batch). Tham số bên trong mô hình được chỉnh bằng đạo hàm, nhưng câu hỏi "nên dùng mấy tầng" thì không có đạo hàm tiện dụng nào: muốn biết, phải huấn luyện thử rồi chấm. Nên phần lớn người làm nghề vẫn chọn siêu tham số bằng cách thử, giống người nấu phở nêm nước dùng: nêm, nếm, chỉnh, rồi nếm lại — chỉ khác là mỗi lần "nếm" là một lần huấn luyện, có khi mất nhiều giờ.
Môn này trả lời câu hỏi gì
Chủ đề này trả lời một câu hỏi: mô hình học từ dữ liệu bằng những phép toán nào? Câu đó tách thành ba câu nhỏ, mỗi câu thuộc về một môn:
- Dữ liệu và mô hình viết bằng gì? — vector và ma trận, của đại số tuyến tính.
- "Sai" đo bằng gì, và vì sao đo như vậy? — hàm mất mát (loss function), mà cách chọn có lý nhất đến từ xác suất.
- Chỉnh tham số theo hướng nào? — gradient và quy tắc dây chuyền (chain rule), của giải tích.
Câu thứ tư — đi theo hướng đó thế nào cho nhanh và chắc — là việc của bài Tối ưu hóa. Bài này dừng ở chỗ tính ra được hướng.
Vì sao cần học? Trên OpenER, đây là chủ đề khuyến khích, không bắt buộc trước Học máy. Nhưng người hiểu chỗ ba môn khớp vào nhau đọc được sách và bài báo, chọn được hàm mất mát cho bài toán của mình, và khi mô hình hỏng — mất mát thành nan, hay không chịu giảm — biết nên nhìn vào đâu, thay vì đổi thư viện cầu may.
Năm ý tưởng cốt lõi
1. Dữ liệu là ma trận, cả lô dữ liệu là một phép nhân
Bài Đại số tuyến tính coi ma trận là một phép biến đổi. Học máy thêm một cách nhìn nữa: một bảng dữ liệu là một ma trận — mỗi hàng một ví dụ, mỗi cột một đặc trưng. Một mô hình tuyến tính là một vector trọng số, và dự đoán cho cả bảng là một phép nhân ma trận. Ví dụ ước lượng thời gian giao đồ ăn:
def nhan_ma_tran(A, B):
"""Ma trận A (n × d) nhân ma trận B (d × k), ra ma trận n × k."""
assert len(A[0]) == len(B), "số cột của A phải bằng số hàng của B"
return [[sum(a * b for a, b in zip(hang, cot)) for cot in zip(*B)] for hang in A]
# Mỗi hàng là một đơn giao đồ ăn: [1, quãng đường (km), số món, giờ cao điểm (1 = có)]
X = [[1, 2.0, 1, 0],
[1, 5.5, 3, 1],
[1, 1.5, 2, 1],
[1, 8.0, 1, 0]]
# Trọng số (coi như đã học xong): 10 phút cố định, 3 phút mỗi km, 2 phút mỗi món, 10 phút giờ cao điểm
w = [[10], [3], [2], [10]]
print(nhan_ma_tran(X, w)) # [[18.0], [42.5], [28.5], [36.0]]: 4 dự đoán, một phép nhânHai mẹo nhỏ đáng nhớ. Cột đầu toàn số 1 để "10 phút cố định" cũng thành một trọng số như mọi trọng số khác — mô hình không phải xử lý riêng phần hằng số. Và nếu thay vector w bằng một ma trận nhiều cột, ta được nhiều đầu ra cùng lúc cho mọi ví dụ: đó chính là một tầng (layer) của mạng nơ-ron, trước khi đi qua hàm kích hoạt (activation function).
Dòng assert cũng không thừa. Ma trận n × d nhân với ma trận d × k ra n × k; hai số d ở giữa phải bằng nhau. Đưa vào một w chỉ có 3 hàng, chương trình dừng ngay. Lệch kích thước (shape mismatch) là lỗi hay gặp nhất khi viết code học máy, và nhẩm được kích thước từng ma trận là kỹ năng đầu tiên chủ đề này rèn cho bạn.
2. Hàm mất mát: biến "mô hình tốt" thành một con số trơn
Muốn máy tự chỉnh, phải nói cho nó biết "tốt hơn" nghĩa là gì, bằng một con số gọi là hàm mất mát: càng nhỏ càng tốt. Bài Học máy đã dùng trung bình bình phương sai số để đoán giá nhà. Câu hỏi ở đây sâu hơn một chút: sao không đo thẳng thứ ta quan tâm, như số lần đoán đúng?
Thử với một bộ lọc thư lừa đảo tí hon, chỉ có một trọng số w:
import math
def sigmoid(z):
return 1 / (1 + math.exp(-z)) # ép một số bất kỳ về khoảng (0, 1)
# 6 email: x là "điểm đáng ngờ" (âm: trông bình thường), y = 1 nếu là thư lừa đảo
x = [-2.0, -1.0, -0.5, 0.5, 1.0, 2.0]
y = [0, 0, 1, 0, 1, 1]
for w in (0.5, 1.0, 1.5, 3.0):
p = [sigmoid(w * xi) for xi in x] # mô hình: xác suất là lừa đảo
dung = sum((pi > 0.5) == (yi == 1) for pi, yi in zip(p, y))
mat_mat = -sum(math.log(pi) if yi else math.log(1 - pi) for pi, yi in zip(p, y)) / len(y)
print(f"w = {w}: đoán đúng {dung}/6, mất mát {mat_mat:.3f}")Kết quả:
w = 0.5: đoán đúng 4/6, mất mát 0.538
w = 1.0: đoán đúng 4/6, mất mát 0.471
w = 1.5: đoán đúng 4/6, mất mát 0.462
w = 3.0: đoán đúng 4/6, mất mát 0.584Số câu đúng đứng yên ở 4/6 dù w đổi gấp sáu lần. Nó chỉ đổi khi xác suất của một email nào đó vượt qua ngưỡng 0,5, như một cái công tắc. Nhích w một chút, số câu đúng không đổi, nên đạo hàm của nó bằng 0 gần như ở mọi nơi — nó không chỉ được hướng nào tốt hơn. Mất mát thì đổi liên tục theo w: giảm dần, nhỏ nhất ở quanh w ≈ 1,35, rồi tăng lại. Vì thế người ta huấn luyện mô hình trên một con số trơn thay cho thước đo thật, rồi mới chấm bằng thước đo thật.
Hàm mất mát trong code, gọi là entropy chéo (cross-entropy), cũng không phải chọn bừa; ý thứ tư sẽ cho thấy nó từ đâu ra.
3. Quy tắc dây chuyền chính là lan truyền ngược
Một mô hình là một chuỗi phép tính lồng nhau: nhân, cộng, qua hàm kích hoạt, so với nhãn, bình phương. Bài Giải tích cho biết đạo hàm và gradient là gì; muốn biết nhích một trọng số ở đầu chuỗi thì mất mát ở cuối chuỗi đổi bao nhiêu, chỉ cần thêm quy tắc dây chuyền, có sách gọi là quy tắc chuỗi: đạo hàm của cả chuỗi bằng tích đạo hàm của từng mắt xích.
So sánh đời thường: chiếc xe đạp. Đạp một vòng bàn đạp, đĩa kéo líp quay ba vòng; líp quay một vòng thì bánh xe lăn được khoảng hai mét. Vậy một vòng bàn đạp là 3 × 2 = 6 mét. Không bộ phận nào biết cả chuỗi; mỗi bộ phận chỉ biết tỷ lệ của riêng nó, nhân lại là xong.
Đó là toàn bộ ý tưởng của lan truyền ngược, và nó ngắn tới mức tự viết được. Lớp So dưới đây là một con số biết mình được tính từ những số nào: mỗi phép cộng, phép nhân, hàm tanh chỉ ghi lại đạo hàm cục bộ của riêng nó. Hàm lan_truyen_nguoc đi từ kết quả ngược về đầu vào, nhân và cộng dồn các đạo hàm cục bộ theo quy tắc dây chuyền:
import math
class So:
"""Một con số nhớ mình được tính từ những số nào, để sau đó tính ngược đạo hàm."""
def __init__(self, gia_tri, nguon=()):
self.gia_tri, self.dao_ham, self.nguon = gia_tri, 0.0, nguon # nguon: [(số, đạo hàm cục bộ)]
def __add__(self, khac):
return So(self.gia_tri + khac.gia_tri, ((self, 1.0), (khac, 1.0)))
def __mul__(self, khac):
return So(self.gia_tri * khac.gia_tri, ((self, khac.gia_tri), (khac, self.gia_tri)))
def tanh(self):
t = math.tanh(self.gia_tri)
return So(t, ((self, 1 - t * t),))
def lan_truyen_nguoc(self):
thu_tu, da_xem = [], set()
def xep(n): # xếp các phép tính theo thứ tự đã làm
if n not in da_xem:
da_xem.add(n)
for m, _ in n.nguon:
xep(m)
thu_tu.append(n)
xep(self)
self.dao_ham = 1.0
for n in reversed(thu_tu): # đi từ kết quả ngược về đầu vào
for m, cuc_bo in n.nguon:
m.dao_ham += cuc_bo * n.dao_ham # quy tắc dây chuyền
# Một nơ-ron: dự đoán = tanh(w1*x1 + w2*x2 + b); mất mát = (dự đoán − nhãn)²
def mat_mat(w1, w2, b, x1=2.0, x2=-1.0, nhan=0.5):
du_doan = (w1 * So(x1) + w2 * So(x2) + b).tanh()
sai = du_doan + So(-nhan)
return sai * sai
w1, w2, b = So(0.3), So(-0.4), So(0.1)
L = mat_mat(w1, w2, b)
L.lan_truyen_nguoc()
print(round(L.gia_tri, 4), [round(v.dao_ham, 4) for v in (w1, w2, b)])
# Kiểm tra bằng sai phân hữu hạn: nhích w1 một chút, xem mất mát đổi bao nhiêu
h = 1e-6
nhich = mat_mat(So(0.3 + h), So(-0.4), So(0.1)).gia_tri - mat_mat(So(0.3 - h), So(-0.4), So(0.1)).gia_tri
print(round(nhich / (2 * h), 4))Kết quả:
0.0903 [0.4318, -0.2159, 0.2159]
0.4318Dòng đầu là mất mát, cùng đạo hàm của nó theo w1, w2 và b. Dòng thứ hai kiểm tra lại đạo hàm theo w1 bằng cách làm thô: nhích w1 lên và xuống một phần triệu, xem mất mát đổi bao nhiêu — gọi là sai phân hữu hạn (finite difference). Hai con số khớp nhau. Dấu += lo trường hợp một số được dùng ở nhiều chỗ, như sai * sai: đạo hàm theo từng nhánh được cộng lại.
Điểm mấu chốt nằm ở chi phí, như bài Giải tích đã báo trước: cách nhích thử cần thêm lượt tính cho mỗi tham số — ở đây là hai lượt, nên mô hình một tỷ tham số cần hai tỷ lượt. Lan truyền ngược cho đạo hàm theo mọi tham số chỉ trong một lượt đi ngược, tốn cỡ vài lần một lượt tính xuôi, dù mô hình có ba tham số hay ba tỷ. PyTorch hay JAX làm cùng việc với lớp So, chỉ là trên cả ma trận và chạy trên card đồ họa. Cách nhích thử thì được giữ lại để kiểm tra đạo hàm (gradient checking) mỗi khi bạn tự viết một phép tính mới.
4. Hợp lý cực đại: vì sao là bình phương, vì sao là log
Ý thứ hai còn bỏ ngỏ một câu hỏi: hàm mất mát lấy từ đâu ra? Câu trả lời của xác suất: hãy coi dữ liệu là kết quả ngẫu nhiên sinh ra từ mô hình, rồi chọn tham số làm cho dữ liệu đã thấy có khả năng xảy ra nhất. Đó là ước lượng hợp lý cực đại (maximum likelihood estimation — MLE).
Ví dụ nhỏ nhất: 10 người xem một quảng cáo, 7 người bấm vào. Nếu mỗi người bấm với cùng một xác suất p, thì p nào làm dãy kết quả này có khả năng nhất?
import math
# 10 người xem một quảng cáo: 1 = bấm vào, 0 = lướt qua
bam = [1, 0, 1, 1, 0, 1, 1, 0, 1, 1]
def log_hop_ly(p):
"""log của xác suất thấy đúng dãy trên, nếu mỗi người bấm với xác suất p."""
return sum(math.log(p) if y == 1 else math.log(1 - p) for y in bam)
tot_nhat = max((k / 100 for k in range(1, 100)), key=log_hop_ly)
print(tot_nhat) # 0.7
print(round(-log_hop_ly(tot_nhat) / len(bam), 3)) # 0.611: entropy chéo trung bình
print(0.9 ** 10_000) # 0.0: nhân 10.000 xác suất, máy làm tròn về 0
print(round(10_000 * math.log(0.9))) # -1054: cộng các log thì vẫn tính đượcMáy thử 99 giá trị và chọn đúng 0,7 — trùng với điều ai cũng đoán: tỷ lệ bấm thấy được. Nhưng giờ ta biết vì sao nó đúng, và cùng một công thức dùng được cả khi không ai đoán nổi đáp án. Ba điều đáng để ý:
- Log biến tích thành tổng. Xác suất của cả tập dữ liệu là tích xác suất của từng ví dụ. Nhân mười nghìn số nhỏ hơn 1, máy làm tròn về 0; cộng log của chúng thì không sao, và tổng lại dễ lấy đạo hàm hơn tích. Vì thế mọi thư viện làm việc với log hợp lý (log-likelihood).
- Đổi dấu, lấy trung bình, là ra hàm mất mát. Khi p không còn là một hằng số mà là đầu ra của mô hình cho từng người — qua
sigmoidnhư ở ý thứ hai — thì trung bình của âm log hợp lý chính là entropy chéo, đúng hàm mất mát của bộ lọc thư lừa đảo. - Bình phương sai số cũng từ đây mà ra. Giả định nhãn bằng dự đoán cộng một sai số theo phân phối chuẩn — hình chuông trong bài Xác suất và thống kê. Log của mật độ hình chuông là
−(y − ŷ)² / 2σ²cộng một hằng số, nên làm cho hợp lý lớn nhất cũng là làm cho tổng bình phương sai số nhỏ nhất: đúng điều Gauss đã thấy năm 1809.
Bài học thực tế: chọn hàm mất mát là nói ra giả định của mình về nhiễu. Thời gian giao hàng thỉnh thoảng trễ cả tiếng vì mưa ngập đường? Sai số kiểu đó có "đuôi" dài hơn hình chuông; giả định phân phối Laplace thay cho phân phối chuẩn thì hợp lý cực đại cho ra tổng trị tuyệt đối sai số, ít bị vài đơn bất thường kéo lệch. Thêm niềm tin có trước theo định lý Bayes, chẳng hạn "trọng số thường nhỏ, quanh 0", thì được chính quy hóa (regularization): phạt trọng số lớn, giảm quá khớp (overfitting).
5. PCA: ba môn trong một bài toán
Ý cuối là một bài toán nhỏ mà cả ba môn cùng góp tay: giảm chiều dữ liệu (dimensionality reduction). Đo chiều cao và sải tay của sáu người, ta có hai cột — nhưng hai cột gần như kể cùng một chuyện: người cao thì tay dài. Có cách nào chỉ giữ một cột mà mất ít thông tin nhất?
PCA trả lời: tìm hướng mà dữ liệu dao động nhiều nhất, rồi chiếu mọi điểm lên hướng đó. Đoạn code dưới làm theo cách thô nhất — thử 1.800 hướng, mỗi hướng cách nhau 0,1 độ:
import math
# Chiều cao và sải tay (cm) của 6 người
du_lieu = [(158, 157), (163, 165), (167, 166), (170, 172), (176, 175), (181, 183)]
tb = [sum(cot) / len(du_lieu) for cot in zip(*du_lieu)]
lech = [(x - tb[0], y - tb[1]) for x, y in du_lieu] # trừ trung bình
def phuong_sai_theo(goc):
"""Chiếu mọi điểm lên hướng `goc` (độ dài 1), đo các hình chiếu dao động bao nhiêu."""
ux, uy = math.cos(goc), math.sin(goc)
return sum((dx * ux + dy * uy) ** 2 for dx, dy in lech) / len(lech)
tong = sum(dx * dx + dy * dy for dx, dy in lech) / len(lech) # tổng dao động của cả hai cột
goc_tot = max((math.radians(d / 10) for d in range(1800)), key=phuong_sai_theo)
print(round(math.degrees(goc_tot), 1), f"{phuong_sai_theo(goc_tot) / tong:.1%}") # 47.0 99.2%Hướng tốt nhất nghiêng 47 độ — gần như "chiều cao cộng sải tay", tức là "cỡ người" — và giữ lại 99,2% dao động của dữ liệu: hai cột thành một.
Nhìn lại, cả ba môn đều có mặt. Dao động là phương sai (variance) của thống kê. Chiếu lên một hướng là tích vô hướng của đại số tuyến tính. Tìm hướng tốt nhất là một bài toán tối ưu. Đại số tuyến tính còn cho một lối tắt: hướng đó chính là vector riêng (eigenvector) ứng với trị riêng lớn nhất của ma trận hiệp phương sai (covariance matrix), tính thẳng ra được. Hai chiều thì thử từng góc vẫn được; một nghìn chiều thì không thử xuể, chỉ còn lối tắt kia.
Toán cho học máy nằm ở đâu trong chồng tầng
Trong chồng tầng của bài Từ electron đến ứng dụng, chủ đề này là một cây cầu hơn là một tầng: phía dưới là ba môn toán nền, phía trên là học máy và học sâu. Nhưng nó chạm cả vào những tầng thấp hơn:
- Tầng thư viện: PyTorch, JAX, TensorFlow về lõi là hai thứ trong bài này — phép toán ma trận và vi phân tự động.
- Tầng phần cứng: gần như mọi thứ quy về nhân ma trận, nên card đồ họa và chip AI được thiết kế quanh đúng phép tính đó — xem bài Kiến trúc máy tính.
- Tầng số học trên máy:
0.9 ** 10_000ra 0 là chuyện của số dấu phẩy động, cùng họ với0.1 + 0.2ở bài Lập trình; tính log, exp sao cho không tràn số là việc của chủ đề Tính toán khoa học (scientific computing).
Đưa lên
Một công thức chung để tầng trên huấn luyện gần như mọi mô hình: dữ liệu xếp thành ma trận, một hàm mất mát suy ra từ giả định về nhiễu, và đạo hàm của nó theo mọi tham số, tính tự động trong một lượt đi ngược.
Giấu đi
Từng đạo hàm riêng, từng phép nhân trong ma trận, từng xác suất nhỏ xíu đã đổi sang log. Người dùng thư viện chỉ viết cách tính xuôi — nên khi đạo hàm sai hay số bị tràn, thường là người nhận ra sau cùng.
Học trước và học sau
· 7 mônGiải tích
Calculus
Đạo hàm, đạo hàm riêng, gradient — nền trực tiếp của lan truyền ngược. Nên học trước.
Đại số tuyến tính
Linear Algebra
Vector, ma trận, tích vô hướng, trị riêng. Nên học trước; ít nhất phải nhân ma trận và nhẩm kích thước thành thạo.
Xác suất và thống kê
Probability and Statistics
Phân phối, kỳ vọng, phương sai, định lý Bayes — nguyên liệu của hợp lý cực đại. Nên học trước.
Tối ưu hóa
Optimization
Bài này tính ra hướng đi; Tối ưu hóa dạy cách đi theo hướng đó: hạ gradient và các biến thể, bài toán lồi, vì sao huấn luyện hội tụ. Học ngay sau.
Học máy
Machine Learning
Nơi mọi mảnh trong bài được dùng thật: hồi quy, phân loại, quá khớp, đánh giá mô hình. Học song song hoặc ngay sau.
Học sâu
Deep Learning
Lan truyền ngược trên mạng hàng tỷ tham số, cùng những chuyện chỉ gặp ở quy mô đó, như đạo hàm teo về 0 qua nhiều tầng.
Tính toán khoa học
Scientific Computing
Số dấu phẩy động, sai số làm tròn, giải hệ và tìm trị riêng sao cho ổn định trên máy thật.
Ứng dụng thật và nghề nghiệp
- Kỹ sư học máy: gỡ lỗi khi huấn luyện hỏng — mất mát thành
nanvì lấy log của 0, đạo hàm phình to, ma trận lệch kích thước; chọn hàm mất mát hợp với bài toán thật thay vì dùng mặc định. - Nhà khoa học dữ liệu: chọn mô hình theo giả định về dữ liệu, dùng PCA để nhìn và làm sạch dữ liệu nhiều chiều.
- Nhà nghiên cứu AI: đọc và viết bài báo — nơi dòng công thức ở đầu bài này là ngôn ngữ hằng ngày.
- Kỹ sư thư viện và hệ thống AI: viết phần vi phân tự động, phép toán ma trận trên GPU — làm cho lớp
Soở trên chạy được với hàng tỷ con số. - Ngoài học máy: vi phân tự động còn dùng trong mô phỏng vật lý, thiết kế kỹ thuật và tài chính định lượng.
Học xong làm được gì, bắt đầu từ đâu
Sau chủ đề này bạn có thể:
- đọc trơn công thức trong giáo trình học máy: ký hiệu nào thuộc môn nào, kích thước bao nhiêu;
- viết dữ liệu và mô hình tuyến tính thành phép nhân ma trận, nhẩm kích thước để bắt lỗi trước khi chạy;
- tính gradient bằng quy tắc dây chuyền, kiểm tra lại bằng sai phân hữu hạn, và hiểu PyTorch đang làm gì bên dưới;
- giải thích vì sao hồi quy hay dùng bình phương sai số còn phân loại dùng entropy chéo, và đổi hàm mất mát khi giả định về nhiễu thay đổi;
- dùng PCA để giảm chiều dữ liệu.
Nên biết trước: đạo hàm một biến, nhân ma trận, xác suất nhập môn và Python cơ bản. Chưa vững phần nào thì đi qua chủ đề tương ứng trong nhóm Toán học của lộ trình trước.
Bắt đầu trên OpenER: trang chủ đề Mathematics for Machine Learning và hướng dẫn học chia chủ đề thành sáu bước, từ vector và ma trận tới ghép thành mô hình hoàn chỉnh, bám theo sách Mathematics for Machine Learning của Deisenroth, Faisal và Ong (bản PDF đọc miễn phí). Bước đầu có khóa tiếng Việt Nhập môn Đại số tuyến tính để ôn lại; bước cuối nối sang khóa Học máy tiếng Việt và khóa CS 189/289A Introduction to Machine Learning của UC Berkeley. Cả chủ đề khoảng 45 giờ.
Lời khuyên cho chủ đề này: mỗi công thức một đoạn code, mỗi đạo hàm một lần kiểm tra. Khi sách viết ra một gradient, đừng chỉ đọc: viết hàm mất mát, tính gradient theo công thức, rồi so với sai phân hữu hạn như ở ý thứ ba. Khớp thì bạn đã hiểu; lệch thì bạn vừa tìm ra chỗ mình — hoặc sách — sai.
Tài liệu tham khảo
- Marc Peter Deisenroth, A. Aldo Faisal, Cheng Soon Ong — Mathematics for Machine Learning, Cambridge University Press, 2020; bản PDF đọc miễn phí tại mml-book.github.io. Sách chính của chủ đề.
- Imperial College London — chuyên đề Mathematics for Machine Learning trên Coursera, gồm ba khóa: Linear Algebra, Multivariate Calculus, PCA.
- Stephen Boyd, Lieven Vandenberghe — Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares, Cambridge University Press, 2018, đọc miễn phí trên trang của sách.
- Gilbert Strang — Linear Algebra and Learning from Data, Wellesley-Cambridge Press, 2019, sách của khóa MIT 18.065.
- Ian Goodfellow, Yoshua Bengio, Aaron Courville — Deep Learning, MIT Press, 2016, đọc miễn phí tại deeplearningbook.org: chương 2–4 (đại số tuyến tính, xác suất, tính toán số) và mục 6.5 về lan truyền ngược.
- Atılım Güneş Baydin, Barak A. Pearlmutter, Alexey Andreyevich Radul, Jeffrey Mark Siskind — "Automatic Differentiation in Machine Learning: a Survey", Journal of Machine Learning Research 18, 2018.
- David E. Rumelhart, Geoffrey E. Hinton, Ronald J. Williams — "Learning representations by back-propagating errors", Nature 323, 1986.