Lò Luyện Mạng Nơ-ron Từ Số 0

Cần biết trước: cộng, nhân, và khái niệm "hàm số" cấp 3 Dựng nên: 4 chiếc hộp của bản đồ chủ đạo Dẫn tới: Module 01 — nơ-ron

1. Hai kiểu lập trình

Giả sử sếp giao: "viết chương trình nhận ảnh và trả lời đây là chó hay mèo".

Cách truyền thống — bạn tự nghĩ ra luật: nếu tai nhọn và mõm ngắn thì mèo, nếu... Bạn viết luật, máy chạy luật. Vấn đề: bạn không bao giờ viết đủ luật. Con mèo Sphynx không lông. Con chó Chihuahua tai nhọn. Sau 3000 dòng if, độ chính xác vẫn 60%.

Cách học từ dữ liệu — bạn không viết luật. Bạn viết một công thức có lỗ trống, rồi để máy tự điền các lỗ trống ấy sao cho khớp với 10.000 ví dụ có sẵn. Những lỗ trống đó gọi là tham số (parameters, thường ký hiệu $W$, $b$, hoặc gộp lại là $\theta$).

2. Chạy tay một ví dụ trọn vẹn (không ma trận, không thư viện)

Đây là phần quan trọng nhất của module. Ta sẽ làm một mô hình có đúng một tham số để mọi con số đều nhìn thấy được.

Bài toán: dự đoán điểm thi từ số giờ ôn bài. Ta có 3 quan sát:

Bạn nhìn phát ra ngay $w = 2$. Nhưng máy thì không — và cách máy mò ra con số 2 chính là toàn bộ Deep Learning. Ta khởi tạo bừa $w = 0.5$.

Bước ③ — đo sai lệch. Ta cần gom mọi sai lệch về một con số duy nhất để biết "hiện tại tệ cỡ nào". Dùng sai số bình phương trung bình (MSE):

Vì sao bình phương? Hai lý do rất thực dụng: (a) sai lệch âm và dương không triệt tiêu nhau; (b) hàm bình phương trơn nên lấy đạo hàm được — điều kiện sống còn ở bước ④.

Với $w = 0.5$: $L = \frac{1}{3}\big[(0.5-2)^2 + (1-4)^2 + (1.5-6)^2\big] = \frac{1}{3}[2.25 + 9 + 20.25] = 10.5$.

Bước ④ — hỏi đạo hàm nên đi hướng nào. Đạo hàm của $L$ theo $w$:

Với $w = 0.5$: $\frac{dL}{dw} = \frac{2}{3}\big[(-1.5)(1) + (-3)(2) + (-4.5)(3)\big] = \frac{2}{3}(-21) = -14$.

Chọn $\eta = 0.1$: $w \leftarrow 0.5 - 0.1 \times (-14) = 1.9$. Chỉ một bước, $w$ đã nhảy từ $0.5$ lên $1.9$ (đáp án đúng là $2.0$). Tính lại: $L(1.9) = 0.0467$. Từ $10.5$ xuống $0.047$ — mô hình vừa học xong.

3. Vòng lặp 5 bước — bộ xương của mọi mô hình

Cái bạn vừa làm bằng tay chính là vòng lặp mà PyTorch chạy hàng triệu lần mỗi giờ. Học thuộc nó, vì từ đây tới hết giáo trình ta chỉ thay ruột chứ không đổi xương:

for buoc in range(so_buoc):
    # 1. LẤY DỮ LIỆU  — một lô (batch) mẫu
    x, y = lay_mot_lo(du_lieu)

    # 2. TRUYỀN XUÔI  — mô hình đoán
    y_du_doan = mo_hinh(x)

    # 3. ĐO SAI SỐ    — gom về đúng MỘT con số
    L = ham_mat_mat(y_du_doan, y)

    # 4. TRUYỀN NGƯỢC — hỏi mọi tham số: "mày ảnh hưởng L thế nào?"
    xoa_gradient_cu()          # optimizer.zero_grad()
    L.backward()               # tính dL/d(tham số) cho TẤT CẢ tham số

    # 5. CẬP NHẬT     — nhích mọi tham số ngược hướng gradient
    for p in tham_so:
        p -= lr * p.grad       # optimizer.step()

Toàn bộ 12 module còn lại chỉ làm ba việc với bộ xương này: (a) làm bước 2 phức tạp hơn (nơ-ron → MLP → Transformer); (b) làm bước 4 tự động và đúng (autograd, Module 03); (c) làm bước 5 thông minh hơn (momentum, Adam, Module 02).

xs = [1.0, 2.0, 3.0]
ys = [2.0, 4.0, 6.0]
w  = 0.5          # tham số, khởi tạo bừa
lr = 0.1          # siêu tham số, do NGƯỜI chọn

for buoc in range(20):
    # 2. truyền xuôi + 3. đo sai số
    preds = [w * x for x in xs]
    L = sum((p - y) ** 2 for p, y in zip(preds, ys)) / len(xs)

    # 4. truyền ngược (ở đây đạo hàm tính tay được)
    grad = sum(2 * (w * x - y) * x for x, y in zip(xs, ys)) / len(xs)

    # 5. cập nhật
    w = w - lr * grad
    print(f"buoc {buoc:2d} | w = {w:6.3f} | L = {L:9.4f} | grad = {grad:8.3f}")

# buoc  0 | w =  1.900 | L =   10.5000 | grad =  -14.000
# buoc  1 | w =  1.993 | L =    0.0467 | grad =   -0.933
# ...
# buoc 19 | w =  2.000 | L =    0.0000 | grad =   -0.000

4. Bộ từ vựng nền — đọc một lần, dùng cả đời

Cần biết trước: Module 00 (vòng lặp 5 bước) Dựng nên: hộp ② — mô hình Dẫn tới: vì sao phải xếp chồng nhiều tầng

1. Nơ-ron toán học: chỉ có hai phép toán

Nơ-ron sinh học nhận tín hiệu từ nhiều nhánh, cộng dồn lại, và bắn nếu tổng vượt ngưỡng. Bản sao toán học của nó rút gọn ý tưởng ấy thành hai dòng:

(1) Tổ hợp tuyến tính — cộng dồn có trọng số:

(2) Hàm kích hoạt — bóp méo phi tuyến:

Trọng số $w$ nghĩa là gì

Độ quan trọng có dấu. $w_1 = 1.2$ nghĩa là "$x_1$ tăng thì tôi phấn khích"; $w_2 = -0.7$ nghĩa là "$x_2$ tăng thì tôi dè chừng"; $w = 0$ nghĩa là "tôi không quan tâm đầu vào này". Trong bộ lọc thư rác, $w$ của từ "trúng thưởng" sẽ lớn và dương.

Bias $b$ nghĩa là gì

Ngưỡng bắn, hay định kiến sẵn có. Nếu $b$ rất âm, nơ-ron cần tổng tín hiệu rất mạnh mới kích hoạt (khó tính). Nếu $b$ dương, nó bắn ngay cả khi đầu vào bằng 0 (dễ tính). Về hình học, $b$ chính là thứ cho phép đường phân chia không đi qua gốc toạ độ — thiếu $b$, mọi đường phân chia bắt buộc phải xuyên qua điểm $(0,0)$, một hạn chế nghiêm trọng.

Hình học: một nơ-ron vẽ một đường thẳng

Tập điểm thoả $w_1x_1 + w_2x_2 + b = 0$ là một đường thẳng (với 2 đầu vào), một mặt phẳng (3 đầu vào), một siêu phẳng (n đầu vào). Nó chia không gian làm đôi: một bên $z > 0$, bên kia $z < 0$.

• Véc-tơ $\mathbf{w} = (w_1, w_2)$ vuông góc với đường đó và chỉ về phía $z$ dương. Đổi dấu $w$ = lật ngược quyết định.
• Độ lớn $\|\mathbf{w}\|$ quyết định độ dốc chuyển tiếp: $w$ lớn → ranh giới sắc lẹm như dao; $w$ bé → chuyển tiếp mờ nhoè.
• $b$ tịnh tiến đường thẳng song song với chính nó. Khoảng cách từ gốc toạ độ tới đường là $|b|/\|\mathbf{w}\|$.

2. Hàm kích hoạt: vì sao không được bỏ

Đây là câu hỏi phỏng vấn kinh điển, và câu trả lời chỉ mất ba dòng đại số. Giả sử ta xếp 2 tầng không có kích hoạt:

Kết quả vẫn đúng dạng $W'x + b'$ — một tầng tuyến tính. Xếp 100 tầng cũng thế: tích của 100 ma trận vẫn chỉ là một ma trận. Toàn bộ sức mạnh "chiều sâu" bốc hơi. Hàm phi tuyến $f$ chen vào giữa chính là thứ ngăn phép sụp đổ đó, và cho phép mạng bẻ cong không gian.

3. Vì sao XOR đánh gục một nơ-ron

XOR là bài toán: đầu ra bằng 1 khi đúng một trong hai đầu vào bằng 1.

Giả sử tồn tại $w_1, w_2, b$ giải được. Điều kiện phân loại đúng đòi hỏi đồng thời:

• $b < 0$  (từ điểm $(0,0)\to 0$)
• $w_2 + b > 0$  (từ $(0,1)\to 1$) $\Rightarrow w_2 > -b > 0$
• $w_1 + b > 0$  (từ $(1,0)\to 1$) $\Rightarrow w_1 > -b > 0$
• $w_1 + w_2 + b < 0$  (từ $(1,1)\to 0$)

Cộng hai bất đẳng thức giữa: $w_1 + w_2 > -2b$, tức $w_1 + w_2 + b > -b > 0$ — mâu thuẫn trực tiếp với điều kiện cuối. Không có nghiệm. Đây chính là chứng minh của Minsky & Papert năm 1969, thứ đã khiến ngành mạng nơ-ron đóng băng gần hai thập kỷ ("mùa đông AI" lần thứ nhất).

Lối thoát: hai nơ-ron ẩn, mỗi cái vẽ một đường thẳng, rồi nơ-ron ra kết hợp hai kết quả đó. Ví dụ $h_1$ học "ít nhất một cái bật" (OR), $h_2$ học "cả hai cùng bật" (AND), tầng ra tính $h_1 - h_2$ = XOR. Ranh giới cuối cùng không còn là đường thẳng trong không gian gốc nữa.

import math, random

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

# Dữ liệu: cổng AND (tách được bằng đường thẳng, khác XOR)
data = [((0,0),0), ((0,1),0), ((1,0),0), ((1,1),1)]

w1, w2, b = random.uniform(-1,1), random.uniform(-1,1), 0.0
lr = 0.5

for buoc in range(3000):
    dw1 = dw2 = db = 0.0
    L = 0.0
    for (x1, x2), y in data:
        z = w1*x1 + w2*x2 + b
        a = sigmoid(z)
        L += -(y*math.log(a + 1e-9) + (1-y)*math.log(1-a + 1e-9))
        # Phép màu của cặp sigmoid + cross-entropy: dL/dz rút gọn thành (a - y)
        dz = (a - y)
        dw1 += dz * x1;  dw2 += dz * x2;  db += dz
    n = len(data)
    w1 -= lr * dw1/n;  w2 -= lr * dw2/n;  b -= lr * db/n
    if buoc % 1000 == 0:
        print(f"buoc {buoc:4d} | L={L/n:.4f} | w=({w1:.2f},{w2:.2f}) b={b:.2f}")

for (x1,x2), y in data:
    print(f"({x1},{x2}) -> {sigmoid(w1*x1+w2*x2+b):.3f}  (thật: {y})")
# Đổi data thành XOR: [((0,0),0),((0,1),1),((1,0),1),((1,1),0)]
# và bạn sẽ thấy L đứng yên ở ~0.693 = log(2) — mô hình bó tay.

Cần biết trước: Module 00–01 Dựng nên: hộp ③ và ④ Dẫn tới: autograd — cách tính gradient tự động cho triệu tham số

1. Chọn hàm mất mát

Hàm mất mát là lời định nghĩa của bạn về chữ "sai". Đổi loss là đổi mục tiêu, và mô hình sẽ tối ưu đúng cái bạn viết ra — kể cả khi đó không phải cái bạn muốn.

Cross-entropy: chỉ là "độ ngạc nhiên" trung bình

Với phân loại, mô hình xuất ra một véc-tơ điểm số thô gọi là logits, softmax biến chúng thành xác suất, rồi loss chỉ lấy xác suất mà mô hình gán cho đáp án đúng và log âm nó:

với $\hat{p}_c$ là xác suất mô hình gán cho lớp đúng.

Đọc bảng này là hiểu ngay vì sao nó hoạt động:

2. Bề mặt mất mát: bức tranh trung tâm của cả ngành

Đây là hình dung quan trọng nhất bạn cần mang theo suốt sự nghiệp:

• Mỗi bộ tham số có thể có = một điểm trong không gian. Mô hình 2 tham số → mặt phẳng; mô hình 7 tỉ tham số → không gian 7 tỉ chiều.
• Độ cao tại điểm đó = giá trị loss khi dùng bộ tham số ấy.
• Tập hợp mọi độ cao tạo thành một địa hình — núi, thung lũng, đèo, cao nguyên.
• Huấn luyện = thả một người mù xuống địa hình đó. Người ấy không nhìn thấy bản đồ; ở mỗi bước anh ta chỉ sờ được độ dốc ngay dưới chân (gradient) rồi bước một bước dài $\eta$ theo hướng dốc xuống.

Toàn bộ nghệ thuật huấn luyện nằm ở chỗ: bước dài bao nhiêu, có nên giữ đà không, có nên đi mỗi hướng một tốc độ khác nhau không. Hãy xoay quả địa hình dưới đây bằng chuột.

3. Ba biến thể của gradient descent — theo lượng dữ liệu mỗi bước

4. Momentum và Adam giải quyết cái gì

Đừng học thuộc công thức trước — hãy nhớ bệnh mà mỗi thuật toán chữa.

Momentum — chữa bệnh zíc-zắc

Bệnh: trong thung lũng hẹp, gradient đổi dấu liên tục theo hướng ngang nhưng luôn cùng dấu theo hướng dọc. SGD phí gần hết công sức để nảy qua nảy lại.

Thuốc: giữ một véc-tơ vận tốc — trung bình trượt của các gradient gần đây. Thành phần ngang đổi dấu nên tự triệt tiêu; thành phần dọc cùng dấu nên cộng dồn thành đà.

Trực giác: thay vì một người bước từng bước, hãy tưởng tượng một quả bóng nặng lăn xuống dốc. Nó có quán tính, nên không đổi hướng xoành xoạch và lăn thẳng qua các hố nông.

Adam — chữa bệnh "mỗi hướng cần một bước chân khác nhau"

Bệnh: tham số A nhận gradient cỡ $10^{-5}$, tham số B nhận gradient cỡ $10^{2}$. Một $\eta$ duy nhất thì hoặc A đứng im, hoặc B nổ tung.

Thuốc: theo dõi thêm trung bình bình phương gradient của từng tham số, rồi chia bước đi cho căn của nó — tham số nào hay bị gradient lớn thì bước ngắn lại, ai bị gradient bé thì được bước dài ra.

Adam = Momentum ($m$) + tỉ lệ bước riêng cho từng tham số ($v$) + hiệu chỉnh sai lệch lúc khởi động ($\hat{\cdot}$). Mặc định huyền thoại: $\beta_1{=}0.9$, $\beta_2{=}0.999$, $\epsilon{=}10^{-8}$, và $\eta = 3\times10^{-4}$ — con số mà Karpathy gọi đùa là "learning rate tốt nhất cho Adam, bất kể bài toán gì".

learning_rate = 6e-4      # đỉnh của lịch trình
min_lr        = 6e-5      # đáy sau khi cosine decay
warmup_iters  = 2000      # 2000 bước đầu tăng dần từ 0 — tránh nổ lúc khởi động
beta1, beta2  = 0.9, 0.95 # beta2 hạ từ 0.999 xuống 0.95 cho ổn định ở batch lớn
grad_clip     = 1.0       # chặn gradient nổ
batch_size    = 12 * 40   # gradient accumulation để giả lập batch to

Cần biết trước: Module 00–02, đạo hàm cơ bản Dựng nên: hộp ④ chạy tự động Dẫn tới: mọi module còn lại — từ đây ta không tính đạo hàm tay nữa

1. Vì sao phải có autograd

Ở Module 00, ta đạo hàm tay được vì mô hình chỉ có một tham số. Bây giờ thử tưởng tượng một MLP nhỏ: 3 tầng, mỗi tầng 100 nơ-ron. Đó là ~20.000 tham số, và biểu thức của loss là một hàm hợp lồng nhau hàng nghìn tầng. Đạo hàm tay: bất khả thi. Đạo hàm bằng cách xấp xỉ số $\frac{L(w+h)-L(w)}{h}$: phải chạy forward 20.000 lần cho một bước cập nhật — chậm gấp hàng chục nghìn lần và sai số tích luỹ.

Autograd (backpropagation) làm việc đó với chi phí chỉ khoảng 2 lần forward, cho toàn bộ tham số cùng lúc. Đây là phát kiến kỹ thuật khiến deep learning khả thi về mặt kinh tế.

2. Chain rule, kể bằng bánh răng

Ba bánh răng ăn khớp: A quay 1 vòng làm B quay 3 vòng, B quay 1 vòng làm C quay 2 vòng. Hỏi A quay 1 vòng thì C quay mấy vòng? Ai cũng trả lời được: $3 \times 2 = 6$. Đó chính là chain rule:

Đạo hàm là "tỉ số truyền động" giữa hai đại lượng. Muốn biết tỉ số truyền từ đầu này sang đầu kia của một dây chuyền dài, chỉ việc nhân dồn các tỉ số dọc đường. Mạng nơ-ron là một dây chuyền như thế, chỉ dài hơn và có nhiều nhánh.

Với các nhánh rẽ, thêm đúng một quy tắc: nếu một giá trị được dùng ở nhiều nơi, gradient từ mọi nơi phải cộng lại. (Bánh răng A truyền lực đồng thời cho hai dây chuyền thì tổng ảnh hưởng là tổng của cả hai.)

3. Ba cổng, ba tính cách

Ở cấp thấp nhất, mạng chỉ gồm vài loại cổng. Mỗi cổng có một hành vi truyền ngược rất dễ nhớ:

4. Lớp Value: một engine autograd hoàn chỉnh

Chỉ cần ba ý tưởng: (a) mỗi Value nhớ nó sinh ra từ đâu; (b) mỗi phép toán tự đăng ký một closure _backward biết cách chia gradient cho cha nó; (c) hàm backward() sắp xếp tô-pô rồi gọi các closure theo thứ tự ngược.

import math

class Value:
    """Một số thực trong đồ thị tính toán, có kèm đạo hàm."""

    def __init__(self, data, _children=(), _op='', label=''):
        self.data = data
        self.grad = 0.0                # dL/d(self) — khởi đầu bằng 0
        self._backward = lambda: None  # cách chia gradient cho các cha
        self._prev = set(_children)    # các nút đã tạo ra nút này
        self._op = _op                 # tên phép toán (để vẽ đồ thị)
        self.label = label

    def __repr__(self):
        return f"Value(data={self.data:.4f}, grad={self.grad:.4f})"

    # ---------- các phép toán cơ bản ----------
    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), '+')
        def _backward():
            self.grad  += 1.0 * out.grad      # cổng cộng: chia đều
            other.grad += 1.0 * out.grad
        out._backward = _backward
        return out

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data * other.data, (self, other), '*')
        def _backward():
            self.grad  += other.data * out.grad   # cổng nhân: đổi chéo
            other.grad += self.data  * out.grad
        out._backward = _backward
        return out

    def __pow__(self, k):                  # chỉ hỗ trợ số mũ hằng
        assert isinstance(k, (int, float))
        out = Value(self.data ** k, (self,), f'**{k}')
        def _backward():
            self.grad += k * (self.data ** (k - 1)) * out.grad
        out._backward = _backward
        return out

    def exp(self):
        out = Value(math.exp(self.data), (self,), 'exp')
        def _backward():
            self.grad += out.data * out.grad   # d(e^x)/dx = e^x = chính out
        out._backward = _backward
        return out

    def tanh(self):
        t = math.tanh(self.data)
        out = Value(t, (self,), 'tanh')
        def _backward():
            self.grad += (1.0 - t ** 2) * out.grad
        out._backward = _backward
        return out

    def relu(self):
        out = Value(max(0.0, self.data), (self,), 'relu')
        def _backward():
            self.grad += (1.0 if out.data > 0 else 0.0) * out.grad
        out._backward = _backward
        return out

    def log(self):
        out = Value(math.log(self.data), (self,), 'log')
        def _backward():
            self.grad += (1.0 / self.data) * out.grad
        out._backward = _backward
        return out

    # ---------- đường tắt cho tiện ----------
    def __neg__(self):        return self * -1
    def __sub__(self, o):     return self + (-o)
    def __radd__(self, o):    return self + o
    def __rmul__(self, o):    return self * o
    def __truediv__(self, o): return self * (o ** -1 if isinstance(o, Value) else 1.0 / o)

    # ---------- trái tim của engine ----------
    def backward(self):
        topo, visited = [], set()
        def build(v):
            if v not in visited:
                visited.add(v)
                for child in v._prev:
                    build(child)
                topo.append(v)          # cha luôn được thêm SAU con
        build(self)

        self.grad = 1.0                 # dL/dL = 1, mồi cho cả dây chuyền
        for node in reversed(topo):     # duyệt ngược: cha trước, con sau
            node._backward()


# ===== chạy thử =====
a = Value(2.0, label='a'); b = Value(-3.0, label='b'); c = Value(-4.0, label='c')
L = (a + b) * c
L.backward()
print(L.data, a.grad, b.grad, c.grad)   # 4.0  -4.0  -4.0  -1.0

# kiểm chứng bằng đạo hàm số
h = 1e-6
L2 = ((2.0 + h) + (-3.0)) * (-4.0)
print("xấp xỉ số dL/da =", (L2 - 4.0) / h)   # ≈ -4.0  ✓

5. Dùng engine đó dựng một mạng thật

Điểm mấu chốt: một khi có Value, bạn không bao giờ phải nghĩ về đạo hàm nữa. Cứ viết forward bằng Python bình thường, engine tự lo phần còn lại.

import random

class Neuron:
    def __init__(self, nin):
        self.w = [Value(random.uniform(-1, 1)) for _ in range(nin)]
        self.b = Value(0.0)
    def __call__(self, x):
        act = sum((wi * xi for wi, xi in zip(self.w, x)), self.b)
        return act.tanh()
    def parameters(self):
        return self.w + [self.b]

class Layer:
    def __init__(self, nin, nout):
        self.neurons = [Neuron(nin) for _ in range(nout)]
    def __call__(self, x):
        outs = [n(x) for n in self.neurons]
        return outs[0] if len(outs) == 1 else outs
    def parameters(self):
        return [p for n in self.neurons for p in n.parameters()]

class MLP:
    def __init__(self, nin, nouts):
        sizes = [nin] + nouts
        self.layers = [Layer(sizes[i], sizes[i+1]) for i in range(len(nouts))]
    def __call__(self, x):
        for layer in self.layers:
            x = layer(x)
        return x
    def parameters(self):
        return [p for l in self.layers for p in l.parameters()]


# ===== huấn luyện: đúng vòng lặp 5 bước của Module 00 =====
xs = [[2.0, 3.0, -1.0], [3.0, -1.0, 0.5], [0.5, 1.0, 1.0], [1.0, 1.0, -1.0]]
ys = [1.0, -1.0, -1.0, 1.0]
model = MLP(3, [4, 4, 1])           # 3 đầu vào → 4 → 4 → 1;  41 tham số
print("số tham số:", len(model.parameters()))

for buoc in range(100):
    ypred = [model(x) for x in xs]                              # 2. forward
    loss  = sum((yp - yt) ** 2 for yp, yt in zip(ypred, ys))    # 3. loss

    for p in model.parameters():                                # 4a. XOÁ grad cũ
        p.grad = 0.0
    loss.backward()                                             # 4b. backward

    for p in model.parameters():                                # 5. cập nhật
        p.data -= 0.05 * p.grad

    if buoc % 20 == 0:
        print(f"buoc {buoc:3d}  loss = {loss.data:.6f}")

print([f"{yp.data:+.3f}" for yp in [model(x) for x in xs]])
# ['+0.997', '-0.998', '-0.996', '+0.997']  ← khớp gần hoàn hảo với ys

Bốn mươi mốt tham số, một trăm bước, và mạng khớp dữ liệu. So sánh với PyTorch: p.data -= 0.05*p.grad chính là optimizer.step(), p.grad = 0.0 chính là optimizer.zero_grad(), và loss.backward() thì tên còn giống hệt. PyTorch chỉ khác ở chỗ mỗi Value được thay bằng một tensor chứa hàng triệu số và chạy trên GPU — kiến trúc thì y hệt cái bạn vừa viết.

Cần biết trước: Module 02 (cross-entropy), Module 03 (autograd) Dựng nên: mô hình ngôn ngữ đầu tiên Dẫn tới: vì sao phải có embedding và ngữ cảnh dài hơn

1. Mô hình ngôn ngữ, phát biểu cho gọn

Một mô hình ngôn ngữ chỉ làm đúng một việc: cho chuỗi ký tự (hoặc từ) đã có, gán xác suất cho ký tự tiếp theo. ChatGPT làm việc đó với 100.000 token và ngữ cảnh 100.000 vị trí; ta bắt đầu với 27 ký tự và ngữ cảnh dài đúng 1.

Dữ liệu: danh sách tên tiếng Việt không dấu — an, binh, chi, dung, giang, .... Ta thêm ký tự đặc biệt . làm dấu bắt đầu và kết thúc. Vậy tên an sinh ra các cặp huấn luyện:

.a   →  ta thấy '.', mục tiêu đoán 'a'
an   →  ta thấy 'a', mục tiêu đoán 'n'
n.   →  ta thấy 'n', mục tiêu đoán '.' (kết thúc)

2. Cách 1 — chỉ cần đếm

Lập bảng $N$ kích thước $27\times27$: ô $N[i][j]$ đếm số lần ký tự $j$ đi ngay sau ký tự $i$. Xong. Xác suất chỉ là chuẩn hoá theo hàng:

$\alpha$ là làm mượt (smoothing): cộng thêm một lượng nhỏ vào mọi ô để không ô nào có xác suất đúng bằng 0. Vì sao quan trọng đến thế? Vì nếu $P = 0$ mà cặp đó lại xuất hiện trong dữ liệu kiểm tra, loss $= -\log 0 = \infty$. Một cặp chưa từng thấy làm hỏng toàn bộ phép đo.

3. Cách 2 — đúng mô hình đó, nhưng bằng mạng nơ-ron

Ta cố tình làm phức tạp lên. Vì sao? Sẽ trả lời ở cuối mục. Trước hết, quy trình:

1. One-hot encoding. Ký tự thứ $i$ được biểu diễn bằng véc-tơ 27 chiều toàn 0, riêng vị trí $i$ bằng 1. Đây là cách nhét một thứ rời rạc (chữ cái) vào một phép toán liên tục (nhân ma trận).
2. Một tầng tuyến tính duy nhất. Nhân véc-tơ one-hot với ma trận trọng số $W$ kích thước $27\times27$, ra 27 logits.
3. Softmax. Biến logits thành 27 xác suất có tổng bằng 1.
4. Cross-entropy + gradient descent. Đúng vòng lặp 5 bước.

import torch
import torch.nn.functional as F

words = open('ten.txt').read().splitlines()      # mỗi dòng một cái tên
chars = sorted(set(''.join(words)))
stoi  = {c: i + 1 for i, c in enumerate(chars)};  stoi['.'] = 0
itos  = {i: c for c, i in stoi.items()}
V     = len(stoi)

# ---- dựng tập huấn luyện: mọi cặp (ký tự hiện tại, ký tự kế tiếp) ----
xs, ys = [], []
for w in words:
    for c1, c2 in zip('.' + w, w + '.'):
        xs.append(stoi[c1]);  ys.append(stoi[c2])
xs, ys = torch.tensor(xs), torch.tensor(ys)
n = xs.nelement()
print(f"{n} cặp huấn luyện")

# ---- mô hình: đúng MỘT ma trận trọng số ----
g = torch.Generator().manual_seed(2147483647)
W = torch.randn((V, V), generator=g, requires_grad=True)

for k in range(200):
    # 2. FORWARD
    xenc   = F.one_hot(xs, num_classes=V).float()   # (n, V)
    logits = xenc @ W                               # (n, V) — log của số đếm
    # softmax viết tay cho rõ ràng:
    counts = logits.exp()
    probs  = counts / counts.sum(dim=1, keepdim=True)

    # 3. LOSS = trung bình -log(xác suất của ký tự đúng) + regularization
    loss = -probs[torch.arange(n), ys].log().mean() + 0.01 * (W ** 2).mean()

    # 4. BACKWARD
    W.grad = None          # tương đương optimizer.zero_grad()
    loss.backward()

    # 5. CẬP NHẬT
    W.data += -50 * W.grad # lr = 50: hợp lệ vì mô hình cực nông và gradient bé

    if k % 40 == 0:
        print(f"buoc {k:3d}  loss = {loss.item():.4f}")
# buoc   0  loss = 3.7686
# buoc 199  loss = 2.4820      ← khớp NLL của bảng đếm

# ---- sinh tên mới ----
g = torch.Generator().manual_seed(2147483647)
for _ in range(5):
    out, ix = [], 0
    while True:
        logits = (F.one_hot(torch.tensor([ix]), num_classes=V).float() @ W)
        p  = F.softmax(logits, dim=1)
        ix = torch.multinomial(p, num_samples=1, generator=g).item()
        if ix == 0: break
        out.append(itos[ix])
    print(''.join(out))

4. Vậy rốt cuộc vì sao phải dùng mạng nơ-ron?

Với ngữ cảnh 1 ký tự, đếm còn nhanh hơn và cho kết quả y hệt. Câu trả lời nằm ở chuyện mở rộng:

Bảng đếm phình theo hàm mũ của độ dài ngữ cảnh, và tệ hơn: nó không biết khái quát hoá. Nếu đã thấy "nguyễn văn" 1000 lần nhưng chưa thấy "nguyễn vân" lần nào, bảng đếm gán xác suất 0 cho trường hợp thứ hai — dù hai chuỗi gần như đồng nhất.

Mạng nơ-ron thoát cả hai vấn đề: số tham số tăng tuyến tính (thậm chí hằng số) theo ngữ cảnh, và vì các đầu vào tương tự nhau được ánh xạ tới các véc-tơ gần nhau trong không gian, mạng chia sẻ được tri thức giữa những trường hợp giống nhau. Chính ý tưởng đó là nội dung Module 05.

Cần biết trước: Module 04 (one-hot = tra bảng) Dựng nên: mạng sâu thật đầu tiên + mini-batch Dẫn tới: vấn đề khởi tạo & bão hoà ở Module 06

1. Ý tưởng cốt lõi: biến ký tự rời rạc thành điểm trong không gian

Vấn đề của bảng đếm là mọi ký tự hoàn toàn xa lạ với nhau: a và e chỉ là chỉ số 1 và 5, không có quan hệ gì. Học được điều gì về a không giúp ích chút nào cho e.

Bengio (2003) đề xuất: gán cho mỗi ký tự một véc-tơ số thực (ví dụ 3 chiều), và để mạng tự học các con số đó cùng lúc với mọi tham số khác. Nếu a và e đóng vai trò giống nhau về mặt ngữ âm, gradient descent sẽ tự đẩy hai véc-tơ của chúng lại gần nhau — vì đặt chúng gần nhau làm giảm loss.

Hệ quả cực mạnh: khi mạng gặp một ngữ cảnh chưa từng thấy nhưng gần một ngữ cảnh đã thấy trong không gian embedding, nó vẫn dự đoán hợp lý. Đây chính là khái quát hoá mà bảng đếm không bao giờ có được.

2. Mã nguồn hoàn chỉnh (PyTorch)

import torch, torch.nn.functional as F, random

# ---------- dữ liệu ----------
block_size = 3          # nhìn lại bao nhiêu ký tự

def build_dataset(words):
    X, Y = [], []
    for w in words:
        context = [0] * block_size          # '...' phần đệm đầu chuỗi
        for ch in w + '.':
            ix = stoi[ch]
            X.append(context); Y.append(ix)
            context = context[1:] + [ix]    # trượt cửa sổ sang phải
    return torch.tensor(X), torch.tensor(Y)

random.seed(42); random.shuffle(words)
n1, n2 = int(0.8 * len(words)), int(0.9 * len(words))
Xtr,  Ytr  = build_dataset(words[:n1])     # 80% học
Xdev, Ydev = build_dataset(words[n1:n2])   # 10% chỉnh siêu tham số
Xte,  Yte  = build_dataset(words[n2:])     #  10% đo lần cuối, đúng MỘT lần

# ---------- tham số ----------
g = torch.Generator().manual_seed(2147483647)
n_emb, n_hid = 10, 200
C  = torch.randn((27, n_emb),               generator=g)
W1 = torch.randn((n_emb * block_size, n_hid), generator=g) * 0.2
b1 = torch.zeros(n_hid)
W2 = torch.randn((n_hid, 27),               generator=g) * 0.01   # ← nhỏ có chủ đích
b2 = torch.zeros(27)
parameters = [C, W1, b1, W2, b2]
for p in parameters: p.requires_grad = True
print(sum(p.nelement() for p in parameters), "tham số")

# ---------- vòng lặp huấn luyện ----------
for i in range(200_000):
    ix = torch.randint(0, Xtr.shape[0], (32,))        # 1. lấy lô 32 mẫu

    emb = C[Xtr[ix]]                                  # (32, 3, 10) — TRA BẢNG
    h   = torch.tanh(emb.view(-1, n_emb * block_size) @ W1 + b1)   # (32, 200)
    logits = h @ W2 + b2                              # (32, 27)
    loss   = F.cross_entropy(logits, Ytr[ix])         # gộp softmax + NLL

    for p in parameters: p.grad = None                # 4a
    loss.backward()                                   # 4b

    lr = 0.1 if i < 100_000 else 0.01                 # 5. hạ lr nửa sau
    for p in parameters: p.data += -lr * p.grad

@torch.no_grad()
def split_loss(X, Y):
    emb = C[X]
    h   = torch.tanh(emb.view(-1, n_emb * block_size) @ W1 + b1)
    return F.cross_entropy(h @ W2 + b2, Y).item()

print("train", split_loss(Xtr, Ytr))    # ≈ 2.12
print("val  ", split_loss(Xdev, Ydev))  # ≈ 2.16   ← so với bigram 2.48

3. Cách dò learning rate như dân chuyên nghiệp

Đừng đoán mò. Chạy vài trăm bước với $\eta$ tăng dần theo hàm mũ, vẽ loss theo $\eta$, rồi chọn giá trị nằm ở giữa đoạn dốc xuống mạnh nhất — thường là khoảng 1/3 của giá trị làm loss bắt đầu nổ.

lre  = torch.linspace(-3, 0, 1000)     # số mũ từ -3 tới 0
lrs  = 10 ** lre                       # tức lr chạy từ 0.001 tới 1.0
losses = []
for i in range(1000):
    ...  # forward + backward như thường
    for p in parameters: p.data += -lrs[i] * p.grad
    losses.append(loss.item())
plt.plot(lre, losses)   # tìm đáy của chữ U → đó là vùng lr tốt

Cần biết trước: Module 03 (cổng tanh làm teo gradient), Module 05 Dựng nên: kỹ năng chẩn đoán mạng không chịu học Dẫn tới: LayerNorm trong Transformer

1. Vì sao khởi tạo lại quan trọng đến thế

Xét một tầng $y = Wx$ với fan-in $= n$. Nếu các thành phần độc lập và có trung bình 0:

Đọc dòng này rất kỹ, vì mọi thứ còn lại chỉ là hệ quả. Đặt $\operatorname{Var}(x) = 1$ và hỏi: tín hiệu ra có giữ được độ xoè bằng tín hiệu vào không?

• Nếu $n\operatorname{Var}(w) > 1$ → phương sai nhân lên mỗi tầng. Qua 10 tầng, hệ số $1.5^{10} \approx 58$: mọi $z$ đều rất lớn, tanh bão hoà hết ở $\pm 1$, đạo hàm $1-t^2 \approx 0$ → không học được gì.
• Nếu $n\operatorname{Var}(w) < 1$ → phương sai teo dần. Qua 10 tầng, $0.5^{10} \approx 0.001$: mọi activation dồn về 0, mạng mất hết khả năng biểu diễn, gradient cũng teo theo.
• Chỉ khi $n\operatorname{Var}(w) = 1$, tức $\boxed{\operatorname{Var}(w) = 1/n}$, tín hiệu mới đi xuyên qua mạng mà giữ nguyên độ xoè.

Từ đó ra đúng các công thức bạn thấy trong tài liệu, chỉ khác nhau ở hằng số bù cho hàm kích hoạt:

2. Mẹo "logits ban đầu phải nhỏ"

Một dạng khác của cùng vấn đề, xảy ra ở tầng cuối. Nếu $W_2$ khởi tạo bình thường, logits ban đầu sẽ rải rác trong khoảng $\pm 5$; softmax biến chúng thành những xác suất rất lệch — mô hình tự tin một cách ngẫu nhiên. Loss khởi đầu có thể là 27 thay vì 3.3.

Hậu quả không phải là sai kết quả cuối cùng, mà là lãng phí: vài nghìn bước đầu tiên chỉ dùng để bóp các logits vô nghĩa về gần 0, tạo ra đường loss hình gậy hockey. Cách chữa nằm gọn trong một dòng:

W2 = torch.randn((n_hid, vocab)) * 0.01   # gần như bằng 0
b2 = torch.zeros(vocab)                   # bias tầng cuối luôn khởi tạo 0

# kiểm tra: loss bước 0 phải xấp xỉ log(vocab)
# log(27) = 3.296 ✓

3. Batch Normalization

Ý tưởng táo bạo của Ioffe & Szegedy (2015): thay vì cầu nguyện cho khởi tạo đúng, hãy ép phân phối về chuẩn ngay trong lúc chạy — biến nó thành một phần của mạng.

Trong đó $\mu_\mathcal{B}, \sigma^2_\mathcal{B}$ là trung bình và phương sai tính trên chiều batch, còn $\gamma$ (gain) và $\beta$ (bias) là hai tham số học được.

Hai chế độ — nguồn gốc của vô số bug

class BatchNorm1d:
    def __init__(self, dim, eps=1e-5, momentum=0.1):
        self.eps, self.momentum, self.training = eps, momentum, True
        self.gamma = torch.ones(dim)          # tham số học được
        self.beta  = torch.zeros(dim)
        self.running_mean = torch.zeros(dim)  # bộ đệm, KHÔNG học bằng gradient
        self.running_var  = torch.ones(dim)

    def __call__(self, x):
        if self.training:
            xmean = x.mean(0, keepdim=True)
            xvar  = x.var(0, keepdim=True, unbiased=True)
            with torch.no_grad():             # cập nhật trung bình trượt
                self.running_mean = (1-self.momentum)*self.running_mean + self.momentum*xmean
                self.running_var  = (1-self.momentum)*self.running_var  + self.momentum*xvar
        else:
            xmean, xvar = self.running_mean, self.running_var
        xhat = (x - xmean) / torch.sqrt(xvar + self.eps)
        return self.gamma * xhat + self.beta

    def parameters(self):
        return [self.gamma, self.beta]        # running_* KHÔNG nằm ở đây

4. LayerNorm — lựa chọn của Transformer

LayerNorm làm đúng phép chuẩn hoá ấy nhưng theo hướng vuông góc: thay vì lấy thống kê dọc theo chiều batch, nó lấy dọc theo chiều đặc trưng của từng mẫu riêng lẻ.

Cần biết trước: Module 03 (chain rule), Module 05 (shape của MLP) Dựng nên: khả năng tự viết layer mới Dẫn tới: hiểu chi phí tính toán của Transformer

1. Đã có autograd rồi, học cái này làm gì?

Câu hỏi chính đáng. Ba lý do rất thực tế:

1. Debug. Khi loss ra nan hoặc một tầng đứng im, bạn phải biết gradient nên trông như thế nào để nhận ra nó đang sai.
2. Viết layer/kernel mới. Mọi torch.autograd.Function, mọi kernel Triton/CUDA đều buộc bạn cung cấp backward bằng tay.
3. Hiểu chi phí. Nhìn công thức là biết backward tốn khoảng gấp đôi forward, và biết tensor trung gian nào bắt buộc phải giữ lại trong VRAM.

2. Ba công thức vàng

Cho $C = A \cdot B$ với $A:(m,k)$, $B:(k,n)$, $C:(m,n)$. Gọi $\bar{X} \equiv \partial L/\partial X$ (luôn cùng shape với $X$ — nhớ kỹ điều này, nó là chìa khoá). Khi đó:

Công thức vàng thứ ba: broadcasting thì backward là tổng

Với $Z = XW + b$, trong đó $b$ có shape $(n,)$ nhưng được phát tán (broadcast) ra cho cả $m$ hàng. Một giá trị dùng lại ở nhiều nơi thì gradient phải cộng dồn từ mọi nơi (đúng quy tắc += ở Module 03):

Quy tắc tổng quát rất gọn: chiều nào bị broadcast lúc forward thì bị sum lúc backward. Chiều nào bị sum lúc forward thì bị broadcast lúc backward. Chúng là hai phép toán chuyển vị của nhau.

3. Dẫn ra $\partial L/\partial \text{logits} = p - y$

Đây là công thức đáng để tự tay dẫn một lần trong đời. Cho logits $z$, xác suất $p_i = \dfrac{e^{z_i}}{\sum_j e^{z_j}}$, và loss $L = -\log p_c$ với $c$ là lớp đúng.

Trường hợp $i = c$:

Trường hợp $i \ne c$:

Gộp lại bằng ký hiệu one-hot $y$:

Đọc ra tiếng Việt: "đẩy mọi lớp sai xuống đúng bằng xác suất bạn lỡ gán cho nó; kéo lớp đúng lên đúng bằng phần xác suất còn thiếu." Khi mô hình đã đúng và tự tin ($p_c \to 1$), gradient tiến về 0 và nó ngừng bị chỉnh — hoàn toàn hợp lý. Bạn đã nhìn thấy chính hai con số này chạy trong phòng thí nghiệm 02a.

4. Bảng tra cứu gradient các lớp thường gặp

import torch, torch.nn.functional as F

def cmp(ten, dt, t):
    """So sánh gradient tay với gradient của PyTorch."""
    ex   = torch.all(dt == t.grad).item()
    maxd = (dt - t.grad).abs().max().item()
    print(f"{ten:12s} | khớp tuyệt đối: {str(ex):5s} | sai lệch tối đa: {maxd:.3e}")

m, k, h, V = 32, 30, 64, 27
X  = torch.randn(m, k)
W1 = torch.randn(k, h) * 0.2; b1 = torch.randn(h) * 0.1
W2 = torch.randn(h, V) * 0.1; b2 = torch.randn(V) * 0.1
Y  = torch.randint(0, V, (m,))
for t in [W1, b1, W2, b2]: t.requires_grad = True

# ---------- FORWARD (giữ lại mọi giá trị trung gian) ----------
Z1     = X @ W1 + b1
A1     = torch.tanh(Z1)
logits = A1 @ W2 + b2
loss   = F.cross_entropy(logits, Y)

for t in [W1, b1, W2, b2]: t.retain_grad()
loss.backward()

# ---------- BACKWARD BẰNG TAY ----------
dlogits = F.softmax(logits, dim=1)          # p
dlogits[range(m), Y] -= 1                   # p - y
dlogits /= m                                # loss lấy trung bình trên lô

dW2 = A1.T @ dlogits                        # (h,m)@(m,V) -> (h,V) ✓
db2 = dlogits.sum(0)                        # broadcast -> sum
dA1 = dlogits @ W2.T                        # (m,V)@(V,h) -> (m,h) ✓
dZ1 = (1 - A1 ** 2) * dA1                   # đạo hàm tanh
dW1 = X.T @ dZ1                             # (k,m)@(m,h) -> (k,h) ✓
db1 = dZ1.sum(0)

cmp('W2', dW2, W2);  cmp('b2', db2, b2)
cmp('W1', dW1, W1);  cmp('b1', db1, b1)
# W2  | khớp tuyệt đối: False | sai lệch tối đa: 2.794e-09
# ...  ← sai lệch cỡ 1e-9 là do dấu phẩy động, KHÔNG phải lỗi công thức

Cần biết trước: Module 05 (flatten của Bengio) Dựng nên: tư duy phân cấp & kỹ năng đọc shape Dẫn tới: Transformer — nơi cây cố định được thay bằng liên kết học được

1. Điểm nghẽn ép phẳng

Ở Module 05, ta ghép 3 embedding thành một véc-tơ 30 chiều rồi nhồi thẳng vào một tầng ẩn. Nếu muốn ngữ cảnh 8 ký tự thay vì 3, ma trận $W_1$ phình từ $(30, 200)$ lên $(80, 200)$ — vẫn chịu được. Nhưng vấn đề sâu hơn nằm ở chỗ khác:

Tầng đầu tiên phải trộn toàn bộ 8 ký tự cùng một lúc, trong một phép nhân duy nhất, rồi ép kết quả qua một hàm tanh. Toàn bộ cấu trúc thời gian bị nghiền nát ngay lập tức.

Điều đó lãng phí về mặt thống kê: quan hệ giữa hai ký tự liền kề mạnh hơn và dễ học hơn nhiều so với quan hệ giữa hai ký tự cách nhau 7 vị trí, nhưng kiến trúc phẳng đối xử với chúng như nhau. Cách sửa của WaveNet (DeepMind, 2016) rất tự nhiên: gộp dần từng cặp, theo tầng.

2. Phép reshape, viết bằng code

Toàn bộ ý tưởng gói gọn trong một lớp 5 dòng:

class FlattenConsecutive:
    """Gộp n bước thời gian liền kề thành một véc-tơ dày hơn."""
    def __init__(self, n):
        self.n = n
    def __call__(self, x):
        B, T, C = x.shape
        x = x.view(B, T // self.n, C * self.n)   # (B, T, C) -> (B, T/n, C*n)
        if x.shape[1] == 1:
            x = x.squeeze(1)                     # bỏ chiều thời gian khi chỉ còn 1
        self.out = x
        return x
    def parameters(self):
        return []                                # không có tham số nào!


model = Sequential([
    Embedding(vocab_size, n_emb),
    FlattenConsecutive(2), Linear(n_emb * 2, n_hid, bias=False), BatchNorm1d(n_hid), Tanh(),
    FlattenConsecutive(2), Linear(n_hid * 2, n_hid, bias=False), BatchNorm1d(n_hid), Tanh(),
    FlattenConsecutive(2), Linear(n_hid * 2, n_hid, bias=False), BatchNorm1d(n_hid), Tanh(),
    Linear(n_hid, vocab_size),
])
# Ngữ cảnh 8 ký tự, ~22.000 tham số, val loss ≈ 1.99
# so với MLP phẳng cùng số tham số: ≈ 2.09.  Cùng ngân sách, kiến trúc tốt hơn thắng.

Phân biệt view, reshape, permute, transpose

Quy tắc vàng: nếu bạn định "gộp hai chiều cạnh nhau" thì dùng view; nếu định "đổi chỗ hai chiều" thì dùng permute. Nhầm hai cái này tạo ra loại bug tệ nhất: code chạy, shape đúng, nhưng dữ liệu bị xáo trộn và mô hình chỉ học kém hơn một chút — không đủ để bạn nghi ngờ.

Cần biết trước: Module 05–08 (embedding, softmax, reshape, residual) Dựng nên: kiến trúc đứng sau toàn bộ LLM hiện đại Dẫn tới: tokenizer và triển khai thực tế

1. Trực giác: một buổi mai mối trong lớp học

Mỗi token trong câu phát ra ba thứ khác nhau, sinh từ chính véc-tơ của nó qua ba ma trận trọng số học được:

Mỗi query so khớp với mọi key bằng tích vô hướng — hai véc-tơ càng cùng hướng thì điểm càng cao. Điểm số được softmax thành trọng số có tổng bằng 1, rồi đầu ra là trung bình có trọng số của các value. Nói ngắn: mỗi token tự chọn xem nên nghe ai, và nghe bao nhiêu.

Điểm mấu chốt phân biệt nó với Module 08: các trọng số này không cố định. Chúng được tính lại cho từng câu, từ chính nội dung câu đó. Cây gộp là hệ thống dây điện hàn cứng; attention là tổng đài tự động định tuyến.

2. Ba chi tiết ai cũng hỏi

Vì sao chia $\sqrt{d_k}$?

Nếu các thành phần của $q,k$ độc lập với phương sai 1, thì tích vô hướng $q\cdot k$ của $d_k$ số hạng có phương sai $d_k$, tức độ lệch chuẩn $\sqrt{d_k}$. Với $d_k = 64$, điểm số dao động cỡ ±8; softmax của những con số đó gần như one-hot. Hậu quả: gradient qua softmax teo về 0 (softmax bão hoà y hệt sigmoid), và attention mất khả năng học phân bổ mềm. Chia cho $\sqrt{d_k}$ kéo phương sai về 1 và giữ softmax ở vùng "mềm". Chuẩn hoá thang đo, đúng bài học của Module 06.

Causal mask thực chất làm gì?

Nó cộng $-\infty$ (thực tế là -1e9) vào mọi ô nằm phía trên đường chéo trước khi softmax. Sau softmax, $e^{-\infty} = 0$, nên các vị trí tương lai nhận trọng số đúng bằng 0.

tril = torch.tril(torch.ones(T, T))
wei  = wei.masked_fill(tril == 0, float('-inf'))
wei  = F.softmax(wei, dim=-1)

Nhờ mask, một lần forward trên câu dài $T$ tạo ra $T$ bài toán dự đoán độc lập cùng lúc (vị trí 1 đoán 2, vị trí 2 đoán 3, ...). Đây là lý do huấn luyện LLM hiệu quả đến vậy: mỗi token vừa là đầu vào vừa là nhãn.

Multi-head để làm gì?

Một head chỉ học được một kiểu quan hệ. Ngôn ngữ có nhiều kiểu cùng lúc: chủ ngữ–động từ, tính từ–danh từ, đại từ–tiền ngữ, dấu câu. Multi-head chạy $h$ attention song song trên các không gian con $d/h$ chiều rồi ghép kết quả. Chi phí gần như không đổi (tổng số chiều giữ nguyên) nhưng mô hình có $h$ "kênh quan hệ" riêng biệt.

3. Khối Transformer đầy đủ

import torch, torch.nn as nn, torch.nn.functional as F

class Head(nn.Module):
    """Một đầu self-attention có che nhân quả."""
    def __init__(self, n_embd, head_size, block_size, dropout=0.1):
        super().__init__()
        self.key   = nn.Linear(n_embd, head_size, bias=False)
        self.query = nn.Linear(n_embd, head_size, bias=False)
        self.value = nn.Linear(n_embd, head_size, bias=False)
        self.register_buffer('tril', torch.tril(torch.ones(block_size, block_size)))
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        B, T, C = x.shape
        k = self.key(x)      # (B, T, hs)
        q = self.query(x)    # (B, T, hs)
        v = self.value(x)    # (B, T, hs)

        wei = q @ k.transpose(-2, -1) * k.shape[-1] ** -0.5   # (B, T, T)
        wei = wei.masked_fill(self.tril[:T, :T] == 0, float('-inf'))
        wei = F.softmax(wei, dim=-1)
        wei = self.dropout(wei)
        return wei @ v                                        # (B, T, hs)


class MultiHeadAttention(nn.Module):
    def __init__(self, n_head, n_embd, block_size):
        super().__init__()
        hs = n_embd // n_head
        self.heads = nn.ModuleList([Head(n_embd, hs, block_size) for _ in range(n_head)])
        self.proj  = nn.Linear(n_embd, n_embd)     # trộn lại sau khi ghép
    def forward(self, x):
        out = torch.cat([h(x) for h in self.heads], dim=-1)
        return self.proj(out)


class FeedForward(nn.Module):
    """Mỗi token tự suy nghĩ một mình, không nhìn ai."""
    def __init__(self, n_embd):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n_embd, 4 * n_embd),   # phình ra 4 lần — tỉ lệ chuẩn
            nn.GELU(),
            nn.Linear(4 * n_embd, n_embd),
            nn.Dropout(0.1),
        )
    def forward(self, x):
        return self.net(x)


class Block(nn.Module):
    """Giao tiếp (attention) rồi suy nghĩ (feed-forward)."""
    def __init__(self, n_embd, n_head, block_size):
        super().__init__()
        self.ln1 = nn.LayerNorm(n_embd)
        self.sa  = MultiHeadAttention(n_head, n_embd, block_size)
        self.ln2 = nn.LayerNorm(n_embd)
        self.ffwd = FeedForward(n_embd)
    def forward(self, x):
        x = x + self.sa(self.ln1(x))     # residual + pre-norm
        x = x + self.ffwd(self.ln2(x))
        return x


class GPT(nn.Module):
    def __init__(self, vocab, n_embd=384, n_head=6, n_layer=6, block_size=256):
        super().__init__()
        self.block_size = block_size
        self.tok_emb = nn.Embedding(vocab, n_embd)
        self.pos_emb = nn.Embedding(block_size, n_embd)   # attention mù vị trí!
        self.blocks  = nn.Sequential(*[Block(n_embd, n_head, block_size) for _ in range(n_layer)])
        self.ln_f    = nn.LayerNorm(n_embd)
        self.head    = nn.Linear(n_embd, vocab)

    def forward(self, idx, targets=None):
        B, T = idx.shape
        x = self.tok_emb(idx) + self.pos_emb(torch.arange(T, device=idx.device))
        x = self.ln_f(self.blocks(x))
        logits = self.head(x)                                  # (B, T, vocab)
        loss = None
        if targets is not None:
            loss = F.cross_entropy(logits.view(B*T, -1), targets.view(B*T))
        return logits, loss

    @torch.no_grad()
    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None):
        for _ in range(max_new_tokens):
            idx_cond = idx[:, -self.block_size:]        # cắt cho vừa cửa sổ
            logits, _ = self(idx_cond)
            logits = logits[:, -1, :] / temperature     # chỉ lấy bước cuối
            if top_k is not None:
                v, _ = torch.topk(logits, top_k)
                logits[logits < v[:, [-1]]] = -float('inf')
            probs = F.softmax(logits, dim=-1)
            idx = torch.cat([idx, torch.multinomial(probs, 1)], dim=1)
        return idx

4. Cái giá: $O(T^2)$

Ma trận attention có kích thước $T \times T$ cho mỗi head, mỗi tầng, mỗi mẫu. Nhân đôi độ dài ngữ cảnh làm chi phí tính toán và bộ nhớ tăng gấp bốn.

Đó là lý do "cửa sổ ngữ cảnh dài" là một hạng mục nghiên cứu riêng, và vì sao API tính tiền theo token đầu vào chứ không chỉ token đầu ra.

Cần biết trước: Module 04 (từ vựng, chỉ số) Dựng nên: lớp vào/ra của mọi LLM Dẫn tới: hiểu vì sao LLM đếm chữ sai và tiếng Việt tốn tiền hơn

1. Ba lựa chọn, hai cực đoan

2. Thuật toán BPE, bốn bước lặp lại

1. Khởi đầu: mỗi byte là một token (256 token gốc — nhờ đó không bao giờ có OOV, kể cả emoji hay tiếng Nhật).
2. Đếm mọi cặp token liền kề trong toàn bộ kho văn bản.
3. Tìm cặp xuất hiện nhiều nhất, gộp nó thành một token mới, ghi lại luật gộp.
4. Lặp lại cho tới khi đạt kích thước từ vựng mong muốn (ví dụ 50.257 với GPT-2).

def get_stats(ids):
    """Đếm tần suất mọi cặp liền kề."""
    counts = {}
    for pair in zip(ids, ids[1:]):
        counts[pair] = counts.get(pair, 0) + 1
    return counts

def merge(ids, pair, idx):
    """Thay mọi lần xuất hiện của `pair` bằng token mới `idx`."""
    new_ids, i = [], 0
    while i < len(ids):
        if i < len(ids) - 1 and ids[i] == pair[0] and ids[i+1] == pair[1]:
            new_ids.append(idx); i += 2
        else:
            new_ids.append(ids[i]); i += 1
    return new_ids

def train_bpe(text, vocab_size):
    ids = list(text.encode('utf-8'))      # 256 token byte làm nền
    merges = {}                           # (int, int) -> int
    for i in range(vocab_size - 256):
        stats = get_stats(ids)
        if not stats: break
        pair = max(stats, key=stats.get)  # cặp phổ biến nhất
        idx  = 256 + i
        ids  = merge(ids, pair, idx)
        merges[pair] = idx
        print(f"gộp {pair} -> {idx}  (xuất hiện {stats[pair]} lần)")
    return ids, merges

def encode(text, merges):
    ids = list(text.encode('utf-8'))
    while len(ids) >= 2:
        stats = get_stats(ids)
        # luôn áp dụng luật gộp có chỉ số NHỎ NHẤT trước — đúng thứ tự lúc train
        pair = min(stats, key=lambda p: merges.get(p, float('inf')))
        if pair not in merges: break
        ids = merge(ids, pair, merges[pair])
    return ids

def decode(ids, merges):
    vocab = {i: bytes([i]) for i in range(256)}
    for (p0, p1), idx in merges.items():          # dict giữ thứ tự chèn
        vocab[idx] = vocab[p0] + vocab[p1]
    return b''.join(vocab[i] for i in ids).decode('utf-8', errors='replace')

3. Vì sao rất nhiều hành vi kỳ quặc của LLM bắt nguồn từ đây

Cần biết trước: toàn bộ Module 00–10 Dựng nên: bản đồ nối kiến thức với công việc thật Dẫn tới: dự án của chính bạn

1. Ba giai đoạn tạo ra một trợ lý AI

2. Số học của việc scale — ba công thức bỏ túi

3. Tuỳ biến mô hình: chọn đúng công cụ

4. Đi tiếp: bốn dự án theo thứ tự tăng dần

Tra nhanh khi đọc tài liệu tiếng Anh. Số trong ngoặc là module giải thích kỹ.