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

Precision, recall và F1 score: chọn metric theo cái giá

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

Bài 9/14 · Chương 3

Đánh giá model

  • 7 phút
  • Cơ bản
  • Python 3.14
  • Cập nhật

Precision, recall và F1 score là ba metric phân loại tính từ confusion matrix, nhìn vào lớp dương. Precision là tỉ lệ báo đúng trong số khách bị báo rời bỏ; recall là tỉ lệ khách đã rời bỏ mà model kịp báo; F1 gộp hai số đó. Bạn chọn giữa chúng theo giá của một lần báo nhầm so với một lần bỏ sót.

Cần biết trước: confusion matrix và trung bình điều hòa.

Precision và recall từ bốn ô

Pipeline của bài trước, trên 750 khách của tập test, có TP = 36, FP = 24, FN = 113. Hai công thức chỉ dùng ba ô đó:

precision=TPTP+FPrecall=TPTP+FN\text{precision} = \frac{TP}{TP + FP} \qquad \text{recall} = \frac{TP}{TP + FN}

Trong đó:

  • TP (tp): khách rời bỏ mà model bắt được.

  • FP (fp): khách ở lại mà model báo rời bỏ.

  • FN (fn): khách rời bỏ mà model bỏ sót.

  • TP + FP: mọi khách bị báo rời bỏ; TP + FN: mọi khách thật sự rời bỏ.

Tính tay: precision = 36 / 60 = 0,6, nghĩa là cứ 10 khách bị báo thì 6 người đúng là sắp rời bỏ. Recall = 36 / 149 ≈ 0,242: cứ bốn khách rời bỏ thì model chỉ báo trúng chừng một người. Python thuần rồi sklearn.metrics trên tám khách nhỏ:

python
from sklearn.metrics import precision_score, recall_score

y_that = [1, 0, 0, 1, 1, 0, 1, 0]
y_doan = [1, 1, 0, 0, 1, 0, 0, 0]
tp = sum(t == 1 and d == 1 for t, d in zip(y_that, y_doan))
fp = sum(t == 0 and d == 1 for t, d in zip(y_that, y_doan))
fn = sum(t == 1 and d == 0 for t, d in zip(y_that, y_doan))
print("Tay:", round(tp / (tp + fp), 3), round(tp / (tp + fn), 3))
print("precision_score:", round(precision_score(y_that, y_doan), 3))
print("recall_score:", round(recall_score(y_that, y_doan), 3))

KẾT QUẢ

Tay: 0.667 0.5
precision_score: 0.667
recall_score: 0.5

Đổi [1, 1, 0, 0, 1, 0, 0, 0] thành [1, 0, 0, 0, 1, 0, 0, 0] rồi chạy lại: bỏ một lần báo nhầm, dòng precision in precision_score: 1.0.

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

F1 gộp precision P và recall R thành một số, bằng trung bình điều hòa:

F1=2⋅P⋅RP+RF_1 = \frac{2 \cdot P \cdot R}{P + R}

Trong đó:

  • P (precision): precision của model.

  • R (recall): recall của model.

  • F₁ (f1_score(y_that, y_doan)): bằng 0 khi một trong hai số bằng 0, bằng 1 khi cả hai bằng 1.

Với pipeline: F1 = 2 · 0,6 · 0,242 / (0,6 + 0,242) ≈ 0,345. Trung bình cộng sẽ là 0,421. Trung bình điều hòa kéo về phía số nhỏ hơn, nên một model không thể bù recall thấp bằng precision cao. Thử với model báo mọi khách rời bỏ:

python
from sklearn.metrics import f1_score, precision_score, recall_score

y_that = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0]
bao_het = [1] * 10
p = precision_score(y_that, bao_het)
r = recall_score(y_that, bao_het)
print("precision:", p, "- recall:", r)
print("trung bình cộng:", (p + r) / 2)
print("F1:", round(f1_score(y_that, bao_het), 3))

KẾT QUẢ

precision: 0.2 - recall: 1.0
trung bình cộng: 0.6
F1: 0.333

Báo hết thì recall bằng 1 và trung bình cộng còn 0,6, nghe khá ổn. F1 chỉ 0,333, phản ánh đúng rằng model này không chọn lọc gì.

Chọn theo giá của từng loại sai

Precision và recall kéo ngược chiều nhau: báo rời bỏ cho nhiều khách hơn thì bắt được nhiều hơn (recall tăng) nhưng báo nhầm cũng nhiều hơn (precision giảm). Giả sử đội chăm sóc gọi điện cho mỗi khách bị báo, mỗi cuộc tốn 40 nghìn đồng, còn mỗi khách rời bỏ bị bỏ sót làm mất 250 nghìn tiền gói. Để phép tính gọn, giả sử cuộc gọi giữ được mọi khách đúng là sắp rời; thật ra chỉ giữ được một phần, và phần còn lại vẫn tính vào chi phí. Thử một luật đơn giản trên bảng khách hàng Sóc Vàng (số giả lập của AIDev): báo rời bỏ khi khách đăng nhập không quá k lần trong 30 ngày.

python
import pandas as pd
from sklearn.metrics import confusion_matrix, f1_score
kh = pd.read_csv("hoi_vien.csv")
y = kh["roi_bo"]
for k in [1, 3, 6, 10]:
    bao = (kh["so_lan_dang_nhap_30_ngay"] <= k).astype(int)
    tn, fp, fn, tp = confusion_matrix(y, bao).ravel()
    p, r = tp / (tp + fp), tp / (tp + fn)
    gia = (tp + fp) * 40 + fn * 250
    print(k, round(p, 2), round(r, 2), round(f1_score(y, bao), 2),
          int(gia), "nghìn")

KẾT QUẢ

1 0.45 0.13 0.2 136640 nghìn
3 0.36 0.36 0.36 118720 nghìn
6 0.29 0.71 0.41 101600 nghìn
10 0.24 0.91 0.38 104160 nghìn

Tăng k, recall tăng còn precision giảm. Với giá này, một lần bỏ sót đắt hơn sáu cuộc gọi, nên chi phí thấp nhất rơi vào k = 6, nơi recall 0,71 dù precision chỉ 0,29; lên k = 10 thì số cuộc gọi thừa lại làm chi phí tăng. Nếu cuộc gọi đắt và bỏ sót rẻ thì ngược lại, precision quan trọng hơn. F1 coi hai loại sai ngang nhau; khi bạn biết giá thật, tính thẳng chi phí như trên. Chọn k trên cả bảng như vậy chỉ để minh họa; chọn thật thì làm trên tập validation.

Kiểm tra nhanh

  1. Sau from sklearn.metrics import recall_score, recall_score([1, 1, 0, 1], [1, 0, 0, 0]) cho kết quả gì?

    • 1.0
    • 0.3333333333333333
    • 0.5
  2. Precision 0,9 và recall 0,1. Vì sao F1 chỉ khoảng 0,18 thay vì 0,5?

    • Vì F1 lấy số lớn hơn trừ số nhỏ hơn
    • Vì F1 là trung bình điều hòa, bị kéo về phía số nhỏ hơn
    • Vì F1 còn tính cả TN
  3. Những trường hợp nào nên ưu tiên recall cao?

    • Sàng lọc bệnh, nơi bỏ sót một người bệnh rất đắt
    • Giữ khách khi cuộc gọi chăm sóc rẻ và mất một khách rất đắt
    • Gửi cảnh báo khóa tài khoản, nơi báo nhầm làm khách tức giận và bỏ đi
    • Mọi bài toán, vì recall luôn quan trọng hơn precision
  4. Trong bảng luật k, vì sao k = 6 cho chi phí thấp hơn k = 1 dù precision thấp hơn?

    • Vì mỗi lần bỏ sót đắt hơn sáu cuộc gọi, nên bắt thêm khách rời bỏ có lợi hơn bớt cuộc gọi
    • Vì precision thấp luôn làm chi phí giảm
    • Vì F1 của k = 6 bằng 1
Đúng hết lần đầu +15 XP

Bài tập

Tính precision, recall và F1 từ ba ô

Viết thân hàm ba_chi_so(tp, fp, fn) nhận ba số nguyên không âm là ba ô của ma trận nhầm lẫn, rồi tính precision, recall và F1 bằng công thức của bài. Khi một mẫu số bằng 0, chỉ số đó là 0.0 (như zero_division=0 của scikit-learn).

Trả về: precision, recall và F1 theo thứ tự đó, gói trong một tuple ba số float.

python
def ba_chi_so(tp, fp, fn):
    pass  # Viết thân hàm thay cho dòng này

Tóm tắt

  • Precision = TP / (TP + FP): trong những khách bị báo, bao nhiêu báo đúng.

  • Recall = TP / (TP + FN): trong những khách thật sự thuộc lớp dương, bao nhiêu bị bắt.

  • F1 = 2PR / (P + R), trung bình điều hòa, bị kéo về số nhỏ hơn.

  • Báo nhiều hơn thì recall tăng, precision giảm; chọn theo giá của báo nhầm và bỏ sót.

  • Hàm của sklearn.metrics nhận giá thật trước; đảo lại thì precision và recall đổi chỗ.

Câu hỏi thường gặp

F1 score bao nhiêu là tốt?

Tùy bài và tỉ lệ lớp dương. So với model báo hết: trên bảng có 20% khách rời bỏ, báo hết cho F1 khoảng 0,33. Model nào không vượt mức đó rõ rệt thì chưa học được gì đáng kể về lớp dương.

Vì sao precision_score báo cảnh báo khi model không đoán lớp dương nào?

Vì TP + FP bằng 0, phép chia không xác định. scikit-learn trả 0 kèm cảnh báo; truyền zero_division=0 để chọn rõ giá trị đó và tắt cảnh báo, như bài tập trên làm bằng tay.

Có cách nào tăng recall mà không đổi model không?

Có: hạ ngưỡng xác suất mà từ đó model báo lớp dương. Bài ROC-AUC dùng predict_proba() để lấy xác suất đó và đo khả năng xếp hạng không phụ thuộc ngưỡng.

Model có recall gần 1 và precision gần 1 ngay lần đầu thì sao?

Đẹp quá thì nghi rò rỉ trước: một cột ghi sau thời điểm dự đoán thường cho đúng kiểu kết quả đó. Đọc bài data leakage trước khi tin con số.

Chủ đề

f1 score

Dữ liệu của bài

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