Sử dụng model pretrained

Mô hình có sẵn gồm những gì?

Lập trình thi đấu có kiểu lời giải “đánh bảng”: chương trình chỉ tra một bảng đã tính sẵn ở nhà, còn phần khó nằm trong bảng. Thiếu bảng, code vẫn biên dịch nhưng không trả lời đúng được câu nào. Với mạng neural, kiến trúc là phần code, mô tả các phép toán; trọng số là cái bảng, tức kết quả đã học. nn.Linear(2, 3) vừa tạo ra ba phép cộng có trọng số từ hai đầu vào, nhưng những trọng số ngẫu nhiên ấy chưa biết phân loại gì.

Model pretrained là mô hình có trọng số đã được học từ một nhiệm vụ trước đó. Nhiệm vụ trước có thể là phân loại ảnh, dự đoán token bị che hoặc ghép ảnh với mô tả. Nó không nhất thiết trùng với nhiệm vụ của ta. Không có pretrained thì trọng số bắt đầu ngẫu nhiên như bài 3.3; có thì bắt đầu từ chỗ đã học.

Vì sao trọng số học cho nhiệm vụ khác lại có ích? Để phân biệt hơn một triệu ảnh thuộc 1000 lớp của ImageNet, mạng buộc phải học những đặc trưng mà ảnh nào cũng có: cạnh, kết cấu, hình dạng, bộ phận của vật thể. Các tầng sâu dần ghép đặc trưng đơn giản thành đặc trưng phức tạp, và phần lớn chúng không gắn với một lớp cụ thể nào. ImageNet không có lớp “thi đấu” hay “bài giảng”, nhưng ảnh câu lạc bộ vẫn có cạnh, kết cấu, bàn ghế, màn hình, máy chiếu. Chỉ tầng cuối, gọi là head, gắn chặt với 1000 lớp cũ.

Một gói có thể dùng lại cần nhiều thứ đi cùng nhau:

• Trọng số: kết quả đã học.
• Cấu hình: số lớp và kích thước các tầng.
• Processor: cách xử lý đầu vào như resize, thứ tự kênh màu, chuẩn hóa, hoặc tokenizer với chữ.
• Bảng nhãn: chỉ số 0, 1, 2… nghĩa là gì.
• Revision: đúng phiên bản đã tải.

Nếu dùng trọng số của phiên bản này với tokenizer của phiên bản khác, chương trình có thể vẫn chạy nhưng đầu vào đã đổi ý nghĩa.

Với ảnh, đầu vào thường có shape (B, C, H, W): $B$ là số ảnh trong batch, $C$ là số kênh, $H$ và $W$ là chiều cao và rộng. Với chữ, tokenizer thường tạo input_ids và attention_mask có shape (B, L), trong đó $L$ là độ dài đã padding. Cùng là float32 không có nghĩa cùng thang đo.

Processor của các model ảnh huấn luyện trên ImageNet thường chia pixel cho 255, rồi chuẩn hóa từng kênh bằng mean $(0.485, 0.456, 0.406)$ và std $(0.229, 0.224, 0.225)$ của tập ấy. Có processor nhận pixel từ 0 đến 255 và tự chia, có processor nhận ảnh đã chia sẵn. Làm một bước hai lần, hoặc bỏ sót một lần, đều đổi dữ liệu mà không gây lỗi nào.

Trong torchvision, transforms.ToTensor() đổi ảnh PIL $(H, W, 3)$ giá trị 0-255 thành tensor float $(3, H, W)$ trong $[0, 1]$; Normalize làm việc trên tensor nên đứng sau nó, như Compose([Resize(...), ToTensor(), Normalize(mean, std)]).

Thử cơ chế bằng một gói nhỏ chạy offline

Trước khi đụng tới một checkpoint cỡ hàng chục đến hàng trăm MiB, ta đi hết đường dữ liệu trên một gói đủ nhỏ để tính tay. Mỗi mẫu có hai đặc trưng thay cho một ảnh, mạng là nn.Linear(2, 3) với trọng số đặt sẵn, đầu ra là ba nhãn hoạt động. Gói này đóng vai checkpoint mà một nhóm khác đã công bố.

Các bước lưu, nạp, tiền xử lý và suy luận giống hệt với model thật, chỉ khác kích thước; vì mọi số đều tính tay được, sai ở bước nào sẽ lộ ngay ở bước ấy.

state_dict là ánh xạ từ tên tham số hoặc buffer đến tensor. Ta lưu thêm các số của processor và bảng nhãn trong cùng gói. BytesIO đóng vai một tệp trong bộ nhớ; với tệp thật, chỉ cần thay bằng đường dẫn .pt.

import io
import numpy as np
import torch
from torch import nn

torch.set_num_threads(1)
torch.manual_seed(0)
source = nn.Linear(2, 3)
with torch.no_grad():
    source.weight.copy_(torch.tensor([[1., -1.], [-1., 1.], [.5, .5]]))
    source.bias.copy_(torch.tensor([0., 0., .25]))

package = {
    "state_dict": source.state_dict(),
    "mean": torch.tensor([10., 10.]),
    "scale": torch.tensor([2., 2.]),
    "labels": ["hoat_dong_A", "hoat_dong_B", "chua_ro"],
}
buffer = io.BytesIO()
torch.save(package, buffer)
buffer.seek(0)
loaded = torch.load(buffer, map_location="cpu", weights_only=True)

model = nn.Linear(2, 3)
model.load_state_dict(loaded["state_dict"], strict=True)
model.eval()
print("shape W:", tuple(model.weight.shape))
print("nhan:", loaded["labels"])

Kết quảshape W: (3, 2)
nhan: ['hoat_dong_A', 'hoat_dong_B', 'chua_ro']

Ba tham số khi nạp:

• strict=True phát hiện tên hoặc shape tham số không khớp, thay vì âm thầm bỏ một tầng.
• map_location="cpu" mở tensor đã được lưu ở thiết bị khác lên CPU.
• weights_only=True, mặc định từ PyTorch 2.6, chỉ mở tensor và kiểu dữ liệu đơn giản như số, chuỗi, list, dict; nó không chạy code tùy ý có thể nằm trong file pickle. Vì vậy gói nên chứa state_dict cùng các số và chuỗi, không chứa cả đối tượng model.

Nạp được cũng chưa có nghĩa là đúng tệp: nguồn và hash vẫn phải kiểm, như ở mục cuối bài.

Ta viết processor thành hàm riêng. Với $\mathbf{x}=(12,8)$, trừ $(10,10)$ rồi chia $(2,2)$ cho $\mathbf{z}=(1,-1)$. Mạng tính

$\boldsymbol{\ell}$ là vector logits, chưa phải xác suất. Softmax không đổi thứ tự các logits, nên argmax trước hay sau softmax như nhau; softmax chỉ cần khi muốn xác suất, chẳng hạn để nộp xác suất hoặc đặt ngưỡng. Logit lớn nhất nằm ở chỉ số 0, và bảng nhãn đổi chỉ số ấy thành tên.

def process(raw):
    raw_tensor = torch.as_tensor(raw, dtype=torch.float32)
    return (raw_tensor - loaded["mean"]) / loaded["scale"]

raw = np.array([[12., 8.], [8., 12.], [10., 10.], [14., 6.], [9., 11.]])
with torch.inference_mode():
    logits = model(process(raw))
    predicted = logits.argmax(dim=1)
print(logits.numpy().round(2))
print([loaded["labels"][i] for i in predicted.tolist()])

Kết quả[[ 2.   -2.    0.25]
 [-2.    2.    0.25]
 [ 0.    0.    0.25]
 [ 4.   -4.    0.25]
 [-1.    1.    0.25]]
['hoat_dong_A', 'hoat_dong_B', 'chua_ro', 'hoat_dong_A', 'hoat_dong_B']

Hàng đầu đúng bằng $(2,-2,0.25)$ như tính tay. Hàng thứ ba có hai đặc trưng bằng trung bình nên thành $(0,0)$ sau processor; chỉ còn bias, và lớp chua_ro thắng. Với checkpoint thật không ai tính tay được toàn bộ logits, nhưng cách kiểm vẫn như vậy: shape phải là (số mẫu, số lớp), vài mẫu đã biết đáp án phải ra đúng, và một đường tính độc lập phải khớp (mục sau).

Batch phải giữ nguyên ý nghĩa và thứ tự

Một batch là nhiều mẫu được tính chung để tận dụng phép toán ma trận. Nó không phải một mẫu mới được tạo bằng cách trộn các ảnh. Batch size đổi lượng công việc mỗi lần gọi, còn thứ tự đầu ra phải khớp với thứ tự đầu vào.

Ở chế độ suy luận, mạng tuyến tính này cho cùng đáp án với mọi cách chia batch. Ta kiểm với cả kết quả chạy một lần và một bản NumPy độc lập; kiểm thứ hai giúp bắt lỗi chuyển vị ma trận, không chỉ lỗi ghép batch.

def infer_batches(raw, batch_size):
    rows = []
    with torch.inference_mode():
        for start in range(0, len(raw), batch_size):
            rows.append(model(process(raw[start:start + batch_size])))
    return torch.cat(rows, dim=0)

batched = infer_batches(raw, batch_size=2)
z_numpy = (raw - np.array([10., 10.])) / np.array([2., 2.])
W_numpy = np.array([[1., -1.], [-1., 1.], [.5, .5]])
expected = z_numpy @ W_numpy.T + np.array([0., 0., .25])
print("batch khop:", torch.allclose(batched, logits))
print("NumPy khop:", np.allclose(batched.numpy(), expected))
print("so mau:", len(batched))

Kết quảbatch khop: True
NumPy khop: True
so mau: 5

Ba dòng cần lần lượt xác nhận cách chia batch, phép toán và số mẫu. Với dữ liệu thật, còn phải giữ id cùng mỗi hàng. Nếu DataLoader shuffle rồi ghi kết quả theo thứ tự CSV ban đầu, mọi tensor đều đúng shape mà file nộp vẫn sai.

model.eval() và torch.inference_mode() giải quyết hai việc:

• eval() đặt các tầng như Dropout và BatchNorm vào chế độ đánh giá; nó không tắt autograd.
• inference_mode() bỏ theo dõi gradient để suy luận gọn hơn, giống no_grad() nhưng chặt hơn; nó không tự gọi eval().

Tensor tạo trong inference_mode() không dùng được cho phép tính cần backward; nếu sau đó muốn học một head trên embedding (bài 4.2), lưu embedding thành mảng NumPy hoặc .clone() ra tensor thường trước.

Mạng ảnh pretrained thường có BatchNorm, và đó là thêm một lý do để gọi eval(). Ở chế độ train, BatchNorm chuẩn hóa mỗi mẫu bằng mean và variance của chính batch chứa nó, nên đầu ra của một ảnh phụ thuộc những ảnh đi cùng. Ở chế độ eval, nó dùng running statistics đã lưu trong checkpoint, và mọi cách chia batch lại cho cùng kết quả như mạng tuyến tính ở trên.

Ước lượng bộ nhớ trước khi chạy

Nếu mô hình có $P$ tham số, mỗi tham số chiếm $s$ byte, bộ nhớ thô của trọng số là $Ps$. float32 dùng 4 byte, float16 dùng 2 byte. MiB là $2^{20}$ byte; đừng lẫn với MB là $10^6$ byte. Một mô hình 100 triệu tham số có phần trọng số float32 khoảng 381.47 MiB, hoặc float16 khoảng 190.73 MiB.

Kích thước ảnh cũng đổi ra số được. Ảnh $1920 \times 1080$ có 1920 điểm ảnh theo chiều ngang, 1080 theo chiều dọc. Ảnh RGB $32 \times 32$ có $32 \cdot 32 \cdot 3 = 3072$ số; ảnh $100 \times 100$ lưu 1 byte mỗi kênh là 30 000 byte. Số điểm ảnh tăng theo bình phương cạnh: thu $4000 \times 3000$ về $400 \times 300$ bớt 100 lần số pixel, giảm $640 \times 640$ về $320 \times 320$ bớt khoảng 4 lần khối tính của mạng tích chập.

P = 100_000_000
print("FP32 MiB:", round(P * 4 / 2**20, 2))
print("FP16 MiB:", round(P * 2 / 2**20, 2))
input_bytes = 16 * 3 * 224 * 224 * 4
print("input batch MiB:", round(input_bytes / 2**20, 2))
actual_bytes = sum(p.numel() * p.element_size() for p in model.parameters())
print("mang tuyen tinh bytes:", actual_bytes)

Kết quảFP32 MiB: 381.47
FP16 MiB: 190.73
input batch MiB: 9.19
mang tuyen tinh bytes: 36

Mạng nhỏ có $3\cdot2+3=9$ tham số, mỗi số 4 byte, nên 36 byte. Input batch 16 ảnh RGB cỡ $224\times224$ là một phần khác: $16\cdot3\cdot224\cdot224\cdot4$ byte, khoảng 9.19 MiB. Khi chạy còn có activation trung gian, buffer, vùng làm việc của thư viện và bộ nhớ dự trữ.

Input và phần lớn activation của mạng tích chập tăng tỉ lệ với $B\cdot H\cdot W$, nên gấp đôi cạnh ảnh tốn ngang gấp bốn batch. Khi training còn có gradient và trạng thái optimizer. Vì vậy “trọng số vừa bộ nhớ” chưa đủ để kết luận “batch này chạy được”. Cách chắc chắn là đo một batch nhỏ trên đúng thiết bị rồi tăng dần.

Dùng model pretrained thật

Với bộ tìm kiếm của câu lạc bộ, việc đầu tiên là đọc model card: model học trên dữ liệu gì, nhận input nào, xuất ra nhãn nào, license cho phép dùng ra sao. Model chỉ học tiếng Anh sẽ yếu với chú thích tiếng Việt. Head phân loại ImageNet chỉ chọn trong 1000 lớp cũ, không tự biến thành head “sinh hoạt”, “thi đấu”, “bài giảng” của câu lạc bộ. Phần dùng lại được là các tầng bên dưới: bài 4.2 lấy đặc trưng từ đó, bài 4.3 học head mới.

Script của chương làm việc này theo hai lượt:

1. Lượt có mạng (download_assets.py --download) tải đúng một revision, tức một commit 40 ký tự hex chứ không phải nhánh main có thể đổi, rồi ghi model ID, license đã đọc, kích thước và SHA-256 của từng tệp vào ASSET.json.
2. Lượt offline kiểm lại mọi hash, đặt HF_HUB_OFFLINE=1, nạp model cùng tokenizer hoặc processor từ đường dẫn local với local_files_only=True, chạy dữ liệu nhỏ của mình và ghi môi trường cùng kết quả vào RESULT.json.

Đọc kết quả theo thứ tự: hash khớp thì tệp đúng; shape và ID khớp thì đường dữ liệu đúng; chỉ khi đó điểm validation mới nói về chất lượng của model trên bài.