⭐ Vision Engineer · Chặng 11Bài 12/13Bài học~75 phút

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àm mất mát cho phân loại: cross-entropy, class weight, focal loss

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
  1. 1. Softmax: biến điểm số thành xác suất
  2. 2. Cross-entropy: phạt theo xác suất của nhãn đúng
  3. 3. Vấn đề dữ liệu mất cân bằng
  4. 4. Cách 1: trọng số lớp (class weight)
  5. 5. Cách 2: focal loss
  6. 6. Thí nghiệm: huấn luyện thật trên dữ liệu 95/5
  7. 7. Bài toán nhị phân một đầu ra: pos_weight
  8. Chọn loss nào?
  9. Bài tập
  10. Tóm tắ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.

Lỗi rất hay gặp: softmax hai lầnĐừng thêm 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_t gầ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.
Một lần chạy không phải là kết luậnNếu bạn chỉ chạy seed 0, bạn có thể kết luận "trọng số lớp tốt ngang sampler" hoặc ngược lại, tùy lần may. Trước khi chọn phương pháp cho dự án, hãy chạy ít nhất 3 seed và luôn in phân phối điểm của từng lớp (trung vị, phân vị) bên cạnh recall: một mô hình xuất cùng một con số cho mọi ảnh có thể trông "ổn" theo accuracy (95%) và theo loss.

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ốngGợi ý
Dữ liệu tương đối cân bằngnn.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 ảnhBắ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 NGChuyển sang anomaly detection, chỉ học từ ảnh OK
Loss không thay thế được ngưỡng quyết địnhDù dùng loss nào, bước cuối vẫn là chọn ngưỡng xác suất NG trên tập validation, phù hợp với chi phí lọt lỗi và chi phí loại nhầm của nhà máy. Xem tiêu chí OK/NG, escape và overkill và chọn ngưỡng theo nhà máy.

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.CrossEntropyLoss nhậ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

  1. 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.
  2. 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.

Bài tiếp theo
Ban biên tập HọcFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và ngoại ngữ, hoàn toàn miễn phí.