0 dní v řadě · 0 bodů

Strojové učení · 35 min

Metriky: přesnost nestačí

Matice záměn, precision, recall, F1, volba prahu, ROC a PR křivky. Jak poznat, že model s vysokou přesností je ve skutečnosti k ničemu.

Hloubka
Úkoly
Lidsky řečeno

Hlídač v obchodě každému zákazníkovi řekne „v pořádku“ a jde si číst noviny. Zloděj přijde jednou za tisíc návštěv, takže hlídač má pravdu v 99,9 % případů a nechytil nikoho. Přesně takhle umí vypadat model s výbornou přesností. Tahle lekce je o číslech, která hlídače usvědčí.

Past jménem přesnost

Přesnost (anglicky accuracy) je podíl správných odpovědí. Zní to jako jediné číslo, které potřebuješ. Vezmi tisíc plateb, z nichž deset je podvodných, a „model“, který na všechno řekne, že je to v pořádku. Co vypíše tenhle kód?

import numpy as np

y = np.zeros(1000, dtype=int)
y[:10] = 1                       # 1 = fraud
pred = np.zeros(1000, dtype=int) # the model never raises an alarm

print("přesnost:", float(np.mean(pred == y)))
print("chycené podvody:", int(np.sum((pred == 1) & (y == 1))))
Výstup
přesnost: 0.99
chycené podvody: 0

Když je jedna třída vzácná, říká se datům nevyvážená a přesnost o nich skoro nic nevypovídá. Podvody, nemoci, poruchy strojů i odchody zákazníků jsou nevyvážené skoro vždy.

Matice záměn

Místo jednoho čísla rozdělíme odpovědi do čtyř přihrádek. Třídě, kterou hledáme (podvod), se říká pozitivní, té druhé negativní. Slovo „pozitivní“ nic nehodnotí, stejně jako pozitivní test na nemoc není dobrá zpráva.

text
                     model řekl: NE         model řekl: ANO
ve skutečnosti NE    TN správné ticho       FP planý poplach
ve skutečnosti ANO   FN přehlédnutí         TP správný zásah

Zkratky se čtou zprava: P/N je odpověď modelu, T/F říká, jestli byla správná. FP je tedy „falešně pozitivní“.

import numpy as np

def matice(y, pred):
    tp = int(np.sum((pred == 1) & (y == 1)))
    fp = int(np.sum((pred == 1) & (y == 0)))
    fn = int(np.sum((pred == 0) & (y == 1)))
    tn = int(np.sum((pred == 0) & (y == 0)))
    return tp, fp, fn, tn

y    = np.array([1, 1, 1, 1, 0, 0, 0, 0, 0, 0])
pred = np.array([1, 1, 1, 0, 1, 1, 0, 0, 0, 0])

tp, fp, fn, tn = matice(y, pred)
print(f"TP={tp}  FP={fp}  FN={fn}  TN={tn}")
Výstup
TP=3  FP=2  FN=1  TN=4

Která chyba je horší, určuje situace, ne matematika.

Roztřiď

Planý poplach, nebo přehlédnutí?

Pozitivní třída je vždy to, co systém hledá. Zařaď každou chybu.

Precision, recall a F1

Ze čtyř přihrádek vzniknou dvě otázky, které si klade každý, kdo model nasazuje:

text
precision = TP / (TP + FP)    když model vyhlásí poplach, jak často má pravdu?
recall    = TP / (TP + FN)    kolik skutečných případů model našel?
F1        = 2 · P · R / (P + R)    jedno číslo, které trestá slabší z obou

Česky se občas říká preciznost a úplnost, v praxi uslyšíš anglické názvy. F1 je harmonický průměr. Na rozdíl od běžného průměru nejde ošidit tím, že jedno z čísel vytáhneš nahoru a druhé zanedbáš.

tp, fp, fn = 10, 990, 0   # the model flags all 1000 payments

precision = tp / (tp + fp)
recall = tp / (tp + fn)
f1 = 2 * precision * recall / (precision + recall)

print(f"precision       {precision:.3f}")
print(f"recall          {recall:.3f}")
print(f"běžný průměr    {(precision + recall) / 2:.3f}")
print(f"F1              {f1:.3f}")
Výstup
precision       0.010
recall          1.000
běžný průměr    0.505
F1              0.020

Model, který označí úplně všechno, má dokonalý recall a bezcennou precision. Běžný průměr by mu dal přes polovinu bodů, F1 ho odhalí.

Spoj dvojice

Která metrika odpovídá?

Spoj otázku s metrikou.

Úkol

Tři metriky v jedné funkci

Napiš funkci metriky(y, pred), která vrátí trojici (precision, recall, f1). Když by se dělilo nulou, má být daná hodnota 0.0.

import numpy as np

def metriky(y, pred):
    y, pred = np.asarray(y), np.asarray(pred)
    tp = np.sum((pred == 1) & (y == 1))
    # doplň
    return 0.0, 0.0, 0.0
Výstup
Najdi chybu

Podezřele dobrý recall

Funkce má vrátit recall. Model našel 1 ze 4 skutečných případů a nevyhlásil žádný planý poplach, takže recall má být 0,25. Funkce ale tvrdí něco jiného.

Práh: otočný knoflík

Logistická regrese vrací pravděpodobnost a teprve práh z ní udělá rozhodnutí. Hodnota 0,5 není přírodní zákon. Posuvníkem měníš, od jaké pravděpodobnosti se vyhlásí poplach.

import numpy as np

np.random.seed(7)
n = 5000
y = (np.random.random(n) < 0.03).astype(int)
z = np.where(y == 1, np.random.normal(0.5, 1.2, n), np.random.normal(-3.0, 1.2, n))
p = 1 / (1 + np.exp(-z))

pred = (p >= prah).astype(int)
tp = int(np.sum((pred == 1) & (y == 1)))
fp = int(np.sum((pred == 1) & (y == 0)))
fn = int(np.sum((pred == 0) & (y == 1)))

precision = tp / (tp + fp) if tp + fp else 0.0
recall = tp / (tp + fn)
print(f"práh {prah:.2f}: poplachů {tp + fp}")
print(f"TP={tp}  FP={fp}  FN={fn}")
print(f"precision {precision:.3f}   recall {recall:.3f}")
Výstup
práh 0.50: poplachů 124
TP=101  FP=23  FN=52
precision 0.815   recall 0.660

Nižší práh znamená víc poplachů: recall nemůže klesnout, zato precision obvykle padá. Správné nastavení závisí na cenách chyb. Když přehlédnutý podvod stojí 500 Kč a prověření planého poplachu 20 Kč, stojí za to prověřit i dost nepravděpodobné případy.

Úkol

Nejlevnější práh

Napiš funkci nejlevnejsi_prah(y, p, cena_fn, cena_fp, prahy). Pro každý práh z prahy urči pred = p >= prah, spočítej celkovou cenu FN · cena_fn + FP · cena_fp a vrať práh s nejnižší cenou. Při shodě vrať ten, který je v seznamu dřív.

import numpy as np

def nejlevnejsi_prah(y, p, cena_fn, cena_fp, prahy):
    y, p = np.asarray(y), np.asarray(p)
    # doplň
    return None
Výstup

Křivky: hodnocení bez prahu

Někdy chceš posoudit model jako celek, dřív než práh zvolíš. K tomu slouží dvě křivky, které projdou všechny prahy.

ROC křivka kreslí recall (zde se mu říká TPR) proti podílu poplašených negativních případů, FPR = FP / (FP + TN). Plocha pod ní, ROC AUC, má krásný význam: je to pravděpodobnost, že náhodně vybraný pozitivní případ dostane vyšší skóre než náhodně vybraný negativní. Hodnota 0,5 je házení mincí, 1,0 je dokonalé seřazení.

PR křivka kreslí precision proti recallu. Její souhrn se jmenuje average precision (AP). Náhodný model tu nemá 0,5, ale podíl pozitivních případů v datech.

Rozdíl vynikne, když stejný model nasadíme na čím dál vzácnější jev. Schopnost modelu rozlišovat se nemění, mění se jen počet negativních případů.

import numpy as np

def auc(poz, neg):
    return float(np.mean(poz[:, None] > neg))

def average_precision(y, skore):
    y = y[np.argsort(-skore)]
    precision = np.cumsum(y) / np.arange(1, len(y) + 1)
    return float(precision[y == 1].mean())

np.random.seed(0)
poz = np.random.normal(1.5, 1.0, 100)

print("podíl pozitivních   ROC AUC     AP")
for pocet_neg in [100, 900, 9900]:
    neg = np.random.normal(0.0, 1.0, pocet_neg)
    y = np.r_[np.ones(100), np.zeros(pocet_neg)]
    skore = np.r_[poz, neg]
    podil = 100 / (100 + pocet_neg)
    print(f"{podil:>16.0%}   {auc(poz, neg):.3f}     {average_precision(y, skore):.3f}")
Výstup
podíl pozitivních   ROC AUC     AP
             50%   0.838     0.837
             10%   0.877     0.539
              1%   0.865     0.146

ROC AUC zůstává skoro stejné, ačkoli v praxi by se model topil v planých poplaších. AP ten propad ukáže. U vzácných jevů proto sleduj PR křivku, ROC AUC je tam příliš optimistické.

Úkol

AUC z dvojic

Napiš funkci auc(y, skore). Porovnej každý pozitivní příklad s každým negativním: vyšší skóre pozitivního se počítá za 1, shoda za 0,5, jinak 0. Vrať průměr.

import numpy as np

def auc(y, skore):
    y, skore = np.asarray(y), np.asarray(skore, dtype=float)
    poz = skore[y == 1]
    neg = skore[y == 0]
    # doplň
    return 0.0
Výstup
Kvíz

Model má ROC AUC 0,5. Co to říká?

Více tříd a regrese

Při více třídách se spočítá metrika pro každou třídu zvlášť a výsledky se zprůměrují. Způsob průměrování rozhoduje, jestli se vzácná třída vůbec projeví.

  • macro: každá třída má stejnou váhu, vzácná třída je vidět.
  • weighted: váhou je počet příkladů, velké třídy přehluší malé.
  • micro: sečte TP, FP a FN přes třídy. Když má každý příklad právě jednu třídu, vyjde stejně jako přesnost.
import numpy as np

y = np.array([0] * 80 + [1] * 15 + [2] * 5)
pred = np.array([0] * 78 + [1] * 2 + [1] * 10 + [0] * 5 + [0] * 5)

f1 = []
pocty = []
for trida in range(3):
    tp = np.sum((pred == trida) & (y == trida))
    fp = np.sum((pred == trida) & (y != trida))
    fn = np.sum((pred != trida) & (y == trida))
    f1.append(2 * tp / (2 * tp + fp + fn))
    pocty.append(np.sum(y == trida))
    print(f"třída {trida}: počet {pocty[-1]:>2}, F1 {f1[-1]:.3f}")

print(f"macro    {np.mean(f1):.3f}")
print(f"weighted {np.average(f1, weights=pocty):.3f}")
print(f"micro    {np.mean(pred == y):.3f}")
Výstup
třída 0: počet 80, F1 0.929
třída 1: počet 15, F1 0.741
třída 2: počet  5, F1 0.000
macro    0.556
weighted 0.854
micro    0.880

Třídu 2 model nezachytil vůbec a weighted to skoro nezaznamená, macro ano.

U regrese se odpovědi nedělí na správné a špatné, měří se vzdálenost od skutečnosti:

text
MAE  = průměr |y - ŷ|                průměrná chyba ve stejných jednotkách jako y
RMSE = odmocnina z průměru (y - ŷ)²  velké chyby váží víc
R²   = 1 - Σ(y - ŷ)² / Σ(y - ȳ)²     o kolik je model lepší než tipovat průměr
import numpy as np

y = np.array([100.0, 120, 140, 160, 180, 200, 220, 240, 260, 280])
vsude_trochu = y + np.array([12, -12, 12, -12, 12, -12, 12, -12, 12, -12])
jeden_ujel = y.copy()
jeden_ujel[-1] += 110

for nazev, odhad in [("všude o trochu", vsude_trochu), ("jeden velký omyl", jeden_ujel)]:
    e = y - odhad
    mae = np.mean(np.abs(e))
    rmse = np.sqrt(np.mean(e ** 2))
    r2 = 1 - np.sum(e ** 2) / np.sum((y - y.mean()) ** 2)
    print(f"{nazev:<17} MAE {mae:5.1f}   RMSE {rmse:5.1f}   R² {r2:.3f}")
Výstup
všude o trochu    MAE  12.0   RMSE  12.0   R² 0.956
jeden velký omyl  MAE  11.0   RMSE  34.8   R² 0.633

Podle MAE je lepší druhý model, podle RMSE první. Rozhodni se podle toho, co tě bolí: pokud jeden obrovský omyl znamená průšvih, sleduj RMSE.

Kvíz

Testovací R² vyšlo záporné. Co to znamená?

scikit-learn

Všechno výše je v sklearn.metrics. Tady model na nevyvážených datech s hloupým soupeřem pro srovnání.

from sklearn.datasets import make_classification
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (accuracy_score, average_precision_score,
                             classification_report, confusion_matrix, roc_auc_score)
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=4000, n_features=12, n_informative=5,
                           weights=[0.96], flip_y=0.01, class_sep=0.9, random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, stratify=y, random_state=0)

modely = {
    "hloupý": DummyClassifier(strategy="most_frequent"),
    "logistický": LogisticRegression(max_iter=1000, random_state=0),
}
for nazev, model in modely.items():
    model.fit(X_tr, y_tr)
    p = model.predict_proba(X_te)[:, 1]
    print(f"{nazev:<11} přesnost {accuracy_score(y_te, model.predict(X_te)):.3f}"
          f"  ROC AUC {roc_auc_score(y_te, p):.3f}"
          f"  AP {average_precision_score(y_te, p):.3f}")

pred = modely["logistický"].predict(X_te)
print(confusion_matrix(y_te, pred))
print(classification_report(y_te, pred, digits=3, zero_division=0))
Výstup
hloupý      přesnost 0.957  ROC AUC 0.500  AP 0.043
logistický  přesnost 0.977  ROC AUC 0.928  AP 0.726
[[953   4]
 [ 19  24]]
              precision    recall  f1-score   support

           0      0.980     0.996     0.988       957
           1      0.857     0.558     0.676        43

    accuracy                          0.977      1000
   macro avg      0.919     0.777     0.832      1000
weighted avg      0.975     0.977     0.975      1000

Sleduj, jak málo se liší přesnost obou modelů a jak moc se liší ROC AUC a AP. V reportu hledej řádek třídy 1: tam je vidět, kolik vzácných případů model opravdu našel.

Úkol

Spočítej metriky přes knihovnu

Model model je natrénovaný. Do proměnné skore ulož pravděpodobnosti třídy 1 pro X_te, do recall hodnotu recall_score pro výsledky model.predict(X_te) a do ap hodnotu average_precision_score ze skore.

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import average_precision_score, recall_score
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=1000, weights=[0.9], random_state=1)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, stratify=y, random_state=1)
model = LogisticRegression(max_iter=1000).fit(X_tr, y_tr)

skore = None
recall = None
ap = None
Výstup
Pod kapotou · prevalence, nejistota a co metriky zamlčí

Precision závisí na prevalenci. TPR a FPR jsou vlastnosti modelu, precision ne. Z Bayesovy věty precision = TPR·π / (TPR·π + FPR·(1 - π)), kde π je podíl pozitivních. Model změřený na vyvážené sadě se v produkci chová úplně jinak. Pozor proto na precision hlášenou z podvzorkovaných dat.

Metrika je odhad. Při 20 pozitivních případech v testu je recall hrubé číslo a rozdíl dvou modelů o pár bodů je často šum. Bootstrap dá poctivý interval, u porovnání modelů převzorkuj obě předpovědi stejnými indexy.

import numpy as np

print("prevalence  precision (TPR 0.90, FPR 0.05)")
for pi in [0.5, 0.1, 0.01, 0.001]:
    print(f"{pi:>9.1%}  {0.90 * pi / (0.90 * pi + 0.05 * (1 - pi)):.3f}")

np.random.seed(0)
print("\npozitivních  recall  95% interval")
for n_poz in [20, 200, 2000]:
    zasahy = (np.random.random(n_poz) < 0.8).astype(float)
    vzorky = zasahy[np.random.randint(0, n_poz, size=(2000, n_poz))].mean(axis=1)
    dolni, horni = np.percentile(vzorky, [2.5, 97.5])
    print(f"{n_poz:>11}  {zasahy.mean():.3f}   {dolni:.3f} až {horni:.3f}")
Výstup
prevalence  precision (TPR 0.90, FPR 0.05)
    50.0%  0.947
    10.0%  0.667
     1.0%  0.154
     0.1%  0.018

pozitivních  recall  95% interval
         20  0.750   0.550 až 0.950
        200  0.840   0.790 až 0.890
       2000  0.807   0.789 až 0.824

Kalibrace. ROC AUC se nezmění při žádné rostoucí transformaci skóre, takže model může mít skvělé AUC a nesmyslné pravděpodobnosti. Jakmile z p počítáš peníze, měř i kalibraci: brier_score_loss, log_loss, CalibrationDisplay. Opravit ji jde přes CalibratedClassifierCV.

Práh z ceny. Pro dobře kalibrované p je nákladově optimální práh C_FP / (C_FP + C_FN). Pro ceny 20 a 500 Kč vychází asi 0,038.

Únik přes práh. Práh ladí na validačních datech, nikdy na testu. Od verze 1.5 to v scikit-learn řeší TunedThresholdClassifierCV s vnitřní křížovou validací.

F1 ignoruje TN a není symetrická vůči přehození tříd. Když záleží na obou stranách, použij matthews_corrcoef nebo balanced_accuracy_score.

Plocha pod PR. average_precision_score je schodovitý součet. auc(recall, precision) používá lichoběžníky, které mezi body PR křivky interpolují příliš optimisticky.

Kartičky

Opakování

Vyzkoušej si: Práh, matice záměn a ROC

Posuvník prahu mění matici záměn, přesnost, úplnost, F1 a bod na ROC křivce.