Hàm mất mát cho phân loại: cross-entropy, class weight, focal loss
Cross-entropy và dữ liệu ít ảnh NG: thí nghiệm thật so sánh trọng số lớp, WeightedRandomSampler, focal loss trên 3 seed, chọn ngưỡng trên validation.
Học xong bài này, bạn sẽ
- Hiểu softmax, cross-entropy và vì sao mô hình học 'luôn OK'
- Dùng trọng số lớp, WeightedRandomSampler, focal loss
- Chọn ngưỡng trên validation, kiểm tra nhiều seed
Nên học trước: Overfitting và chia train/val/test
Nội dung bài viết
Mạng nơ-ron học bằng cách giảm dần một con số gọi là loss (hàm mất mát). Chọn sai loss, mô hình vẫn "học" rất chăm chỉ nhưng học sai điều bạn cần. Trong bài toán kiểm tra lỗi, sai lầm kinh điển là: dữ liệu có 95% ảnh OK, mô hình học được cách luôn trả lời OK, loss rất thấp, còn ảnh NG thì lọt hết. Bài này giải thích softmax, cross-entropy, và hai cách xử lý dữ liệu mất cân bằng: trọng số lớp và focal loss.
Nên đọc trước: PyTorch cơ bản: tensor, autograd và gradient descent từ đầu với NumPy.
1. Softmax: biến điểm số thành xác suất
Lớp cuối của mạng phân loại xuất ra các con số thô gọi là logits, mỗi lớp một số, có thể âm hoặc dương tùy ý. Softmax biến chúng thành xác suất: lấy exp từng số rồi chia cho tổng.
import numpy as np
def softmax(z):
z = z - z.max() # trừ max để tránh tràn số exp
e = np.exp(z)
return e / e.sum()
logits = np.array([2.0, 0.5, -1.0]) # đầu ra thô của mạng: OK, trầy xước, móp
p = softmax(logits)
print("xác suất:", p.round(3), "tổng =", p.sum().round(3))
for nhan in range(3):
print(f"nhãn đúng = {nhan}: loss = {-np.log(p[nhan]):.3f}")
xác suất: [0.786 0.175 0.039] tổng = 1.0
nhãn đúng = 0: loss = 0.241
nhãn đúng = 1: loss = 1.741
nhãn đúng = 2: loss = 3.241
Dòng z - z.max() không làm thay đổi kết quả (softmax không đổi khi cộng cùng một hằng số vào mọi logit) nhưng tránh được exp(1000) tràn số.
2. Cross-entropy: phạt theo xác suất của nhãn đúng
Cross-entropy cho một mẫu rất đơn giản: loss = −log(xác suất mô hình gán cho nhãn đúng). Ở ví dụ trên, nếu ảnh thật sự là OK (nhãn 0), mô hình gán 78,6% nên loss nhỏ (0,241). Nếu ảnh thật sự bị móp (nhãn 2), mô hình chỉ gán 3,9% nên bị phạt nặng (3,241).
Trong PyTorch, nn.CrossEntropyLoss nhận thẳng logits, tự tính softmax và log bên trong:
import torch
import torch.nn as nn
import torch.nn.functional as F
logits_t = torch.tensor([[2.0, 0.5, -1.0]])
nhan_t = torch.tensor([1]) # nhãn đúng: trầy xước
print(f"nn.CrossEntropyLoss: {nn.CrossEntropyLoss()(logits_t, nhan_t).item():.3f}")
nn.CrossEntropyLoss: 1.741
Khớp với kết quả tự tính 1,741.
nn.Softmax ở cuối mô hình rồi đưa vào nn.CrossEntropyLoss. Hàm loss đã tự làm softmax; áp thêm một lần nữa khiến gradient yếu đi và mô hình học rất chậm. Chỉ dùng torch.softmax khi suy luận, để đọc xác suất.Vì sao dùng log?
Hãy xem loss tăng thế nào khi mô hình càng sai:
for p_dung in [0.9, 0.6, 0.3, 0.05]:
print(f"p_dung = {p_dung:4}: loss = {-np.log(p_dung):.3f}")
p_dung = 0.9: loss = 0.105
p_dung = 0.6: loss = 0.511
p_dung = 0.3: loss = 1.204
p_dung = 0.05: loss = 2.996
Đoán đúng với 90% chắc chắn gần như không bị phạt; tự tin sai (chỉ 5% cho nhãn đúng) bị phạt gấp gần 30 lần. Loss tiến tới vô cùng khi xác suất nhãn đúng tiến về 0, nên mô hình bị "ép" không được tự tin sai.
3. Vấn đề dữ liệu mất cân bằng
Dữ liệu nhà máy thường có rất ít ảnh NG. Hãy xem một "mô hình lười" luôn tự tin trả lời OK trên 950 ảnh OK và 50 ảnh NG:
# 1000 mẫu: 950 OK (nhãn 0), 50 NG (nhãn 1)
nhan = torch.cat([torch.zeros(950, dtype=torch.long), torch.ones(50, dtype=torch.long)])
# Mô hình "lười": luôn tự tin rằng mọi thứ đều OK
logits_luoi = torch.tensor([[3.0, -3.0]]).repeat(1000, 1)
ce = nn.CrossEntropyLoss()
print(f"loss trung bình: {ce(logits_luoi, nhan).item():.3f}")
print(f"loss trên mẫu OK: {ce(logits_luoi[:950], nhan[:950]).item():.3f}")
print(f"loss trên mẫu NG: {ce(logits_luoi[950:], nhan[950:]).item():.3f}")
loss trung bình: 0.302
loss trên mẫu OK: 0.002
loss trên mẫu NG: 6.002
Mỗi ảnh NG bị phạt rất nặng (6,0), nhưng vì chỉ chiếm 5% nên loss trung bình vẫn thấp (0,30). Mô hình thật trong quá trình huấn luyện dễ mắc kẹt ở trạng thái này: accuracy 95%, loss nhỏ, nhưng không phát hiện được lỗi nào.
4. Cách 1: trọng số lớp (class weight)
Ý tưởng: mỗi mẫu NG được tính nặng hơn. Công thức phổ biến (giống class_weight="balanced" trong scikit-learn): trọng số = tổng số mẫu / (số lớp × số mẫu của lớp).
so_mau = torch.tensor([950.0, 50.0])
trong_so = so_mau.sum() / (2 * so_mau) # cùng công thức "balanced" của scikit-learn
print("trọng số lớp:", trong_so)
ce_w = nn.CrossEntropyLoss(weight=trong_so)
print(f"loss có trọng số: {ce_w(logits_luoi, nhan).item():.3f}")
trọng số lớp: tensor([ 0.5263, 10.0000])
loss có trọng số: 3.002
Lúc này 50 ảnh NG có tổng trọng số (50 × 10 = 500) bằng 950 ảnh OK (950 × 0,526 ≈ 500). Loss của mô hình lười tăng từ 0,30 lên 3,0, đủ để buộc mô hình phải học nhận ra NG. Lưu ý: khi có weight, PyTorch chia cho tổng trọng số chứ không chia cho số mẫu.
Một cách tương đương là lấy mẫu lại (oversampling): dùng torch.utils.data.WeightedRandomSampler để ảnh NG xuất hiện thường xuyên hơn trong mỗi epoch. Hai cách cho hiệu quả tương tự; đừng dùng cả hai cùng lúc với trọng số đầy đủ, vì sẽ bù quá tay.
5. Cách 2: focal loss
Focal loss được giới thiệu trong bài báo RetinaNet (Lin và cộng sự, 2017) cho object detection, nơi số vùng nền áp đảo số vùng có vật. Ý tưởng: nhân cross-entropy với hệ số (1 − p_t)^γ, trong đó p_t là xác suất của nhãn đúng.
- Mẫu dễ (mô hình đã chắc,
p_tgần 1): hệ số gần 0, gần như không đóng góp vào loss. - Mẫu khó (mô hình phân vân hoặc sai): hệ số lớn, giữ lại phần lớn loss.
Với γ = 0, focal loss chính là cross-entropy. PyTorch không có sẵn focal loss nhiều lớp trong torch.nn, nhưng tự viết rất ngắn:
def focal_loss(logits, nhan, gamma=2.0, alpha=None):
"""Focal loss nhiều lớp: (1 - p_t)^gamma * cross-entropy."""
log_p = F.log_softmax(logits, dim=1)
log_pt = log_p.gather(1, nhan.unsqueeze(1)).squeeze(1) # log xác suất của nhãn đúng
pt = log_pt.exp()
loss = -((1 - pt) ** gamma) * log_pt
if alpha is not None: # trọng số theo lớp (tùy chọn)
loss = alpha[nhan] * loss
return loss.mean()
de = torch.tensor([[4.0, -4.0]]) # mẫu dễ: OK, mô hình rất chắc (p_t ≈ 0.9997)
kho = torch.tensor([[0.2, 0.0]]) # mẫu khó: OK nhưng mô hình phân vân (p_t ≈ 0.55)
nhan_ok = torch.tensor([0])
for ten, lg in [("dễ", de), ("khó", kho)]:
ce_v = F.cross_entropy(lg, nhan_ok).item()
fl_v = focal_loss(lg, nhan_ok).item()
print(f"mẫu {ten:3}: CE = {ce_v:.2e} focal = {fl_v:.2e} giảm {ce_v / fl_v:.0f} lần")
mẫu dễ : CE = 3.35e-04 focal = 3.77e-11 giảm 8892837 lần
mẫu khó: CE = 5.98e-01 focal = 1.21e-01 giảm 5 lần
Mẫu dễ bị giảm hàng triệu lần, mẫu khó chỉ giảm 5 lần. Hàng nghìn ảnh OK "dễ" không còn lấn át gradient; mô hình dồn sức vào các ảnh khó, thường chính là ảnh NG và ảnh OK trông giống NG.
Với bài toán nhị phân dùng sigmoid (một đầu ra), torchvision có sẵn torchvision.ops.sigmoid_focal_loss với mặc định alpha=0.25, gamma=2, đúng cấu hình dùng trong RetinaNet.
6. Thí nghiệm: huấn luyện thật trên dữ liệu 95/5
Các con số ở trên chỉ là loss của một "mô hình lười" tưởng tượng. Câu hỏi thực tế là: khi huấn luyện một CNN trên dữ liệu mất cân bằng, mỗi cách xử lý cho ra mô hình thế nào? Thí nghiệm dưới đây tạo ảnh bề mặt kim loại 32 × 32 có vân gia công hướng ngẫu nhiên; ảnh NG có thêm một vết tối nhỏ, mờ (độ sâu 0,12–0,25 trên nền 0,5, bán kính 1,5–3 px). Ba tập riêng: train 2000 ảnh (100 NG), validation 1000 ảnh (50 NG) để chọn ngưỡng, test 2000 ảnh (100 NG) chỉ để báo cáo, đúng quy tắc của bài overfitting và chia train/val/test.
import numpy as np
from torch.utils.data import DataLoader, TensorDataset, WeightedRandomSampler
torch.set_num_threads(4)
def tao_anh(n_ok, n_ng, hat):
"""Ảnh 32×32 bề mặt kim loại: vân ngẫu nhiên; NG có một vết tối nhỏ, mờ, vị trí ngẫu nhiên."""
g = np.random.default_rng(hat)
n = n_ok + n_ng
yy, xx = np.mgrid[0:32, 0:32]
anh = 0.5 + 0.08 * g.standard_normal((n, 32, 32))
goc = g.uniform(0, np.pi, n)[:, None, None] # vân gia công, hướng ngẫu nhiên
anh += 0.06 * np.sin(0.9 * (xx * np.cos(goc) + yy * np.sin(goc)))
nhan = np.r_[np.zeros(n_ok), np.ones(n_ng)].astype(np.int64)
for i in np.nonzero(nhan)[0]:
cx, cy, r = g.uniform(6, 26), g.uniform(6, 26), g.uniform(1.5, 3.0)
anh[i] -= g.uniform(0.12, 0.25) * np.exp(-((xx - cx) ** 2 + (yy - cy) ** 2) / (2 * r ** 2))
return torch.tensor(anh[:, None], dtype=torch.float32), torch.tensor(nhan)
X_tr, y_tr = tao_anh(1900, 100, 1) # train: 95% OK, 5% NG
X_va, y_va = tao_anh(950, 50, 2) # validation: chọn ngưỡng
X_te, y_te = tao_anh(1900, 100, 3) # test: chỉ dùng để báo cáo
def tao_mo_hinh():
return nn.Sequential(
nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),
nn.Conv2d(32, 32, 3, padding=1), nn.ReLU(), nn.AdaptiveMaxPool2d(1), nn.Flatten(),
nn.Linear(32, 2))
def huan_luyen(ham_loss, sampler=False, epoch=40, hat=0):
"""Huấn luyện một mô hình; trả về xác suất NG trên validation và test."""
torch.manual_seed(hat)
mo_hinh = tao_mo_hinh()
opt = torch.optim.Adam(mo_hinh.parameters(), lr=2e-3)
ds = TensorDataset(X_tr, y_tr)
gen = torch.Generator().manual_seed(hat)
if sampler:
w_mau = torch.where(y_tr == 1, 1.0 / 100, 1.0 / 1900) # rút mỗi lớp với xác suất ngang nhau
loader = DataLoader(ds, batch_size=64, sampler=WeightedRandomSampler(w_mau, len(ds), generator=gen))
else:
loader = DataLoader(ds, batch_size=64, shuffle=True, generator=gen)
for _ in range(epoch):
mo_hinh.train()
for xb, yb in loader:
loss = ham_loss(mo_hinh(xb), yb)
opt.zero_grad()
loss.backward()
opt.step()
mo_hinh.eval()
with torch.no_grad():
return [torch.softmax(mo_hinh(X), dim=1)[:, 1].numpy() for X in (X_va, X_te)]
def recall_overkill(p_ng, nhan, nguong):
bao_ng = p_ng >= nguong
return bao_ng[nhan == 1].mean(), bao_ng[nhan == 0].mean()
print("train:", tuple(X_tr.shape), "NG:", int(y_tr.sum()), "| val NG:", int(y_va.sum()), "| test NG:", int(y_te.sum()))
train: (2000, 1, 32, 32) NG: 100 | val NG: 50 | test NG: 100
Mỗi cấu hình được huấn luyện với 3 seed khác nhau (khởi tạo trọng số và thứ tự batch). Với mỗi lần chạy ta báo cáo hai cách đặt ngưỡng: ngưỡng mặc định 0,5, và ngưỡng chọn trên validation sao cho 99% ảnh OK nằm dưới ngưỡng (overkill mục tiêu khoảng 1%). Cột cuối là trung vị xác suất NG mà mô hình gán cho ảnh NG và ảnh OK của tập test: nếu hai số gần bằng nhau, mô hình chưa học được gì. Toàn bộ khối mất khoảng 5 phút trên CPU.
nhan_va, nhan_te = y_va.numpy(), y_te.numpy()
trong_so = torch.tensor([2000 / (2 * 1900), 2000 / (2 * 100)]) # công thức "balanced" ở mục 4
cau_hinh = [
("CE thường", lambda lg, y: F.cross_entropy(lg, y), False),
("CE + trọng số lớp", lambda lg, y: F.cross_entropy(lg, y, weight=trong_so), False),
("CE + WeightedRandomSampler", lambda lg, y: F.cross_entropy(lg, y), True),
("Focal γ=2", lambda lg, y: focal_loss(lg, y), False),
("Focal γ=2 + α", lambda lg, y: focal_loss(lg, y, alpha=trong_so), False),
]
print("cấu hình seed | ngưỡng 0,5: recall overkill | ngưỡng val: giá trị recall overkill | p_NG trung vị NG/OK")
for ten, ham, dung_sampler in cau_hinh:
for hat in range(3):
p_va, p_te = huan_luyen(ham, dung_sampler, hat=hat)
r05, o05 = recall_overkill(p_te, nhan_te, 0.5)
nguong = float(np.quantile(p_va[nhan_va == 0], 0.99))
r, o = recall_overkill(p_te, nhan_te, nguong)
print(f"{ten:28s} {hat} | {100 * r05:5.1f}% {100 * o05:6.2f}% |"
f" {nguong:.3f} {100 * r:5.1f}% {100 * o:6.2f}% |"
f" {np.median(p_te[nhan_te == 1]):.3f}/{np.median(p_te[nhan_te == 0]):.3f}")
cấu hình seed | ngưỡng 0,5: recall overkill | ngưỡng val: giá trị recall overkill | p_NG trung vị NG/OK
CE thường 0 | 0.0% 0.00% | 0.048 4.0% 0.74% | 0.044/0.043
CE thường 1 | 0.0% 0.00% | 0.058 6.0% 2.05% | 0.055/0.054
CE thường 2 | 0.0% 0.00% | 0.056 7.0% 1.16% | 0.049/0.045
CE + trọng số lớp 0 | 90.0% 0.32% | 0.172 94.0% 1.53% | 1.000/0.002
CE + trọng số lớp 1 | 94.0% 0.74% | 0.336 96.0% 1.11% | 1.000/0.009
CE + trọng số lớp 2 | 0.0% 0.00% | 0.456 1.0% 1.16% | 0.454/0.454
CE + WeightedRandomSampler 0 | 87.0% 0.16% | 0.058 96.0% 0.89% | 1.000/0.000
CE + WeightedRandomSampler 1 | 90.0% 0.21% | 0.063 93.0% 1.32% | 1.000/0.000
CE + WeightedRandomSampler 2 | 92.0% 0.26% | 0.047 99.0% 1.42% | 1.000/0.000
Focal γ=2 0 | 0.0% 0.00% | 0.285 60.0% 1.79% | 0.300/0.201
Focal γ=2 1 | 0.0% 0.00% | 0.275 1.0% 0.74% | 0.258/0.255
Focal γ=2 2 | 71.0% 0.00% | 0.116 94.0% 1.32% | 0.786/0.032
Focal γ=2 + α 0 | 0.0% 0.00% | 0.498 100.0% 100.00% | 0.498/0.498
Focal γ=2 + α 1 | 93.0% 0.42% | 0.395 94.0% 1.00% | 0.996/0.047
Focal γ=2 + α 2 | 41.0% 0.00% | 0.477 76.0% 1.47% | 0.494/0.470
Đọc bảng theo từng cấu hình (con số cụ thể có thể lệch đôi chút trên máy khác, nhưng các xu hướng dưới đây nên giữ nguyên):
- CE thường mắc kẹt ở mô hình lười ở cả ba seed: trung vị xác suất NG của ảnh NG và của ảnh OK gần như bằng nhau (khoảng 0,05), tức là mô hình trả cùng một con số cho mọi ảnh. Chỉnh ngưỡng không cứu được: recall chỉ 4–7%. Đúng kịch bản ở mục 3, giờ là thật.
- WeightedRandomSampler ổn định nhất: cả ba seed đều học được, recall 93–99% ở overkill khoảng 1% khi dùng ngưỡng chọn trên validation. Mỗi batch 64 ảnh có trung bình 32 ảnh NG thay vì 3, nên mô hình nhận tín hiệu từ lỗi ở mọi bước cập nhật.
- Trọng số lớp và focal loss phụ thuộc may rủi: CE + trọng số lớp học được ở seed 0 và 1 nhưng mắc kẹt ở seed 2 (trung vị NG/OK cùng là 0,454). Focal loss chỉ học tốt ở seed 2, học dở ở seed 0, mắc kẹt ở seed 1. Trên bài toán này, nhân hệ số vào loss chưa đủ để thoát khỏi lời giải hằng số trong 40 epoch ở mọi lần khởi tạo.
- Focal loss nén xác suất: ở seed 0, mô hình focal chỉ gán cho ảnh NG xác suất trung vị 0,30 nên recall ở ngưỡng 0,5 là 0%, trong khi ngưỡng chọn trên validation (0,285) cho 60%; ở seed 2, recall tăng từ 71% lên 94% khi chọn ngưỡng 0,116. Focal loss giảm phạt cho mẫu đã "đủ đúng", nên mô hình không bị ép đẩy xác suất về 0 hay 1; đầu ra không còn là xác suất hiệu chỉnh (calibrated). Với focal loss, ngưỡng 0,5 gần như luôn sai.
- Mô hình hằng số làm hỏng cả phép chọn ngưỡng: Focal γ=2 + α ở seed 0 trả đúng 0,498 cho mọi ảnh. Ngưỡng chọn trên validation cũng là 0,498, và vì mọi ảnh đều bằng ngưỡng nên tất cả bị báo NG: "recall 100%" đi kèm overkill 100%. Nhìn riêng cột recall, bạn sẽ tưởng đây là cấu hình tốt nhất.
Kết quả trên là của một bài toán tổng hợp nhỏ với CNN huấn luyện từ đầu; với mô hình pretrained (transfer learning) và dữ liệu thật, các cách thường gần nhau hơn. Điều chắc chắn rút ra được: (1) không xử lý mất cân bằng thì mô hình dễ học "luôn OK"; (2) cách xử lý nào cũng phải đi kèm chọn ngưỡng trên validation; (3) kiểm tra nhiều seed.
7. Bài toán nhị phân một đầu ra: pos_weight
Nhiều mô hình OK/NG chỉ có một logit đầu ra và dùng nn.BCEWithLogitsLoss (sigmoid + binary cross-entropy gộp lại, ổn định số học hơn Sigmoid + BCELoss). Tương đương của trọng số lớp ở đây là tham số pos_weight: nhân loss của mẫu dương (NG) lên. Giá trị hay dùng là số mẫu âm chia số mẫu dương.
logit = torch.tensor([-3.0, 3.0, -3.0]) # một đầu ra: logit > 0 nghĩa là nghiêng về NG
nhan_bce = torch.tensor([0.0, 1.0, 1.0]) # mẫu 1: OK (đoán đúng), mẫu 2: NG (đúng), mẫu 3: NG (đoán sai)
for pw in (1.0, 19.0): # 19 = 1900 OK / 100 NG
bce = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([pw]), reduction="none")
print(f"pos_weight = {pw:4}: loss từng mẫu = {[round(v, 3) for v in bce(logit, nhan_bce).tolist()]}")
pos_weight = 1.0: loss từng mẫu = [0.049, 0.049, 3.049]
pos_weight = 19.0: loss từng mẫu = [0.049, 0.923, 57.923]
pos_weight chỉ nhân loss của mẫu NG (mẫu 2 và 3) lên 19 lần, không đụng tới mẫu OK. Khác với weight của CrossEntropyLoss, BCEWithLogitsLoss với reduction="mean" vẫn chia cho số mẫu, không chia cho tổng trọng số.
Chọn loss nào?
| Tình huống | Gợi ý |
|---|---|
| Dữ liệu tương đối cân bằng | nn.CrossEntropyLoss thông thường |
| Mất cân bằng vừa phải đến nặng (1:5 đến 1:50), phân loại ảnh | Bắt đầu với WeightedRandomSampler (ổn định nhất trong thí nghiệm mục 6), hoặc cross-entropy + weight; nhị phân một đầu ra thì BCEWithLogitsLoss(pos_weight=...). Chạy vài seed |
| Mất cân bằng nặng, rất nhiều mẫu dễ (detection, segmentation vết lỗi nhỏ) | Focal loss, bắt đầu với γ = 2. RetinaNet dùng focal loss làm loss phân loại, và nhiều thư viện detection có sẵn các biến thể của nó. Luôn chọn ngưỡng trên validation |
| Gần như không có ảnh NG | Chuyển sang anomaly detection, chỉ học từ ảnh OK |
Luôn theo dõi recall và precision của lớp NG trên tập validation, cùng phân phối điểm của từng lớp; đừng chỉ nhìn loss và accuracy. Loss giảm đều không có nghĩa là mô hình đã bắt được lỗi.
Bài tập
Bài 1. Dữ liệu có 3 lớp: 900 ảnh OK, 80 ảnh trầy xước, 20 ảnh móp. Tính trọng số lớp theo công thức "balanced" và kiểm tra rằng mỗi lớp đóng góp tổng trọng số bằng nhau.
Xem đáp án
so_mau_3 = torch.tensor([900.0, 80.0, 20.0])
w3 = so_mau_3.sum() / (3 * so_mau_3)
print("trọng số:", [round(v, 3) for v in w3.tolist()])
print("tổng trọng số theo lớp:", [round(v, 1) for v in (w3 * so_mau_3).tolist()])
trọng số: [0.37, 4.167, 16.667]
tổng trọng số theo lớp: [333.3, 333.3, 333.3]
Mỗi lớp đóng góp tổng trọng số 333,3 (= 1000/3). Một ảnh móp nặng gấp 45 lần một ảnh OK. Với 20 ảnh, trọng số lớn như vậy dễ làm mô hình học thuộc đúng 20 ảnh đó: nên kết hợp với augmentation (xem Dataset, DataLoader và augmentation) và kiểm tra recall của lớp móp trên validation riêng.
Bài 2. Lập bảng hệ số giảm (1 − pt)γ của focal loss với γ = 0, 0,5, 1, 2, 5 và pt = 0,5, 0,9, 0,99. Từ bảng, giải thích vì sao γ quá lớn có thể làm mô hình học chậm.
Xem đáp án
print("γ | p_t=0.5 p_t=0.9 p_t=0.99")
for gamma in (0, 0.5, 1, 2, 5):
print(f"{gamma:<4} | " + " ".join(f"{(1 - p) ** gamma:8.5f}" for p in (0.5, 0.9, 0.99)))
γ | p_t=0.5 p_t=0.9 p_t=0.99
0 | 1.00000 1.00000 1.00000
0.5 | 0.70711 0.31623 0.10000
1 | 0.50000 0.10000 0.01000
2 | 0.25000 0.01000 0.00010
5 | 0.03125 0.00001 0.00000
Với γ = 2, mẫu đã đúng 90% chỉ còn 1% loss, mẫu phân vân (pt = 0,5) còn 25%. Với γ = 5, ngay cả mẫu phân vân cũng chỉ còn khoảng 3% loss: tổng gradient rất nhỏ, mô hình học chậm và nhạy với learning rate. Bài báo RetinaNet thử nhiều giá trị và chọn γ = 2; hãy coi đó là điểm khởi đầu, không phải hằng số.
Bài 3. Ở mục 4 có cảnh báo: đừng dùng cả WeightedRandomSampler và trọng số lớp đầy đủ cùng lúc. Dùng hàm huan_luyen ở mục 6 để kiểm chứng: so sánh "sampler" với "sampler + trọng số lớp" trên 3 seed, ở ngưỡng 0,5 và ở ngưỡng chọn trên validation.
Xem đáp án
for ten, ham in (("sampler", lambda lg, y: F.cross_entropy(lg, y)),
("sampler + trọng số lớp", lambda lg, y: F.cross_entropy(lg, y, weight=trong_so))):
for hat in range(3):
p_va, p_te = huan_luyen(ham, sampler=True, hat=hat)
r05, o05 = recall_overkill(p_te, nhan_te, 0.5)
r, o = recall_overkill(p_te, nhan_te, float(np.quantile(p_va[nhan_va == 0], 0.99)))
print(f"{ten:24s} {hat} | ngưỡng 0,5: recall {100 * r05:5.1f}%, overkill {100 * o05:5.2f}% "
f"| ngưỡng val: recall {100 * r:5.1f}%, overkill {100 * o:5.2f}%")
sampler 0 | ngưỡng 0,5: recall 87.0%, overkill 0.16% | ngưỡng val: recall 96.0%, overkill 0.89%
sampler 1 | ngưỡng 0,5: recall 90.0%, overkill 0.21% | ngưỡng val: recall 93.0%, overkill 1.32%
sampler 2 | ngưỡng 0,5: recall 92.0%, overkill 0.26% | ngưỡng val: recall 99.0%, overkill 1.42%
sampler + trọng số lớp 0 | ngưỡng 0,5: recall 99.0%, overkill 9.32% | ngưỡng val: recall 96.0%, overkill 0.95%
sampler + trọng số lớp 1 | ngưỡng 0,5: recall 91.0%, overkill 0.37% | ngưỡng val: recall 92.0%, overkill 1.53%
sampler + trọng số lớp 2 | ngưỡng 0,5: recall 95.0%, overkill 0.74% | ngưỡng val: recall 97.0%, overkill 1.11%
Bù hai lần làm mô hình "thiên vị" NG: ở ngưỡng 0,5, overkill tăng từ khoảng 2 lần (seed 1) đến gần 60 lần (seed 0, 9,32% so với 0,16%) so với chỉ dùng sampler, vì mỗi ảnh NG vừa xuất hiện nhiều hơn vừa bị phạt nặng hơn. Sau khi chọn lại ngưỡng trên validation, hai cách cho kết quả gần như nhau. Bù kép không giúp mô hình phân biệt tốt hơn, chỉ làm xác suất lệch đi và khó đọc hơn; chọn một trong hai cách.
Tóm tắt
- Softmax biến logits thành xác suất; cross-entropy = −log(xác suất của nhãn đúng).
nn.CrossEntropyLossnhận logits, đừng thêm softmax vào mô hình. - Dữ liệu 95/5 làm mô hình dễ học "luôn OK": accuracy 95%, loss thấp, không bắt được lỗi nào. Thí nghiệm mục 6 cho thấy CE thường mắc kẹt đúng như vậy ở mọi seed.
- Ba cách bù: trọng số lớp (
weight,pos_weight), lấy mẫu lại (WeightedRandomSampler), focal loss \((1 - p_t)^\gamma \cdot CE\). Chỉ dùng một cách bù đầy đủ, không dùng chồng. - Focal loss và trọng số làm xác suất đầu ra lệch khỏi xác suất thật: luôn chọn ngưỡng trên validation, báo cáo trên test.
- Chạy nhiều seed, in phân phối điểm từng lớp; một mô hình xuất hằng số có thể trông tốt theo accuracy, loss, thậm chí theo recall.
Bài tiếp theo: Dự án chặng 11: phân loại ảnh OK/NG bằng transfer learning, nơi bạn ghép mọi thứ của chặng, kể cả xử lý mất cân bằng và chọn ngưỡng, thành một mô hình hoàn chỉnh.
Nguồn tham khảo: Lin và cộng sự, Focal Loss for Dense Object Detection (arXiv:1708.02002), PyTorch: CrossEntropyLoss, PyTorch: BCEWithLogitsLoss (pos_weight), PyTorch: WeightedRandomSampler, torchvision.ops.sigmoid_focal_loss.
Bài tập thực hành
- Chạy thí nghiệm 5 cấu hình × 3 seed, đánh dấu những lần mô hình mắc kẹt bằng trung vị điểm NG/OK.
- So sánh sampler với sampler + trọng số lớp ở ngưỡng 0,5 và ở ngưỡng chọn trên validation.
Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.


