Backpropagation & autograd

Mở đầu: thuật toán khiến deep learning khả thi

Bài 6 kết thúc bằng một lời hứa: "đây là lần cuối bạn phải tự tay đạo hàm". Lời hứa đó không phải nói cho vui — nó dựa trên một thuật toán cụ thể, backpropagation, thứ biến deep learning từ một ý tưởng lý thuyết đẹp đẽ nhưng vô dụng thành thứ chạy được trên phần cứng thật. Không có nó, huấn luyện một mạng vài triệu tham số sẽ tốn thời gian tính bằng năm thay vì mili giây mỗi bước — bạn sẽ thấy con số đó cụ thể ngay Mục 1.

Bài này xây autograd — cỗ máy tự động tính đạo hàm — thẳng vào NeuroJS. Sau bài này, mọi phép toán (+, *, matmul, relu, sigmoid) tự nhớ cách lan truyền gradient ngược qua chính nó; bạn không còn phải viết backward tay như Bài 6 nữa, dù kiến trúc mạng có phức tạp tới đâu. Đây là bước nhảy quan trọng nhất biến NeuroJS từ "thư viện tensor" thành "thư viện học sâu" thật sự — mọi bài từ Bài 9 trở đi (optimizer, CNN, attention) đều đứng trên vai autograd của bài này.

1. Bài toán: vì sao không thể tính đạo hàm bằng tay ở quy mô thật

Mạng XOR của Bài 6 có $9$ tham số — đủ nhỏ để tự đạo hàm tay một lần. Nhưng thử tưởng tượng cách "ngây thơ" để tính gradient mà không cần biết công thức đạo hàm nào cả: sai phân hữu hạn (finite difference) — nhích từng tham số lên một chút, chạy lại forward, xem loss đổi bao nhiêu:

$$\frac{\partial L}{\partial w_i} \approx \frac{L(w_i+\epsilon) - L(w_i-\epsilon)}{2\epsilon}$$

Cách này ĐÚNG về mặt toán học (Mục 4 dùng chính nó để kiểm tra autograd), nhưng để tính gradient cho MỘT tham số cần 2 lần forward pass (một lần $+\epsilon$, một lần $-\epsilon$). Muốn gradient cho TẤT CẢ tham số, phải lặp lại cho từng cái một:

Giả sử một lần forward mất khoảng $1$ mili giây (hợp lý cho mạng cỡ vừa) — mạng $9$ tham số vẫn ổn ($18$ ms), nhưng mạng $1$ triệu tham số cần $2$ triệu lần forward CHO MỖI BƯỚC cập nhật — xấp xỉ $33$ phút, trong khi một bước huấn luyện thật cần hàng nghìn tới hàng triệu bước. Hoàn toàn bất khả thi. Trong khi đó, backprop tính gradient cho TẤT CẢ tham số cùng lúc, chỉ với đúng $1$ lượt forward và $1$ lượt ngược — chi phí gần như không đổi dù mạng có $9$ hay $1$ triệu tham số. Đây là lý do backprop tồn tại: chain rule được tổ chức lại để không phải lặp lại công việc cho từng tham số riêng lẻ.

2. Computation graph: mỗi phép toán là 1 nút

Backprop hoạt động trên một cấu trúc gọi là computation graph: mỗi phép toán (cộng, nhân, matmul...) là một nút, các nút nối với nhau theo đúng thứ tự phép toán được thực hiện ở forward pass. Hai bước:

1. Forward: chạy phép tính như bình thường, nhưng LƯU lại giá trị trung gian ở mỗi nút.
2. Backward: đi ngược đúng thứ tự đã tạo ra các nút (thứ tự topo), tại mỗi nút áp dụng công thức lõi:

$$\text{gradient tai nut} = \text{local gradient} \times \text{upstream gradient}$$

Trong đó "local gradient" là đạo hàm của đúng phép toán tạo ra nút đó (vd $c=ab$ thì local gradient theo $a$ là $b$), còn "upstream gradient" là gradient đã tích luỹ từ MỌI nút phía sau dùng tới nút này. Tính tay ví dụ nhỏ nhất có thể còn minh hoạ được điểm quan trọng nhất (một biến dùng lại ở 2 nhánh): $a=2$, $b=3$, $c=a \cdot b$, $d = c + a$ (dùng lại $a$!), $L = d^2$:

Vì $a$ được dùng ở CẢ 2 nhánh ($c=ab$ và $d=c+a$), gradient của nó là tổng đóng góp từ cả hai nhánh ($48+16=64$), không phải chỉ một trong hai. Đây chính là điểm sẽ trở thành cạm bẫy lớn nhất Mục 3. Demo Mục 5 cho bạn bấm từng bước ngược này trên đúng sơ đồ SVG, xem giá trị hiện ra tại mỗi nút.

3. Xây autograd thật vào NeuroJS

Theo đúng kiểu micrograd của Andrej Karpathy: mỗi Tensor giờ mang thêm $3$ trường — .grad (gradient tích luỹ), ._backward (closure "1 bước lùi" riêng của phép toán tạo ra nó), và ._prev (các tensor input, để dò thứ tự topo bằng DFS):

// Moi Tensor gio mang: .grad (Float32Array), ._backward (closure), ._prev (mang input)
function mul(a, b) {
  const out = /* ...tinh gia tri forward nhu Bai 5... */;
  out._prev = [a, b];
  out._backward = () => {
    a._ensureGrad(); b._ensureGrad();
    a.grad += out.grad * b.data;   // local gradient cua phep nhan: d(ab)/da = b
    b.grad += out.grad * a.data;   // d(ab)/db = a
  };
  return out;
}

// backward(): duyet TOPO (DFS) roi lui NGUOC dung thu tu do
Tensor.prototype.backward = function () {
  const topo = [], visited = new Set();
  const build = (t) => { if (visited.has(t)) return; visited.add(t);
    for (const p of t._prev) build(p); topo.push(t); };
  build(this);
  this.grad = 1;                                  // seed: chi goi tren scalar (loss)
  for (let i = topo.length - 1; i >= 0; i--) topo[i]._backward();
};

Cài đủ $5$ phép NeuroJS cần cho Bài 6 trở đi: add, mul (cả hai đã hỗ trợ broadcasting từ Bài 5 — backward phải "un-broadcast" đúng ngược lại, cộng dồn theo đúng chiều đã bị nhân bản ở forward), matmul (backward chuẩn: $dA = d_{out} \cdot B^T$, $dB = A^T \cdot d_{out}$), relu, sigmoid (dùng đúng công thức đạo hàm Bài 6 đã lập bảng, giờ chạy tự động).

// batch (4,3) + bias (3,) -> out (4,3): forward NHAN BAN bias ra 4 dong (Bai 5).
// Backward phai lam NGUOC LAI: CONG DON gradient cua 4 dong do ve lai dung 1
// dong (3,) cua bias - khong lam vay, shape gradient se khong khop input.
function unbroadcast(gradOut, outShape, targetShape) {
  const result = new Float32Array(targetShape.reduce((a, b) => a * b, 1));
  // ... duyet outShape, cong don tung phan tu ve dung vi tri da bi "nhan ban" ...
  return result;
}
// vd: dOut shape (4,3) -> unbroadcast ve bias shape (3,) = CONG 4 dong lai voi nhau

4. Gradient checking: tự kiểm tra autograd bằng chính công thức Mục 1

Câu hỏi tự nhiên: làm sao biết autograd viết ở Mục 3 tính ĐÚNG? Trả lời bằng đúng công cụ tưởng đã "quá chậm để dùng" ở Mục 1 — sai phân hữu hạn — nhưng giờ dùng để KIỂM TRA (chỉ vài tham số, không phải để huấn luyện thật) thay vì để tính gradient sản xuất. Chọn $\epsilon$ sai thì phép kiểm tra vô nghĩa: quá lớn thì công thức xấp xỉ (bỏ qua đạo hàm bậc cao) sai; quá nhỏ thì phép trừ 2 số gần bằng nhau bị lỗi làm tròn dấu phẩy động nuốt mất tín hiệu thật. Quét $\epsilon$ trên một hàm có độ cong thật ($L=\sigma(ab+a)^3$):

// Sai phan huu han TRUNG TAM (central difference) - chinh xac hon 1 phia
function centralDiff(f, x, eps) {
  return (f(x + eps) - f(x - eps)) / (2 * eps);
}
// L(a) = sigmoid(a*b + a)^3 voi b=-1.3 co dinh - ham co DO CONG that (khac
// vi du 3-phep-toan Muc 2, chi la da thuc bac thap nen khong lo ro 2 phia sai so)
function L(a) { const c = a * (-1.3) + a; const s = 1/(1+Math.exp(-c)); return s*s*s; }
centralDiff(L, 0.7, 1e-5);  // ~sai so 8e-13 so voi dao ham giai tich - xem bang duoi

Sai số giảm dần khi $\epsilon$ nhỏ lại, chạm đáy quanh $10^{-5}$, rồi tăng trở lại khi $\epsilon$ tiếp tục nhỏ hơn nữa — một hình chữ U rõ ràng. Vùng đáy $10^{-4}$–$10^{-6}$ là "vùng vàng": đủ nhỏ để công thức xấp xỉ chính xác, đủ lớn để không bị lỗi làm tròn nuốt mất.

5. Nếm trước: vanishing & exploding gradient

Backprop nhân liên tiếp nhiều "local gradient" qua từng lớp (công thức Mục 2). Chuyện gì xảy ra khi xếp rất nhiều lớp? Tính bằng autograd thật, không đoán: xích $N$ lớp sigmoid liên tiếp (đạo hàm sigmoid tối đa chỉ $0{,}25$, tại $z=0$), và xích $N$ lần nhân với hằng số $2$:

Chỉ $20$ lớp sigmoid đã đủ làm gradient tiêu biến về $10^{-13}$ — với mạng sâu thật ($50$–$100$ lớp), gradient ở những lớp đầu tiên thực chất bằng $0$, model không học được gì ở đó nữa. Ngược lại, nếu mỗi lớp khuếch đại tín hiệu lên (như nhân hằng số $>1$), gradient bùng nổ theo cấp số nhân, làm bước cập nhật GD trở nên vô nghĩa (quá lớn, số học tràn). Đây là hai vấn đề cốt lõi ngăn cản mạng thật sự sâu trước khi có các kỹ thuật khắc phục — chi tiết đầy đủ và lời giải (LSTM, residual connection, chuẩn hoá gradient) dành cho Bài 13 khi cần xử lý chuỗi dài thật.

6. Thực hành: computation graph — bấm Backward xem gradient chảy ngược

Đúng ví dụ 3 phép toán của Mục 2 ($a=2, b=3, c=ab, d=c+a, L=d^2$), chạy bằng autograd thật của ai-neuro.js. Bấm Bước ngược liên tiếp để tô sáng từng nút theo ĐÚNG thứ tự backward() thật sự xử lý, xem giá trị gradient hiện ra:

Đối chiếu công nghiệp: 3 dòng "thần chú" PyTorch mà giờ bạn đã hiểu rõ cơ chế bên trong:

# Doi chieu 1-1 voi vi du 3 phep toan Muc 2 - cai dat: pytorch.org/get-started/locally
import torch

a = torch.tensor(2.0, requires_grad=True)   # requires_grad=True: bao PyTorch GHI LAI computation graph
b = torch.tensor(3.0, requires_grad=True)

c = a * b        # moi phep toan tu dong them 1 nut vao graph (giong ._prev cua Muc 3)
d = c + a        # a duoc DUNG LAI o day - PyTorch tu biet phai cong don gradient
L = d ** 2

L.backward()     # DUNG 1 lan goi: tu dong duyet topo NGUOC, chay het moi ._backward()
print(a.grad)     # 64.0 - khop chinh xac tay tinh Muc 2
print(b.grad)     # 32.0

# optimizer.zero_grad() trong vong lap that: xoa .grad truoc MOI buoc moi,
# tranh dung cam bay Muc 3 (cong don gradient tu vong lap truoc)

Tóm lược

• ✅ Sai phân hữu hạn chết ở quy mô thật: $O(N)$ lần forward cho $N$ tham số — mạng $1$ triệu tham số cần $2$ triệu lần forward MỖI bước, ~$33$ phút so với vài mili giây của backprop.
• ✅ Computation graph + công thức lõi: gradient tại nút = local gradient × upstream gradient, đi ngược đúng thứ tự topo — verified tay trên ví dụ $3$ phép toán ($a.grad=64=48+16$).
• ✅ Autograd thật đã có trong NeuroJS: mỗi Tensor mang .grad, ._backward, ._prev; cài đủ add/mul/matmul/relu/sigmoid — không cần viết backward tay nữa từ đây trở đi.
• ✅ Gradient CỘNG DỒN là bắt buộc (một node dùng ở 2 nhánh) nhưng cũng là cạm bẫy số 1: quên zeroGrad() làm gradient nhiễm vòng lặp cũ (verified: $174$ thay vì $150$).
• ✅ Gradient checking dùng chính sai phân hữu hạn để KIỂM TRA (không phải để huấn luyện) — vùng vàng $\epsilon \in [10^{-4}, 10^{-6}]$, và phải tính ở double precision, không phải trên buffer float32 của Tensor.
• ✅ Vanishing/exploding: $20$ lớp sigmoid đủ làm gradient tiêu biến về $10^{-13}$; nhân hằng số $>1$ liên tiếp làm gradient bùng nổ theo cấp số nhân — chi tiết + lời giải ở Bài 13.