0 dní v řadě · 0 bodů

Strojové učení · 55 min

Mise: model od dat po vyhodnocení

Projdeš celý projekt: od zadání přes výběr modelu a nastavení prahu až po poctivý test a zprávu, které se dá věřit.

Hloubka
Úkoly
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:

text
                        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:

text
recall    = TP / (TP + FN)    kolik zhoubných jsme chytili
precision = TP / (TP + FP)    kolik poplachů bylo oprávněných

Zadá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))
Výstup
recall 0.75
precision 0.6
Úkol

Ú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
Výstup

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}")
Výstup
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

Ú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í
Výstup
Najdi chybu

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}")
Výstup
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

Ú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
Výstup

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_)
Výstup
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}
Kvíz

Dva modely mají v křížové validaci AP 0,991 a 0,989 a kolísání kolem 0,01. Co z toho plyne?

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")
Výstup
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

Ú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
Výstup

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}")
Výstup
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ň

Doplň odhady mimo trénink

Doplň název funkce, metodu a sloupec s pravděpodobností třídy 1.

Úkol

Ú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
Výstup

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

Ú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
Výstup

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}")
Výstup
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:

  1. 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.
  2. 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.
  3. 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ů.
  4. 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.

Kvíz

Na testu vyšel recall 0,95 a cíl byl 0,98. Co je správný další krok?

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}")
Výstup
 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ýstup
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:

text
Úč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ž kód

Slož správné pořadí projektu

Seřaď kroky tak, aby test zůstal nezávislý. Jeden řádek do postupu nepatří.

Roztřiď

Co smí vidět testovací data?

Roztřiď činnosti podle toho, na kterých datech se dělají.

Kvíz

Proč se práh nehledá z pravděpodobností, které model dá vlastním trénovacím vzorkům?

Kartičky

Co si odnést z mise