Regression và ranking metrics

Độ lớn lỗi và đơn vị

Gọi phần dư $r_i=\hat y_i-y_i$. Với $n$ mẫu,

MAE giữ cùng đơn vị với target. Nếu target là số người, MAE cũng là số người. MSE có đơn vị người bình phương, nên khó đọc trực tiếp; RMSE đưa về người. Cả ba đều càng thấp càng tốt. RMSE 0.5 tỉ đồng cho giá nhà nghĩa là dự đoán thường lệch cỡ nửa tỉ, với lỗi lớn được tính nặng hơn.

Bình phương khiến lỗi 4 đóng góp 16, gấp 16 lần lỗi 1; trong MAE chỉ gấp bốn lần. MSE/RMSE nhạy với sai số lớn và outlier. Điều ấy có thể phù hợp nếu lỗi rất lớn đắt giá; cũng có thể bị một nhãn nhập nhầm chi phối. Không coi outlier mặc nhiên là rác: cần kiểm ý nghĩa và nguồn ghi nhãn.

RMSE không phải trung bình căn của từng lỗi bình phương. Làm theo cách ấy sẽ thành MAE, vì $\sqrt{r_i^2}=|r_i|$. Thứ tự lấy trung bình và căn quan trọng.

Huber loss nằm giữa hai cách: bằng $\tfrac12 e^2$ khi $|e|\le\delta$ và bằng $\delta(|e|-\tfrac12\delta)$ khi xa hơn. Gần 0 nó trơn như MSE, ở xa tăng tuyến tính như MAE, nên một điểm ngoại lai không kéo lệch cả mô hình: với $\delta=1$, lỗi $e=3$ chỉ góp 2.5 thay vì 4.5.

R²: so với mốc đoán trung bình

Ba buổi có target $(10,20,30)$ và dự đoán $(12,18,27)$. Phần dư là $(2,-2,-3)$, nên MAE $=7/3\approx2.333$, MSE $=17/3\approx5.667$, RMSE $=\sqrt{17/3}\approx2.380$.

$R^2$ so tổng bình phương lỗi với phương án dự đoán trung bình của tập đang chấm:

Trong ví dụ $\bar y=20$, mẫu số là $100+0+100=200$, nên $R^2=1-17/200=0.915$. Mốc “đoán trung bình tập chấm” chỉ dùng để định nghĩa metric: một model thật không được biết trung bình ấy. Baseline thật học trung bình train, nên trên validation nó thường có $R^2$ hơi dưới 0 chứ không đúng bằng 0.

import numpy as np
from sklearn.metrics import (
    mean_absolute_error, mean_squared_error, r2_score,
    mean_absolute_percentage_error,
)

y = np.array([10.0, 20.0, 30.0])
prediction = np.array([12.0, 18.0, 27.0])
residual = prediction - y
print('Phần dư:', residual)
print(f'MAE={mean_absolute_error(y, prediction):.3f}')
print(f'MSE={mean_squared_error(y, prediction):.3f}')
print(f'RMSE={np.sqrt(mean_squared_error(y, prediction)):.3f}')
print(f'R2={r2_score(y, prediction):.3f}')

Kết quảPhần dư: [ 2. -2. -3.]
MAE=2.333
MSE=5.667
RMSE=2.380
R2=0.915

Các dòng phải khớp phép tính tay. $R^2=1$ là dự đoán đúng hết; bằng 0 là ngang mốc trung bình tập chấm; âm là tệ hơn mốc ấy. Nó không phải phần trăm số mẫu đoán đúng. Chẳng hạn $R^2=0.915$ không nói rằng 91.5% buổi có số người dự đoán chính xác.

Nếu mọi target của tập chấm bằng nhau, mẫu số bằng 0 và $R^2$ không xác định; scikit-learn khi đó trả về 0 hoặc 1 theo quy ước riêng. Ngoài ra, $R^2$ phụ thuộc độ phân tán của tập chấm, nên không so $R^2$ của hai bộ dữ liệu khác hẳn nhau để nói model nào tốt hơn.

MAPE: tỉ lệ lỗi nhưng có mẫu số nguy hiểm

Mean absolute percentage error dùng độ lớn tương đối so với target:

Muốn biểu diễn phần trăm, nhân kết quả với 100. Mẫu số là giá trị thật, không phải dự đoán: đoán 453 khi thật là 488 lệch $35/488\approx7.2\%$. Với ba buổi trên, các lỗi tương đối là 0.2, 0.1, 0.1: trung bình khoảng 0.1333, tức 13.33%.

Target nhỏ khiến cùng một lỗi tuyệt đối bị phạt lớn hơn. Đoán 2 khi thật là 1 sai 100%; đoán 101 khi thật là 100 chỉ sai 1%, dù cả hai sai một đơn vị. Nếu có $y=0$, công thức này chia 0. Thư viện thay mẫu số bằng một số rất nhỏ nên có thể trả số hữu hạn khổng lồ; đó không có nghĩa metric đã trở nên dễ diễn giải.

print(f'MAPE dạng tỉ lệ={mean_absolute_percentage_error(y, prediction):.4f}')
print(f'MAPE phần trăm={100 * mean_absolute_percentage_error(y, prediction):.2f}%')
zero_case = mean_absolute_percentage_error([0.0, 10.0], [1.0, 9.0])
print(f'MAPE với target 0 theo thư viện={zero_case:.3e}')

Kết quảMAPE dạng tỉ lệ=0.1333
MAPE phần trăm=13.33%
MAPE với target 0 theo thư viện=2.252e+15

Dòng cuối cho thấy: có target bằng 0 thì MAPE của thư viện ra một số khổng lồ, chẳng còn ý nghĩa. Vì vậy trước khi dùng MAPE, kiểm xem target có số 0 không. Nếu đề có cách xử lý riêng, như cộng thêm một số nhỏ vào mẫu số hay dùng sMAPE, thì cài đúng như đề.

Để thấy việc chọn metric làm đổi quyết định, xét hai dự đoán sau trên cùng target $(1,100)$.

small_large = np.array([1.0, 100.0])
candidate_a = np.array([2.0, 100.0])
candidate_b = np.array([1.0, 104.0])
for name, pred in [('A', candidate_a), ('B', candidate_b)]:
    mae = mean_absolute_error(small_large, pred)
    mape = mean_absolute_percentage_error(small_large, pred)
    print(f'{name}: MAE={mae:.3f}, MAPE={mape:.3f}')

Kết quảA: MAE=0.500, MAPE=0.500
B: MAE=2.000, MAPE=0.020

Theo MAE, A tốt hơn vì tổng lỗi chỉ là 1 thay vì 4. Theo MAPE, B tốt hơn vì tránh lỗi trên target 1. Không có mâu thuẫn: hai metric đặt trọng số khác nhau cho hai buổi.

Loss học và metric chấm có thể khác nhau

Loss là hàm mà thuật toán làm nhỏ nhất khi học trên train. Metric là thước đo dùng để chấm trên validation và test, theo đúng yêu cầu của đề. Hai thứ có thể trùng nhau, nhưng không bắt buộc: một model học bằng MSE vẫn có thể được chấm bằng MAE.

Loss quyết định model đoán về đâu. Nếu chỉ được đoán một hằng số, MSE nhỏ nhất khi đoán bằng trung bình (mean), còn MAE nhỏ nhất khi đoán bằng trung vị (median). Train có target $(10, 10, 10, 50)$: mean bằng 20, bị mẫu 50 kéo lên; median vẫn là 10.

Loss còn phải có đạo hàm dùng được (bài 0.6). Accuracy thì không: nhích trọng số một chút thường không đổi nhãn nào, nên đạo hàm gần như luôn bằng 0. Vì vậy bộ phân loại học bằng cross-entropy (bài 2.3) rồi mới chấm bằng accuracy.

train_targets = np.array([10.0, 10.0, 10.0, 50.0])
for name, value in [('mean', train_targets.mean()), ('median', np.median(train_targets))]:
    constant_prediction = np.full(len(train_targets), value)
    print(
        f'{name}: giá trị={value:.1f}, '
        f'MAE={mean_absolute_error(train_targets, constant_prediction):.1f}, '
        f'MSE={mean_squared_error(train_targets, constant_prediction):.1f}'
    )

Kết quảmean: giá trị=20.0, MAE=15.0, MSE=300.0
median: giá trị=10.0, MAE=10.0, MSE=400.0

Mean có MSE thấp hơn, median có MAE thấp hơn: mỗi loss kéo dự đoán về “tâm” riêng của nó. Muốn chọn model thì vẫn đo trên validation bằng metric của đề. Riêng MSE và RMSE luôn xếp hạng các model giống nhau, vì RMSE chỉ là căn bậc hai của MSE.

Ranking: một danh sách, không phải một số

Câu lạc bộ muốn gợi ý ba bài luyện cho mỗi học sinh. Với một query, tức một yêu cầu gợi ý của một học sinh, ta có tập bài thật sự phù hợp (relevant). Một danh sách tốt đặt nhiều bài phù hợp gần đầu. Xét tập relevant {A,C,E} và danh sách [A,B,C]: vị trí 1 đúng, vị trí 2 sai, vị trí 3 đúng.

Precision@r là số bài relevant trong $r$ vị trí đầu chia $r$. Average precision ở top $k$ cần một quy ước mẫu số. Trong bài này chọn

Ở đây $R$ là số bài thật sự phù hợp, $\operatorname{rel}(r)$ bằng 1 nếu bài ở vị trí $r$ phù hợp, bằng 0 nếu không. Nói cách khác: tại mỗi vị trí có bài đúng, lấy precision tính đến vị trí đó, cộng lại, rồi chia cho số bài đúng tối đa có thể có trong top $k$.

Mỗi đề có thể định nghĩa AP hơi khác: có đề chia cho $R$ thay vì $\min(R, k)$, có đề bỏ query không có bài phù hợp nào, có đề quy định riêng khi một bài bị lặp. Vì vậy đọc kỹ công thức của đề trước khi viết hàm chấm. Code trong bài cho AP bằng 0 khi $R = 0$, và không cho phép bài lặp trong top $k$.

Với [A,B,C], tử số là $1+2/3=5/3$, mẫu số là 3, nên AP@3 $=5/9$. Với [C,E,B], tử số là $1+1=2$, mẫu số 3, nên AP@3 $=2/3$. Precision@3 của cả hai bằng $2/3$, nhưng AP thích cách đặt bài đúng sớm hơn.

Tìm kiếm và hệ gợi ý (recommender) đều là bài xếp hạng: quan trọng là thứ tự, không phải con số chính xác. Ngoài AP còn hai metric xếp hạng hay gặp:

• MRR: trung bình của $1/\text{hạng}$ của đáp án đúng đầu tiên. Ba câu hỏi có đáp án đúng ở hạng 1, hạng 3 và không có, cho MRR $= (1 + 1/3 + 0)/3 \approx 0.44$.
• nDCG: dùng khi độ phù hợp có nhiều mức. $\mathrm{DCG} = \sum_r \mathrm{rel}_r / \log_2(r + 1)$ cộng điểm phù hợp, giảm dần theo vị trí; nDCG chia DCG cho DCG của thứ tự lý tưởng để ra một số trong $[0, 1]$.

Cài một scorer nhỏ và kiểm tay

MAP@k (mean average precision) là trung bình AP@k của mọi query, mỗi query nặng như nhau. Đừng nối mọi danh sách lại rồi tính AP một lần: mỗi học sinh có tập bài phù hợp riêng.

def ap_at_k(ranking, relevant, k):
    assert k >= 1, 'k phải dương'
    top = list(ranking[:k])
    assert len(top) == len(set(top)), 'Không cho duplicate trong top k'
    relevant = set(relevant)
    if not relevant:
        return 0.0
    hits = 0
    total = 0.0
    for rank, item in enumerate(top, start=1):
        if item in relevant:
            hits += 1
            total += hits / rank
    return total / min(len(relevant), k)

rankings = [['A', 'B', 'C'], ['B', 'D', 'E']]
relevant_sets = [{'A', 'C', 'E'}, {'D'}]
ap_scores = [ap_at_k(rank, rel, 3) for rank, rel in zip(rankings, relevant_sets)]
print('AP@3 từng query:', np.round(ap_scores, 6))
print(f'MAP@3={np.mean(ap_scores):.6f}')
assert np.isclose(ap_scores[0], 5 / 9)
assert np.isclose(ap_scores[1], 1 / 2)

Kết quảAP@3 từng query: [0.555556 0.5     ]
MAP@3=0.527778

Query thứ hai có một bài relevant ở hạng 2 nên AP@3 $=1/2$. MAP của hai query là $(5/9+1/2)/2=19/36\approx0.527778$. Các assert đối chiếu với phép tính độc lập, giống kiểm một hàm CP bằng vài trường hợp nhỏ có đáp án chắc chắn.

Chọn model gợi ý cũng cần chia dữ liệu như bài 1.3: theo người mới hoặc theo thời gian, và không đưa tương tác ở tương lai vào feature. Metric đúng mà cách chia sai thì điểm vẫn không đáng tin.