Lidsky řečeno
Představ si zkoušku z autoškoly. Instruktor s tebou jezdí po městě, opravuje tě a ty se zlepšuješ. To je trénink. Závěrečná jízda s komisařem je test, a má smysl jen tehdy, když trasu neznáš předem. Celá tahle mise stojí na jednom pravidle: komisařovu trasu nesmíš vidět, dokud nejsi hotový.
Každá ukázka běží samostatně, proto se na začátku bloků opakuje načtení dat. V reálném projektu by tohle bydlelo v jedné funkci.
Krok 1: převeď přání na číslo
„Ať je model dobrý“ se měřit nedá. Než otevřeš data, rozhodni, podle čeho poznáš úspěch. Každý vzorek skončí v jedné ze čtyř škatulek:
model: poplach model: klid
opravdu zhoubný TP (chycený) FN (přehlédnutý)
opravdu nezhoubný FP (planý poplach) TN (správný klid)Z nich vzniknou dvě čísla, která znáš z lekce o metrikách:
recall = TP / (TP + FN) kolik zhoubných jsme chytili
precision = TP / (TP + FP) kolik poplachů bylo oprávněnýchZadání teď zní přesně: recall aspoň 0,98 a při něm co nejvyšší precision. Běžná přesnost (accuracy) by tu lhala. Přehlédnutý nádor a planý poplach by počítala jako stejně velkou chybu.
Než spustíš kód, spočítej škatulky v hlavě.
import numpy as np
y_true = np.array([1, 1, 1, 1, 0, 0, 0, 0, 0, 0])
y_pred = np.array([1, 1, 1, 0, 1, 1, 0, 0, 0, 0])
tp = np.sum((y_true == 1) & (y_pred == 1))
fn = np.sum((y_true == 1) & (y_pred == 0))
fp = np.sum((y_true == 0) & (y_pred == 1))
print("recall", tp / (tp + fn))
print("precision", tp / (tp + fp))
recall 0.75 precision 0.6
Úkol 1: vlastní měřidlo
Napiš funkci metriky(y_true, y_pred), která dostane dvě pole nul a jedniček a vrátí dvojici (recall, precision). Když je jmenovatel nula, vrať místo daného čísla 0.0.
import numpy as np
def metriky(y_true, y_pred):
# doplň
return None
Krok 2: poznej data a zamkni trezor
Dataset je přibalený ve scikit-learn. Každý řádek popisuje jeden vzorek a sloupce jsou vlastnosti buněčných jader změřené z mikroskopického snímku: poloměr, plocha, hladkost a další.
import numpy as np
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
X = data.data
print("tvar:", X.shape)
print("třídy:", data.target_names.tolist())
print("počty 0 a 1:", np.bincount(data.target))
for jmeno in ["mean area", "mean smoothness"]:
sloupec = X[:, list(data.feature_names).index(jmeno)]
print(f"{jmeno}: {sloupec.min():.3f} až {sloupec.max():.3f}")
tvar: (569, 30) třídy: ['malignant', 'benign'] počty 0 a 1: [212 357] mean area: 143.500 až 2501.000 mean smoothness: 0.053 až 0.163
Ve výstupu hledej dvě věci. Za prvé, která třída má číslo 0. Za druhé, jak odlišné rozsahy mají sloupce. Plocha a hladkost se liší o několik řádů, takže modely citlivé na měřítko budou potřebovat škálování.
Teď přijde nejdůležitější řádek celého projektu. Pětinu dat odložíš do „trezoru“ a otevřeš ho až na konci. Parametr stratify=y zajistí, že v obou částech bude stejný podíl zhoubných vzorků. Podrobnosti jsou v lekci o trénovacích a testovacích datech.
Úkol 2: cíl a trezor
Vytvoř y, kde 1 znamená zhoubný nález. Potom rozděl data na X_train, X_test, y_train, y_test: 20 % do testu, se stratifikací a s random_state=42.
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
data = load_breast_cancer()
X = data.data
# doplň y a rozdělení
Kudy uniká test do tréninku?
Kód má škálovat data tak, aby průměr trénovacích dat vyšel 0. Parametry škálování se ale smějí počítat jen z tréninku. Jinak model nepřímo vidí test.
Krok 3: vyber model, aniž by ses dotkl testu
Jak porovnat modely bez testu? Křížovou validací. Trénink se rozdělí na pět dílů, model se pětkrát učí na čtyřech a zkouší se na pátém. Dostaneš pět známek místo jedné a vidíš i to, jak moc kolísají.
Modely srovnáváme podle average precision (AP). Ta nezávisí na žádném prahu. Měří, jak dobře model řadí vzorky, tedy jestli jsou zhoubné nahoře. A to je přesně přání z úvodu.
Do závodu vždy patří i slepý model, který data ignoruje. U AP dosáhne zhruba podílu zhoubných vzorků. Co ho nepřekoná, nic neumí.
from sklearn.datasets import load_breast_cancer
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
data = load_breast_cancer()
X, y = data.data, (data.target == 0).astype(int)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42
)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
modely = {
"slepý": DummyClassifier(strategy="prior"),
"logistická": make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
"les": RandomForestClassifier(n_estimators=60, random_state=42),
}
for jmeno, model in modely.items():
s = cross_val_score(model, X_train, y_train, cv=cv, scoring="average_precision")
print(f"{jmeno:<11} AP {s.mean():.3f} kolísání {s.std():.3f}")
slepý AP 0.374 kolísání 0.000 logistická AP 0.995 kolísání 0.005 les AP 0.987 kolísání 0.007
Čti to takhle: když je rozdíl mezi dvěma modely menší než jejich kolísání, nemáš důkaz, že je jeden lepší. V takové remíze vyhrává ten jednodušší, protože se líp vysvětluje a hůř rozbíjí. Proto v misi pokračujeme s logistickou regresí. Kdyby ji les porazil o víc, než je kolísání, stálo by za to volbu změnit.
make_pipeline spojí škálování a model do jednoho celku. Při křížové validaci se škálování učí znovu v každém kole, jen z příslušné části dat. Past z minulého úkolu tak nemůže nastat. Víc v lekci o pipelines.
Úkol 3: třetí kandidát
Zkus metodu nejbližších sousedů. Do proměnné model ulož pipeline ze StandardScaler a KNeighborsClassifier(n_neighbors=7). Do skore ulož výsledek cross_val_score s připraveným cv a metrikou "average_precision", do prumer jeho průměr.
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
data = load_breast_cancer()
X, y = data.data, (data.target == 0).astype(int)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42
)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
# doplň model, skore, prumer
Logistická regrese má hlavní knoflík C, který určuje sílu regularizace. Malé C model drží zkrátka, velké mu dovolí se víc přizpůsobit. GridSearchCV zkusí každou hodnotu a na závěr nejlepší variantu natrénuje na celém tréninku.
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV, StratifiedKFold, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
data = load_breast_cancer()
X, y = data.data, (data.target == 0).astype(int)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42
)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
mrizka = {"logisticregression__C": [0.01, 0.1, 1, 10]}
grid = GridSearchCV(pipe, mrizka, scoring="average_precision", cv=cv).fit(X_train, y_train)
for c, m, s in zip(mrizka["logisticregression__C"],
grid.cv_results_["mean_test_score"],
grid.cv_results_["std_test_score"]):
print(f"C={c:<5} AP {m:.4f} kolísání {s:.4f}")
print("nejlepší:", grid.best_params_)
C=0.01 AP 0.9898 kolísání 0.0086
C=0.1 AP 0.9942 kolísání 0.0052
C=1 AP 0.9949 kolísání 0.0046
C=10 AP 0.9926 kolísání 0.0032
nejlepší: {'logisticregression__C': 1}Dva modely mají v křížové validaci AP 0,991 a 0,989 a kolísání kolem 0,01. Co z toho plyne?
Rozdíl se ztrácí v šumu. A výběr podle testu by test proměnil v další trénink, takže by přestal být nezávislý.
Krok 4: nastav práh
Model nevrací „ano“ nebo „ne“. Vrací pravděpodobnost a ty určuješ, od jaké hodnoty se spustí poplach. Výchozí hranice 0,5 je jen zvyk, s tvým zadáním nemá nic společného. Posouvej práh a sleduj, co se děje. Data jsou tady umělá, aby šlo vidět princip.
import numpy as np
rng = np.random.default_rng(42)
y = np.array([1] * 40 + [0] * 60)
p = np.where(y == 1, rng.beta(5, 2, 100), rng.beta(2, 5, 100))
poplach = p >= prah
tp = np.sum(poplach & (y == 1))
fp = np.sum(poplach & (y == 0))
fn = np.sum(~poplach & (y == 1))
print(f"práh {prah:.2f}")
print(f"chycených {tp} z 40, přehlédnutých {fn}")
print(f"planých poplachů {fp} z 60")
práh 0.50 chycených 39 z 40, přehlédnutých 1 planých poplachů 15 z 60
Snížením prahu poplachů jen přibývá. Chycených neubude, planých poplachů taky ne. Proto platí jednoduchý recept: vezmi nejvyšší práh, který ještě splní podmínku na recall. Vyšší už by ji porušil a nižší by jen přidal plané poplachy.
Lidsky řečeno
Je to jako citlivost kouřového hlásiče. Nastavíš ji vysoko a spustí ho i toast. Nastavíš ji nízko a nespustí ho ani hořící záclona. U hlásiče chceš nejdřív jistotu, že požár nezaspí, a teprve potom co nejméně toastových poplachů.
Úkol 4: hledač prahu
Napiš vyber_prah(y, p, min_recall). Zkoušej jako prahy hodnoty z pole p, poplach platí pro p >= prah. Vrať nejvyšší práh, při kterém je recall aspoň min_recall.
import numpy as np
def vyber_prah(y, p, min_recall):
# doplň
return 0.5
Odkud ale vzít pravděpodobnosti pro hledání prahu? Z tréninku ne: model ty vzorky viděl, a proto si je jistý víc, než si zaslouží. Z testu taky ne, ten je v trezoru. Řešení dává cross_val_predict: každý trénovací vzorek dostane odhad od modelu, který se učil bez něj. Takovým odhadům se říká out-of-fold.
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import (
GridSearchCV, StratifiedKFold, cross_val_predict, train_test_split
)
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
def vyber_prah(y, p, min_recall):
for prah in np.unique(p)[::-1]:
if np.mean(p[y == 1] >= prah) >= min_recall:
return float(prah)
return float(p.min())
data = load_breast_cancer()
X, y = data.data, (data.target == 0).astype(int)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42
)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
grid = GridSearchCV(pipe, {"logisticregression__C": [0.01, 0.1, 1, 10]},
scoring="average_precision", cv=cv).fit(X_train, y_train)
p_oof = cross_val_predict(grid.best_estimator_, X_train, y_train, cv=cv,
method="predict_proba")[:, 1]
prah = vyber_prah(y_train, p_oof, 0.98)
for t in [0.5, prah]:
poplach = p_oof >= t
recall = poplach[y_train == 1].mean()
plane = np.sum(poplach & (y_train == 0))
print(f"práh {t:.4f}: recall {recall:.3f}, planých poplachů {plane}")
práh 0.5000: recall 0.953, planých poplachů 4 práh 0.2074: recall 0.982, planých poplachů 13
Porovnej oba řádky. První ukazuje, jak by dopadla výchozí hranice, druhý cenu za splnění tvé podmínky. Tahle cena se platí planými poplachy a je dobré ji říct vedoucímu laboratoře nahlas, protože každý z nich znamená práci navíc.
Doplň odhady mimo trénink
Doplň název funkce, metodu a sloupec s pravděpodobností třídy 1.
Úkol 5: stojí les méně poplachů?
AP hodnotí řazení celkově, tebe ale zajímá jedno místo na křivce. Spočítej pro náhodný les out-of-fold pravděpodobnosti p_les, najdi prah_les pro recall 0,98 a do plane_les ulož počet planých poplachů na trénovacích datech. Výsledek si porovnej s logistickou regresí z ukázky výše.
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import StratifiedKFold, cross_val_predict, train_test_split
def vyber_prah(y, p, min_recall):
for prah in np.unique(p)[::-1]:
if np.mean(p[y == 1] >= prah) >= min_recall:
return float(prah)
return float(p.min())
data = load_breast_cancer()
X, y = data.data, (data.target == 0).astype(int)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42
)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
les = RandomForestClassifier(n_estimators=60, random_state=42)
# doplň p_les, prah_les, plane_les
Les potřebuje k témuž recallu výrazně víc planých poplachů než logistická regrese, ačkoli v AP byl rozdíl malý. AP shrnuje celé řazení, kdežto provoz běží v jediném bodě křivky. Proto se finalisté nakonec srovnávají právě tam.
Pod kapotou · proč práh z out-of-fold odhadů nesedí přesně
Práh se našel na modelech učených z 80 % tréninku, ale nasazuje se model učený ze 100 %. Rozdělení jeho skóre je obvykle mírně ostřejší, takže práh se přenáší jen přibližně. Navíc C bylo vybráno na stejných foldech, ze kterých práh počítáme, což dává lehce optimistický odhad. Čistá varianta je vnořená křížová validace: vnitřní smyčka ladí, vnější měří.
Od scikit-learn 1.5 existují TunedThresholdClassifierCV a FixedThresholdClassifier, které práh zabalí přímo do estimátoru, takže se uloží a nasadí spolu s modelem. Ladění optimalizuje jeden scorer. Podmínku „recall aspoň X“ proto musíš vyjádřit vlastním scorerem. Ruční verze v téhle lekci ukazuje, co se uvnitř děje.
Práh je nejcitlivější na okraji: při recallu 0,98 o něm rozhoduje několik nejhůře skórovaných pozitivních vzorků. Jeden odlehlý případ ho může posunout hodně. Proto se v praxi přidává rezerva nebo se práh mediánuje přes bootstrap. A pokud jsou v reálných datech od jednoho pacienta vzorky vícekrát, patří do validace StratifiedGroupKFold, jinak se pacient objeví na obou stranách dělení.
Krok 5: otevři trezor
Než se na test podíváš, připrav si nástroj na nejistotu. Testovacích zhoubných vzorků je jen pár desítek, takže jedno přehlédnutí pohne recallem o celé procentní body. Samotné číslo by budilo falešný dojem přesnosti.
Bootstrap to řeší jednoduše. Z testovacích řádků tahej náhodně se vracením stejně velký vzorek, změř metriku a opakuj to třeba dvoutisíckrát. Rozptyl výsledků ukáže, jak moc by se číslo hýbalo s jinými daty.
Úkol 6: jak moc tomu věřit
Napiš interval_recall(y_true, y_pred, n=2000, seed=0). Funkce vrátí dvojici (dolni, horni), tedy 2,5. a 97,5. percentil recallu přes n bootstrapových vzorků. Vzorek bez jediné jedničky přeskoč.
import numpy as np
def interval_recall(y_true, y_pred, n=2000, seed=0):
rng = np.random.default_rng(seed)
# doplň
return 0.0, 0.0
Teď je všechno rozhodnuté: model, C i práh. Test se spouští jednou.
import numpy as np
from scipy.stats import binomtest
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import (
GridSearchCV, StratifiedKFold, cross_val_predict, train_test_split
)
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
def vyber_prah(y, p, min_recall):
for prah in np.unique(p)[::-1]:
if np.mean(p[y == 1] >= prah) >= min_recall:
return float(prah)
return float(p.min())
data = load_breast_cancer()
X, y = data.data, (data.target == 0).astype(int)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42
)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
grid = GridSearchCV(pipe, {"logisticregression__C": [0.01, 0.1, 1, 10]},
scoring="average_precision", cv=cv).fit(X_train, y_train)
model = grid.best_estimator_
p_oof = cross_val_predict(model, X_train, y_train, cv=cv, method="predict_proba")[:, 1]
prah = vyber_prah(y_train, p_oof, 0.98)
# The vault opens here, once.
p_test = model.predict_proba(X_test)[:, 1]
poplach = p_test >= prah
tp = int(np.sum(poplach & (y_test == 1)))
fn = int(np.sum(~poplach & (y_test == 1)))
fp = int(np.sum(poplach & (y_test == 0)))
tn = int(np.sum(~poplach & (y_test == 0)))
ci = binomtest(tp, tp + fn).proportion_ci(method="exact")
print(f"C = {grid.best_params_['logisticregression__C']}, práh = {prah:.4f}")
print(f"TP {tp} FN {fn} FP {fp} TN {tn}")
print(f"recall {tp / (tp + fn):.3f}, 95% interval {ci.low:.3f} až {ci.high:.3f}")
print(f"precision {tp / (tp + fp):.3f}")
print("skóre přehlédnutých:", np.round(p_test[~poplach & (y_test == 1)], 4))
vahy = model[-1].coef_[0]
for i in np.argsort(-np.abs(vahy))[:5]:
print(f"{data.feature_names[i]:<22} {vahy[i]:+.2f}")
C = 1, práh = 0.2074 TP 41 FN 1 FP 3 TN 69 recall 0.976, 95% interval 0.874 až 0.999 precision 0.932 skóre přehlédnutých: [0.0614] worst texture +1.43 radius error +1.23 worst symmetry +1.06 mean concave points +0.95 worst concavity +0.91
Ve výstupu postupně hledej:
- Recall oproti cíli. V testu je 42 zhoubných vzorků, takže 0,98 splní jen výsledek bez jediného přehlédnutí. Jedna chyba už znamená 41/42, tedy asi 0,976. Co vyjde, to napiš do zprávy, i kdyby to bylo těsně pod cílem.
- Interval. Leží 0,98 uvnitř? A jak daleko pod ní končí dolní mez? Široký interval říká, že test nedokáže cíl potvrdit ani vyvrátit.
- Přehlédnuté vzorky. Těsně pod prahem, nebo hluboko pod ním? To první je věc nastavení. To druhé znamená, že model tenhle typ případu nepoznává, a posun prahu by stál hodně planých poplachů.
- Největší váhy. Dávají odborníkovi smysl? Poloměr, obvod a plocha spolu silně souvisí a váhu si mezi sebou dělí, takže pořadí sloupců neber doslova. Kdyby ale nahoře trčel sloupec bez vztahu k nálezu, hledej únik dat.
Bootstrap z úkolu 6 tu nahradil přesný binomický interval. Při žádné nebo jediné chybě je bootstrap nespolehlivý. Bez chyb dá každý vzorek recall 1 a interval se smrskne do jediného bodu, přitom nula chyb na pár desítkách případů nedokazuje dokonalost.
Na testu vyšel recall 0,95 a cíl byl 0,98. Co je správný další krok?
První dvě možnosti dají hezké číslo, které o budoucích vzorcích nic neříká. Vybírání random_state je totéž ladění na testu, jen hůř vidět.
Pod kapotou · kolik důkazu unese malý test
Když je chyb nula, platí „pravidlo tří“: jednostranná 95% dolní mez pro úspěšnost je přibližně 1 - 3/n. Plyne z 0.05 ** (1/n). Chceš-li doložit recall 0,98, potřebuješ aspoň kolem 150 pozitivních případů a ani jednu chybu. Pár desítek na to nestačí, ať model vypadá jakkoli.
from scipy.stats import binomtest
for n in [40, 150, 400]:
mez = binomtest(n, n, alternative="greater").proportion_ci(0.95).low
print(f"{n:>3} zachycených z {n}: recall je aspoň {mez:.3f}, odhad 1 - 3/n = {1 - 3 / n:.3f}")
40 zachycených z 40: recall je aspoň 0.928, odhad 1 - 3/n = 0.925 150 zachycených z 150: recall je aspoň 0.980, odhad 1 - 3/n = 0.980 400 zachycených z 400: recall je aspoň 0.993, odhad 1 - 3/n = 0.993
Pozor i na změnu výskytu. Dataset je silně obohacený o zhoubné případy, ale ve skutečném provozu jich může být zlomek. Recall a podíl falešných poplachů (FPR) se tím v ideálním případě nezmění, precision se ale zhroutí. Plyne to z Bayesovy věty. Čísla níže jsou ilustrační.
recall, fpr = 0.98, 0.10
for vyskyt in [0.37, 0.05, 0.005]:
precision = recall * vyskyt / (recall * vyskyt + fpr * (1 - vyskyt))
print(f"výskyt {vyskyt:>5.1%}: precision {precision:.1%}")
výskyt 37.0%: precision 85.2% výskyt 5.0%: precision 34.0% výskyt 0.5%: precision 4.7%
Precision z testu tedy nepřenášej do provozu bez přepočtu na reálný výskyt. Stejně opatrně čti i AP, která na výskytu závisí, na rozdíl od ROC AUC.
Krok 6: předej výsledek
Model bez zprávy je jen soubor. Dobrá předávka je krátká a odpovídá na to, na co se bude někdo ptát za půl roku:
Účel řazení vzorků k přednostnímu čtení, nenahrazuje lékaře
Data veřejný dataset, 30 měření jader, jeden zdroj
Model škálování + logistická regrese, C z křížové validace
Práh z out-of-fold odhadů, cíl recall 0,98
Test jednorázový: TP, FN, FP, TN, recall s intervalem, precision
Slabiny malý test, jiný výskyt než v provozu, jiná zařízení neověřena
Dohled sledovat recall podle pozdějších diagnóz, práh přepočítat při změněDo řádku Test patří skutečná čísla z tvého běhu. U slabin nešetři: právě ty rozhodují, jestli model někdo použije správně.
Slož správné pořadí projektu
Seřaď kroky tak, aby test zůstal nezávislý. Jeden řádek do postupu nepatří.
Co smí vidět testovací data?
Roztřiď činnosti podle toho, na kterých datech se dělají.
Proč se práh nehledá z pravděpodobností, které model dá vlastním trénovacím vzorkům?
Na vlastních vzorcích vypadá model lépe než na nových. Práh by vyšel příliš vysoko a nové zhoubné případy by pod ním propadaly.