Bỏ qua đến nội dung chính
Mục lục

Log loss và cross entropy: xác suất, odds, log-odds

AIDev Team · duyệt: Nguyễn Việt Chung

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

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:

python
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:

L=−1n∑i=1n[yiln⁡pi+(1−yi)ln⁡(1−pi)]L = -\frac{1}{n}\sum_{i=1}^{n} \left[ y_i \ln p_i + (1 - y_i) \ln (1 - p_i) \right]

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ủa predict_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

python
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.299

Tê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:

python
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.6931

Hai 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:

python
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:

python
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

  1. Sau import numpy as np, print(round(float(np.log(0.75 / 0.25)), 4)) in ra gì?

    • 3.0
    • 0.4771
    • 1.0986
  2. 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
  3. 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
  4. 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() đòi y là số thực
Đúng hết lần đầu +15 XP

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.

python
import numpy as np

def do_log_loss(y, p):
    pass  # Viết thân hàm thay cho dòng này

Tó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ủa predict().

  • 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ủ đề

cross entropy

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

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.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập