AI Engineer Roadmap: So Sánh Transformers.js và Python SDK trong Tác Vụ Suy Luận (Inference)

Cùng một mô hình trên Hugging Face Hub, hai đường chạy: ONNX trong trình duyệt và PyTorch trên server. Chọn sai đường, bạn hoặc đưa cho người dùng một trang web tải 40 giây rồi treo tab, hoặc trả tiền cho một GPU chỉ để phân loại vài nghìn câu mỗi ngày.

Bài này so sánh Transformers.js với Python SDK ở đúng góc nhìn kỹ thuật: mô hình nào chạy được, kích thước và quantization, độ trễ, bộ nhớ, giới hạn của trình duyệt, và ranh giới quyết định giữa suy luận trên client với suy luận trên server.

Cập nhật 2026

  • transformers Python hiện là 5.22.2 (2026-11-06). Bản 5.0.0 ra ngày 2026-01-26 và chỉ còn PyTorch, một backend tokenizer duy nhất. Các đoạn code cũ dựa vào TensorFlow hoặc JAX không còn chạy trên nhánh này.
  • Transformers.js vẫn là con đường ONNX: model phải được chuyển sang ONNX rồi chạy bằng ONNX Runtime Web (WASM, WebGPU). Không phải mọi model trên Hub đều có bản ONNX tương thích.
  • Gói npm hiện hành là @huggingface/transformers; tên @xenova/transformers trong bài cũ là gói của thế hệ trước — xác nhận lại trên npm trước khi khóa dependency. Bài này không ghim số phiên bản Transformers.js vì nhịp phát hành của nó khác PyPI; hãy đọc changelog trên npm trước khi khóa dependency.
  • Hệ sinh thái phụ trợ: huggingface_hub 2.4.0 (2026-10-29), sentence-transformers 6.2.0. Khi cần phục vụ nhiều request đồng thời, đích đến là vLLM 0.33.0 (yêu cầu CUDA 13.0) hoặc HF Inference Endpoints, không phải vòng lặp pipeline() trần.

Hai runtime, một đồ thị tính toán

Mô hình Transformer là một đồ thị các phép toán tensor cộng với trọng số. Python SDK chạy đồ thị đó qua PyTorch trên CPU hoặc GPU. Transformers.js chạy cùng đồ thị đó nhưng đã được đóng gói thành file ONNX, và thực thi qua ONNX Runtime Web. Hai bên không chia sẻ trọng số thời gian chạy, chỉ chia sẻ kiến trúc và tokenizer.

Hugging Face Hub
   |
   |-- PyTorch weights (.safetensors) --> transformers 5.22.2 --> PyTorch --> CUDA / CPU
   |
   +-- ONNX export (.onnx + tokenizer.json) --> Transformers.js --> ONNX Runtime Web
                                                                     |-- WASM (CPU)
                                                                     +-- WebGPU (GPU)

Hệ quả đầu tiên: kiến trúc mô hình quyết định độ khó chuyển đổi. Các encoder như BERT, RoBERTa, DistilBERT, các mô hình embedding và reranker nhỏ chuyển ONNX tốt vì đồ thị tĩnh, ít tùy biến. Các mô hình generative có attention tùy biến, sliding window, MoE hoặc kernel riêng khó hơn nhiều, và một số không có bản ONNX chạy được trong browser. Đây là lý do Transformers.js mạnh ở embedding, phân loại, NER, zero-shot, chứ không phải ở chat với LLM lớn.

Transformers.js thực chất làm gì

Thư viện tải file ONNX từ Hub (hoặc từ bundle của bạn), khởi tạo session ONNX Runtime Web, rồi chọn backend. Trên CPU, nó dùng WASM, có SIMD và đa luồng nếu trình duyệt cho phép. Trên GPU, nó dùng WebGPU khi trình duyệt và driver hỗ trợ; nếu không, nó rơi về WASM. Toàn bộ việc này chạy trong tab, không có request nào ra server AI.

Model đã tải được trình duyệt cache lại, nên lần truy cập sau không phải tải lại từ Hub. Nhưng cache là cache của trình duyệt: người dùng xóa dữ liệu trang, đổi thiết bị, hoặc dùng chế độ riêng tư thì mất. Bạn phải tính chi phí tải lần đầu vào thiết kế UX, không được giả định nó bằng 0.

Để vừa bộ nhớ, model thường được quantize: int8 hoặc 4-bit. Quantization giảm kích thước và tăng tốc trên CPU, nhưng đổi chất lượng. Với phân loại và embedding, sai lệch thường chấp nhận được; với tác vụ cần phân biệt tinh, hãy đo trên tập eval của bạn thay vì tin vào cảm giác.

Python SDK 5.22.2 làm gì

Python SDK giữ nguyên trọng số gốc, chạy trên PyTorch, và có toàn bộ không gian tối ưu của PyTorch: FP16/BF16, batch lớn, đa GPU, CPU vectorized. Nó cũng là đường duy nhất để fine-tune và để dùng những kiến trúc chưa từng được export ONNX.

Nhưng “dùng transformers trên server” không đồng nghĩa với “viết một API bọc pipeline()“. Với lưu lượng thật, bạn cần continuous batching và PagedAttention — đó là việc của vLLM hoặc SGLang. transformers là thư viện nghiên cứu và tích hợp; nó không phải inference server.

So sánh trên các tiêu chí quyết định

Tiêu chí Transformers.js Python transformers 5.22.2
Nơi chạy Trình duyệt, Node.js Server, máy trạm, cloud
Định dạng ONNX, thường quantized PyTorch gốc
Độ phủ model Tập con đã export ONNX Toàn bộ kiến trúc được hỗ trợ trên Hub
Tăng tốc WASM, WebGPU (không phổ quát) CUDA, ROCm, TPU, batch lớn
Bộ nhớ Giới hạn bởi tab và thiết bị Giới hạn bởi RAM/VRAM bạn mua
Độ trễ Không có round trip mạng, nhưng phụ thuộc máy người dùng Ổn định theo cấu hình, cộng round trip mạng
Riêng tư Dữ liệu không rời thiết bị Dữ liệu phải gửi lên server
Chi phí biên Gần 0 cho mỗi request, trả bằng pin và CPU người dùng Trả tiền GPU, băng thông, vận hành
Fine-tune Không Có

Code tối thiểu cho cùng một việc

Ví dụ dưới đây là embedding và phân loại — hai tác vụ mà cả hai runtime đều làm tốt. Với Python, dùng sentence-transformers 6.2.0 cho embedding vì nó gọn hơn pipeline cho tác vụ này.

Python: embedding có chuẩn hóa

# File: embed.py — chạy trên server, có GPU thì đặt device="cuda"
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("BAAI/bge-m3", device="cuda")

texts = [
    "Hoàn tiền đơn hàng mất bao lâu?",
    "Thời gian xử lý refund là 3 ngày làm việc.",
]

vectors = model.encode(
    texts,
    batch_size=32,
    normalize_embeddings=True,
)

print(vectors.shape)  # (2, 1024) — bge-m3, chuẩn hóa sẵn để dùng dot product

normalize_embeddings=True quan trọng: sau đó cosine similarity và dot product cho cùng thứ tự xếp hạng, nên bạn có thể dùng index dot product nhanh hơn. Đừng trộn vector đã chuẩn hóa với vector chưa chuẩn hóa trong cùng một index.

JavaScript: cùng tác vụ, chạy trong tab

// File: embedding.worker.js — chạy trong Web Worker, không chặn UI
import { pipeline } from "@huggingface/transformers";

let extractor;
async function getExtractor() {
  if (!extractor) {
    extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
      dtype: "q8", // int8: nhỏ hơn, nhanh hơn trên CPU, chất lượng thấp hơn bản fp32
    });
  }
  return extractor;
}

self.onmessage = async (event) => {
  const { texts } = event.data;
  const model = await getExtractor();
  const output = await model(texts, { pooling: "mean", normalize: true });
  self.postMessage({ vectors: output.tolist() });
};

Hai điểm cần chú ý trong đoạn trên. Thứ nhất, model chạy trong Web Worker; nếu chạy trên main thread, mỗi lần suy luận sẽ chặn scroll và input, và người dùng sẽ thấy trang “đứng”. Thứ hai, dtype quyết định dung lượng tải và chất lượng; hãy thử q8 và fp32 trên cùng một tập kiểm tra trước khi chọn.

Với phân loại, API tương tự: pipeline("sentiment-analysis") trả về nhãn và score. Nhưng đừng hard-code ngưỡng tin cậy từ ví dụ trên mạng; đo phân bố score trên dữ liệu thật của bạn.

Giới hạn thật của phía trình duyệt

Độ phủ model, không phải “mọi model đều chạy”

ONNX Runtime Web chỉ chạy được các operator mà nó hỗ trợ. Một model có custom op, dynamic shape phức tạp hoặc kiến trúc mới có thể export được nhưng không chạy, hoặc chạy chậm bất thường. Trước khi hứa với team sản phẩm, hãy kiểm tra bản ONNX tồn tại và chạy thử trên đúng model đó.

Kích thước và bộ nhớ

Model ONNX và tokenizer phải nằm trong bộ nhớ của tab khi chạy. Trình duyệt không cấp cho bạn VRAM tùy ý, và trên mobile, tab nền có thể bị hệ điều hành thu hồi. Model phân loại nhỏ thì nhẹ; model embedding lớn, reranker, hoặc bất kỳ LLM generative nào đều nhanh chóng vượt ngân sách bộ nhớ của một trang web. Quy tắc thực dụng: nếu model không chạy thoải mái trên một laptop 8 GB RAM, đừng đưa nó vào browser.

Tải lần đầu và cache

Người dùng đầu tiên trên một thiết bị mới phải tải toàn bộ trọng số. Với mạng di động, đây là vài giây đến vài chục giây tùy kích thước model và băng thông. Hãy tải trước khi cần, hiển thị tiến trình, và có đường lui (ví dụ gọi API server) nếu tải thất bại. Đừng làm feature chính của trang phụ thuộc vào một tải xuống không kiểm soát.

WebGPU không phải bảo đảm

WebGPU đã có trên các trình duyệt mới nhưng không đồng đều giữa thiết bị, driver và hệ điều hành. Cùng một model có thể chạy bằng WebGPU trên máy này và rơi về WASM trên máy khác, với độ trễ khác nhau vài lần. Nếu UI của bạn cần phản hồi dưới một ngưỡng, hãy thiết kế theo trường hợp xấu nhất, và đo trên thiết bị thật thay vì laptop của dev.

Không có bí mật trong bundle

Mọi thứ chạy trên client đều có thể đọc: prompt, logic lọc, danh sách nhãn, ngưỡng. Nếu logic đó là tài sản hoặc là biện pháp kiểm soát, nó phải ở server. Transformers.js phù hợp cho suy luận, không phù hợp để giấu quyết định nghiệp vụ.

Lỗi thường gặp và cách sửa

  • Chạy model trên main thread. Trang treo trong lúc suy luận. Sửa: đặt toàn bộ pipeline trong Worker, truyền text qua postMessage.
  • Dùng model fp32 rồi than chậm. Tải nặng, RAM cao. Sửa: thử q8 trước, đo chất lượng, chỉ nâng lên fp16/fp32 khi eval yêu cầu.
  • Giả định mọi model Hub đều có ONNX. Sửa: kiểm tra repo có file ONNX và chạy smoke test trong CI.
  • Bọc pipeline() trong FastAPI rồi gọi là “inference server”. Không có batching, không có queue, sập dưới tải đồng thời. Sửa: dùng vLLM/SGLang, hoặc chấp nhận một hàng đợi có giới hạn và timeout rõ ràng.
  • Trộn vector từ hai runtime/model khác nhau. Không gian vector khác nhau, khoảng cách vô nghĩa. Sửa: một cột model trong schema và một index cho mỗi model.
  • Đo độ trễ trên mạng LAN. Sửa: đo bằng Network throttling và trên thiết bị tầng trung, không chỉ máy dev.

Khi nào chọn cái nào

Bài toán Chọn Lý do
Gợi ý tag, phân loại cảm xúc, kiểm tra chính tả ngay khi gõ Transformers.js Model nhỏ, phản hồi tức thời, không round trip
Dữ liệu nhạy cảm không được rời thiết bị Transformers.js Không có đường ra mạng
Ứng dụng phải chạy offline Transformers.js + service worker Model đã cache, không phụ thuộc server
Embedding toàn bộ kho tài liệu Python, batch trên GPU Khối lượng lớn, cần ổn định và tái lập
Rerank 50–100 ứng viên mỗi query Python trên server Cross-encoder nặng, cần GPU và latency ổn định
Fine-tune hoặc đánh giá model mới Python Transformers.js không huấn luyện
API dùng chung cho web, mobile, đối tác Python + vLLM/Endpoints Một nguồn sự thật, dễ version và đo

Mô hình lai thường là câu trả lời đúng: Transformers.js xử lý bước nhẹ và nhạy cảm trên client, Python xử lý bước nặng và cần tính tái lập trên server. Ví dụ, browser chuẩn hóa và lọc PII cục bộ trước khi gửi phần còn lại lên API embedding. Bạn giảm dữ liệu rời máy, giảm tải server, mà vẫn giữ được chất lượng của model lớn.

Nhìn tới 2027

Hai xu hướng đang chạy song song. Thứ nhất, WebGPU và các backend ONNX ngày càng phổ biến, làm biên giới “model nào đủ nhẹ cho browser” dịch lên. Thứ hai, các mô hình embedding và reranker nhỏ đang được tối ưu riêng cho edge, nên khoảng cách chất lượng giữa bản quantized và bản server thu hẹp ở các tác vụ hẹp. Điều không đổi: model generative lớn vẫn thuộc về server, và quyết định vẫn phải dựa trên số đo trên thiết bị thật.

Checklist trước khi chốt

  • Xác nhận model có bản ONNX chạy được, không chỉ có trên lý thuyết.
  • Đo kích thước tải lần đầu và độ trễ trên thiết bị tầng trung, có throttle mạng.
  • Chạy pipeline trong Worker và có fallback khi WebGPU không khả dụng.
  • So sánh q8 với fp32 trên tập eval của bạn, ghi lại chênh lệch chất lượng.
  • Ghim phiên bản Python (transformers==5.22.2, sentence-transformers==6.2.0) và khóa lockfile npm.
  • Nếu cần phục vụ đồng thời, thiết kế cho vLLM/SGLang ngay từ đầu thay vì độ lại sau.

Đọc tiếp trong series