Classification metrics

Bốn ô trước một con số tổng

Quy ước lớp dương (positive) là cần hỗ trợ, nhãn 1. Lớp âm (negative), nhãn 0, là chưa cần hỗ trợ. Dương không có nghĩa tốt, âm không có nghĩa xấu; chúng là tên hai vai trò trong phép đo.

True positive (TP) là báo cần và thật sự cần. False positive (FP) là báo cần nhưng thật sự chưa cần. False negative (FN) là báo chưa cần nhưng thật sự cần. True negative (TN) là báo chưa cần và đúng là chưa cần.

Cách nhớ: chữ thứ hai (positive, negative) là điều model báo; chữ đầu (true, false) cho biết báo đúng hay sai. Mỗi buổi rơi vào đúng một ô, và tổng bốn ô bằng số buổi. Bảng bốn ô này gọi là confusion matrix: hai ô trên đường chéo (TP, TN) là đoán đúng, hai ô còn lại cho biết model nhầm lớp nào thành lớp nào. Trong scikit-learn, với labels=[0, 1], nó được in theo thứ tự [[TN, FP], [FN, TP]]; tài liệu khác có thể vẽ theo chiều khác, nên luôn đọc nhãn hàng, cột trước.

Khi hai loại lỗi có giá khác nhau, nhân số lỗi với giá rồi so tổng: nếu một FP tốn 1 và một FN tốn 10, thì 20 FP và 30 FN tốn $20 + 300 = 320$.

Precision, recall và F1 nhìn những nhóm khác nhau

Accuracy đo tỉ lệ dự đoán đúng trên mọi mẫu:

Precision hỏi: trong những buổi model đã báo cần, bao nhiêu buổi thật sự cần? Recall hỏi: trong những buổi thật sự cần, model phát hiện được bao nhiêu?

Precision thấp thì người hỗ trợ phải đến nhiều buổi không cần. Recall thấp thì nhiều buổi cần hỗ trợ bị bỏ sót. Model luôn báo “cần” có recall bằng 1, nhưng precision chỉ bằng tỉ lệ buổi cần trong dữ liệu. Ngoài ra còn specificity $= TN/(TN + FP)$, tức recall của lớp âm.

Ưu tiên cái nào là tùy bài toán. Sàng lọc bệnh hay quét mã độc: bỏ sót rất đắt, còn báo nhầm thì đã có người kiểm lại, nên ưu tiên recall. Lọc thư rác mà vứt nhầm thư công việc, hay ẩn nhầm bình luận bình thường: báo nhầm gây hại, nên ưu tiên precision.

F1 là trung bình điều hòa của precision $P$ và recall $R$:

Chỉ cần một trong hai thấp là F1 bị kéo thấp: $P = 0.5$, $R = 1$ cho $F_1 = 2 \cdot 0.5 \cdot 1 / 1.5 \approx 0.67$, thấp hơn trung bình cộng 0.75. F1 không dùng đến TN. Khi model không báo dương lần nào, precision có mẫu số 0; khi dữ liệu không có mẫu dương nào, recall có mẫu số 0. Code trong bài ghi rõ zero_division=0 để những trường hợp đó tính là 0.

Một validation nhỏ để tính và đối chiếu

Giả sử mô hình đã trả xác suất cần hỗ trợ cho mười buổi validation. Ta cố ý dùng một mảng nhỏ để tính tay; code không huấn luyện mô hình trong bài này. Score lớn hơn nghĩa là model đánh giá khả năng cần hỗ trợ cao hơn. Threshold $t$ biến score thành nhãn:

$\mathbf 1[\cdot]$ bằng 1 khi điều kiện đúng, bằng 0 khi sai. Quy tắc dùng dấu lớn hơn hay lớn hơn hoặc bằng phải thống nhất, nhất là khi score đúng bằng threshold.

import numpy as np
from sklearn.metrics import (
    confusion_matrix, accuracy_score, precision_score, recall_score, f1_score,
)

y_valid = np.array([1, 0, 1, 0, 0, 1, 0, 0, 1, 0])
p_valid = np.array([0.95, 0.80, 0.70, 0.65, 0.60, 0.55, 0.40, 0.30, 0.20, 0.10])
prediction = (p_valid >= 0.5).astype(int)
cm = confusion_matrix(y_valid, prediction, labels=[0, 1])
tn, fp, fn, tp = cm.ravel()
print(cm)
print('TN, FP, FN, TP:', tn, fp, fn, tp)
print(f'Accuracy={accuracy_score(y_valid, prediction):.3f}')
print(f'Precision={precision_score(y_valid, prediction, zero_division=0):.3f}')
print(f'Recall={recall_score(y_valid, prediction, zero_division=0):.3f}')
print(f'F1={f1_score(y_valid, prediction, zero_division=0):.3f}')

Kết quả[[3 3]
 [1 3]]
TN, FP, FN, TP: 3 3 1 3
Accuracy=0.600
Precision=0.500
Recall=0.750
F1=0.600

Ở ngưỡng 0.5, sáu buổi được báo cần; trong đó ba buổi thật sự cần. Có bốn buổi dương thật và ta tìm được ba. Vì vậy precision 0.5, recall 0.75, F1 $=6/(6+3+1)=0.6$. Accuracy cũng bằng 0.6 ở dữ liệu này, nhưng hai metric trùng số chỉ là tình cờ.

Quay lại ví dụ 100 buổi đầu bài: luôn đoán 0 cho TP = 0, FN = 3, FP = 0, TN = 97. Accuracy 0.97, nhưng recall và F1 đều bằng 0. Accuracy không tính sai, chỉ là nó không đo điều ta cần: tìm ra lớp hiếm.

Threshold là một lựa chọn phải đánh giá

Hạ threshold thì nhiều mẫu được báo dương hơn: recall không bao giờ giảm, còn precision lên hay xuống tùy mẫu mới được thêm vào là dương thật hay âm thật. Vì vậy không có công thức chung; ta thử vài ngưỡng trên validation và chọn theo metric của đề.

Nếu biết giá của hai loại lỗi và xác suất của model đáng tin, có một cách tính thẳng: báo dương khi chi phí kỳ vọng của việc không báo, $p \cdot c_{FN}$, lớn hơn chi phí kỳ vọng của việc báo, $(1-p) \cdot c_{FP}$. Tức là báo dương khi $p > c_{FP}/(c_{FP} + c_{FN})$. Bỏ sót đắt gấp 10 lần báo nhầm thì ngưỡng là $1/11 \approx 0.09$.

thresholds = np.array([0.3, 0.5, 0.7, 0.9])
valid_f1 = []
for threshold in thresholds:
    prediction = p_valid >= threshold
    score = f1_score(y_valid, prediction, zero_division=0)
    valid_f1.append(score)
    print(f't={threshold:.1f}: F1={score:.3f}')
chosen_threshold = float(thresholds[np.argmax(valid_f1)])
print('Chọn trên validation:', chosen_threshold)

Kết quảt=0.3: F1=0.500
t=0.5: F1=0.600
t=0.7: F1=0.571
t=0.9: F1=0.400
Chọn trên validation: 0.5

argmax chọn ngưỡng có F1 lớn nhất; nếu hòa thì lấy ngưỡng đầu tiên. Threshold cũng là một thứ ta chọn bằng dữ liệu, giống các tham số khác (bài 1.7 gọi là hyperparameter), dù nó không đổi trọng số nào của model.

Chọn xong, ta áp đúng ngưỡng đó lên một tập test riêng. Không thử lại bốn ngưỡng trên test rồi đổi ý.

y_test = np.array([0, 1, 0, 0, 1, 0, 1, 0])
p_test = np.array([0.70, 0.80, 0.20, 0.40, 0.55, 0.10, 0.30, 0.65])
test_prediction = p_test >= chosen_threshold
print(f'Test F1 với ngưỡng đã chốt={f1_score(y_test, test_prediction, zero_division=0):.3f}')

Kết quảTest F1 với ngưỡng đã chốt=0.571

Điểm test khác validation vì là những mẫu khác. Nếu xem test xong lại thử ngưỡng khác rồi báo điểm tốt nhất, test đã thành một phần của việc chọn. Khi validation quá nhỏ, ngưỡng chọn được dễ chạy theo nhiễu; có thể chọn ngưỡng trên dự đoán OOF (bài 1.3) để có nhiều mẫu hơn.

ROC-AUC: thứ tự trước khi cắt ngưỡng

ROC dùng trục ngang false positive rate (FPR) và trục dọc true positive rate (TPR, chính là recall):

Hạ threshold từ rất cao xuống rất thấp, mỗi ngưỡng cho một điểm (FPR, TPR); nối các điểm lại được đường ROC. ROC-AUC là diện tích dưới đường đó.

Có một cách tính tay cho cùng kết quả: xét mọi cặp gồm một mẫu dương và một mẫu âm; cặp nào score của mẫu dương cao hơn thì được 1 điểm, bằng nhau được 0.5, thấp hơn được 0; AUC là trung bình số điểm. Vậy:

• AUC chỉ phụ thuộc thứ tự các score. Biến đổi score mà giữ nguyên thứ tự, như $\sigma(3s - 1)$, không đổi AUC.
• AUC bằng 0.5 là xếp hạng không hơn đoán bừa, bằng 1 là hoàn hảo. Nó không phải accuracy.

Với mảng validation, bốn score dương là 0.95, 0.70, 0.55, 0.20. Sáu score âm là 0.80, 0.65, 0.60, 0.40, 0.30, 0.10. Số cặp xếp đúng lần lượt là 6, 5, 3, 1: AUC $=15/(4\cdot6)=0.625$.

from sklearn.metrics import roc_auc_score, average_precision_score

positive_scores = p_valid[y_valid == 1]
negative_scores = p_valid[y_valid == 0]
pair_points = []
for positive in positive_scores:
    for negative in negative_scores:
        pair_points.append(float(positive > negative) + 0.5 * float(positive == negative))
print(f'AUC tính theo cặp={np.mean(pair_points):.3f}')
print(f'AUC thư viện={roc_auc_score(y_valid, p_valid):.3f}')
print(f'Average precision={average_precision_score(y_valid, p_valid):.3f}')

Kết quảAUC tính theo cặp=0.625
AUC thư viện=0.625
Average precision=0.653

Hai dòng AUC trùng nhau, xác nhận cách đếm cặp. Với lớp hiếm, ROC có thể trông tốt dù số báo nhầm tuyệt đối vẫn lớn, vì FPR chia cho một số TN khổng lồ; khi ấy nên đọc thêm đường precision-recall và average precision (AP), một cách tổng hợp precision khi recall tăng dần.

AUC cần cả hai lớp và phải nhận score liên tục, không dùng nhãn đã cắt 0/1 để đo khả năng xếp hạng. Nếu một fold chỉ có một lớp, hãy sửa phép đánh giá hoặc ghi rõ metric không xác định ở đó, không lặng lẽ thay bằng 1.

Xác suất và nhiều lớp

Log loss chấm mức xác suất chứ không chỉ nhãn. Với binary classification,

$\log$ ở đây là logarithm tự nhiên. Đoán sai rất tự tin bị phạt nặng: với một mẫu dương, $p=0.01$ cho loss $-\log0.01\approx4.605$, còn $p=0.4$ cho khoảng 0.916. Thư viện xử lý xác suất sát 0 hoặc 1 để tránh log(0); khi tự cài cần xem quy ước chính xác.

from sklearn.metrics import log_loss

truth = np.array([1, 0])
confident_wrong = np.array([0.01, 0.99])
less_confident_wrong = np.array([0.4, 0.6])
print(f'Sai rất tự tin: log loss={log_loss(truth, confident_wrong):.3f}')
print(f'Sai ít tự tin: log loss={log_loss(truth, less_confident_wrong):.3f}')

Kết quảSai rất tự tin: log loss=4.605
Sai ít tự tin: log loss=0.916

Ở ngưỡng 0.5, cả hai đều sai hai nhãn, nhưng log loss khác nhau rất xa.

Xác suất của model gọi là hiệu chỉnh tốt (well-calibrated) khi nó khớp tần suất thật: trong các mẫu được đoán khoảng 0.7, có khoảng 70% thật sự dương. Nếu trong 100 ca được đoán 0.9 mà chỉ 60 ca dương thật, model đang quá tự tin. Điều này phải kiểm trên nhiều mẫu, không nhìn một mẫu mà biết được. Hiệu chỉnh xác suất chỉ đổi các con số, không đổi thứ tự xếp hạng, nên không đổi AUC.

Với nhiều lớp, tính F1 cho từng lớp bằng cách coi lớp đó là dương, các lớp còn lại là âm. Trong confusion matrix nhiều lớp (hàng là nhãn thật, cột là dự đoán), precision của một lớp đọc theo cột của lớp ấy, recall đọc theo hàng. Rồi gộp lại thành một số theo một trong ba cách:

• Macro-F1: trung bình đều F1 của các lớp; lớp hiếm nặng ngang lớp đông.
• Weighted-F1: trung bình có trọng số theo số mẫu của từng lớp.
• Micro-F1: cộng TP, FP, FN của mọi lớp rồi mới tính; khi mỗi mẫu có đúng một nhãn, micro-F1 bằng accuracy.

Đề chấm macro-F1 thì báo macro-F1, đừng đổi sang weighted chỉ vì nó cao hơn.

Lớp hiếm

Khi một lớp rất hiếm, model dễ lờ nó đi. Hai cách hay dùng:

• class_weight: lỗi trên lớp hiếm bị tính nặng hơn khi học, không thêm bớt mẫu nào. class_weight='balanced' đặt trọng số $n/(K \cdot n_c)$ cho lớp $c$, với $n$ là tổng số mẫu, $K$ là số lớp, $n_c$ là số mẫu của lớp $c$. Ví dụ 900 và 100 mẫu cho trọng số 0.56 và 5.
• Resampling: nhân bản mẫu lớp hiếm hoặc bớt mẫu lớp đông. Chỉ làm trên train của mỗi fold; validation giữ nguyên tỉ lệ thật.

Cả hai đều không bảo đảm F1 tăng, nên vẫn phải đo trên validation và chọn lại ngưỡng.