Метрики качества

Потери и метрики — не одно и то же

Функция потерь нужна оптимизатору: она гладкая и дифференцируемая (кросс-энтропия, MSE). Метрика нужна людям: она отвечает на вопрос «насколько модель хороша для нашей задачи?» — и может быть недифференцируемой. Модель обучают по потерям, а выбирают и оценивают по метрикам.

Точность и её ловушка

Точность (accuracy) — доля правильных ответов. Понятная, но обманчивая на несбалансированных данных. Если мошеннических транзакций 1%, модель «всегда нет» имеет точность 99% и при этом абсолютно бесполезна.

Матрица ошибок

Для бинарной задачи у каждого предсказания четыре исхода:

Из этих четырёх чисел строятся все метрики:

• Precision (точность найденного) = \frac{TP}{TP + FP} — какая доля того, что модель назвала «1», правда «1». Важна, когда ложная тревога дорога.
• Recall (полнота) = \frac{TP}{TP + FN} — какую долю всех настоящих «1» модель нашла. Важна, когда пропуск дорог.
• F1 = \frac{2 \cdot P \cdot R}{P + R} — среднее гармоническое: высокое, только если высоки обе.

import numpy as np

rng = np.random.default_rng(0)
y_true = (rng.random(1000) < 0.05).astype(int)          # 5% положительных
y_lazy = np.zeros(1000, dtype=int)                       # «всегда 0»
y_model = np.where(rng.random(1000) < 0.8, y_true, 1 - y_true)  # модель, правая в 80% случаев

def report(name, y_pred):
    tp = ((y_pred == 1) & (y_true == 1)).sum()
    fp = ((y_pred == 1) & (y_true == 0)).sum()
    fn = ((y_pred == 0) & (y_true == 1)).sum()
    p = tp / (tp + fp) if tp + fp else 0.0
    r = tp / (tp + fn) if tp + fn else 0.0
    f1 = 2 * p * r / (p + r) if p + r else 0.0
    print(f"{name:12} accuracy {np.mean(y_pred == y_true):.3f}  precision {p:.3f}  recall {r:.3f}  F1 {f1:.3f}")

report("всегда 0", y_lazy)
report("модель", y_model)

У «ленивой» модели точность 95%, но recall и F1 — ноль. Модель, правая лишь в 80% случаев, по точности хуже, но хоть что-то находит. Правда, precision у неё низкая: среди её срабатываний большинство — ложные тревоги (положительных мало, и 20% ошибок на огромном классе «0» дают много FP).

Порог и компромисс precision/recall

Классификатор выдаёт вероятность p, а решение «1» принимается при p > t. Порог t = 0.5 не священен:

• повышаем порог — модель срабатывает реже, но увереннее: precision растёт, recall падает;
• понижаем — находим больше, но и ошибаемся чаще.

Порог выбирают по цене ошибок в конкретной задаче.

import numpy as np
import nanotorch as nt
import vis

X, y = nt.make_blobs(600, centers=((-1, -1), (1.2, 1.2)), std=1.1, seed=0)
nt.manual_seed(0)
model = nt.Linear(2, 1)
opt = nt.Adam(model.parameters(), lr=0.05)
for _ in range(200):
    loss = nt.binary_cross_entropy(model(nt.Tensor(X)), y)
    opt.zero_grad(); loss.backward(); opt.step()
scores = model(nt.Tensor(X)).sigmoid().data.ravel()

ts = np.linspace(0.05, 0.95, 19)
prec, rec = [], []
for t in ts:
    pred = scores > t
    tp = (pred & (y == 1)).sum()
    prec.append(tp / max(pred.sum(), 1))
    rec.append(tp / (y == 1).sum())
vis.line(ts, {"precision": prec, "recall": rec}, title="Precision и recall при разных порогах", xlabel="порог")

ROC-кривая и AUC

ROC-кривая показывает работу классификатора сразу при всех порогах: по оси x — доля ложных тревог FPR = \frac{FP}{FP + TN}, по оси y — полнота TPR = \frac{TP}{TP + FN}. Случайная модель — диагональ, идеальная — угол (0, 1).

ROC-AUC — площадь под ROC-кривой. У неё красивый смысл: это вероятность того, что случайный объект класса 1 получит оценку выше, чем случайный объект класса 0. 0.5 — случайное угадывание, 1.0 — идеальное ранжирование. AUC не зависит от порога и от баланса классов — удобно сравнивать модели.

import numpy as np
import nanotorch as nt
import vis

X, y = nt.make_blobs(600, centers=((-1, -1), (1.2, 1.2)), std=1.1, seed=0)
scores_good = X.sum(axis=1)                                            # хорошая оценка
scores_weak = X.sum(axis=1) + np.random.default_rng(1).normal(0, 3, 600)  # зашумлённая
scores_rand = np.random.default_rng(2).random(600)                      # случайная

curves = {}
for name, s in [("хорошая", scores_good), ("слабая", scores_weak), ("случайная", scores_rand)]:
    order = np.argsort(-s)
    tpr = np.r_[0, np.cumsum(y[order] == 1) / (y == 1).sum()]
    fpr = np.r_[0, np.cumsum(y[order] == 0) / (y == 0).sum()]
    auc = np.sum(np.diff(fpr) * (tpr[1:] + tpr[:-1]) / 2)
    curves[f"{name}, AUC = {auc:.2f}"] = np.interp(np.linspace(0, 1, 101), fpr, tpr)
vis.line(np.linspace(0, 1, 101), curves, title="ROC-кривые", xlabel="доля ложных тревог (FPR)", ylabel="полнота (TPR)")

Многоклассовые метрики

Для C классов матрица ошибок — C \times C: строка — настоящий класс, столбец — предсказанный. На диагонали — правильные ответы, вне её видно, что с чем путается. Precision и recall считают для каждого класса («этот против остальных»), а затем усредняют:

• macro — простое среднее по классам: все классы одинаково важны, редкие тоже;
• micro (или взвешенное) — учитывает размеры классов.

import numpy as np
import nanotorch as nt
import ml_data
import vis

X, y = ml_data.load_digits()
X = X / 16.0
X_train, X_test, y_train, y_test = nt.train_test_split(X, y, test_size=0.3, seed=0)
nt.manual_seed(0)
model = nt.Linear(64, 10)                                 # нарочно простая модель, чтобы были ошибки
nt.fit(model, X_train, y_train, nt.cross_entropy, nt.SGD(model.parameters(), lr=0.05), epochs=8, batch_size=64, verbose=False)
with nt.no_grad():
    pred = model(nt.Tensor(X_test)).data.argmax(1)

cm = nt.confusion_matrix(y_test, pred, 10)
vis.heatmap(cm, xlabels=[str(i) for i in range(10)], ylabels=[str(i) for i in range(10)],
            title="Матрица ошибок: строка — правда, столбец — ответ модели", fmt=".0f")
precision = cm.diagonal() / np.maximum(cm.sum(axis=0), 1)
recall = cm.diagonal() / cm.sum(axis=1)
vis.table([[d, f"{precision[d]:.2f}", f"{recall[d]:.2f}"] for d in range(10)], header=["цифра", "precision", "recall"])
print(f"accuracy {np.mean(pred == y_test):.3f}, macro-F1 {np.mean(2 * precision * recall / (precision + recall + 1e-12)):.3f}")

Метрики регрессии

• MAE — средняя абсолютная ошибка, в единицах y, устойчива к выбросам.
• RMSE — корень из MSE, в единицах y, сильнее штрафует большие ошибки.
• R² (коэффициент детерминации) = 1 - \frac{\sum(y - \hat y)^2}{\sum(y - \bar y)^2} — какую долю разброса y объясняет модель. 1 — идеально, 0 — не лучше предсказания средним, меньше 0 — хуже среднего.
• MAPE — средняя относительная ошибка в процентах; понятна бизнесу, но ломается при y около нуля.

Итог

• Потери — для оптимизатора, метрики — для оценки и выбора модели.
• Accuracy обманчива на несбалансированных данных; смотрите на матрицу ошибок.
• Precision — доля верных среди найденного, recall — доля найденного среди всех нужных, F1 — их баланс; порог двигает компромисс.
• ROC-AUC — качество ранжирования при всех порогах (0.5 — случайно, 1 — идеально).
• Многоклассовые: матрица C \times C, macro/micro усреднение. Регрессия: MAE, RMSE, R².