Log loss và cross entropy: xác suất, odds, log-odds
Bài 3/8 · Chương 12
Toán vừa đủ cho Machine Learning
- 9 phút
- Trung cấp
- Python 3.14
- Cập nhật
Trong bài này · 12
Log loss, còn gọi là cross entropy nhị phân (binary cross entropy), chấm các xác suất mà một model phân loại đưa ra: mỗi dòng bị phạt −log của xác suất model gán cho nhãn thật, rồi lấy trung bình. Dòng có nhãn thật được gán xác suất cao chịu phạt gần 0, dòng bị gán xác suất gần 0 chịu phạt rất lớn. Vì vậy log loss là thước đo bạn cần khi chính con số xác suất được đem đi dùng.
Cần biết trước: hàm sigmoid và odds ratio.
Từ xác suất tới odds và log-odds
Model của Sóc Nhanh đoán xác suất một hội viên Sóc Vàng hủy gói trong hai tháng tới. Xác suất p nằm từ 0 tới 1. Odds là p / (1 − p): p = 0,75 cho odds 3, tức khả năng hủy gấp ba khả năng ở lại. Log-odds (logit) là log tự nhiên của odds, chạy từ âm vô cùng tới dương vô cùng, và bằng 0 đúng khi p = 0,5:
import numpy as np
p = np.array([0.1, 0.25, 0.5, 0.75, 0.9])
odds = p / (1 - p)
log_odds = np.log(odds)
print(odds.round(3))
print(log_odds.round(3))
print((1 / (1 + np.exp(-log_odds))).round(3))KẾT QUẢ
[0.111 0.333 1. 3. 9. ]
[-2.197 -1.099 0. 1.099 2.197]
[0.1 0.25 0.5 0.75 0.9 ]Log-odds đối xứng quanh 0: p = 0,25 và p = 0,75 cho −1,099 và +1,099. Dòng cuối đưa log-odds qua sigmoid và nhận lại đúng năm xác suất ban đầu, vì logit và sigmoid là hai hàm ngược của nhau. Vì logit trải trên cả trục số, logistic regression đặt phần tuyến tính của nó (hệ số chặn cộng các trọng số nhân feature) trên thang này, rồi mới dùng sigmoid để quay về xác suất. Đổi 0.9 thành 0.99 rồi chạy lại: log-odds cuối thành 4.595, tăng gấp đôi chỉ vì p nhích thêm 0,09.
Công thức log loss và tính tay
Với n dòng, nhãn yᵢ là 0 hay 1, và pᵢ là xác suất model gán cho nhãn 1:
Trong đó:
n (
len(y)): số dòng được chấm.y với chỉ số i (
y[i]): nhãn thật của dòng thứ i, 1 là hủy gói.p với chỉ số i (
p[i]): xác suất hủy mà model đưa ra cho dòng đó, cột 1 củapredict_proba().ln (
np.log): log tự nhiên.L (
log_loss(y, p)): log loss, càng nhỏ càng tốt.
Ở mỗi dòng chỉ một trong hai số hạng còn lại: nhãn 1 thì phạt −ln p, nhãn 0 thì phạt −ln(1 − p). Bốn hội viên có nhãn 1, 0, 1, 0 và xác suất hủy 0,8; 0,3; 0,6; 0,1:
Hội viên | Nhãn | p | Phạt |
|---|---|---|---|
1 | 1 | 0,8 | −ln 0,8 = 0,2231 |
2 | 0 | 0,3 | −ln 0,7 = 0,3567 |
3 | 1 | 0,6 | −ln 0,6 = 0,5108 |
4 | 0 | 0,1 | −ln 0,9 = 0,1054 |
Trung bình | 1,1960 / 4 = 0,299 |
import math
y = [1, 0, 1, 0]
p = [0.8, 0.3, 0.6, 0.1]
tong = 0
for yi, pi in zip(y, p):
phat = -(yi * math.log(pi) + (1 - yi) * math.log(1 - pi))
tong += phat
print(yi, pi, round(phat, 4))
print("log loss:", round(tong / len(y), 4))KẾT QUẢ
1 0.8 0.2231
0 0.3 0.3567
1 0.6 0.5108
0 0.1 0.1054
log loss: 0.299Tên "cross entropy" đến từ lý thuyết thông tin, cùng nguồn với entropy ở bài Gini, entropy và information gain. Nó đo mức lệch giữa phân phối nhãn thật (chắc chắn 0 hay 1) và phân phối model đoán; mức lệch này không đối xứng, nên không phải một khoảng cách. Với hai lớp, hai tên chỉ cùng một con số.
So với log_loss() của sklearn
sklearn.metrics.log_loss(y, p) nhận nhãn và xác suất của lớp 1. Bản NumPy viết công thức trên cả mảng một lần, rồi mean() lấy trung bình theo trục duy nhất:
import numpy as np
from sklearn.metrics import log_loss
y = np.array([1, 0, 1, 0])
p = np.array([0.8, 0.3, 0.6, 0.1])
tu_tinh = -(y * np.log(p) + (1 - y) * np.log(1 - p)).mean()
print(round(tu_tinh, 4), round(log_loss(y, p), 4))
print("đoán 0,5 cho cả bốn:", round(log_loss(y, [0.5] * 4), 4))KẾT QUẢ
0.299 0.299
đoán 0,5 cho cả bốn: 0.6931Hai cách khớp nhau. Một model chẳng biết gì, đoán 0,5 cho mọi dòng, có log loss ln 2 ≈ 0,693, nên 0,299 là tốt hơn hẳn mức đoán mò. Mốc so sánh đúng hơn là đoán đúng tỉ lệ hủy của tập train cho mọi dòng, như cách baseline đặt mốc cho hồi quy.
Tự tin mà sai bị phạt nặng
Phạt −ln p của một hội viên thật sự hủy gói, khi model gán cho người đó xác suất hủy 0,99; 0,8; 0,5; 0,2; 0,02:
import numpy as np
p_dung = np.array([0.99, 0.8, 0.5, 0.2, 0.02])
print((-np.log(p_dung)).round(3))KẾT QUẢ
[0.01 0.223 0.693 1.609 3.912]Từ 0,99 xuống 0,8 phạt chỉ tăng 0,21, nhưng từ 0,2 xuống 0,02 phạt tăng 2,3. Hệ quả: hai model cùng accuracy có thể có log loss khác xa. Hai phiên bản model chấm mười hội viên và cùng nhầm hội viên thứ ba và thứ năm. Bản "dè dặt" chỉ nói 0,65 hay 0,35; bản "quả quyết" nói 0,98 hay 0,02:
import numpy as np
from sklearn.metrics import accuracy_score, log_loss
y = np.array([1, 0, 0, 1, 1, 0, 1, 0, 0, 1])
p_de_dat = np.array([0.65, 0.35, 0.65, 0.65, 0.35,
0.35, 0.65, 0.35, 0.35, 0.65])
p_quyet = np.array([0.98, 0.02, 0.98, 0.98, 0.02,
0.02, 0.98, 0.02, 0.02, 0.98])
for ten, p in [("dè dặt", p_de_dat), ("quả quyết", p_quyet)]:
acc = accuracy_score(y, p > 0.5)
print(ten, acc, round(log_loss(y, p), 3))KẾT QUẢ
dè dặt 0.8 0.555
quả quyết 0.8 0.799Ở tám dòng đúng, bản quả quyết chỉ mất khoảng 0,02 mỗi dòng. Nhưng mỗi dòng nhầm của nó tốn 3,9, con số cuối của khối trước, nên hai lần nhầm đủ đẩy trung bình của nó vượt bản dè dặt. Accuracy chỉ nhìn xác suất nằm bên nào của 0,5, còn log loss nhìn cả độ chắc. ROC-AUC cũng chỉ nhìn thứ tự xếp hạng, nên model có AUC cao vẫn có thể có log loss xấu.
Kiểm tra nhanh
Sau
import numpy as np,print(round(float(np.log(0.75 / 0.25)), 4))in ra gì?3.00.47711.0986
Trong ví dụ mười hội viên, bản dè dặt và bản quả quyết cùng accuracy 0,8. Vì sao log loss của bản quả quyết lớn hơn?
- Hai dòng nó nhầm chỉ được gán xác suất 0,02 cho nhãn thật, mỗi dòng phạt khoảng 3,9
- Bản quả quyết nhầm nhiều dòng hơn
- Log loss thưởng cho model nói 0,5 ở mọi dòng
Những câu nào đúng về log loss và log-odds?
- Log-odds bằng 0 khi p = 0,5
- Một dòng nhãn 1 có p = 0,99 bị phạt gần 0
- Hai model cùng accuracy thì cùng log loss
- Log loss nhỏ hơn khi model gán p = 0 cho dòng có nhãn 1
Trong khung bẫy, vì sao
log_loss(y, model.predict(X))ra 9,011 trong khi xác suất cho 0,322?- Vì
predict()trả về log-odds - Vì nhãn 0/1 bị coi là xác suất chắc chắn, mỗi dòng sai phạt khoảng 36
- Vì
log_loss()đòiylà số thực
- Vì
Bài tập
Tự tính log loss bằng NumPy
y là mảng nhãn 0/1, p là mảng xác suất của nhãn 1 cùng độ dài, có thể có số đúng bằng 0 hay 1.
Viết thân hàm do_log_loss(y, p): dùng np.clip() kẹp p vào đoạn từ 1e-15 tới 1 - 1e-15, rồi tính log loss theo công thức của bài với log tự nhiên. Không dùng log_loss() của sklearn.
Hàm không sửa y, p của nơi gọi.
Trả về: log loss, một float.
Ví dụ: do_log_loss(np.array([1, 0, 1, 0]), np.array([0.8, 0.3, 0.6, 0.1])) trả về khoảng 0.299.
import numpy as np
def do_log_loss(y, p):
pass # Viết thân hàm thay cho dòng nàyTóm tắt
Odds là p / (1 − p); log-odds là ln của odds, bằng 0 khi p = 0,5, và sigmoid đổi nó về p.
Log loss là trung bình của −ln xác suất mà model gán cho nhãn thật; hai lớp thì cross entropy là cùng con số.
log_loss(y, p)cần cột xác suất của lớp 1, không cần nhãn củapredict().Phạt tăng rất nhanh khi p của nhãn thật tiến về 0: tự tin mà sai đắt hơn nhiều sai mà lưỡng lự.
Hai model cùng accuracy có thể có log loss khác xa.
Tự viết công thức thì kẹp p bằng
np.clip()trước khi lấy log.
Câu hỏi thường gặp
Hàm log loss là gì, khác accuracy ở đâu?
Log loss chấm xác suất, accuracy chấm nhãn sau khi cắt ở 0,5. Trong ví dụ mười hội viên, hai bản model cùng accuracy 0,8 nhưng log loss 0,555 và 0,799. Dùng log loss khi xác suất được đem đi dùng, ví dụ để xếp hội viên cần gọi giữ chân, hay khi so độ tin cậy của xác suất như bài calibration.
Trong phân loại hai lớp, cross entropy loss và log loss có khác nhau không?
Không. Với hai lớp, binary cross entropy của Keras, PyTorch và log_loss() của sklearn tính cùng công thức, chỉ khác cách đặt tên. Với nhiều lớp, cross entropy lấy −ln của xác suất gán cho lớp đúng trong số các lớp, và log_loss() vẫn tính được khi bạn đưa cả ma trận predict_proba().
Log loss bao nhiêu thì là tốt?
Không có mốc chung, vì nó phụ thuộc tỉ lệ nhãn. So với mô hình đoán đúng tỉ lệ nhãn 1 của tập train cho mọi dòng: với tỉ lệ 20%, mốc này có log loss khoảng 0,5. Model phải thấp hơn mốc đó trên tập test, như cách bài baseline so model với mốc.
Vì sao logistic regression học bằng log loss, không học bằng MSE?
Log loss trên đầu ra sigmoid là một hàm lồi theo hệ số, nên không có đáy giả để gradient descent mắc kẹt; MSE trên sigmoid thì không lồi và gradient gần như tắt khi model sai mà tự tin. Bài logistic regression dùng predict_proba() của model học theo cách này.
Chủ đề
Bài này có hữu ích?
Hỏi đáp
Tham vấn chuyên môn
Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE
- Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
- Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
- Xây hệ thống AI cho doanh nghiệp tại VietPlatform.