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))))
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.
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ásahZkratky 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}")
TP=3 FP=2 FN=1 TN=4
Která chyba je horší, určuje situace, ne matematika.
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:
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}")
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í.
Která metrika odpovídá?
Spoj otázku s metrikou.
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
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}")
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.
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
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}")
podíl pozitivních ROC AUC AP
50% 0.838 0.837
10% 0.877 0.539
1% 0.865 0.146ROC 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é.
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
Model má ROC AUC 0,5. Co to říká?
AUC popisuje pořadí. Přesnost ani precision z něj přímo neplynou, ty závisí i na prahu a podílu tříd.
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}")
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:
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ěrimport 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š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.
Testovací R² vyšlo záporné. Co to znamená?
Navzdory názvu to není druhá mocnina. Na testovacích datech může být chyba modelu větší než chyba průměru.
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))
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 1000Sleduj, 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.
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
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}")
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.824Kalibrace. 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.
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.