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

Trước khi có học sâu

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

Học sâu: mỗi tầng học một cách nhìn mới

Vì sao xếp nhiều tầng nơ-ron lại học được: tầng ẩn tự tìm đặc trưng, phi tuyến và độ sâu, tích chập, chú ý và transformer, cái giá của quy mô — 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

Điện thoại của bạn có vài nghìn tấm ảnh. Gõ "mèo" vào ô tìm kiếm của ứng dụng ảnh, mọi tấm có mèo hiện ra — cả con mèo đen chỉ ló nửa cái đầu sau rèm — dù bạn chưa từng đánh dấu tấm nào. Bấm micro trên bàn phím, nói một câu tiếng Việt, chữ hiện ra đủ dấu.

Bài Học máy đã kể cách chương trình rút ra quy tắc từ ví dụ. Nhưng với ảnh, mỗi ví dụ là vài triệu con số — độ sáng từng điểm ảnh — và một con số lẻ không nói gì về con mèo. Phải có ai đó biến đống số ấy thành thứ có nghĩa: tai có nhọn không, có ria không. Suốt nhiều chục năm, "ai đó" là con người.

Học sâu (deep learning) giao luôn việc đó cho máy. Một mạng nơ-ron (neural network) gồm nhiều tầng (layer) xếp chồng: tầng đầu nhận ra nét, tầng sau ghép nét thành hình, tầng sau nữa ghép hình thành vật — và không ai viết ra mỗi tầng phải tìm gì.

Trước khi có học sâu

Trước học sâu, người làm nghề phải thiết kế đặc trưng bằng tay — công thức đo độ chênh sáng tối quanh mỗi điểm ảnh, cách tách âm thanh thành các dải tần — rồi mới đưa những con số đã chọn lọc cho một thuật toán học máy. Mỗi bộ đặc trưng là công sức nhiều năm, và bộ tốt cho ảnh không giúp gì cho tiếng nói.

Học sâu đến từng bước, chậm hơn nhiều người nghĩ:

  1. Não mèo và neocognitron — 1959 tới 1980. David Hubel và Torsten Wiesel thấy trong vỏ não thị giác của mèo có tế bào chỉ phản ứng với một nét nghiêng đúng một góc, và có tế bào vẫn phản ứng khi nét ấy dịch đi một chút. Năm 1980, Kunihiko Fukushima ở Nhật Bản dựng neocognitron với các tầng xen kẽ "tìm nét" và "bỏ qua lệch vị trí" — tổ tiên của mạng tích chập, nhưng chưa có cách huấn luyện cả mạng một lượt.
  2. LeNet — 1989. Yann LeCun ở Bell Labs ghép ý ấy với lan truyền ngược (backpropagation) để đọc mã bưu chính viết tay trên thư ở Mỹ. Mạng này, về sau gọi là LeNet, đưa mạng nơ-ron tích chập (convolutional neural network — CNN) ra một bài toán thật.
  3. Gradient biến mất và LSTM — 1991 tới 1997. Mạng càng sâu, tín hiệu sửa sai đi ngược về các tầng đầu càng teo gần bằng 0: hiện tượng gradient biến mất (vanishing gradient), được Sepp Hochreiter phân tích trong luận văn năm 1991. Năm 1997, ông và Jürgen Schmidhuber công bố LSTM (long short-term memory): một ô nhớ có các "cửa" đóng mở, cho thông tin đi qua hàng trăm bước của một chuỗi mà không phai. Phải tới 2015–2016, LSTM mới chạy trong nhận dạng giọng nói và dịch máy của Google; suốt thời gian dài trước đó, mạng sâu bị coi là khó huấn luyện.
  4. Cái tên "học sâu" — 2006. Geoffrey Hinton, Simon Osindero và Yee-Whye Teh huấn luyện mạng niềm tin sâu (deep belief network) bằng cách dạy từng tầng một rồi mới tinh chỉnh cả mạng. Cách này về sau ít dùng, nhưng nó cho thấy mạng sâu huấn luyện được, và tên gọi "học sâu" phổ biến từ đây.
  5. GPU và dữ liệu lớn — 2009 tới 2012. Việc huấn luyện chuyển sang card đồ họa (GPU), vốn làm ra để chạy hàng nghìn phép tính giống nhau cùng lúc; bộ ảnh ImageNet ra đời năm 2009. Năm 2012, bài báo chung của bốn nhóm (Đại học Toronto, Microsoft, Google, IBM) cho thấy mạng sâu giảm rõ lỗi nhận dạng giọng nói, và AlexNet thắng cuộc thi ImageNet (bài Học máy đã kể) sau năm, sáu ngày huấn luyện trên hai card chơi game.
  6. ResNet — 2015. Nhóm của Kaiming He ở Microsoft Research thêm vào mỗi khối của mạng một đường tắt (residual connection) cho tín hiệu đi thẳng qua. Mạng 152 tầng của họ thắng ImageNet năm đó, khi các mạng mạnh nhất năm trước chỉ khoảng hai mươi tầng.
  7. Transformer — 2017. Bài báo Attention Is All You Need của tám tác giả, phần lớn ở Google, bỏ hẳn cách đọc chuỗi từng bước, chỉ giữ cơ chế chú ý (attention). Transformer thành nền của các mô hình ngôn ngữ lớn — bước cuối trong phần lịch sử của bài Nhập môn trí tuệ nhân tạo — rồi lan sang ảnh và âm thanh.
  8. Được ghi nhận — Giải Turing năm 2018 trao cho Yoshua Bengio, Geoffrey Hinton và Yann LeCun. Năm 2024, giải Nobel Vật lý trao cho John Hopfield và Geoffrey Hinton, vì mạng Hopfield (1982) và máy Boltzmann — hai mô hình mượn ý của vật lý thống kê.

Đặt cạnh nhau:

Đặc trưng thiết kế bằng tay
Học sâu
Ai quyết định nhìn vào đâu
Chuyên gia, sau nhiều năm thử
Mạng tự học từ dữ liệu
Đầu vào
Những con số đã chọn lọc
Dữ liệu thô: điểm ảnh, sóng âm, chữ
Đổi sang bài toán khác
Thiết kế lại từ đầu
Cùng cách làm, đổi dữ liệu
Cần có
Dữ liệu vừa phải, máy thường
Rất nhiều dữ liệu, GPU
Hỏi "vì sao đoán vậy"
Chỉ vào được từng đặc trưng
Khó: tri thức rải trong hàng triệu trọng số

Ngày nay vẫn có nơi học sâu không thắng: dữ liệu dạng bảng. Trong bảng hồ sơ vay vốn — thu nhập, tuổi, số khoản nợ — mỗi cột đã là một đặc trưng có nghĩa do người chọn. Ở đây, cây quyết định tăng cường (gradient-boosted trees) thường vẫn ngang hoặc hơn mạng nơ-ron, lại nhanh và dễ giải thích hơn; một nghiên cứu trên 45 bộ dữ liệu cỡ vừa ở hội nghị NeurIPS 2022 đi tới đúng kết luận ấy. Học sâu mạnh nhất ở chỗ đặc trưng còn chưa ai tìm ra.

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

Môn Học sâu trả lời ba câu hỏi:

  1. Vì sao xếp nhiều tầng lại học được những thứ một tầng không học nổi — mạng tự tìm ra đặc trưng bằng cách nào?
  2. Làm sao huấn luyện một mạng hàng trăm tầng, hàng tỷ tham số mà tín hiệu không tắt giữa đường?
  3. Dữ liệu nào hợp kiến trúc nào — ảnh là một lưới điểm, câu văn là một chuỗi từ; mỗi loại cần một cách nối nơ-ron riêng.

Vì sao cần học? Vì phần lớn tiến bộ của AI hơn mười năm qua — nhận dạng ảnh, giọng nói, dịch máy, chatbot — là học sâu. Kể cả khi chỉ gọi mô hình qua API, hiểu bên trong giúp bạn biết nó mạnh ở đâu, tốn bao nhiêu, và sai theo kiểu nào.

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

1. Tầng ẩn tự tìm ra đặc trưng

Phép XOR (hoặc loại trừ) cho ra 1 khi hai đầu vào khác nhau. Trên mặt phẳng, hai điểm đáp án 1 — (0, 1) và (1, 0) — nằm ở hai góc chéo nhau, hai điểm đáp án 0 ở hai góc kia. Không đường thẳng nào tách được hai nhóm, nên một perceptron, vốn chỉ vạch được một đường thẳng, không học nổi XOR — một trong những giới hạn Minsky và Papert chỉ ra năm 1969 (bài Học máy).

Thêm vào giữa một tầng ẩn (hidden layer) hai nơ-ron, rồi huấn luyện bằng lan truyền ngược:

python
import math, random

random.seed(2)
X = [(0, 0), (0, 1), (1, 0), (1, 1)]
Y = [0, 1, 1, 0]                       # XOR: ra 1 khi hai đầu vào khác nhau

def sigmoid(z):
    return 1 / (1 + math.exp(-z))

# Tầng ẩn 2 nơ-ron, tầng ra 1 nơ-ron; mỗi nơ-ron có 2 trọng số và 1 hệ số tự do (bias)
W = [[random.uniform(-1, 1) for _ in range(3)] for _ in range(2)]
V = [random.uniform(-1, 1) for _ in range(3)]

def chay(x):
    h = [sigmoid(w[0] * x[0] + w[1] * x[1] + w[2]) for w in W]
    return h, sigmoid(V[0] * h[0] + V[1] * h[1] + V[2])

toc_do = 0.5
for vong in range(20_000):
    for x, y in zip(X, Y):
        h, p = chay(x)
        d_ra = p - y                                                 # tầng ra sai bao nhiêu
        d_an = [d_ra * V[j] * h[j] * (1 - h[j]) for j in range(2)]   # chia phần sai về tầng ẩn
        for j in range(2):
            V[j] -= toc_do * d_ra * h[j]
            W[j][0] -= toc_do * d_an[j] * x[0]
            W[j][1] -= toc_do * d_an[j] * x[1]
            W[j][2] -= toc_do * d_an[j]
        V[2] -= toc_do * d_ra

for x in X:
    h, p = chay(x)
    print(x, "tầng ẩn thấy", [round(v, 2) for v in h], "→ đoán", round(p, 2))

Kết quả:

text
(0, 0) tầng ẩn thấy [0.0, 0.97] → đoán 0.0
(0, 1) tầng ẩn thấy [0.02, 0.01] → đoán 1.0
(1, 0) tầng ẩn thấy [0.02, 0.01] → đoán 1.0
(1, 1) tầng ẩn thấy [0.96, 0.0] → đoán 0.0

Nhìn cột giữa. Không ai bảo, nơ-ron ẩn thứ nhất tự học câu hỏi "cả hai cùng bật?" — chỉ sáng ở (1, 1); nơ-ron thứ hai học "cả hai cùng tắt?" — chỉ sáng ở (0, 0). Trong hai tọa độ mới, (0, 1) và (1, 0) dồn về gần gốc, hai điểm kia nằm trên hai trục, và một đường thẳng đã tách được. Tầng ẩn đổi cách nhìn dữ liệu cho tới khi bài toán thành dễ — ý tưởng trung tâm của học sâu, gọi là học biểu diễn (representation learning). Mạng nhận dạng ảnh làm đúng điều này, chỉ là qua hàng chục tầng.

Hai điều nên tự thử. Đổi random.seed(2) thành random.seed(0): mạng kẹt, hai ô đoán 0,47 mãi không nhích; với hai nơ-ron ẩn, khoảng bốn trong mười lần chạy kẹt như vậy, mạng rộng hơn thì hiếm kẹt hơn hẳn. Và dòng d_an là quy tắc dây chuyền (chain rule) chia phần sai về từng nơ-ron ẩn; bài Toán cho học máy viết hẳn một bộ tính đạo hàm tự động cho việc này.

2. Phi tuyến và độ sâu: mỗi tầng gấp không gian thêm một lần

Mỗi nơ-ron cộng các đầu vào nhân trọng số — một phép tuyến tính — rồi đưa kết quả qua một hàm kích hoạt (activation function). Bỏ hàm kích hoạt đi thì như nhân 2 rồi nhân 3 cũng chỉ là nhân 6: bao nhiêu tầng tuyến tính chồng lên nhau vẫn gộp được thành một tầng, và lại bất lực trước XOR. Hàm kích hoạt là chỗ bẻ cong.

Hàm kích hoạt phổ biến nhất hiện nay đơn giản đến bất ngờ: ReLU (rectified linear unit), max(0, z) — số âm thành 0, số dương giữ nguyên. Nó cho thấy vì sao sâu lại hơn rộng: một tầng chỉ hai nơ-ron ReLU gấp được đoạn [0, 1] làm đôi như gấp tờ giấy, và nối nhiều tầng là gấp đi gấp lại:

python
def relu(z):
    return max(0.0, z)                 # số âm thành 0, số dương giữ nguyên

def tang(x):
    """Một tầng chỉ có hai nơ-ron ReLU: gấp đoạn [0, 1] làm đôi (0 → 0, 0,5 → 1, 1 → 0)."""
    return 2 * relu(x) - 4 * relu(x - 0.5)

def dem_dinh(so_tang, so_diem=4096):
    """Cho x chạy từ 0 tới 1 qua `so_tang` tầng nối tiếp, đếm số đỉnh của đường kết quả."""
    ys = []
    for i in range(so_diem + 1):
        y = i / so_diem
        for _ in range(so_tang):
            y = tang(y)
        ys.append(y)
    return sum(1 for a, b, c in zip(ys, ys[1:], ys[2:]) if a < b > c)

for so_tang in (1, 2, 3, 5, 10):
    print(f"{so_tang:2d} tầng, {2 * so_tang:2d} nơ-ron: {dem_dinh(so_tang):3d} đỉnh")

Kết quả:

text
 1 tầng,  2 nơ-ron:   1 đỉnh
 2 tầng,  4 nơ-ron:   2 đỉnh
 3 tầng,  6 nơ-ron:   4 đỉnh
 5 tầng, 10 nơ-ron:  16 đỉnh
10 tầng, 20 nơ-ron: 512 đỉnh

Mỗi tầng thêm vào nhân đôi số đỉnh: 10 tầng, 20 nơ-ron vẽ ra 512 đỉnh, tức 1.024 đoạn thẳng. Mạng chỉ một tầng ẩn thì mỗi nơ-ron ReLU thêm được nhiều nhất một chỗ gãy, nên cần ít nhất 1.023 nơ-ron. Thêm chiều rộng là cộng, thêm chiều sâu là nhân. Định lý xấp xỉ phổ quát (1989) nói một tầng ẩn đủ rộng xấp xỉ được mọi hàm liên tục — nhưng "đủ rộng" có thể rộng tới mức vô dụng. Dữ liệu thật cũng lồng nhau như thế: nét thành chữ, chữ thành từ, từ thành câu.

Nhưng độ sâu có giá. Lan truyền ngược nhân đạo hàm của từng tầng với nhau, mà hàm kích hoạt thời trước là sigmoid hình chữ S, đạo hàm lớn nhất chỉ 0,25: qua nhiều tầng, tín hiệu sửa sai teo về 0 trước khi tới các tầng đầu. Đường tắt của ResNet chữa việc này: mỗi khối tính y + f(y) thay cho f(y), nên đạo hàm luôn có thêm một phần bằng 1 đi thẳng qua:

python
import math

def sigmoid(z):
    return 1 / (1 + math.exp(-z))

def dao_ham(z):                        # đạo hàm của sigmoid: lớn nhất chỉ 0,25
    return sigmoid(z) * (1 - sigmoid(z))

for so_tang in (5, 20, 50):
    y, thuong = 0.5, 1.0
    for _ in range(so_tang):           # tầng thường: y ← sigmoid(y)
        thuong *= dao_ham(y)           # quy tắc dây chuyền: nhân đạo hàm từng tầng
        y = sigmoid(y)
    y, tat = 0.5, 1.0
    for _ in range(so_tang):           # tầng có đường tắt: y ← y + sigmoid(y)
        tat *= 1 + dao_ham(y)
        y = y + sigmoid(y)
    print(f"{so_tang:2d} tầng: thường còn {thuong:.0e}, có đường tắt {tat:.2f}")

Kết quả:

text
 5 tầng: thường còn 6e-04, có đường tắt 1.77
20 tầng: thường còn 1e-13, có đường tắt 1.79
50 tầng: thường còn 4e-33, có đường tắt 1.79

Qua năm mươi tầng thường, tín hiệu chỉ còn cỡ 10⁻³³ — các tầng đầu coi như không học. Có đường tắt, nó vẫn quanh 1,8. Ba thứ cùng gỡ nút thắt này: ReLU, có đạo hàm bằng 1 ở phía dương; khởi tạo trọng số cẩn thận; và đường tắt, nay gần như mạng sâu nào cũng có, kể cả transformer. Các "cửa" của LSTM là cùng một ý cho chuỗi thời gian.

3. Tích chập: một bộ lọc nhỏ dùng chung cho cả bức ảnh

Một ảnh màu 224 × 224 điểm — cỡ ảnh AlexNet hay ResNet nhận vào — có 150.528 con số. Nối mỗi con số với mỗi nơ-ron của tầng sau như ở ý thứ nhất, riêng một tầng một nghìn nơ-ron đã cần 150 triệu trọng số; tệ hơn, mạng phải học riêng "mèo ở góc trái" và "mèo ở góc phải".

Tích chập (convolution) dựa trên hai quan sát: thứ cần tìm thường nhỏ và cục bộ — một cạnh chỉ cần vài điểm ảnh liền nhau — và có thể nằm ở bất kỳ đâu. Vậy hãy trượt một bộ lọc (filter) nhỏ qua khắp ảnh, dùng chung trọng số (weight sharing) ở mọi vị trí — như rà một cái khuôn nhỏ khắp tờ giấy, chỗ nào khớp thì sáng lên:

python
# Ảnh xám 4 × 6 điểm: nền tối (0), một vạch sáng (9) dựng đứng ở giữa
anh = [[0, 0, 9, 9, 0, 0] for _ in range(4)]
loc = [[-1, 1],
       [-1, 1]]                        # bộ lọc 2 × 2: "bên phải sáng hơn bên trái?"

def tich_chap(anh, loc):
    """Trượt bộ lọc qua mọi vị trí; ở mỗi chỗ, nhân từng cặp số rồi cộng lại."""
    k = len(loc)
    return [[sum(loc[a][b] * anh[i + a][j + b] for a in range(k) for b in range(k))
             for j in range(len(anh[0]) - k + 1)]
            for i in range(len(anh) - k + 1)]

for hang in tich_chap(anh, loc):
    print(hang)

# Đếm tham số cho một ảnh màu 224 × 224 điểm, 3 kênh màu
dau_vao = 224 * 224 * 3
print("Nối đầy đủ tới 1.000 nơ-ron:", dau_vao * 1000 + 1000, "tham số")
print("64 bộ lọc 3 × 3 × 3:        ", 64 * 3 * 3 * 3 + 64, "tham số")

Kết quả:

text
[0, 18, 0, -18, 0]
[0, 18, 0, -18, 0]
[0, 18, 0, -18, 0]
Nối đầy đủ tới 1.000 nơ-ron: 150529000 tham số
64 bộ lọc 3 × 3 × 3:         1792 tham số

Bộ lọc bốn trọng số chỉ "hiểu" một điều: bên phải sáng hơn bên trái. Nó cho 18 ở mép trái vạch sáng, −18 ở mép phải, 0 ở chỗ phẳng — cùng bốn số bắt được cạnh ở bất kỳ cột nào. Mạng thật tự học hàng chục, hàng trăm bộ lọc như vậy. Tầng tích chập đầu tiên của mạng VGG (2014) — 64 bộ lọc 3 × 3 trên ba kênh màu — chỉ có 1.792 tham số, ít hơn tầng nối đầy đủ ở trên khoảng tám mươi nghìn lần, mà cho ra 64 bản đồ đặc trưng cỡ gần bằng ảnh gốc.

Chồng nhiều tầng, xen những bước gộp (pooling) thu nhỏ ảnh, thì nơ-ron ở tầng sau "nhìn" một vùng rộng dần: nét ở tầng đầu, hoa văn ở tầng giữa, mắt hay bánh xe ở tầng sau — đúng cấu trúc Hubel và Wiesel thấy ở não mèo. Bài Thị giác máy tính đi tiếp từ đây: tìm cạnh trên ảnh thật, phát hiện và phân vùng vật thể.

4. Chú ý và transformer: mỗi từ tự tìm từ liên quan

Câu văn khác ảnh: nghĩa của một từ phụ thuộc các từ khác, có khi ở rất xa. Chữ "bàn" trong "cầu thủ ghi bàn" và trong "thợ mộc đóng bàn" là hai thứ khác hẳn. Mạng hồi quy (recurrent neural network — RNN) và LSTM đọc câu từng từ một, mang theo một "trí nhớ": chậm, vì bước sau phải chờ bước trước, và từ ở đầu câu dài dễ phai.

Cơ chế chú ý làm khác: mỗi từ là một vector; để hiểu một từ, mô hình chấm điểm độ liên quan giữa nó với mọi từ trong câu bằng tích vô hướng, đổi điểm thành trọng số có tổng bằng 1 bằng hàm softmax, rồi lấy trung bình có trọng số các vector. Thử với vector hai chiều tự đặt — chiều thứ nhất là "bóng đá", chiều thứ hai là "đồ gỗ":

python
import math

# Vector hai chiều tự đặt: (bóng đá, đồ gỗ). "bàn" đứng giữa hai nghĩa.
vec = {"cầu thủ": [3, 0], "ghi": [2, 0], "thợ mộc": [0, 3], "đóng": [0, 3], "bàn": [1, 1]}

def chu_y(cau, tu):
    q = vec[tu]
    # điểm liên quan = tích vô hướng, chia căn số chiều cho điểm khỏi quá lớn
    diem = [sum(a * b for a, b in zip(q, vec[t])) / math.sqrt(len(q)) for t in cau]
    mu = [math.exp(d) for d in diem]
    trong_so = [m / sum(mu) for m in mu]          # softmax: trọng số dương, cộng lại bằng 1
    moi = [sum(w * vec[t][i] for w, t in zip(trong_so, cau)) for i in range(len(q))]
    return trong_so, moi

for cau in (["cầu thủ", "ghi", "bàn"], ["thợ mộc", "đóng", "bàn"]):
    trong_so, moi = chu_y(cau, "bàn")
    print(" ".join(cau), "| trọng số:", [round(w, 2) for w in trong_so],
          "| 'bàn' thành", [round(x, 2) for x in moi])

Kết quả:

text
cầu thủ ghi bàn | trọng số: [0.5, 0.25, 0.25] | 'bàn' thành [2.26, 0.25]
thợ mộc đóng bàn | trọng số: [0.4, 0.4, 0.2] | 'bàn' thành [0.2, 2.6]

Cùng vector (1, 1) của chữ "bàn", sau một bước chú ý, thành (2,26; 0,25) trong câu đầu — nghiêng về bóng đá — và (0,2; 2,6) trong câu sau — nghiêng về đồ gỗ. Từ đã được đọc theo ngữ cảnh.

Transformer chồng nhiều tầng như vậy, xen với tầng nơ-ron thường và đường tắt. Khác ví dụ trên: vector có hàng nghìn chiều do mô hình tự học; mỗi từ được chiếu thành ba vector truy vấn, khóa, giá trị (query, key, value) bằng ba ma trận học được; mỗi tầng có nhiều "đầu chú ý" song song, mỗi đầu để ý một kiểu quan hệ. Và mọi từ tính chú ý cùng lúc, nên cả phép tính là vài phép nhân ma trận lớn — đúng việc GPU giỏi nhất; vì thế transformer thay LSTM. Cái giá: câu dài gấp đôi thì phần chú ý tốn gấp bốn. Cắt câu thành token thế nào, nhất là với tiếng Việt, và mô hình ngôn ngữ đoán từ tiếp theo ra sao là chuyện của bài Xử lý ngôn ngữ tự nhiên.

5. Quy mô, và cái giá của nó

Khoảng năm 2020, các nhóm nghiên cứu đo được một quy luật khá đều: mô hình to hơn, dữ liệu nhiều hơn, tính toán nhiều hơn thì mất mát giảm theo một đường đoán trước được — quy luật mở rộng (scaling laws). Cả ba đều đắt. Quy tắc ngón tay cái: huấn luyện tốn khoảng 6 phép tính cho mỗi tham số trên mỗi token. Áp vào GPT-3 (2020):

python
tham_so = 175e9                  # GPT-3 (2020): 175 tỷ tham số
token = 300e9                    # học trên khoảng 300 tỷ token
phep_tinh = 6 * tham_so * token  # quy tắc ngón tay cái: ~6 phép tính / tham số / token
print(f"{phep_tinh:.2e} phép tính")

dien_kwh = 1_287_000             # ước tính điện huấn luyện GPT-3 (Patterson và cộng sự, 2021)
print(round(dien_kwh / 200), "hộ gia đình, mỗi hộ 200 kWh một tháng")

Kết quả: 3.15e+23 phép tính — khớp con số 3,14 × 10²³ bài báo GPT-3 công bố. Ba trăm nghìn tỷ tỷ phép tính chỉ chạy nổi trên hàng nghìn GPU song song (Tính toán song song). Điện huấn luyện GPT-3 ước tính khoảng 1.287 MWh — bằng điện một tháng của 6.435 hộ gia đình, nếu mỗi hộ dùng 200 kWh. Đó mới là một lần huấn luyện; phục vụ người dùng còn tốn thêm, và mô hình mới lớn hơn nhiều. Dữ liệu cũng thế: Llama 3 của Meta (2024) học trên hơn 15 nghìn tỷ token, gấp năm mươi lần GPT-3.

Quy mô không chữa được mọi thứ. Mô hình ngôn ngữ đoán từ tiếp theo nghe hợp lý chứ không tra cứu sự thật, nên có thể kể rất trôi chảy về một sự kiện không hề có — gọi là ảo giác (hallucination). Mô hình học luôn thiên kiến trong dữ liệu (bài Học máy đã nói kỹ). Và năm 2013, Christian Szegedy cùng cộng sự chỉ ra: cộng vào ảnh một lớp nhiễu nhỏ tới mức mắt người không thấy là đủ làm một mạng tốt đổi hẳn câu trả lời. Hàng tỷ trọng số không cho ta dòng code nào để chỉ vào và nói: sai ở đây.

Học sâu 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 sâu nằm ở tầng ứng dụng, nhưng là một trong số ít môn kéo cả chồng tầng đổi theo:

  • Toán: mỗi tầng là một phép nhân ma trận (Đại số tuyến tính); huấn luyện là lan truyền ngược (Toán cho học máy) cộng hạ gradient (Tối ưu hóa).
  • Phần cứng: GPU và chip AI được thiết kế quanh phép nhân ma trận (Kiến trúc máy tính), tính bằng số 16 bit, 8 bit cho nhanh (Tính toán khoa học).
  • Hệ thống: một lần huấn luyện chia ra hàng nghìn GPU, nhiều máy (Tính toán song song, Hệ phân tán).
  • Ứng dụng: Thị giác máy tính, Xử lý ngôn ngữ tự nhiên, Học tăng cường đều đã được học sâu viết lại.

Đưa lên

Một hàm học từ dữ liệu thô — đưa vào ảnh, tiếng nói, câu văn; nhận về nhãn, bản dịch, câu trả lời, hay một vector "ý nghĩa" để tầng trên dùng tiếp.

Giấu đi

Hàng triệu tới hàng tỷ trọng số, những đặc trưng tự học không ai đặt tên, và nhiều tuần huấn luyện trên hàng nghìn GPU.

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

· 6 môn

Học máy

Machine Learning

Hàm mất mát, hạ gradient, quá khớp, chia tập huấn luyện và kiểm tra — học sâu dùng lại tất cả. Nên học trước.

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

Toán cho học máy

Mathematics for Machine Learning

Nhân ma trận, quy tắc dây chuyền, entropy chéo — đủ để đọc trơn công thức trong giáo trình học sâu. Học trước hoặc song song.

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

Tính toán song song

Parallel Computing

GPU, song song dữ liệu và song song mô hình — cách một lần huấn luyện khổng lồ chạy được trong vài tuần.

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

Thị giác máy tính

Computer Vision

Mạng tích chập và transformer cho ảnh: phân loại, phát hiện, phân vùng vật thể. Học sau.

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

Xử lý ngôn ngữ tự nhiên

Natural Language Processing

Transformer cho văn bản: token, mô hình ngôn ngữ, dịch máy, và những khó khăn riêng của tiếng Việt. Học sau.

Xem chủ đề trên OpenER: Natural Language Processing

Học tăng cường

Reinforcement Learning

Mạng sâu làm "mắt" và "trực giác" cho tác tử tự học bằng thưởng phạt: chơi cờ, chơi game, điều khiển robot. Học sau.

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

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

  • Trên điện thoại: dịch tấm ảnh chụp thực đơn, mở khóa bằng khuôn mặt.
  • Ngôn ngữ: dịch máy, trợ lý trò chuyện, tóm tắt văn bản, gợi ý code.
  • Khoa học và y tế: dự đoán cấu trúc protein — câu chuyện giải Nobel Hóa học 2024 trong bài Sinh học — và hỗ trợ đọc ảnh y khoa.
  • Công nghiệp: kiểm lỗi sản phẩm trên dây chuyền, xe tự hành, robot trong kho.
  • Tạo nội dung: ảnh, giọng đọc, nhạc — kèm những câu hỏi mới về bản quyền và giả mạo.

Các nghề liên quan: kỹ sư học sâu / học máy huấn luyện và tinh chỉnh (fine-tune) mô hình trên dữ liệu riêng; kỹ sư hạ tầng AI lo GPU, chia việc huấn luyện, phục vụ mô hình nhanh và rẻ; nhà nghiên cứu; và ngày càng nhiều kỹ sư phần mềm ghép mô hình có sẵn vào sản phẩm.

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

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

  • tự cài một mạng nhiều tầng và lan truyền ngược bằng Python thuần, rồi chuyển sang PyTorch;
  • giải thích vì sao cần phi tuyến, vì sao mạng sâu từng khó huấn luyện, và ReLU, đường tắt, khởi tạo tốt gỡ nút thắt ấy ra sao;
  • huấn luyện mạng tích chập cho ảnh, transformer cho chuỗi; tinh chỉnh một mô hình huấn luyện sẵn trên dữ liệu của mình;
  • ước lượng cái giá của một mô hình — dữ liệu, phép tính, tiền điện — và nghi ngờ đúng chỗ: ảo giác, thiên kiến, mô hình bị đánh lừa.

Nên biết trước: Học máy, nhân ma trận, đạo hàm và quy tắc dây chuyền, Python vững.

Bắt đầu trên OpenER: trang chủ đề Deep Learning và hướng dẫn học chia chủ đề thành sáu bước, khoảng 47 giờ: từ perceptron tới mạng nhiều tầng, huấn luyện hiệu quả, mạng tích chập, RNN và transformer, dùng lại mô hình huấn luyện sẵn, và một dự án cuối. Sách chính là Dive into Deep Learning, đọc miễn phí, mỗi khái niệm kèm code PyTorch. Khóa chính là CMU 11-785 Introduction to Deep Learning: có video công khai, bài tập bắt bạn tự viết một thư viện mạng nơ-ron nhỏ. Thích làm trước, hiểu sau thì có Practical Deep Learning for Coders của fast.ai; muốn bài lập trình chấm tự động thì có Deep Learning Specialization của Andrew Ng trên Coursera; khóa video của IIT Ropar trên NPTEL giảng chậm, dễ theo. Bước đầu còn gợi ý khóa tiếng Việt Học máy để ôn lại.

Lời khuyên cho môn này: viết tay một lần, rồi mới dùng thư viện. Tự gõ lại mạng XOR ở trên, đổi seed, in tầng ẩn sau mỗi nghìn vòng. Thấy tận mắt một tầng ẩn tự nghĩ ra "cả hai cùng bật" rồi, bạn sẽ đọc một mạng trăm tầng trong PyTorch như đọc thứ mình hiểu, không phải một hộp đen.

Tài liệu tham khảo

  • Aston Zhang, Zachary C. Lipton, Mu Li, Alexander J. Smola — Dive into Deep Learning, Cambridge University Press, 2023; đọc miễn phí tại d2l.ai.
  • Ian Goodfellow, Yoshua Bengio, Aaron Courville — Deep Learning, MIT Press, 2016; đọc miễn phí tại deeplearningbook.org.
  • Simon J. D. Prince — Understanding Deep Learning, MIT Press, 2023; bản PDF miễn phí trên trang của sách.
  • Carnegie Mellon University 11-785 Introduction to Deep Learning (Bhiksha Raj, Rita Singh), Fall 2024 — trang khóa học, video bài giảng và bài tập.
  • Yann LeCun, Yoshua Bengio, Geoffrey Hinton — "Deep learning", Nature 521, 2015.
  • Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun — "Deep Residual Learning for Image Recognition", CVPR 2016.
  • Ashish Vaswani và cộng sự — "Attention Is All You Need", NeurIPS 2017.

Ban biên tập OpenER, “Học sâu: mỗi tầng học một cách nhìn mới”, 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.