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

Trước khi có học máy

· Bài đọc mở đầu

Học máy: dạy máy tính bằng ví dụ thay vì bằng luật

Học máy là gì và vì sao nó đổi cách viết phần mềm: học có giám sát, hàm mất mát và hạ gradient, quá khớp, dữ liệu và đặc trưng, phân cụm — và nên bắt đầu học từ đâu.

Ban biên tập OpenER

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

Bạn chạy xe vào hầm gửi xe của một chung cư. Camera chụp biển số, vài giây sau màn hình đã hiện "30A-123.45", barie mở. Không ai ngồi gõ biển số. Nhưng thử nghĩ xem người lập trình đã viết gì để máy phân biệt chữ số 8 với chữ B, số 0 với chữ D, khi biển số thì bẩn, ánh đèn thì chói, chữ thì nghiêng theo góc camera?

Câu trả lời là: gần như không ai viết những quy tắc đó. Người ta đưa cho chương trình hàng chục nghìn ảnh biển số đã có người đọc sẵn, rồi để chương trình tự rút ra quy tắc từ các ví dụ. Đó là học máy (machine learning): viết chương trình học từ dữ liệu, thay vì viết từng quy tắc bằng tay.

Tom Mitchell, trong cuốn giáo trình Machine Learning (1997), đưa ra một định nghĩa hay được nhắc lại: một chương trình được gọi là học nếu, với một loại việc (task) nào đó, kết quả (performance) của nó — đo bằng một thước đo rõ ràng — tốt lên nhờ kinh nghiệm (experience). Với camera hầm xe: việc là đọc biển số, thước đo là tỷ lệ đọc đúng, kinh nghiệm là những ảnh đã được người đọc sẵn. Ba thứ đó phải nói rõ được trước khi bắt tay vào bất kỳ bài toán học máy nào.

Trước khi có học máy

Trước học máy, muốn máy tính làm một việc, chỉ có một cách: người hiểu việc đó viết ra quy tắc. Muốn máy chơi cờ, người lập trình viết cách đánh giá thế cờ. Muốn máy đọc chữ, người ta mô tả từng nét: chữ "L" là một nét đứng nối một nét ngang ở dưới. Cách này chạy tốt khi quy tắc rõ ràng, nhưng bế tắc trước những việc con người làm dễ dàng mà không giải thích được — nhận ra khuôn mặt mẹ, nghe rõ một câu nói giữa tiếng ồn, đọc nét chữ xấu của bạn cùng lớp.

Học máy ra đời từng bước:

  1. Chương trình tự chơi để giỏi lên — thập niên 1950. Arthur Samuel ở IBM viết một chương trình chơi cờ đam (checkers) có thể tự cải thiện cách đánh giá thế cờ sau nhiều ván, kể cả những ván tự chơi với chính mình. Bài báo năm 1959 của ông có tên "Some Studies in Machine Learning Using the Game of Checkers", và Samuel thường được ghi công là người đưa cụm từ "machine learning" vào sử dụng.
  2. Bắt chước nơ-ron — năm 1958, Frank Rosenblatt công bố perceptron: một mô hình đơn giản cộng các tín hiệu đầu vào có trọng số rồi quyết định "có" hay "không", và tự chỉnh trọng số mỗi khi đoán sai. Năm 1969, Marvin Minsky và Seymour Papert chỉ ra những giới hạn của perceptron một lớp, và hướng mạng nơ-ron (neural network) chững lại nhiều năm.
  3. Mạng nhiều lớp học được — năm 1986, David Rumelhart, Geoffrey Hinton và Ronald Williams công bố bài báo làm phổ biến lan truyền ngược (backpropagation), cách huấn luyện mạng nơ-ron nhiều lớp.
  4. Học máy thống kê — thập niên 1990 và 2000. Những phương pháp có nền toán chắc chắn như máy vector hỗ trợ (support vector machine), cây quyết định (decision tree) và rừng ngẫu nhiên (random forest) đi vào sản phẩm thật: lọc thư rác, chấm điểm tín dụng. Mạng nơ-ron cũng có chỗ đứng: cuối thập niên 1990, hệ thống của Yann LeCun và cộng sự dùng mạng tích chập để đọc chữ số viết tay trên séc ngân hàng ở Mỹ.
  5. Dữ liệu lớn gặp GPU — năm 2012. Tại cuộc thi nhận dạng ảnh ImageNet (hơn một triệu ảnh, một nghìn loại vật), mạng nơ-ron sâu AlexNet huấn luyện trên card đồ họa (GPU) thắng với tỷ lệ lỗi thấp hơn hẳn các đội còn lại — mở đầu thời học sâu (deep learning).

Đặt hai cách làm phần mềm cạnh nhau:

Viết quy tắc bằng tay
Học quy tắc từ ví dụ
Ai nghĩ ra quy tắc
Người lập trình, dựa trên hiểu biết của mình
Thuật toán, dựa trên dữ liệu
Việc hợp nhất
Quy tắc rõ ràng, phải đúng tuyệt đối
Quy tắc khó nói thành lời: ảnh, giọng nói, hành vi
Khi thế giới thay đổi
Sửa code
Thu thêm dữ liệu, huấn luyện lại
Giải thích "vì sao"
Chỉ thẳng vào dòng code
Thường khó, có khi không giải thích được
Kiểu sai hay gặp
Bỏ sót trường hợp hiếm
Sai âm thầm khi gặp dữ liệu khác lúc học

Ngày nay, rất nhiều phần mềm quan trọng vẫn cố ý không dùng học máy. Phần mềm tính thuế thu nhập cá nhân hay bảng lương của một công ty làm đúng theo quy định, từng bậc thuế, từng khoản giảm trừ, viết thẳng thành if và công thức. Ở đây không có gì phải "học": quy tắc đã có sẵn trong luật, kết quả phải đúng tới từng đồng, và khi có người thắc mắc thì phải chỉ ra được vì sao. Một mô hình học máy "đúng 99%" là không chấp nhận được với bảng lương. Biết khi nào không nên dùng học máy cũng là một phần của môn học.

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

Môn Học máy trả lời hai câu hỏi đi liền nhau:

  1. Làm sao để chương trình tự rút ra quy tắc từ các ví dụ? — chọn dạng mô hình nào, đo "sai" bằng cách nào, chỉnh mô hình ra sao để bớt sai.
  2. Làm sao biết quy tắc học được cũng đúng với những ví dụ chưa từng thấy? — đây mới là câu khó. Thuộc lòng dữ liệu cũ thì dễ; đoán đúng dữ liệu mới mới là học.

Vì sao người học khoa học máy tính cần môn này? Vì học máy đã thành công cụ thường ngày của phần mềm, và kể cả khi không làm nghề học máy, kỹ sư ngày nay cũng thường phải gọi một mô hình, đánh giá nó, và hiểu vì sao nó sai. Môn này cho bạn đủ hiểu biết để không coi mô hình là phép màu.

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

1. Học có giám sát: tìm một hàm khớp với các ví dụ

Dạng học máy phổ biến nhất là học có giám sát (supervised learning). Ta có nhiều ví dụ, mỗi ví dụ gồm đầu vào — gọi là các đặc trưng (features) — và đáp án đúng, gọi là nhãn (label). Việc của thuật toán là tìm một hàm biến đầu vào thành đáp án, sao cho đúng với các ví dụ đã có và — quan trọng hơn — đúng với ví dụ mới.

  • Đáp án là một con số (giá nhà, thời gian giao hàng, nhiệt độ ngày mai): bài toán hồi quy (regression).
  • Đáp án là một loại (chữ số nào, thư có phải lừa đảo không, ảnh có khối u không): bài toán phân loại (classification).

Hàm đó gọi là mô hình (model). Mô hình có những con số bên trong, gọi là tham số (parameters), và "học" chính là tìm giá trị tốt cho các tham số. Một mô hình hồi quy đơn giản chỉ có hai tham số; một mô hình ngôn ngữ lớn có hàng tỷ — nhưng ý tưởng giống nhau.

So sánh đời thường: một người môi giới nhà đất đã xem hàng trăm căn hộ, nghe diện tích, tầng, quận là đoán được giá xê xích. Không ai đưa cho họ công thức; họ rút ra từ kinh nghiệm. Học có giám sát làm đúng việc đó, nhưng bằng toán.

2. Hàm mất mát và tối ưu: đi xuống dốc trong sương mù

Muốn chỉnh mô hình cho bớt sai, trước hết phải đo được sai. Con số đo độ sai gọi là hàm mất mát (loss function). Với hồi quy, cách phổ biến là lấy trung bình bình phương sai số: đoán lệch 1 tỷ thì phạt 1, lệch 2 tỷ thì phạt 4.

Học trở thành một bài toán tối ưu (optimization): tìm tham số làm hàm mất mát nhỏ nhất. Cách làm phổ biến nhất là hạ gradient (gradient descent). Hãy hình dung bạn đứng trên sườn núi trong sương mù, chỉ thấy mặt đất dưới chân. Muốn xuống thung lũng, bạn dò xem hướng nào dốc xuống nhất, bước một bước nhỏ theo hướng đó, rồi lặp lại.

Ví dụ: đoán giá căn hộ theo diện tích, với năm căn hộ (số liệu bịa cho dễ tính). Mô hình là một đường thẳng giá ≈ a × diện tích + b, bắt đầu từ a = 0, b = 0 và tự chỉnh dần:

python
# Diện tích (m²) và giá (tỷ đồng) của 5 căn hộ — số liệu bịa cho dễ tính
dien_tich = [40, 55, 70, 85, 100]
gia       = [1.9, 2.6, 3.3, 4.0, 4.6]

a, b = 0.0, 0.0          # mô hình: giá ≈ a * diện tích + b, bắt đầu từ 0
toc_do = 0.00015         # độ dài mỗi bước (learning rate)
n = len(gia)

for buoc in range(300_000):
    # sai số của từng căn: giá đoán trừ giá thật
    sai = [a * x + b - y for x, y in zip(dien_tich, gia)]
    # độ dốc của hàm mất mát (trung bình bình phương sai số) theo a và theo b
    doc_a = 2 * sum(s * x for s, x in zip(sai, dien_tich)) / n
    doc_b = 2 * sum(sai) / n
    # bước một bước ngược chiều dốc
    a -= toc_do * doc_a
    b -= toc_do * doc_b

print(f"giá ≈ {a:.4f} × diện tích + {b:.3f}")
print(f"căn 60 m² đoán giá {a * 60 + b:.2f} tỷ")

Chạy trong khoảng hai giây, chương trình in ra giá ≈ 0.0453 × diện tích + 0.107 và đoán căn 60 m² giá khoảng 2.83 tỷ. Không ai viết con số 0,0453 vào code: chương trình tự tìm ra nó từ dữ liệu.

Hai điều đáng để ý. Thứ nhất, tốc độ học (learning rate) phải chọn khéo: thử đổi toc_do thành 0.001, chỉ sau 100 bước các tham số đã phình thành những con số khổng lồ — mỗi bước nhảy quá xa, vượt qua thung lũng sang sườn bên kia, cao hơn chỗ cũ. Thứ hai, bài này nhỏ nên có công thức giải thẳng (bình phương tối thiểu, đã gặp trong bài Đại số tuyến tính), nhưng mạng nơ-ron hàng tỷ tham số thì không có công thức nào — chúng được huấn luyện bằng đúng ý tưởng "dò dốc, bước một bước nhỏ" này, chỉ là ở quy mô lớn hơn rất nhiều.

3. Khái quát hóa và quá khớp: học hiểu, không học thuộc

Có một cách "đạt điểm tuyệt đối" rất dễ: nhớ hết các ví dụ. Hỏi lại đúng ví dụ đã thấy thì trả lời đúng; hỏi ví dụ mới thì chịu. Giống người học thuộc lòng đề cương ôn thi: gặp đúng câu trong đề cương thì làm được, đổi cách hỏi một chút là lúng túng. Trong học máy, hiện tượng này gọi là quá khớp (overfitting): mô hình khớp cả những chi tiết ngẫu nhiên, nhiễu và sai sót trong dữ liệu học, nên đoán kém trên dữ liệu mới. Ngược lại, khả năng đoán đúng dữ liệu chưa thấy gọi là khái quát hóa (generalization).

Ví dụ dưới đây dùng k láng giềng gần nhất (k-nearest neighbors): muốn phân loại một điểm mới, tìm k điểm gần nó nhất trong dữ liệu học rồi cho chúng bỏ phiếu. Dữ liệu có quy luật đơn giản (nhãn 1 nếu x + y > 1), nhưng 20% nhãn bị ghi nhầm — như dữ liệu thật luôn có người nhập sai:

python
import random

random.seed(1)

def tao_diem(so_diem):
    """Điểm (x, y) trong hình vuông 1×1; nhãn 1 nếu x + y > 1, nhưng 20% nhãn bị ghi nhầm."""
    du_lieu = []
    for _ in range(so_diem):
        x, y = random.random(), random.random()
        nhan = 1 if x + y > 1 else 0
        if random.random() < 0.2:
            nhan = 1 - nhan          # nhiễu: ghi nhầm nhãn
        du_lieu.append((x, y, nhan))
    return du_lieu

def du_doan(huan_luyen, x, y, k):
    """k láng giềng gần nhất bỏ phiếu."""
    gan_nhat = sorted(huan_luyen, key=lambda d: (d[0] - x) ** 2 + (d[1] - y) ** 2)[:k]
    so_phieu_1 = sum(d[2] for d in gan_nhat)
    return 1 if so_phieu_1 * 2 > k else 0

def do_chinh_xac(huan_luyen, tap_kiem_tra, k):
    dung = sum(du_doan(huan_luyen, x, y, k) == nhan for x, y, nhan in tap_kiem_tra)
    return dung / len(tap_kiem_tra)

huan_luyen = tao_diem(200)       # dữ liệu để học
kiem_tra = tao_diem(1000)        # dữ liệu mô hình chưa từng thấy

for k in (1, 15, 199):
    print(f"k = {k:3d}: trên dữ liệu học {do_chinh_xac(huan_luyen, huan_luyen, k):.0%}, "
          f"trên dữ liệu mới {do_chinh_xac(huan_luyen, kiem_tra, k):.0%}")

Kết quả:

text
k =   1: trên dữ liệu học 100%, trên dữ liệu mới 64%
k =  15: trên dữ liệu học 75%, trên dữ liệu mới 73%
k = 199: trên dữ liệu học 59%, trên dữ liệu mới 51%

Với k = 1, mỗi điểm chỉ nghe chính nó, nên trên dữ liệu học đúng 100% — một con số rất đẹp và hoàn toàn vô nghĩa. Trên dữ liệu mới nó chỉ đúng 64%, vì nó đã học thuộc cả 20% nhãn sai. Với k = 15, các điểm nhiễu bị số đông át đi: điểm trên dữ liệu học thấp hơn, nhưng trên dữ liệu mới lại cao hơn. Còn k = 199 thì ngược lại: gần như cả tập bỏ phiếu chung, mô hình quá đơn giản tới mức không học được gì — gọi là chưa khớp (underfitting). (Vì 20% nhãn là nhiễu, không mô hình nào vượt được khoảng 80% trên dữ liệu mới.)

Bài học quan trọng nhất của cả môn nằm ở đây: không bao giờ chấm mô hình bằng chính dữ liệu nó đã học. Người ta chia dữ liệu thành tập huấn luyện (training set) để học và tập kiểm tra (test set) để chấm, giống như thầy giáo không ra đề thi trùng với bài tập đã chữa. Muốn chọn k, hay chọn giữa nhiều mô hình, thì dùng thêm một tập kiểm định (validation set) riêng, để tập kiểm tra vẫn "chưa ai nhìn thấy" cho tới lần chấm cuối.

4. Dữ liệu và đặc trưng: rác vào thì rác ra

Mô hình chỉ biết những gì dữ liệu cho nó biết. Người làm học máy hay nhắc câu "rác vào, rác ra" (garbage in, garbage out), và trong thực tế phần lớn thời gian của một dự án dành cho dữ liệu chứ không phải cho thuật toán: thu thập, gán nhãn, làm sạch, kiểm tra.

Ba cái bẫy hay gặp, kể bằng ví dụ tưởng tượng:

  • Dữ liệu không đại diện. Một mô hình nhận dạng giọng nói tiếng Việt được huấn luyện gần như toàn bằng giọng Hà Nội có thể nghe kém hẳn giọng miền Tây — không phải vì thuật toán dở, mà vì nó chưa bao giờ được "nghe" giọng đó. Mô hình đọc biển số học toàn ảnh ban ngày thì gặp ảnh ban đêm dễ sai.
  • Dữ liệu mang sẵn thiên kiến. Nếu một ngân hàng huấn luyện mô hình duyệt hồ sơ vay bằng những quyết định cũ của nhân viên, mà nhân viên từng vô tình khắt khe với một nhóm khách hàng nào đó, thì mô hình sẽ học luôn sự khắt khe ấy — và áp dụng nó đều đặn, nhanh hơn, trên hàng triệu hồ sơ.
  • Đặc trưng "lộ đáp án". Một mô hình đoán khách có trả được nợ không đạt độ chính xác rất cao, cho tới khi người ta phát hiện trong đặc trưng có cột "số tiền phạt trả chậm" — thứ chỉ biết được sau khi khách đã trả chậm. Hiện tượng này gọi là rò rỉ dữ liệu (data leakage), và nó làm mô hình đẹp trên giấy, vô dụng ngoài đời.

Chọn và tạo đặc trưng tốt — kỹ thuật đặc trưng (feature engineering) — cũng là một kỹ năng lớn. Đoán giá nhà, "khoảng cách tới ga tàu điện gần nhất" có thể quan trọng hơn "số cửa sổ". Học sâu tự học được nhiều đặc trưng từ dữ liệu thô như ảnh và âm thanh, nhưng câu hỏi "dữ liệu này có thật sự chứa đáp án không, và có công bằng không" thì vẫn là việc của con người.

5. Học không giám sát: tự tìm nhóm khi không có đáp án

Không phải lúc nào cũng có nhãn. Một cửa hàng có danh sách khách hàng và lịch sử mua sắm, nhưng không ai ghi sẵn "khách này thuộc nhóm nào". Học không giám sát (unsupervised learning) tìm cấu trúc trong dữ liệu không có đáp án. Bài toán quen thuộc nhất là phân cụm (clustering): gom những thứ giống nhau vào một nhóm.

Thuật toán phân cụm đơn giản nhất là k-means: chọn k điểm làm "tâm" ban đầu, rồi lặp hai bước — mỗi điểm về nhóm có tâm gần nhất, mỗi tâm dời về giữa nhóm của nó:

python
import random

# Mỗi khách: (số lần mua trong tháng, số tiền trung bình mỗi lần — trăm nghìn đồng)
khach = [(2, 9), (3, 8.5), (1, 10), (12, 0.6), (15, 0.5), (10, 0.8),
         (6, 3), (5, 3.5), (7, 2.8)]

def k_means(diem, k, so_vong=10):
    random.seed(0)
    tam = random.sample(diem, k)                 # chọn ngẫu nhiên k khách làm tâm ban đầu
    for _ in range(so_vong):
        nhom = [[] for _ in range(k)]
        for x, y in diem:                        # bước 1: mỗi khách về nhóm có tâm gần nhất
            i = min(range(k), key=lambda i: (x - tam[i][0]) ** 2 + (y - tam[i][1]) ** 2)
            nhom[i].append((x, y))
        tam = [(sum(p[0] for p in g) / len(g), sum(p[1] for p in g) / len(g))
               for g in nhom]                    # bước 2: dời tâm về giữa nhóm
    return nhom

for g in k_means(khach, 3):
    print(g)

Chương trình in ra ba nhóm: khách ít mua nhưng mỗi lần mua nhiều tiền, khách mua thường xuyên những món nhỏ, và nhóm ở giữa. Không ai đặt tên nhóm trước; thuật toán tự tìm ra, còn việc gọi chúng là "khách sỉ", "khách quen" hay gì khác là việc của người đọc kết quả.

Có một điều nên tự thử: đổi random.seed(0) thành số khác, có lần bạn sẽ được ba nhóm khác hẳn — chẳng hạn một nhóm chỉ có một khách. K-means phụ thuộc vào điểm xuất phát, nên trong thực tế người ta chạy nhiều lần và giữ kết quả tốt nhất.

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, học máy nằm ở tầng ứng dụng và thuật toán, nhưng nó kéo theo gần như mọi tầng bên dưới:

Trong bức tranh lớn của trí tuệ nhân tạo — xem bài Nhập môn trí tuệ nhân tạo — học máy là nhánh đã thắng thế: thay vì cố viết tri thức thành luật, ta để máy học tri thức từ dữ liệu.

Đưa lên

Một hàm đã học xong — đưa vào ảnh, câu văn hay hồ sơ, nhận về dự đoán, thường kèm mức độ chắc chắn — để tầng ứng dụng gọi như gọi một hàm bình thường.

Giấu đi

Từng ví dụ huấn luyện, hàng triệu tham số và quá trình dò dốc để tìm ra chúng. Cái giá của việc giấu đi: khi mô hình sai, thường khó chỉ ra sai ở đâu.

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

· 7 môn

Lập trình

Programming

Học máy được học tốt nhất bằng cách tự viết code: đọc dữ liệu, cài một thuật toán nhỏ, vẽ kết quả. Python là ngôn ngữ chung của ngành.

Xem chủ đề trên OpenER: Programming

Đại số tuyến tính

Linear Algebra

Dữ liệu là vector, mô hình là ma trận. Nên học trước; ít nhất phải quen nhân ma trận và hiểu bình phương tối thiểu.

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

Xác suất và thống kê

Probability and Statistics

Kỳ vọng, phân phối, ước lượng và kiểm định — ngôn ngữ để nói mô hình đúng tới đâu và vì sao nó sai trên dữ liệu mới. Nên học trước.

Xem chủ đề trên OpenER: Probability and Statistics

Toán cho học máy

Mathematics for Machine Learning

Gom phần đạo hàm nhiều biến, ma trận và xác suất mà các khóa học máy dùng, cho ai muốn đọc trơn công thức trong giáo trình như CS229.

Xem chủ đề trên OpenER: Mathematics for Machine Learning

Học sâu

Deep Learning

Mạng nơ-ron nhiều lớp, lan truyền ngược, mạng tích chập, transformer — bước tiếp theo tự nhiên sau môn này.

Xem chủ đề trên OpenER: Deep Learning

Học tăng cường

Reinforcement Learning

Học bằng thử và nhận thưởng: chơi game, điều khiển robot, ra quyết định nhiều bước.

Xem chủ đề trên OpenER: Reinforcement Learning

Mô hình đồ thị xác suất

Probabilistic Graphical Models

Nhìn học máy dưới góc xác suất trên rất nhiều biến cùng lúc.

Xem chủ đề trên OpenER: Probabilistic Graphical Models

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

  • Thương mại điện tử, mạng xã hội và tài chính: gợi ý sản phẩm, xếp hạng bảng tin, dự báo nhu cầu, phát hiện giao dịch gian lận, chấm điểm tín dụng.
  • Ảnh và cảm biến: đọc biển số, hỗ trợ đọc ảnh X-quang (bác sĩ vẫn quyết định cuối cùng), nhận dạng sâu bệnh qua ảnh lá, phát hiện lỗi sản phẩm trên dây chuyền.
  • Ngôn ngữ: dịch máy, nhận dạng giọng nói, trợ lý trò chuyện.

Các nghề liên quan:

  • Kỹ sư học máy (machine learning engineer): đưa mô hình từ bản chạy thử vào sản phẩm thật — huấn luyện, triển khai, theo dõi khi dữ liệu thay đổi.
  • Nhà khoa học dữ liệu (data scientist): đặt câu hỏi đúng, làm sạch dữ liệu, chọn và đánh giá mô hình, giải thích kết quả cho người ra quyết định.
  • Nhà nghiên cứu: phát triển phương pháp mới, ở trường đại học hoặc phòng nghiên cứu của doanh nghiệp.
  • Kỹ sư phần mềm nói chung: hiểu học máy giúp bạn biết khi nào tin một mô hình, khi nào phải có phương án dự phòng.

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

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

  • đặt một bài toán thực tế thành bài toán học máy: việc là gì, dữ liệu là gì, đo kết quả bằng gì — và nhận ra khi nào không nên dùng học máy;
  • tự cài và giải thích những thuật toán nền tảng: hồi quy tuyến tính, hồi quy logistic, k láng giềng gần nhất, cây quyết định, k-means;
  • hiểu hạ gradient và vì sao chọn tốc độ học lại quan trọng;
  • chia dữ liệu huấn luyện, kiểm định, kiểm tra cho đúng, nhận ra quá khớp và chưa khớp;
  • nghi ngờ đúng chỗ: con số chính xác đẹp quá, dữ liệu không đại diện, đặc trưng lộ đáp án;
  • đủ nền để học tiếp học sâu, học tăng cường và các chủ đề ứng dụng.

Nên biết trước: lập trình Python cơ bản, đại số tuyến tính, xác suất thống kê nhập môn và đạo hàm riêng — chưa vững thì học toán song song.

Bắt đầu trên OpenER: trang chủ đề Machine Learning có các khóa đã chọn lọc, và hướng dẫn học gợi ý thứ tự đi qua chúng. Khóa chính là Stanford CS229 của Andrew Ng: video, ghi chú bài giảng chi tiết và bài tập, phủ từ học có giám sát, không giám sát tới lý thuyết học. Nếu muốn từng thuật toán được giảng trực quan, kèm ví dụ, có Cornell CS4780; muốn hiểu sâu "vì sao học được" thì có Learning from Data của Caltech; còn khóa Học máy tiếng Việt trên OpenER hợp để ôn nhanh trước khi vào khóa dài.

Lời khuyên cho môn này: tự cài trước, dùng thư viện sau. Mỗi thuật toán chính, hãy viết một bản nhỏ bằng Python thuần như các ví dụ ở trên, chạy trên vài chục điểm dữ liệu, in ra từng bước. Khi đã thấy tận mắt mô hình học thế nào và sai thế nào, chuyển sang thư viện như scikit-learn bạn sẽ dùng nó như một người hiểu chuyện, không phải như một người bấm nút.

Tài liệu tham khảo

  • Stanford CS229 Machine Learning (Andrew Ng) — video bài giảng trên Stanford Engineering Everywhere và ghi chú bài giảng trên trang khóa học.
  • Tom M. Mitchell — Machine Learning, McGraw-Hill, 1997: giáo trình kinh điển, nguồn của định nghĩa việc – kinh nghiệm – thước đo.
  • Gareth James, Daniela Witten, Trevor Hastie, Robert Tibshirani — An Introduction to Statistical Learning, sách đọc miễn phí trên trang của sách, đi cùng khóa Statistical Learning của Stanford.
  • Yaser S. Abu-Mostafa, Malik Magdon-Ismail, Hsuan-Tien Lin — Learning From Data, cùng khóa giảng Learning from Data của Caltech.
  • Cornell CS4780 Machine Learning for Intelligent Systems (Kilian Weinberger) — ghi chú và video bài giảng trên trang khóa học.
  • Christopher M. Bishop — Pattern Recognition and Machine Learning, Springer, 2006.

Ban biên tập OpenER, “Học máy: dạy máy tính bằng ví dụ thay vì bằng luật”, 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.