Tensor engine mini

Mở đầu: mọi lỗi PyTorch bạn từng gặp đều là lỗi shape

Nếu bạn từng nghịch PyTorch hay TensorFlow, gần như chắc chắn bạn từng dính lỗi đỏ chót RuntimeError: size mismatch hoặc tệ hơn — không lỗi gì cả, chỉ là model huấn luyện xong cho kết quả vô nghĩa. Cả hai tình huống đều bắt nguồn từ đúng một khái niệm: shape (hình dạng) của tensor. Bốn bài trước, mọi "dữ liệu" chỉ là vài con số hoặc cặp toạ độ $(x, y)$ — đủ đơn giản để không cần nghĩ về shape. Từ bài này trở đi, dữ liệu là tensor nhiều chiều, và school hiểu sai một chiều duy nhất có thể khiến cả pipeline chạy "bình thường" nhưng học ra thứ hoàn toàn sai.

Bài này tự xây một tensor engine tối giản từ số 0 — không dùng thư viện nào — để bạn thấy tận mắt shape chỉ là cách diễn giải một dải số phẳng trong bộ nhớ. Bạn sẽ tự tay tạo ra cạm bẫy nguy hiểm nhất của cả chương (một phép cộng sai shape "âm thầm" chạy được, không báo lỗi, và bạn sẽ tận mắt xem gradient descent vẫn giảm loss trong khi học ra tham số sai), rồi đo bằng số thật vì sao bỏ qua lớp trừu tượng tiện lợi lại nhanh hơn tới hơn chục lần. Kết thúc bài, mã nguồn viết ra chính là NeuroJS — engine sẽ được tái sử dụng nguyên vẹn ở mọi bài còn lại của series.

1. Vì sao mọi thứ đều là tensor

"Tensor" nghe huyền bí nhưng chỉ là một từ tổng quát cho: vô hướng (1 con số) → vector (dãy số 1 chiều) → ma trận (bảng số 2 chiều) → tensor bậc cao hơn (3, 4 chiều trở lên). Điểm chung: tất cả chỉ là số được sắp theo một số chiều (dimension) nào đó, và con số đó — gọi là bậc (rank) hay shape — chính là "ngôn ngữ chung" mà mọi framework deep learning dùng để mô tả dữ liệu VÀ mô tả model:

Sự thật quan trọng nhất bài, đáng nhớ hơn mọi công thức: một model deep learning chỉ là một chuỗi phép toán trên tensor — nhân ma trận, cộng, phi tuyến, lặp lại. Không có phép màu nào khác. Và vì mọi phép toán đều yêu cầu shape đầu vào khớp theo quy tắc nhất định, hiểu rõ shape giải quyết được phần lớn lỗi khi debug deep learning — thói quen số 1 của người viết model thành thạo là in ra .shape sau MỌI phép toán khi có gì đó khả nghi, trước khi nghi ngờ bất cứ thứ gì khác.

2. Xây tensor trên Float32Array phẳng + shape/stride

Cách hiện thực ngây thơ nhất cho ma trận trong JS là mảng lồng mảng: [[1,2,3],[4,5,6]]. Vấn đề: mỗi hàng con là một object riêng nằm rải rác trong bộ nhớ (không liền mạch), và mỗi số là một giá trị "boxed" (bọc thêm metadata) thay vì số thô. Tensor thật sự (NumPy, PyTorch, và NeuroJS ở đây) dùng cách khác hẳn: một dải số PHẲNG duy nhất (Float32Array), cộng với 2 mảng nhỏ mô tả cách "đọc" dải số đó theo nhiều chiều — shape (kích thước từng chiều) và stride (bước nhảy trong bộ nhớ ứng với mỗi chiều).

Với layout row-major (chuẩn của NumPy/PyTorch — duyệt hết 1 hàng rồi mới sang hàng kế), công thức stride cực đơn giản: chiều cuối cùng luôn có stride $1$ (đi 1 bước trong chiều đó = đi 1 ô trong bộ nhớ), còn stride của mỗi chiều còn lại = stride chiều kế tiếp nhân với kích thước chiều kế tiếp:

$$\text{stride}[i] = \text{stride}[i+1] \times \text{shape}[i+1] \qquad (\text{stride cuối} = 1)$$

Truy cập phần tử tại chỉ số $(i_0, i_1, \ldots)$ chỉ là một phép nhân-cộng: nhân từng chỉ số với stride tương ứng rồi cộng lại — chính là _flatIndex() trong file tải về cuối bài. Sức mạnh thật sự lộ ra ở phép transpose: đảo ngược shape THÌ CŨNG đảo ngược đúng stride tương ứng — không hề đụng vào dải số gốc:

transpose(perm) {
  const p = perm || this.shape.map((_, i) => i).reverse();
  return new Tensor(
    this.data,                    // CUNG mot buffer - khong sao chep gi ca
    p.map(i => this.shape[i]),    // shape MOI: hoan doi thu tu
    p.map(i => this.strides[i]),  // stride MOI: hoan doi cung thu tu
    this.offset
  );
}
// shape (2,3) stride (3,1) -> transpose -> shape (3,2) stride (1,3)
// t.get(1,0) sau transpose == goc.get(0,1) — DUNG gia tri, KHONG di chuyen 1 byte nao

Vì chỉ đổi 2 mảng nhỏ (shape, stride) chứ không đụng dải số gốc, transpose có độ phức tạp $O(1)$ — tốn thời gian y hệt nhau dù tensor có 6 phần tử hay 1 triệu phần tử. Đo trực tiếp: transpose một tensor $1000 \times 1000$ (1 triệu phần tử) mất $0{,}016$ mili giây — chỉ là tạo 1 object mới, không lặp qua phần tử nào cả.

const t = Tensor.fromNested([[1,2,3],[4,5,6]]);   // shape (2,3), CONTIGUOUS
const tt = t.transpose();                          // shape (3,2), KHONG con contiguous
tt.reshape([6]);
// -> throw: "reshape() yeu cau tensor CONTIGUOUS - goi .contiguous() truoc"

const fixed = tt.contiguous().reshape([6]);        // dung: materialize roi moi reshape
// fixed = [1, 4, 2, 5, 3, 6] — DUNG thu tu sau transpose, khong phai [1,2,3,4,5,6] goc

3. Broadcasting: tiện lợi và cạm bẫy nguy hiểm nhất chương

Bài toán thực tế cực phổ biến: cộng bias (1 vector, vd shape $(3,)$) vào CẢ một batch dữ liệu (shape $(4,3)$ — 4 mẫu, 3 đặc trưng mỗi mẫu) mà không cần lặp tay từng dòng. Broadcasting giải đúng bài này bằng quy tắc căn phải (right-align): so 2 shape từ chiều cuối về đầu; hai chiều tương thích nếu bằng nhau HOẶC một trong hai bằng $1$ (chiều $1$ sẽ tự "nhân bản" để khớp chiều còn lại); chiều thiếu ở đầu coi như $1$. Cộng bias vào batch, hoạt động đúng như kỳ vọng:

Đúng như kỳ vọng — bias $(3,)$ được "trải" ra cộng vào cả 4 dòng. Nhưng cơ chế "chiều thiếu coi như 1" chính là con dao hai lưỡi:

const col = Tensor.fromNested([[1],[2],[3]]);      // shape (3,1) - Y DINH la (3,)
const row = Tensor.fromNested([[10,20,30]]);       // shape (1,3) - Y DINH la (3,)
add(col, row);
// KHONG throw loi gi ca! Ket qua shape (3,3):
// [[11,21,31],
//  [12,22,32],
//  [13,23,33]]
// -- thay vi (3,) ma nguoi viet code DINH tinh: [11,22,33]

4. Matmul: công thức, và vì sao lớp trừu tượng có giá của nó

Phép toán trung tâm của mọi mạng neural — nhân ma trận (matmul). Với $A$ shape $(m,k)$ và $B$ shape $(k,n)$, kết quả $C = AB$ có shape $(m,n)$:

$$C_{ij} = \sum_{p=1}^{k} A_{ip} B_{pj}$$

Ba vòng lặp lồng nhau ($i$, $j$, $p$) cho độ phức tạp $O(m \cdot n \cdot k)$ — thường viết gọn $O(n^3)$ khi các chiều cùng cỡ $n$. Câu hỏi thật sự không phải "công thức là gì" (chỉ 1 dòng) mà là viết code thế nào cho nhanh. Trực giác phổ biến: "dùng mảng phẳng (Float32Array) thay vì mảng lồng nhau sẽ nhanh hơn hẳn nhờ cache tốt hơn, không boxing". Đo thẳng bằng số thay vì tin trực giác — so mảng lồng nhau (nested array) với mảng phẳng cùng thứ tự vòng lặp, cùng cỡ $n=200$:

Bất ngờ: gần như không khác biệt. JIT compiler của V8 (engine chạy JS trong Chrome/Node) đủ thông minh để tối ưu mảng lồng nhau "packed" (toàn số, không lỗ hổng) gần bằng mảng phẳng trên phần cứng hiện đại — trực giác "mảng phẳng luôn nhanh hơn nhiều" không còn đúng như 10 năm trước. Vậy chi phí thật sự nằm ở đâu? Đo lại, lần này so API tiện lợi tensor.get(i,j)/.set(i,j,v) (dùng tham số rest + vòng lặp tính stride mỗi lần gọi — đúng API Mục 2) với việc đọc/ghi trực tiếp trên Float32Array bằng công thức data[i*n+j] đã tính sẵn:

Đây mới là khoảng cách "hàng chục lần" thật sự tồn tại — nhưng nó tới từ chi phí gọi hàm và tham số rest/spread lặp lại hàng triệu lần (với $n=200$, matmul gọi get() tới $200^3 \times 2 = 16$ triệu lần), không phải từ bản thân "mảng phẳng vs mảng lồng". Đây chính xác là lý do matmul() trong ai-neuro.js đọc/ghi trực tiếp trên Float32Array ở vòng lặp trong cùng, không đi qua get()/set() — và cũng là lý do PyTorch/NumPy hiện thực các phép "hot path" (matmul, convolution) bằng kernel C/C++/CUDA cấp thấp thay vì lớp Python/API tiện lợi mà người dùng thấy. Bài học tổng quát: lớp trừu tượng đẹp không miễn phí — nó chỉ đáng đánh đổi khi không nằm trên đường găng hiệu năng.

5. Thực hành: khởi sinh NeuroJS

Toàn bộ engine viết trong bài này được đóng gói vào ai-neuro.js — file DUY NHẤT sẽ được import ở mọi bài học sau của series (Bài 7 thêm autograd, Bài 9 thêm optimizer, Bài 11 thêm Conv2D, Bài 14 thêm attention), không viết lại logic tensor từ đầu lần nào nữa:

Demo A — máy tính broadcast: nhập 2 shape (hoặc bấm nút mẫu), xem shape kết quả (hoặc thông báo lỗi nếu không tương thích), và với shape nhỏ, xem luôn bảng số outer-broadcast để cảm nhận trực tiếp cạm bẫy Mục 3:

Demo B — benchmark matmul sống: chọn cỡ ma trận $n$, bấm chạy để đo trực tiếp trên máy bạn cả hai cách (qua get()/set() và chỉ số phẳng trực tiếp) — số đo có thể khác máy tôi dùng viết bài, nhưng tỉ lệ chênh lệch phải cùng bậc độ lớn:

Đối chiếu công nghiệp: PyTorch dùng đúng khái niệm tensor + shape + stride + broadcasting này (không phải phát minh riêng của bài — đây là chuẩn chung mọi framework), chỉ khác là các phép "hot path" chạy bằng kernel C++/CUDA thay vì JS:

# Doi chieu 1-1 voi ai-neuro.js - cai dat: pytorch.org/get-started/locally
import torch

batch = torch.tensor([[1.,2.,3.],[4.,5.,6.],[7.,8.,9.],[10.,11.,12.]])  # shape (4,3)
bias  = torch.tensor([10.,20.,30.])                                     # shape (3,)
print((batch + bias).shape)       # torch.Size([4, 3]) - broadcasting giong het NeuroJS

col = torch.tensor([[1.],[2.],[3.]])   # shape (3,1)
row = torch.tensor([[10.,20.,30.]])    # shape (1,3)
print((col + row).shape)          # torch.Size([3, 3]) - CUNG cam bay outer-broadcast!
                                   # PyTorch KHONG bao loi o day - giong het NeuroJS

A = torch.tensor([[1.,2.],[3.,4.]])
B = torch.tensor([[5.,6.],[7.,8.]])
print(A @ B)                      # toan tu @ la matmul - ket qua [[19,22],[43,50]]
print(A.T.is_contiguous())        # False - transpose la view, giong het Muc 2

Tóm lược

• ✅ Mọi thứ là tensor: vô hướng → vector → ma trận → tensor bậc cao, phân biệt bởi shape; hiểu shape giải quyết được phần lớn lỗi debug deep learning.
• ✅ Tensor = dữ liệu phẳng + shape + stride; row-major cho công thức stride đơn giản (chiều cuối luôn $=1$); transpose chỉ hoán đổi shape/stride nên là $O(1)$, không đụng dữ liệu gốc.
• ✅ Materialize (contiguous) là $O(n)$ thật sự — chậm hơn transpose gần $200$ lần trên tensor $1$ triệu phần tử; reshape bắt buộc dữ liệu liền mạch, nên ném lỗi rõ ràng thay vì âm thầm sai.
• ✅ Broadcasting căn phải, chiều $1$ tự nhân bản — tiện cho bias+batch, nhưng không hề báo lỗi khi shape sai kiểu $(3,1)$ vs $(1,3)$; verified bằng GD thật: loss cả hai đều giảm, nhưng tham số lệch $16\%$ so với nghiệm đúng.
• ✅ Matmul $O(n^3)$; khoảng cách tốc độ thật không nằm ở "mảng phẳng vs mảng lồng" (chỉ $1{,}1$ lần) mà ở chi phí lớp trừu tượng get()/set() so với chỉ số phẳng trực tiếp ($11{,}5$ lần) — lý do các framework thật viết hot path bằng kernel cấp thấp.
• ✅ NeuroJS khởi sinh (ai-neuro.js): Tensor, add/mul (broadcasting), matmul, transpose/contiguous/reshape — dùng lại nguyên vẹn từ Bài 7 trở đi.