Lỗi thường gặp khi huấn luyện mô hình: chẩn đoán và cách sửa
Bảng tra theo triệu chứng: loss không giảm, NaN, overfitting, dữ liệu lệch lớp, chạy thật kém, lỗi PyTorch. Có thí nghiệm đo hiệu quả từng cách sửa.
Nội dung bài viết
- 1. Bảng tra nhanh theo triệu chứng
- 2. Bốn phép thử trước khi huấn luyện dài
- 3. Loss không giảm: các lỗi code kinh điển
- 4. Loss thành NaN hoặc inf
- 5. Loss dao động, chọn learning rate
- 6. Underfitting: mô hình học chưa tới
- 7. Overfitting: học thuộc thay vì học quy luật
- 8. Val tốt hơn train, và val "đẹp quá"
- 9. Accuracy cao nhưng bỏ sót lớp hiếm
- 10. Đánh giá tốt, chạy thật lại kém
- 11. Thông báo lỗi thường gặp
- 12. Kết quả không lặp lại được
- 13. Checklist khi huấn luyện "có vấn đề"
- 14. Bài tập
- Tóm tắt
Bạn bấm chạy, đợi vài giờ, và nhận về một trong những cảnh quen thuộc: loss đứng yên, loss thành nan, accuracy train 100% nhưng ảnh mới đoán sai, hoặc mô hình chấm 97% trên máy mà xuống dây chuyền bỏ sót gần nửa số sản phẩm lỗi. Hầu hết các tình huống này có nguyên nhân rất cụ thể và có cách kiểm tra trong vài phút. Bài này là một cẩm nang chẩn đoán: đi từ triệu chứng (nhìn vào đường loss, thông báo lỗi, con số đánh giá) đến nguyên nhân và cách sửa, kèm thí nghiệm nhỏ bằng PyTorch để bạn thấy tận mắt từng lỗi và đo được hiệu quả của từng cách sửa.
1. Bảng tra nhanh theo triệu chứng
Thói quen quan trọng nhất khi huấn luyện là ghi lại loss của cả tập train và tập validation sau mỗi epoch, rồi nhìn hai đường đó cùng nhau. Phần lớn chẩn đoán dưới đây dựa vào hình dạng của hai đường này.
| Triệu chứng | Nguyên nhân hay gặp | Xem mục |
|---|---|---|
| Loss train gần như không giảm ngay từ đầu | Lỗi code (softmax thừa, quên zero_grad, nhãn lệch), learning rate sai, dữ liệu chưa chuẩn hóa | 2, 3 |
Loss thành nan hoặc inf | Learning rate quá lớn, dữ liệu chưa chuẩn hóa, log(0), tràn số float16, dữ liệu có NaN | 4 |
| Loss dao động mạnh, thỉnh thoảng vọt lên | Learning rate quá lớn, batch quá nhỏ, thiếu warmup, vài mẫu nhãn sai | 5 |
| Loss train và val cùng cao, gần nhau | Underfitting: mô hình quá yếu, học chưa đủ lâu, đặc trưng không chứa thông tin | 6 |
| Loss train tiến về 0, loss val giảm rồi tăng lại | Overfitting | 7 |
| Loss val thấp hơn loss train | Thường không phải lỗi: dropout và augmentation chỉ chạy lúc train | 8 |
| Kết quả val đẹp bất thường | Rò rỉ dữ liệu: ảnh "họ hàng" nằm ở cả train và val | 8 |
| Accuracy cao nhưng bỏ sót lớp hiếm (ảnh NG) | Dữ liệu mất cân bằng, đo sai chỉ số | 9 |
| Đánh giá tốt, chạy thật kém | Quên model.eval(), tiền xử lý lúc chạy khác lúc train, dữ liệu thật khác dữ liệu train | 10 |
Chương trình dừng với RuntimeError, ValueError | Sai kiểu dữ liệu, sai kích thước, khác thiết bị, hết bộ nhớ GPU | 11 |
| Chạy lại cùng code ra kết quả khác | Chưa cố định seed, thuật toán không tất định | 12 |
2. Bốn phép thử trước khi huấn luyện dài
Đừng bắt đầu bằng một lần huấn luyện 100 epoch. Andrej Karpathy, trong bài "A Recipe for Training Neural Networks", khuyên làm một loạt kiểm tra nhỏ trước, vì lỗi trong mạng neural thường im lặng: code vẫn chạy, loss vẫn giảm một chút, chỉ là kết quả tệ hơn mức đáng có. Bốn phép thử dưới đây mất vài phút nhưng bắt được phần lớn lỗi code.
Phép thử 1: loss lúc khởi tạo
Với bài toán phân loại \(C\) lớp và cross-entropy, mô hình vừa khởi tạo gần như đoán đều cho mọi lớp, xác suất mỗi lớp khoảng \(1/C\). Loss lúc đó phải gần \(-\ln(1/C) = \ln C\): khoảng 0,69 với 2 lớp, 1,10 với 3 lớp, 2,30 với 10 lớp. Lệch vài phần mười là bình thường (trọng số khởi tạo ngẫu nhiên nên logits không đúng bằng 0). Nếu loss ban đầu là 10 hay 50 với bài 3 lớp, có gì đó sai: nhãn không đúng dạng, loss function không hợp, đầu vào có giá trị khổng lồ vì chưa chuẩn hóa.
Phép thử 2: học thuộc một batch
Lấy một batch nhỏ cố định (vài ảnh) và huấn luyện lặp lại trên đúng batch đó. Mô hình đủ lớn phải học thuộc được, loss phải tiến về gần 0. Nếu không, lỗi nằm trong code (forward, loss, optimizer), không phải trong dữ liệu hay siêu tham số: không cần huấn luyện dài để biết.
import math
import torch
from torch import nn
torch.manual_seed(0)
SO_LOP = 3
# Mạng nhỏ cho ảnh xám 32x32, 3 lớp: OK, xước, móp
model = nn.Sequential(
nn.Conv2d(1, 16, 3, padding=1), nn.BatchNorm2d(16), nn.ReLU(), nn.MaxPool2d(2),
nn.Conv2d(16, 32, 3, padding=1), nn.BatchNorm2d(32), nn.ReLU(), nn.MaxPool2d(2),
nn.Flatten(), nn.Linear(32 * 8 * 8, SO_LOP),
)
loss_fn = nn.CrossEntropyLoss()
# Một batch nhỏ cố định: 8 ảnh, nhãn ngẫu nhiên
x = torch.randn(8, 1, 32, 32)
y = torch.randint(0, SO_LOP, (8,))
# Phép thử 1: loss lúc khởi tạo phải gần ln(số lớp), đo trên nhiều ảnh cho ổn định
with torch.no_grad():
x_nhieu = torch.randn(512, 1, 32, 32)
y_nhieu = torch.randint(0, SO_LOP, (512,))
loss0 = loss_fn(model(x_nhieu), y_nhieu).item()
print(f"Loss khởi tạo: {loss0:.3f} (kỳ vọng khoảng {math.log(SO_LOP):.3f})")
# Phép thử 2: học thuộc một batch, loss phải tiến về 0
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
model.train()
for buoc in range(1, 201):
opt.zero_grad()
loss = loss_fn(model(x), y)
loss.backward()
opt.step()
if buoc in (1, 50, 100, 200):
print(f"Bước {buoc:3d}: loss = {loss.item():.4f}")
Loss khởi tạo: 1.353 (kỳ vọng khoảng 1.099)
Bước 1: loss = 1.3598
Bước 50: loss = 0.0006
Bước 100: loss = 0.0003
Bước 200: loss = 0.0002
Loss khởi tạo 1,35 so với kỳ vọng 1,10: cùng cỡ, chấp nhận được. Sau 50 bước, mô hình đã thuộc lòng 8 ảnh. Code huấn luyện cơ bản đúng.
Phép thử 3: xem dữ liệu ngay trước khi vào mô hình
Lưu hoặc hiển thị vài ảnh lấy từ DataLoader (không phải từ thư mục gốc), kèm nhãn. Đây là chỗ hay phát hiện: augmentation xoay mất vùng lỗi, ảnh bị lật màu BGR/RGB, ảnh toàn đen do chia 255 hai lần, nhãn lệch so với ảnh do sắp xếp tên file khác nhau. Kiểm tra thêm x.min(), x.max(), x.mean(), x.dtype, y.unique() của một batch.
Phép thử 4: mốc so sánh đơn giản
Tính trước kết quả của cách đơn giản nhất: luôn đoán lớp đông nhất, hoặc một mô hình nhỏ như logistic regression. Với dữ liệu 95% OK, đoán "OK" cho mọi ảnh đã được 95% accuracy. Mô hình của bạn chỉ có giá trị khi vượt rõ mốc này, đo bằng đúng chỉ số bài toán cần (mục 9).
3. Loss không giảm: các lỗi code kinh điển
Khi phép thử 2 thất bại, rà lần lượt danh sách dưới đây. Mỗi lỗi đều đã làm mất nhiều ngày của rất nhiều người.
| Lỗi | Hậu quả | Cách sửa |
|---|---|---|
Áp softmax trước nn.CrossEntropyLoss | Loss giảm rất chậm và kẹt ở một mức sàn, không bao giờ về 0 | Đưa thẳng logits (đầu ra lớp Linear cuối) vào loss. CrossEntropyLoss đã gồm LogSoftmax + NLLLoss. Chỉ dùng softmax khi cần xác suất lúc dự đoán. |
Áp sigmoid trước nn.BCEWithLogitsLoss | Như trên, với bài nhị phân | Dùng logits; hoặc dùng nn.BCELoss nếu thật sự muốn tự áp sigmoid (kém ổn định số hơn) |
Quên optimizer.zero_grad() | Gradient cộng dồn qua các bước, bước cập nhật ngày càng lớn, loss dao động hoặc phân kỳ | Gọi zero_grad() mỗi bước, trước backward() (trừ khi cố ý tích lũy gradient, mục 11) |
Quên loss.backward() hoặc optimizer.step() | Trọng số không đổi, loss đứng yên | Đủ bốn dòng: zero_grad, forward + loss, backward, step |
| Tạo optimizer trước khi thay lớp cuối của mô hình pretrained | Optimizer giữ tham số của lớp cũ, lớp mới không bao giờ được cập nhật | Sửa kiến trúc xong mới tạo optimizer |
Đóng băng nhầm (requires_grad = False cho cả mô hình) | Không lớp nào học | Kiểm tra sum(p.numel() for p in model.parameters() if p.requires_grad) phải lớn hơn 0 |
| Nhãn lệch so với ảnh | Loss giảm tới mức đoán theo tỉ lệ lớp rồi dừng, val ngang mức ngẫu nhiên | Phép thử 3: in tên file và nhãn của vài mẫu từ DataLoader |
| Learning rate quá nhỏ (ví dụ 1e-7) hoặc quá lớn | Quá nhỏ: loss giảm cực chậm. Quá lớn: dao động, NaN | Bắt đầu với Adam/AdamW lr = 1e-3 (huấn luyện từ đầu) hoặc 1e-4 (fine-tune), hoặc tìm bằng LR range test (mục 5) |
| Đầu vào chưa chuẩn hóa (ảnh 0–255, đặc trưng cỡ hàng nghìn) | Gradient rất lớn hoặc rất lệch giữa các chiều, khó hội tụ | Chia 255 rồi chuẩn hóa theo mean/std; với dữ liệu bảng, chuẩn hóa từng cột theo mean/std của tập train |
Thí nghiệm sau cho thấy lỗi đầu tiên tai hại thế nào. Cùng mô hình, cùng dữ liệu, chỉ khác một dòng softmax:
import torch
from torch import nn
torch.manual_seed(0)
x = torch.randn(64, 20)
y = torch.randint(0, 3, (64,))
def huan_luyen(softmax_thua):
torch.manual_seed(1)
model = nn.Sequential(nn.Linear(20, 64), nn.ReLU(), nn.Linear(64, 3))
opt = torch.optim.Adam(model.parameters(), lr=1e-2)
loss_fn = nn.CrossEntropyLoss()
for _ in range(500):
opt.zero_grad()
out = model(x)
if softmax_thua:
out = torch.softmax(out, dim=1) # SAI: CrossEntropyLoss đã tự làm softmax
loss = loss_fn(out, y)
loss.backward()
opt.step()
return loss.item()
print(f"Đúng (logits): loss cuối = {huan_luyen(False):.4f}")
print(f"Sai (softmax 2 lần): loss cuối = {huan_luyen(True):.4f}")
Đúng (logits): loss cuối = 0.0001
Sai (softmax 2 lần): loss cuối = 0.5657
Bản lỗi kẹt ở 0,566. Lý do: sau softmax, mọi giá trị nằm trong [0, 1]; CrossEntropyLoss lại softmax lần nữa trên các giá trị đó, nên trường hợp tốt nhất (lớp đúng bằng 1, hai lớp kia bằng 0) vẫn chỉ cho xác suất \(e/(e+2)\), loss tối thiểu \(-\ln\frac{e}{e+2} \approx 0{,}551\). Mô hình đúng là đúng, nhưng tín hiệu học bị bóp nghẹt, và với dữ liệu thật bạn sẽ chỉ thấy "mô hình học kém" mà không có thông báo lỗi nào.
Chi tiết về loss và optimizer: Loss function và optimizer: SGD, Momentum, RMSProp, Adam.
4. Loss thành NaN hoặc inf
Một khi loss là nan, mọi trọng số nhận gradient nan và mô hình hỏng vĩnh viễn: huấn luyện tiếp là vô ích. Nguyên nhân thường gặp, theo thứ tự nên kiểm tra:
- Learning rate quá lớn làm trọng số tăng vọt qua vài bước (exploding). Giảm lr 10 lần và thử lại.
- Đầu vào hoặc nhãn chưa chuẩn hóa, giá trị lớn làm loss và gradient khổng lồ (đặc biệt với hồi quy và MSE).
- Phép toán không xác định:
torch.log(0)cho-inf,0 * -infchonan, chia cho 0,sqrtcủa số âm. Hay gặp trong loss tự viết. Dùng hàm ổn định có sẵn (log_softmax,BCEWithLogitsLoss), hoặc kẹp giá trị:torch.log(p.clamp(min=1e-7)). - Tràn số float16 khi dùng mixed precision: float16 chỉ biểu diễn tới 65504. Dùng
torch.amp.GradScalerđúng cách (mục 11), hoặcbfloat16nếu GPU hỗ trợ (dải giá trị như float32). - Dữ liệu có sẵn NaN: file CSV có ô trống, ảnh hỏng, bản đồ độ sâu có điểm không đo được. Kiểm tra
torch.isfinite(x).all()trên dữ liệu.
Thí nghiệm hồi quy với đầu vào chưa chuẩn hóa (giá trị cỡ ±150) và nhãn rất lớn:
import torch
from torch import nn
torch.manual_seed(0)
x = torch.randn(256, 10) * 50 # đặc trưng chưa chuẩn hóa: giá trị cỡ hàng chục, hàng trăm
y = x.sum(dim=1, keepdim=True) # nhãn cũng rất lớn
def chay(x, y, lr, clip=None):
torch.manual_seed(1)
m = nn.Sequential(nn.Linear(10, 64), nn.ReLU(), nn.Linear(64, 1))
opt = torch.optim.SGD(m.parameters(), lr=lr)
for buoc in range(1, 201):
opt.zero_grad()
loss = nn.functional.mse_loss(m(x), y)
if not torch.isfinite(loss):
return f"loss = {loss.item()} ở bước {buoc}, dừng"
loss.backward()
if clip is not None:
nn.utils.clip_grad_norm_(m.parameters(), max_norm=clip)
opt.step()
return f"loss cuối = {loss.item():.4f}"
print("Dữ liệu thô, không clip:", chay(x, y, lr=1e-3))
print("Dữ liệu thô, clip=1.0 :", chay(x, y, lr=1e-3, clip=1.0))
# Cách sửa gốc: chuẩn hóa đầu vào và nhãn (dùng mean/std của tập train)
x_tb, x_dl = x.mean(dim=0), x.std(dim=0)
y_tb, y_dl = y.mean(), y.std()
x_c = (x - x_tb) / x_dl
y_c = (y - y_tb) / y_dl
print("Đã chuẩn hóa, không clip:", chay(x_c, y_c, lr=1e-2))
Dữ liệu thô, không clip: loss = inf ở bước 5, dừng
Dữ liệu thô, clip=1.0 : loss cuối = 19113.4805
Đã chuẩn hóa, không clip: loss cuối = 0.0271
Ba dòng kết quả cho ba bài học. Không làm gì: loss thành inf sau 5 bước. Gradient clipping (giới hạn chuẩn của vector gradient, ở đây là 1,0) chặn được bùng nổ nhưng không chữa bệnh: loss vẫn ở mức 19 nghìn vì mô hình bước quá ngắn so với độ lớn của bài toán. Chuẩn hóa dữ liệu mới là cách sửa gốc: cùng mô hình, loss về 0,027 (trên thang đã chuẩn hóa, phương sai của nhãn là 1, tức mô hình giải thích được khoảng 97% biến thiên). Clipping là lưới an toàn nên giữ, nhưng đừng dùng nó để che một learning rate sai hay dữ liệu chưa chuẩn hóa.
with torch.autograd.detect_anomaly():. Khi backward gặp NaN, PyTorch báo lỗi kèm traceback của phép toán forward đã tạo ra nó. Chế độ này làm chậm huấn luyện nhiều, chỉ bật khi gỡ lỗi. Song song, in chuẩn gradient mà clip_grad_norm_ trả về mỗi bước: nó thường tăng vọt vài bước trước khi loss thành NaN.Vanishing và exploding gradient trong mạng sâu được giải thích kỹ ở Vanishing/Exploding gradient và khởi tạo trọng số.
5. Loss dao động, chọn learning rate
Loss của từng batch luôn nhấp nhô vì mỗi batch khác nhau; điều cần nhìn là trung bình theo epoch. Nếu trung bình đó dao động lớn hoặc thỉnh thoảng vọt lên rồi mới giảm lại, nghi ngờ theo thứ tự: learning rate quá lớn, batch quá nhỏ (gradient nhiễu), thiếu giai đoạn warmup cho mô hình lớn, vài mẫu nhãn sai có loss khổng lồ.
Cách tìm learning rate có hệ thống là LR range test (Leslie Smith, 2015): tăng lr theo cấp số nhân từ rất nhỏ đến rất lớn trong một lượt ngắn, ghi loss ở mỗi bước. Loss sẽ đứng yên (lr quá nhỏ), rồi giảm nhanh, rồi bùng nổ (lr quá lớn). Quy tắc kinh nghiệm phổ biến: chọn lr nhỏ hơn khoảng 10 lần so với điểm loss thấp nhất, nằm trong đoạn loss đang giảm dốc.
import math
import torch
from torch import nn
torch.manual_seed(0)
x = torch.randn(2048, 20)
y = (x[:, :3].sum(dim=1) > 0).long()
model = nn.Sequential(nn.Linear(20, 64), nn.ReLU(), nn.Linear(64, 2))
opt = torch.optim.SGD(model.parameters(), lr=1e-6, momentum=0.9)
loss_fn = nn.CrossEntropyLoss()
lr_dau, lr_cuoi, so_buoc = 1e-6, 10.0, 100
he_so = (lr_cuoi / lr_dau) ** (1 / so_buoc) # tăng lr theo cấp số nhân mỗi bước
lr, loss_muot, tot_nhat, ket_qua = lr_dau, 0.0, float("inf"), []
for buoc in range(1, so_buoc + 1):
idx = torch.randint(0, len(x), (64,))
for g in opt.param_groups:
g["lr"] = lr
opt.zero_grad()
loss = loss_fn(model(x[idx]), y[idx])
loss.backward()
opt.step()
loss_muot = 0.9 * loss_muot + 0.1 * loss.item() # làm mượt cho dễ đọc
loss_hien = loss_muot / (1 - 0.9 ** buoc)
ket_qua.append((lr, loss_hien))
tot_nhat = min(tot_nhat, loss_hien)
if not math.isfinite(loss_hien) or loss_hien > 4 * tot_nhat: # loss bùng nổ: dừng
break
lr *= he_so
for lr, l in ket_qua[::10]:
print(f"lr = {lr:.1e} loss = {l:.3f}")
lr_min = min(ket_qua, key=lambda t: t[1])[0]
print(f"Loss thấp nhất ở lr ≈ {lr_min:.1e}; chọn lr khoảng {lr_min / 10:.1e}")
lr = 1.0e-06 loss = 0.689
lr = 5.0e-06 loss = 0.703
lr = 2.5e-05 loss = 0.707
lr = 1.3e-04 loss = 0.708
lr = 6.3e-04 loss = 0.709
lr = 3.2e-03 loss = 0.698
lr = 1.6e-02 loss = 0.670
lr = 7.9e-02 loss = 0.560
lr = 4.0e-01 loss = 0.302
lr = 2.0e+00 loss = 0.623
Loss thấp nhất ở lr ≈ 7.6e-01; chọn lr khoảng 7.6e-02
Với bài này, vùng lr từ 1e-2 đến 4e-1 cho loss giảm nhanh nhất; lr khoảng 8e-2 là điểm xuất phát tốt cho SGD momentum. Lưu ý: phép thử đã làm thay đổi trọng số, nên khởi tạo lại mô hình trước khi huấn luyện thật.
Sau khi chọn lr, dùng một bộ lập lịch để giảm dần lr theo thời gian: torch.optim.lr_scheduler.OneCycleLR hoặc CosineAnnealingLR (thường kèm vài trăm bước warmup cho Transformer và mô hình lớn), hoặc ReduceLROnPlateau (giảm lr khi val loss không cải thiện sau một số epoch).
6. Underfitting: mô hình học chưa tới
Dấu hiệu: loss train và loss val cùng cao và gần nhau; accuracy train cũng thấp. Mô hình chưa nắm được quy luật, chưa nói đến chuyện học thuộc. Trước khi làm mô hình phức tạp hơn, hãy chắc phép thử 2 ở mục 2 đã qua (nếu không học thuộc nổi một batch thì đó là lỗi code, không phải underfitting).
- Huấn luyện lâu hơn: loss train còn đang giảm đều thì chưa nên dừng.
- Mô hình lớn hơn hoặc phù hợp hơn: thêm lớp, thêm kênh; với ảnh, dùng CNN hoặc mô hình pretrained thay vì MLP trên pixel.
- Giảm regularization đang quá tay: weight decay quá lớn, dropout 0,7, augmentation phá hủy chi tiết (làm mờ mất vết xước nhỏ).
- Kiểm tra thông tin trong dữ liệu: ảnh resize về 64×64 có còn thấy vết lỗi 3 pixel không? ROI cắt có chứa vùng lỗi không? Người nhìn ảnh đầu vào (đúng kích thước mô hình thấy) có tự phân biệt được không? Nếu người còn không phân biệt được, mô hình cũng khó.
- Chọn lại learning rate (mục 5): lr quá nhỏ trông rất giống underfitting.
7. Overfitting: học thuộc thay vì học quy luật
Dấu hiệu kinh điển: loss train tiếp tục giảm về gần 0, accuracy train lên 100%, trong khi loss val giảm đến một lúc rồi tăng trở lại. Điểm val loss thấp nhất là lúc mô hình tổng quát hóa tốt nhất; sau đó nó bắt đầu học thuộc cả nhiễu và chi tiết riêng của từng ảnh train.
Có nhiều biện pháp, nhưng hiệu quả của chúng rất khác nhau và phụ thuộc bài toán. Thí nghiệm dưới đây đo từng biện pháp trên cùng một bài: phân loại hai lớp, 40 đặc trưng nhưng chỉ 5 đặc trưng có ích, 10% nhãn bị gán sai (nên độ chính xác tối đa có thể đạt là khoảng 90%), chỉ có 400 mẫu train cho một mạng 77 nghìn tham số. Mọi cấu hình được đánh giá trên cùng 4000 mẫu val, đo bằng cross-entropy gốc.
import copy
import torch
from torch import nn
torch.manual_seed(0)
def tao_du_lieu(n, ti_le_nhieu=0.1):
"""40 đặc trưng, chỉ 5 đặc trưng đầu quyết định nhãn; 10% nhãn bị gán sai."""
x = torch.randn(n, 40)
y = (x[:, :5].sum(dim=1) > 0).long()
lat = torch.rand(n) < ti_le_nhieu
y[lat] = 1 - y[lat]
return x, y
X_TR, Y_TR = tao_du_lieu(400) # tập train nhỏ: rất dễ quá khớp
X_THEM, Y_THEM = tao_du_lieu(3600) # dữ liệu "thu thập thêm"
X_VA, Y_VA = tao_du_lieu(4000)
def do_chinh_xac(model, x, y):
model.eval()
with torch.no_grad():
return (model(x).argmax(dim=1) == y).float().mean().item()
def huan_luyen(x_tr, y_tr, dropout=0.0, weight_decay=0.0, label_smoothing=0.0,
early_stopping=False, so_epoch=100, kien_nhan=15):
torch.manual_seed(1)
model = nn.Sequential(
nn.Linear(40, 256), nn.ReLU(), nn.Dropout(dropout),
nn.Linear(256, 256), nn.ReLU(), nn.Dropout(dropout),
nn.Linear(256, 2),
)
opt = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=weight_decay)
loss_fn = nn.CrossEntropyLoss(label_smoothing=label_smoothing)
loss_val_fn = nn.CrossEntropyLoss() # val luôn đo bằng loss gốc để so sánh công bằng
tot_nhat, trang_thai_tot, cho = float("inf"), None, 0
for epoch in range(1, so_epoch + 1):
model.train()
hoan_vi = torch.randperm(len(x_tr))
for i in range(0, len(x_tr), 32):
idx = hoan_vi[i:i + 32]
opt.zero_grad()
loss_fn(model(x_tr[idx]), y_tr[idx]).backward()
opt.step()
model.eval()
with torch.no_grad():
loss_val = loss_val_fn(model(X_VA), Y_VA).item()
if loss_val < tot_nhat - 1e-4:
tot_nhat, cho = loss_val, 0
trang_thai_tot = copy.deepcopy(model.state_dict())
else:
cho += 1
if early_stopping and cho >= kien_nhan:
break
if early_stopping: # quay về checkpoint có val loss thấp nhất
model.load_state_dict(trang_thai_tot)
model.eval()
with torch.no_grad():
loss_val = loss_val_fn(model(X_VA), Y_VA).item()
return epoch, do_chinh_xac(model, x_tr, y_tr), loss_val, do_chinh_xac(model, X_VA, Y_VA)
x_nhieu = torch.cat([X_TR, X_THEM])
y_nhieu = torch.cat([Y_TR, Y_THEM])
cau_hinh = [
("Gốc, 400 mẫu", X_TR, Y_TR, {}),
("+ early stopping", X_TR, Y_TR, dict(early_stopping=True)),
("+ weight decay 1.0", X_TR, Y_TR, dict(weight_decay=1.0)),
("+ dropout 0.5", X_TR, Y_TR, dict(dropout=0.5)),
("+ label smoothing 0.1", X_TR, Y_TR, dict(label_smoothing=0.1)),
("+ cả bốn", X_TR, Y_TR, dict(dropout=0.5, weight_decay=1.0, label_smoothing=0.1, early_stopping=True)),
("Gốc, 4000 mẫu", x_nhieu, y_nhieu, {}),
("4000 mẫu + early stopping", x_nhieu, y_nhieu, dict(early_stopping=True)),
]
print(f"{'Cấu hình':27s} {'epoch':>5s} {'acc train':>9s} {'loss val':>8s} {'acc val':>7s}")
for ten, x, y, tham_so in cau_hinh:
epoch, acc_tr, loss_va, acc_va = huan_luyen(x, y, **tham_so)
print(f"{ten:27s} {epoch:5d} {acc_tr:9.1%} {loss_va:8.3f} {acc_va:7.1%}")
Cấu hình epoch acc train loss val acc val
Gốc, 400 mẫu 100 100.0% 1.818 73.8%
+ early stopping 18 87.7% 0.520 76.5%
+ weight decay 1.0 100 100.0% 1.135 73.6%
+ dropout 0.5 100 100.0% 1.584 73.9%
+ label smoothing 0.1 100 100.0% 0.627 71.6%
+ cả bốn 25 92.5% 0.501 78.4%
Gốc, 4000 mẫu 100 100.0% 2.377 79.8%
4000 mẫu + early stopping 17 88.0% 0.432 84.9%
Đọc bảng (một lần chạy, một seed: chênh lệch dưới 1 điểm phần trăm chưa có ý nghĩa):
- Mô hình gốc thuộc lòng 100% tập train, val chỉ 73,8%, val loss 1,82 (mô hình "tự tin sai" rất nhiều).
- Early stopping (giữ checkpoint có val loss thấp nhất, dừng sau 15 epoch không cải thiện) là cách rẻ nhất mà hiệu quả nhất trong nhóm: +2,7 điểm, val loss về 0,52, tiết kiệm 80% thời gian huấn luyện.
- Weight decay, dropout, label smoothing dùng riêng lẻ làm val loss tốt lên (mô hình bớt tự tin thái quá) nhưng không tăng độ chính xác ở đây, vì sau 100 epoch mô hình vẫn đủ sức học thuộc 400 mẫu. Đừng kỳ vọng một biện pháp đơn lẻ cứu được tập dữ liệu quá nhỏ.
- Kết hợp cả bốn cho kết quả tốt nhất với 400 mẫu: 78,4%.
- Thêm dữ liệu thắng tất cả: 4000 mẫu không cần mẹo gì đã được 79,8%, thêm early stopping lên 84,9%, gần mức trần khoảng 90%.
Thứ tự nên thử với bài toán ảnh thực tế:
- Kiểm tra rò rỉ dữ liệu trước (mục 8): đôi khi "overfitting" thật ra là val quá dễ hoặc quá khó so với thực tế.
- Thêm dữ liệu thật, đặc biệt dữ liệu đa dạng: nhiều lô, nhiều ca, nhiều ngày, nhiều điều kiện chiếu sáng. Đây gần như luôn là cách hiệu quả nhất.
- Transfer learning: dùng mô hình pretrained thay vì huấn luyện từ đầu khi chỉ có vài trăm đến vài nghìn ảnh.
- Augmentation hợp lý với vật lý của bài toán: lật, xoay nhẹ, đổi độ sáng trong dải đèn thật có thể dao động. Augmentation sai (lật ảnh có chữ, đổi màu khi màu là dấu hiệu lỗi) làm hại mô hình.
- Early stopping và luôn lưu checkpoint tốt nhất theo val.
- Weight decay với AdamW (0,01 đến 0,1 là dải thường dùng), dropout trước lớp phân loại (0,2 đến 0,5), label smoothing 0,05 đến 0,1 khi nhãn có thể không chắc chắn.
- Mô hình nhỏ hơn nếu mọi cách trên chưa đủ.
torch.optim.Adam, tham số weight_decay được cộng vào gradient (L2 cổ điển) rồi đi qua cơ chế thích nghi của Adam, nên tác dụng yếu và khó dự đoán. torch.optim.AdamW tách riêng phần giảm trọng số (Loshchilov và Hutter, "Decoupled Weight Decay Regularization"). Khi cần weight decay, dùng AdamW.Cách chia train/val/test không rò rỉ, tìm ảnh trùng bằng hash và đo các biện pháp trên dữ liệu ảnh: Overfitting, chia train/val/test không rò rỉ. Augmentation và transfer learning: Transfer Learning và Data Augmentation khi có ít dữ liệu. Khi thiếu ảnh lỗi: augmentation, cắt dán lỗi và dữ liệu tổng hợp.
8. Val tốt hơn train, và val "đẹp quá"
Loss val thấp hơn loss train
Thường không phải lỗi. Ba lý do phổ biến:
- Dropout và augmentation chỉ chạy lúc train (khi gọi
model.train()), làm bài train khó hơn bài val. - Loss train của một epoch là trung bình trong suốt epoch, khi mô hình còn đang học; loss val đo ở cuối epoch, khi mô hình đã tốt hơn.
- Label smoothing làm loss train không thể về 0, trong khi bạn đo val bằng loss gốc.
Muốn so sánh công bằng, đo lại loss trên tập train ở chế độ model.eval(), cùng cách đo với val.
Rò rỉ dữ liệu
Nếu val đạt 99,9% trong khi bài toán nổi tiếng là khó, hoặc kết quả val đẹp nhưng mang ra dây chuyền giảm mạnh, nghi ngờ đầu tiên là rò rỉ: thông tin của tập val đã lọt vào quá trình huấn luyện. Dạng hay gặp:
- Chia ngẫu nhiên theo ảnh, trong khi nhiều ảnh chụp cùng một sản phẩm, cùng lô, cùng phút: ảnh "anh em" nằm ở cả train và val. Chia theo nhóm (mã sản phẩm, lô, ngày).
- Ảnh trùng hoặc gần trùng (chụp lặp, file sao chép) giữa các tập.
- Tính mean/std chuẩn hóa, chọn đặc trưng, cân bằng lớp (oversampling) trên toàn bộ dữ liệu trước khi chia. Mọi thống kê phải tính trên tập train.
- Chỉnh siêu tham số nhiều vòng theo tập test: tập test dần dần trở thành tập val. Giữ một tập test chỉ dùng một lần ở cuối.
9. Accuracy cao nhưng bỏ sót lớp hiếm
Trong kiểm tra chất lượng, ảnh NG thường chỉ chiếm 1–5%. Mô hình có thể đạt accuracy rất cao chỉ bằng cách gần như luôn đoán OK. Thí nghiệm với dữ liệu 95% OK, 5% NG:
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset, WeightedRandomSampler
torch.manual_seed(0)
def tao_du_lieu(n_ok, n_ng):
"""Lớp 0 = OK, lớp 1 = NG. Hai lớp chồng lấn một phần."""
x_ok = torch.randn(n_ok, 8)
x_ng = torch.randn(n_ng, 8) + 1.0
x = torch.cat([x_ok, x_ng])
y = torch.cat([torch.zeros(n_ok), torch.ones(n_ng)]).long()
return x, y
x_tr, y_tr = tao_du_lieu(1900, 100) # 95% OK, 5% NG
x_te, y_te = tao_du_lieu(1900, 100)
def danh_gia(model):
model.eval()
with torch.no_grad():
du_doan = model(x_te).argmax(dim=1)
acc = (du_doan == y_te).float().mean().item()
tp = ((du_doan == 1) & (y_te == 1)).sum().item()
fn = ((du_doan == 0) & (y_te == 1)).sum().item()
fp = ((du_doan == 1) & (y_te == 0)).sum().item()
return acc, tp / (tp + fn), fp
def huan_luyen(cach):
torch.manual_seed(1)
model = nn.Sequential(nn.Linear(8, 32), nn.ReLU(), nn.Linear(32, 2))
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
ds = TensorDataset(x_tr, y_tr)
dem = torch.bincount(y_tr) # [1900, 100]
if cach == "class weight":
trong_so = len(y_tr) / (2 * dem.float()) # lớp hiếm có trọng số lớn hơn
loss_fn = nn.CrossEntropyLoss(weight=trong_so)
else:
loss_fn = nn.CrossEntropyLoss()
if cach == "sampler":
w_mau = (1.0 / dem.float())[y_tr] # mỗi mẫu NG được bốc thường hơn
sampler = WeightedRandomSampler(w_mau, num_samples=len(y_tr), replacement=True)
loader = DataLoader(ds, batch_size=64, sampler=sampler)
else:
loader = DataLoader(ds, batch_size=64, shuffle=True)
for _ in range(30):
model.train()
for xb, yb in loader:
opt.zero_grad()
loss_fn(model(xb), yb).backward()
opt.step()
return danh_gia(model)
for cach in ("không xử lý", "class weight", "sampler"):
acc, recall_ng, fp = huan_luyen(cach)
print(f"{cach:13s}: accuracy {acc:.1%} | bắt được {recall_ng:.0%} ảnh NG | báo nhầm {fp} ảnh OK thành NG")
không xử lý : accuracy 97.0% | bắt được 57% ảnh NG | báo nhầm 16 ảnh OK thành NG
class weight : accuracy 93.4% | bắt được 89% ảnh NG | báo nhầm 120 ảnh OK thành NG
sampler : accuracy 93.4% | bắt được 86% ảnh NG | báo nhầm 118 ảnh OK thành NG
Mô hình không xử lý có accuracy cao nhất (97%) nhưng bỏ lọt 43% sản phẩm lỗi, điều tệ nhất có thể xảy ra trong kiểm tra chất lượng. Trọng số lớp (weight trong CrossEntropyLoss) hoặc lấy mẫu cân bằng (WeightedRandomSampler) nâng tỉ lệ bắt lỗi lên 86–89%, đổi lại nhiều ảnh OK bị báo nhầm hơn (accuracy giảm còn 93,4%). Đây là đánh đổi thật, không có bữa trưa miễn phí: điểm cân bằng do bài toán quyết định (một sản phẩm lỗi lọt ra ngoài thiệt hại bao nhiêu so với một sản phẩm tốt bị loại nhầm).
Cách làm đúng:
- Đo bằng chỉ số đúng: ma trận nhầm lẫn, recall (tỉ lệ bắt được) và precision của lớp hiếm, F1; trong nhà máy thường gọi là tỉ lệ lọt (escape) và tỉ lệ loại nhầm (overkill). Không dùng accuracy làm chỉ số chính khi dữ liệu lệch.
- Chọn ngưỡng: thay vì
argmax, lấy xác suất NG và chọn ngưỡng trên tập val theo ràng buộc, ví dụ "recall NG ≥ 99%, rồi tối thiểu báo nhầm". Đây thường là đòn bẩy mạnh nhất và không cần huấn luyện lại. - Trọng số lớp, lấy mẫu cân bằng, focal loss: dùng một trong các cách, không chồng tất cả (dễ bù quá tay).
- Thu thập thêm mẫu lớp hiếm, hoặc tạo dữ liệu tổng hợp có kiểm soát.
Cross-entropy có trọng số, focal loss và pos_weight cho bài nhị phân: Hàm mất mát cho phân loại: cross-entropy, class weight, focal loss.
10. Đánh giá tốt, chạy thật lại kém
Quên chuyển chế độ eval
Dropout và BatchNorm hoạt động khác nhau giữa hai chế độ. Ở model.train(), dropout tắt ngẫu nhiên nơ-ron và BatchNorm dùng thống kê của chính batch đang chạy; ở model.eval(), dropout tắt hẳn và BatchNorm dùng thống kê tích lũy lúc huấn luyện. Quên model.eval() khi dự đoán thì kết quả nhảy lung tung giữa các lần gọi, phụ thuộc vào ảnh khác trong batch, và với một ảnh duy nhất thì báo lỗi:
import torch
from torch import nn
torch.manual_seed(0)
model = nn.Sequential(nn.Linear(4, 16), nn.BatchNorm1d(16), nn.ReLU(), nn.Dropout(0.5), nn.Linear(16, 2))
x = torch.randn(1, 4)
# Giả lập vài bước huấn luyện để BatchNorm có thống kê chạy (running mean/var)
model.train()
for _ in range(20):
model(torch.randn(32, 4))
with torch.no_grad():
model.train()
try:
model(x)
except ValueError as loi:
print("Chế độ train, 1 ảnh:", loi)
model.eval()
a, b = model(x), model(x)
print("Chế độ eval, 2 lần gọi ra cùng kết quả:", torch.equal(a, b))
Chế độ train, 1 ảnh: Expected more than 1 value per channel when training, got input size torch.Size([1, 16])
Chế độ eval, 2 lần gọi ra cùng kết quả: True
Quy tắc: gọi model.train() đầu mỗi epoch huấn luyện, model.eval() trước mọi lần đánh giá hay dự đoán, kèm torch.no_grad() (hoặc torch.inference_mode()) để không tốn bộ nhớ lưu đồ thị tính gradient. Đánh giá giữa các epoch xong nhớ chuyển lại model.train().
Tiền xử lý lúc chạy khác lúc huấn luyện
Lỗi rất phổ biến khi đưa mô hình xuống máy trạm: lúc huấn luyện ảnh được đọc bằng PIL (thứ tự kênh RGB), lúc chạy đọc từ camera bằng OpenCV (BGR); resize bằng phép nội suy khác; quên chia 255; dùng mean/std khác; cắt ROI lệch vài pixel. Mô hình vẫn cho ra kết quả, chỉ là sai hơn, và không có thông báo lỗi. Cách phòng: viết một hàm tiền xử lý duy nhất và dùng nó ở cả ba nơi (train, val, chạy thật), kiểm tra bằng một ảnh mẫu: đầu ra của pipeline huấn luyện và pipeline triển khai phải giống nhau đến từng giá trị.
import cv2
import numpy as np
import torch
# Một nguồn sự thật duy nhất cho tiền xử lý, dùng chung cho train, val và lúc chạy thật
KICH_THUOC = 224
MEAN = np.array([0.485, 0.456, 0.406], dtype=np.float32) # mean/std ImageNet khi dùng mô hình pretrained
STD = np.array([0.229, 0.224, 0.225], dtype=np.float32)
def tien_xu_ly(anh_bgr):
"""Ảnh BGR uint8 từ cv2.imread hoặc camera -> tensor 1x3x224x224 float32."""
anh = cv2.cvtColor(anh_bgr, cv2.COLOR_BGR2RGB) # OpenCV đọc BGR, mô hình học bằng RGB
anh = cv2.resize(anh, (KICH_THUOC, KICH_THUOC), interpolation=cv2.INTER_AREA)
anh = anh.astype(np.float32) / 255.0
anh = (anh - MEAN) / STD
return torch.from_numpy(anh.transpose(2, 0, 1)).unsqueeze(0)
anh = np.zeros((480, 640, 3), dtype=np.uint8)
anh[:, :, 2] = 255 # ảnh đỏ thuần theo thứ tự BGR
t = tien_xu_ly(anh)
print(t.shape, t.dtype, [round(t[0, c].mean().item(), 2) for c in range(3)])
torch.Size([1, 3, 224, 224]) torch.float32 [2.25, -2.04, -1.8]
Ảnh đỏ thuần cho kênh đầu tiên (R) giá trị cao nhất sau chuẩn hóa: đúng thứ tự RGB. Nếu bạn thấy kênh thứ ba cao nhất, ảnh đã bị đảo kênh.
Dữ liệu thật khác dữ liệu huấn luyện
Đèn già đi, camera bị chỉnh lại tiêu cự, nhà cung cấp linh kiện đổi màu nhựa, ca đêm có ánh sáng khác: phân phối dữ liệu thay đổi (domain shift, drift) và mô hình xuống cấp dần. Cách xử lý: đưa dữ liệu từ nhiều điều kiện vào train ngay từ đầu, giữ một "golden set" ảnh chuẩn để kiểm tra định kỳ, theo dõi phân phối điểm tin cậy của mô hình trên dây chuyền, và định kỳ thu ảnh mới để huấn luyện lại.
11. Thông báo lỗi thường gặp
Các thông báo dưới đây được tái hiện với PyTorch 2.14; nội dung có thể thay đổi nhẹ giữa các phiên bản, nhưng từ khóa chính giữ nguyên.
| Thông báo | Nguyên nhân | Cách sửa |
|---|---|---|
expected target dtype to be Long or Byte, but got Float | Nhãn của CrossEntropyLoss là số thực | Nhãn chỉ số lớp phải là số nguyên: y.long() |
Target 3 is out of bounds. | Có nhãn ≥ số lớp đầu ra (nhãn đánh số từ 1, hoặc lớp cuối khai thiếu) | Nhãn phải từ 0 đến C−1; kiểm tra y.unique() và số đầu ra của lớp cuối |
Target size (torch.Size([4])) must be the same as input size (torch.Size([4, 1])) | BCEWithLogitsLoss cần nhãn cùng kích thước với đầu ra | y.float().unsqueeze(1), hoặc model(x).squeeze(1) |
mat1 and mat2 shapes cannot be multiplied (4x2048 and 1024x3) | Số đặc trưng sau Flatten khác in_features của lớp Linear (thường do đổi kích thước ảnh) | In x.shape ngay trước lớp Linear; hoặc dùng nn.AdaptiveAvgPool2d(1) để không phụ thuộc kích thước ảnh |
Given groups=1, weight of size [8, 3, 3, 3], expected input[1, 32, 32, 3] to have 3 channels, but got 32 channels instead | Ảnh ở dạng HWC (NumPy, OpenCV) trong khi PyTorch cần CHW | torch.from_numpy(anh).permute(2, 0, 1), thêm chiều batch bằng unsqueeze(0) |
mat1 and mat2 must have the same dtype, but got Double and Float; Input type (unsigned char) and bias type (float) should be the same | Dữ liệu là float64 (mặc định của NumPy) hoặc uint8 (ảnh thô) | x.float(); với ảnh, x.float() / 255 rồi chuẩn hóa |
Expected more than 1 value per channel when training | BatchNorm ở chế độ train nhận batch 1 mẫu: hay gặp ở batch cuối của epoch, hoặc khi quên model.eval() | Dự đoán thì gọi model.eval(); huấn luyện thì DataLoader(..., drop_last=True) |
Expected all tensors to be on the same device | Mô hình trên GPU, dữ liệu trên CPU (hoặc ngược lại); tensor tạo mới trong forward mà quên chuyển thiết bị | xb, yb = xb.to(thiet_bi), yb.to(thiet_bi) trong mỗi bước; tensor mới tạo theo device=x.device |
CUDA out of memory | Batch, ảnh hoặc mô hình quá lớn so với bộ nhớ GPU; giữ đồ thị tính toán ngoài ý muốn | Xem bên dưới |
Chương trình treo hoặc chạy lại từ đầu nhiều lần khi num_workers > 0 trên Windows | Windows (và macOS) khởi động worker bằng cách chạy lại script chính | Đặt code chính trong if __name__ == "__main__": (ví dụ ở mục 12) |
Hết bộ nhớ GPU
Theo thứ tự ít ảnh hưởng đến kết quả nhất:
- Không giữ đồ thị tính toán: ghi log bằng
loss.item()chứ không cộng dồntong += loss(cách sau giữ toàn bộ đồ thị của mọi bước trong bộ nhớ); đánh giá trongtorch.no_grad(). - Mixed precision (
torch.autocast+torch.amp.GradScaler): giảm bộ nhớ kích hoạt và thường tăng tốc trên GPU có Tensor Core. - Giảm batch và tích lũy gradient: chạy 4 batch 8 ảnh rồi mới cập nhật trọng số một lần, tương đương về gradient với batch 32 (trừ các lớp phụ thuộc kích thước batch như BatchNorm).
- Gradient checkpointing (
torch.utils.checkpoint): tính lại kích hoạt khi backward thay vì lưu, đổi thời gian lấy bộ nhớ. - Giảm kích thước ảnh hoặc dùng mô hình nhỏ hơn: ảnh hưởng đến độ chính xác, nên để cuối.
Đoạn sau kết hợp mixed precision, tích lũy gradient và gradient clipping theo đúng thứ tự mà tài liệu PyTorch hướng dẫn (phải unscale_ trước khi clip). Code tự tắt AMP khi không có GPU, nên chạy được cả trên CPU:
import torch
from torch import nn
thiet_bi = "cuda" if torch.cuda.is_available() else "cpu"
dung_amp = thiet_bi == "cuda" # float16 chỉ có lợi trên GPU
model = nn.Sequential(nn.Linear(100, 256), nn.ReLU(), nn.Linear(256, 10)).to(thiet_bi)
opt = torch.optim.AdamW(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()
scaler = torch.amp.GradScaler(thiet_bi, enabled=dung_amp)
BATCH_NHO = 8 # batch vừa bộ nhớ GPU
TICH_LUY = 4 # 4 batch nhỏ = 1 batch hiệu dụng 32
du_lieu = [(torch.randn(BATCH_NHO, 100), torch.randint(0, 10, (BATCH_NHO,))) for _ in range(16)]
model.train()
opt.zero_grad(set_to_none=True)
for i, (xb, yb) in enumerate(du_lieu, start=1):
xb, yb = xb.to(thiet_bi), yb.to(thiet_bi)
with torch.autocast(device_type=thiet_bi, dtype=torch.float16, enabled=dung_amp):
loss = loss_fn(model(xb), yb) / TICH_LUY # chia để gradient bằng trung bình của batch lớn
scaler.scale(loss).backward()
if i % TICH_LUY == 0:
scaler.unscale_(opt) # bỏ hệ số scale trước khi clip
chuan = nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
scaler.step(opt) # tự bỏ qua bước nếu gradient có inf/NaN
scaler.update()
opt.zero_grad(set_to_none=True)
print(f"Cập nhật trọng số sau batch {i:2d}, chuẩn gradient {chuan.item():.3f}")
Cập nhật trọng số sau batch 4, chuẩn gradient 1.370
Cập nhật trọng số sau batch 8, chuẩn gradient 1.292
Cập nhật trọng số sau batch 12, chuẩn gradient 1.257
Cập nhật trọng số sau batch 16, chuẩn gradient 1.188
torch.cuda.empty_cache() không giải phóng được tensor bạn vẫn còn giữ tham chiếu; nó chỉ trả lại bộ nhớ đệm không dùng cho các chương trình khác. Đừng dựa vào nó để sửa lỗi hết bộ nhớ.
12. Kết quả không lặp lại được
Chạy lại cùng code ra kết quả lệch vài điểm phần trăm là bình thường nếu chưa cố định nguồn ngẫu nhiên: khởi tạo trọng số, thứ tự xáo trộn dữ liệu, augmentation, dropout, và một số thuật toán GPU không tất định. Khi cần so sánh hai cấu hình một cách công bằng, hoặc cần tái hiện một lỗi, cố định seed theo hướng dẫn trong tài liệu PyTorch:
import random
import numpy as np
import torch
from torch.utils.data import DataLoader, TensorDataset
def dat_hat_giong(seed=42):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed) # gieo cho cả CPU và mọi GPU
torch.backends.cudnn.benchmark = False
torch.use_deterministic_algorithms(True, warn_only=True)
def seed_worker(worker_id):
worker_seed = torch.initial_seed() % 2**32
np.random.seed(worker_seed)
random.seed(worker_seed)
if __name__ == "__main__": # bắt buộc trên Windows khi num_workers > 0
dat_hat_giong(42)
g = torch.Generator()
g.manual_seed(42)
ds = TensorDataset(torch.arange(10.0))
loader = DataLoader(ds, batch_size=4, shuffle=True, num_workers=2,
worker_init_fn=seed_worker, generator=g)
print([b[0].tolist() for b in loader])
[[6.0, 5.0, 4.0, 0.0], [8.0, 9.0, 2.0, 1.0], [3.0, 7.0]]
Chạy script bao nhiêu lần cũng in ra đúng dòng trên: cùng thứ tự batch, kể cả khi dùng 2 worker. Lưu ý:
- Tài liệu PyTorch nói rõ: kết quả tái lập hoàn toàn không được đảm bảo giữa các phiên bản PyTorch, giữa CPU và GPU, giữa các loại GPU. Mục tiêu thực tế là lặp lại trên cùng máy, cùng môi trường.
use_deterministic_algorithms(True)có thể làm chậm và báo lỗi với phép toán không có bản tất định;warn_only=Truechỉ cảnh báo thay vì dừng.- Ngay cả khi đã cố định seed, đừng kết luận từ một lần chạy: chạy 3 đến 5 seed khác nhau và so sánh trung bình, nhất là khi chênh lệch chỉ một hai điểm phần trăm.
13. Checklist khi huấn luyện "có vấn đề"
- Loss khởi tạo có gần \(\ln C\) không?
- Mô hình có học thuộc được một batch nhỏ không?
- Ảnh và nhãn lấy ra từ DataLoader có đúng không (màu, hướng, giá trị, dtype, khớp nhãn)?
- Đầu vào đã chuẩn hóa theo thống kê của tập train chưa?
- Loss nhận logits (không softmax/sigmoid thừa), có đủ
zero_grad,backward,step? - Learning rate đã chọn có cơ sở (LR range test, giá trị chuẩn cho optimizer) chưa?
- Có ghi loss train và val mỗi epoch, lưu checkpoint tốt nhất theo val không?
- Đã chia dữ liệu theo nhóm, kiểm tra ảnh trùng giữa các tập chưa?
- Dữ liệu có lệch lớp không? Đang đo bằng recall/precision và đã chọn ngưỡng trên val chưa?
- Đánh giá và dự đoán có
model.eval()vàtorch.no_grad()không? - Tiền xử lý lúc chạy thật có dùng đúng hàm của lúc huấn luyện không?
- Kết luận có dựa trên nhiều seed không?
14. Bài tập
Bài 1. Đọc nhật ký huấn luyện
Phân loại 10 lớp. Nhật ký sau 4 lần huấn luyện khác nhau (loss train / loss val):
- A: epoch 1: 2,31 / 2,30; epoch 20: 2,30 / 2,30; epoch 50: 2,30 / 2,30.
- B: epoch 1: 1,90 / 1,85; epoch 20: 0,45 / 0,62; epoch 50: 0,02 / 1,40.
- C: epoch 1: 27,6 / nan.
- D: epoch 1: 1,20 / 1,05; epoch 20: 0,60 / 0,48; epoch 50: 0,41 / 0,35.
Chẩn đoán từng trường hợp và nêu việc đầu tiên nên làm.
Xem đáp án
- A: loss đứng yên ở \(\ln 10 \approx 2{,}30\), tức mô hình vẫn đoán đều như lúc khởi tạo. Gần như chắc chắn là lỗi code hoặc lr: trọng số không được cập nhật (quên
step, optimizer giữ tham số cũ, đóng băng nhầm), lr quá nhỏ, hoặc nhãn không khớp ảnh. Việc đầu tiên: phép thử học thuộc một batch. - B: overfitting rõ ràng. Val tốt nhất quanh epoch 20, sau đó tăng mạnh. Việc đầu tiên: lưu checkpoint tốt nhất theo val (early stopping); sau đó kiểm tra rò rỉ, thêm dữ liệu, augmentation, weight decay.
- C: loss ban đầu 27,6 gấp hơn 10 lần \(\ln 10\), rồi NaN. Đầu vào chưa chuẩn hóa hoặc có giá trị khổng lồ, có thể kèm lr quá lớn. Việc đầu tiên: in min/max/mean của một batch, kiểm tra
torch.isfinite, chuẩn hóa dữ liệu. - D: bình thường. Val thấp hơn train do dropout/augmentation, và cả hai vẫn đang giảm: có thể huấn luyện thêm.
Bài 2. Tìm lỗi trong vòng lặp huấn luyện
Đoạn code sau chạy không báo lỗi nhưng mô hình học rất kém và kết quả đánh giá thay đổi mỗi lần chạy. Tìm ít nhất 4 lỗi.
# Vòng lặp có lỗi (minh họa)
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
model.fc = nn.Linear(512, 2)
tong_loss = 0
for xb, yb in train_loader:
out = torch.softmax(model(xb), dim=1)
loss = nn.CrossEntropyLoss()(out, yb)
loss.backward()
opt.step()
tong_loss += loss
dung = 0
for xb, yb in val_loader:
dung += (model(xb).argmax(1) == yb).sum().item()
Xem đáp án
- Optimizer được tạo trước khi thay
model.fc: lớp phân loại mới không bao giờ được cập nhật. Thay lớp trước rồi mới tạo optimizer. torch.softmaxtrướcCrossEntropyLoss: bỏ softmax, đưa logits vào loss.- Thiếu
opt.zero_grad(): gradient cộng dồn qua mọi bước. tong_loss += lossgiữ đồ thị tính toán của mọi bước (tốn bộ nhớ, có thể hết bộ nhớ GPU): dùngloss.item().- Đánh giá thiếu
model.eval()vàtorch.no_grad(): dropout và BatchNorm còn ở chế độ train nên kết quả thay đổi mỗi lần, lại tốn bộ nhớ. Thiếu cảmodel.train()ở đầu vòng huấn luyện (cần thiết khi vòng lặp chạy nhiều epoch xen kẽ đánh giá).
Bài 3. Chọn chỉ số cho trạm kiểm tra
Trạm kiểm tra vỏ hộp: trung bình 2 sản phẩm lỗi trên 1000. Mô hình A: accuracy 99,8%, recall NG 10%. Mô hình B: accuracy 97,0%, recall NG 99%. Khách hàng phạt rất nặng khi nhận hàng lỗi. Chọn mô hình nào, và mô hình B còn cần gì trước khi đưa vào chạy?
Xem đáp án
Chọn B. Mô hình A gần như chỉ đoán OK: accuracy 99,8% ngang mức "luôn đoán OK", bỏ lọt 90% hàng lỗi. Mô hình B bắt 99% lỗi, đổi lại khoảng 3% sản phẩm bị loại nhầm (gần như toàn bộ 3% accuracy mất đi là báo nhầm hàng tốt, vì hàng lỗi chỉ chiếm 0,2%). Trước khi chạy: chọn lại ngưỡng trên tập val để giảm loại nhầm mà vẫn giữ recall theo yêu cầu, ước lượng số sản phẩm phải kiểm tra lại bằng tay mỗi ca (khoảng 30 trên 1000), kiểm tra trên một tập test chụp ở ngày, lô khác với dữ liệu huấn luyện.
Tóm tắt
- Luôn ghi và nhìn hai đường loss train và val; hình dạng của chúng chỉ thẳng tới nhóm nguyên nhân.
- Trước khi huấn luyện dài: kiểm tra loss khởi tạo ≈ \(\ln C\), học thuộc một batch, xem dữ liệu ngay trước mô hình, tính mốc đơn giản.
- Lỗi code hay gặp nhất: softmax thừa trước
CrossEntropyLoss, quênzero_grad, optimizer tạo trước khi sửa mô hình, dữ liệu chưa chuẩn hóa. - NaN: giảm lr, chuẩn hóa dữ liệu, dùng hàm loss ổn định số; clipping là lưới an toàn, không phải cách chữa.
- Overfitting: thêm dữ liệu đa dạng là mạnh nhất, early stopping là rẻ nhất; weight decay (AdamW), dropout, label smoothing hỗ trợ khi kết hợp.
- Dữ liệu lệch: đo recall/precision của lớp hiếm, chọn ngưỡng trên val, không tin accuracy.
- Triển khai:
model.eval(),torch.no_grad(), một hàm tiền xử lý dùng chung, theo dõi drift.
Nguồn tham khảo: Andrej Karpathy: A Recipe for Training Neural Networks, PyTorch: CrossEntropyLoss, PyTorch: CUDA Automatic Mixed Precision examples, PyTorch: Reproducibility, PyTorch: torch.utils.data (multi-process loading trên Windows), Leslie N. Smith: Cyclical Learning Rates for Training Neural Networks (LR range test), Loshchilov, Hutter: Decoupled Weight Decay Regularization (AdamW), Szegedy và cộng sự: Rethinking the Inception Architecture (label smoothing).


