Cheat-sheet – POK-ISI (Python, pandas, scikit-learn)¶
Zhrnutie vysvetlení, otázok a odpovedí z práce na cvičeniach 4, 5 a praktickej úlohe Titanic.
Obsah¶
- Ako prísť na to, čo napísať (všeobecný postup)
- Jupyter notebook – základy
- Python syntax
- Ako zistiť, čo objekt vie (metódy, vlastnosti, dokumentácia)
- pandas – prieskum dát
- Pojmy strojového učenia
- scikit-learn – predspracovanie a Pipeline
- Výber príznakov (filter, wrapper, embedded)
- Modely
- Praktická úloha Titanic – postup krok za krokom
- Cvičenie 4 a 5 – kľúčové pojmy
1. Ako prísť na to, čo napísať¶
Otázka: „Nemám potuchy, čo tu mám napísať, z prsta si to nevycucám.“
Postup, ktorý funguje pri každom bode zadania:
- Povedz vlastnými slovami, čo zadanie chce. Vypíš si kľúčové slová.
- V ktorej premennej sú dáta? Príznaky →
X, cieľ (odpoveď) →y. - Prelož operáciu do angličtiny. „počet chýbajúcich hodnôt“ → count missing values.
- Nájdi príkaz:
- Google: „pandas how to …“ / „sklearn …“ (takmer vždy prvý výsledok),
- našepkávač:
X.+ Tab a píš začiatok slova, - staré cvičenia (Ctrl+F v
labs/*/notebooks/main.ipynb) – praktická úloha je skúška z cvičení, - prednášky v
lectures/. - Vyskúšaj. Ak vypíše
<bound method ...>, pridaj(). help(...)– pozri, či má metóda parameter na to, čo ešte chceš.- Pripíš záver (markdown) – čo výsledok znamená pre ďalší postup.
Kde sú veci, ktoré praktická úloha predpokladá¶
| Čo treba | Kde ste to robili |
|---|---|
SimpleImputer, OneHotEncoder, ColumnTransformer |
cvičenie 4, prvá bunka (linear_prep) |
StandardScaler |
cvičenie 4 (linear_prep), cvičenie 5 (úloha 1.1c) |
train_test_split(stratify=y), StratifiedKFold |
cvičenie 4, prvá bunka |
cross_validate, cross_val_score, Pipeline |
cvičenie 4, úloha 1.1 |
y.value_counts(), podiel tried |
cvičenie 5, úloha 1.1 |
lineárne modely s regularizáciou, GridSearchCV |
cvičenie 3 |
| škálovanie pri lineárnych modeloch | prednáška 1, sekcia 2.8 |
| stromy nepotrebujú škálovanie | prednáška 2, sekcia 1.1 |
| filter / wrapper / embedded | prednáška 1, kapitola 3 |
Dokumentácia sklearn: príklad „Column Transformer with Mixed Types“ robí predspracovanie presne na Titanicu (medián + StandardScaler pre čísla, OneHotEncoder pre kategórie).
2. Jupyter notebook – základy¶
Premenné zmiznú po zatvorení¶
Otázka: „Vždy keď sa vrátim k projektu, musím znova načítať všetky skripty?“
Áno. Premenné (X, y, titanic, natrénované modely) žijú iba v pamäti kernelu. Po zatvorení VS Code / reštarte sa vymažú. V súbore .ipynb ostane len kód a staré výstupy.
- Run All (▶▶ hore) – spustí celý notebook.
- Execute Above Cells (pravý klik na bunku) – spustí všetko nad aktuálnou bunkou.
Chyba NameError: name 'X' is not defined = bunka, ktorá X vytvára, ešte v tejto relácii nebežala.
Čo sa zobrazí¶
Jupyter automaticky zobrazí iba výsledok posledného riadku bunky.
X.shape # NEZOBRAZÍ sa (nie je posledný)
X.isna().sum() # NEZOBRAZÍ sa
y.value_counts() # zobrazí sa (posledný riadok)
Riešenie: každá vec vo vlastnej bunke, alebo obaliť do print(...).
? – dokumentácia v Jupyteri¶
- print(y.value_counts?) → SyntaxError (? nie je Python, je to príkaz Jupytera).
- V bežnom kóde použi help(y.value_counts) (bez print).
Inštalácia balíka do správneho prostredia¶
%pip inštaluje do Pythonu, v ktorom beží kernel. Potom reštartuj kernel.
3. Python syntax¶
Zátvorky () – metóda vs. vlastnosť¶
Otázka: „Prečo sa niektoré volajú so zátvorkami (isna()) a niektoré nie (shape)?“
| Príklad | Čo to je | |
|---|---|---|
vlastnosť (bez ()) |
X.shape, X.dtypes, X.columns |
hotový údaj, ktorý si objekt pamätá |
metóda (s ()) |
X.isna(), X.head(), y.value_counts() |
akcia – niečo vypočíta |
Do zátvoriek idú nastavenia (argumenty): X.head(10), y.value_counts(normalize=True).
Pomôcka: názov opisuje, čo objekt má (podstatné meno) → bez (). Názov opisuje, čo urobí (sloveso, otázka is…) → s ().
Keď sa pomýliš:
- X.isna (bez ()) → vypíše <bound method DataFrame.isna ...> → pridaj ().
- X.shape() → TypeError: 'tuple' object is not callable → odober ().
- X.info bez () vypíše <bound method DataFrame.info of ...celá tabuľka...> – vyzerá to ako „viac dát“, ale je to len náhľad tabuľky, metóda sa nespustila.
Overenie:
V notebooku VS Code má v našepkávači všetko rovnakú ikonku 🔧 – podľa nej to nerozlíšiš.
List comprehension (skrátený cyklus)¶
je to isté ako: Čítaj: „daj mia pre každé a v public, ak platí podmienka“.
cisla = [1, 2, 3, 4, 5, 6]
[c for c in cisla] # [1, 2, 3, 4, 5, 6]
[c * 10 for c in cisla] # [10, 20, ..., 60] – zmeň každý prvok (map)
[c for c in cisla if c > 3] # [4, 5, 6] – len niektoré (filter)
getattr, .tolist()¶
getattr(X, "shape")=X.shape, len s názvom ako textom.X.columnsvráti pandasIndex;.tolist()z neho spraví obyčajný Python zoznam. Dávam ho, keď si názvy ukladám do premennej (num_cols); pri pozeraní netreba.
4. Ako zistiť, čo objekt vie¶
Najprv zisti typ¶
type(X) # pandas DataFrame (tabuľka)
type(y) # pandas Series (jeden stĺpec)
type(titanic) # sklearn Bunch (balík od fetch_openml)
.shape nepochádzajú „od Titanicu“, ale od typu – má ich každý DataFrame.
| Objekt | Typ | Čo to je | Kde hľadať |
|---|---|---|---|
titanic |
Bunch |
balík: data, target, DESCR, … |
titanic.keys() |
X |
DataFrame |
tabuľka príznakov | „pandas DataFrame API reference“ |
y |
Series |
jeden stĺpec (cieľ) | „pandas Series API reference“ |
Pozor:
titanic.keys()= obsah balíka.X.keys()= názvy stĺpcov (nie vlastnosti!).shapenie je stĺpec, preto ho tam nenájdeš.
Zoznam metód a vlastností¶
# všetko (bez interných _vecí)
[a for a in dir(X) if not a.startswith("_")]
# rozdelené na vlastnosti a metódy (bez názvov stĺpcov)
public = [a for a in dir(X) if not a.startswith("_") and a not in X.columns]
methods = [a for a in public if callable(getattr(X, a))]
properties = [a for a in public if not callable(getattr(X, a))]
X. + Tab v bunke. (V zozname sú aj stĺpce, napr. .age – X.age = X["age"].)
Dokumentácia¶
| Chcem… | Použijem |
|---|---|
| rýchlo vidieť, čo existuje | X. + Tab |
vedieť, či písať () |
callable(X.niečo) alebo spustiť bez () |
| prehľadný zoznam s popismi | web: „pandas DataFrame API reference“ (sekcie Attributes a Methods) |
| čo jedna vec robí a aké má parametre | help(X.niečo) alebo X.niečo? |
Ako čítať výstup help(...)¶
- Prvý riadok (signatúra) – najdôležitejší: parametre a ich predvolené hodnoty.
value_counts(normalize=False, sort=True, ascending=False, bins=None, dropna=True) - Krátky popis – čo metóda robí.
Parameters– čo robí každý parameter (normalize : bool, default False — If True ... relative frequencies).Returns– čo dostaneš späť.Examples(riadky>>>) – hotové ukážky. Skopíruj ich a spusti, raz s parametrom a raz bez – rozdiel ti povie viac než text.
5. pandas – prieskum dát¶
Ťahák¶
| Zadanie hovorí | Príkaz |
|---|---|
| rozmery | X.shape → (riadky, stĺpce) |
| typy príznakov | X.dtypes alebo X.info() |
| chýbajúce hodnoty | X.isna().sum() |
| chýbajúce v % | (X.isna().mean() * 100).round(1) |
| počet rôznych hodnôt | X.nunique() |
| zastúpenie tried | y.value_counts() / y.value_counts(normalize=True) |
| aké hodnoty má cieľ | y.unique() |
| popis datasetu | print(titanic.DESCR) |
| základné štatistiky | X.describe() |
shape¶
X.shape # (1309, 13) → 1309 riadkov (cestujúcich), 13 stĺpcov (príznakov)
X.shape[0] # 1309
X.shape[1] # 13
y.shape # (1309,) – len jeden rozmer, je to jeden stĺpec
dtypes vs. info()¶
X.dtypes– len typy (krátke, dá sa použiť v kóde).X.info()– typy + počet riadkov + koľko hodnôt nechýba (non-null). Dobrý prvý pohľad.- numpy pole má len
.dtype(jednotné číslo),info()nemá.
| Typ | Význam | Titanic |
|---|---|---|
int64, float64 |
číselný | age, fare, sibsp, parch, pclass |
category |
kategorický | sex, embarked |
object / str |
text | name, ticket, home.dest |
isna().sum()¶
isna() dá pre každú bunku True/False (chýba?), .sum() spočíta True v každom stĺpci.
- X.count() – koľko hodnôt nechýba.
- X.nunique() – koľko rôznych hodnôt (name ≈ 1307 → nepoužiteľný).
value_counts a normalize¶
y.value_counts() # počty: 0 → 809, 1 → 500
y.value_counts(normalize=True) # podiely: 0 → 0.618, 1 → 0.382
normalize=True = každý počet vydelí celkovým súčtom (809/1309 = 0,618). „Relatívna početnosť“ = podiel z celku.
Príklad z dokumentácie: [3, 1, 2, 3, 4, NaN] → počty 3:2×, 1:1×, 2:1×, 4:1× (NaN sa nepočíta) = 5 → podiely 0,4 / 0,2 / 0,2 / 0,2.
⚠️
X.value_counts()na celej tabuľke počíta celé riadky a vynecháva riadky s NaN → pri Titanicu vyjde prázdne. Triedy sú vy.
select_dtypes¶
X.select_dtypes("number") # číselné stĺpce
X.select_dtypes("category") # kategorické
X.select_dtypes(exclude="number") # všetko, čo nie je číslo (bezpečnejšie pre kategórie)
X_model.select_dtypes("number").columns.tolist() # len názvy
Pomocná prehľadová tabuľka¶
pd.DataFrame({
"dtype": X.dtypes,
"missing_%": (X.isna().mean() * 100).round(1),
"unique": X.nunique(),
})
pd = knižnica pandas (import pandas as pd), pd.DataFrame({...}) vytvorí tabuľku zo slovníka (kľúč = názov stĺpca).
Únik – test cez crosstab¶
pd.crosstab(X["boat"].notna(), y) # počty
pd.crosstab(X["boat"].notna(), y, normalize="index") # podiely v riadku
| neprežil | prežil | prežilo | |
|---|---|---|---|
boat vyplnený |
9 | 477 | 98 % |
boat prázdny |
800 | 23 | 3 % |
body vyplnený |
121 | 0 | 0 % |
Celkovo prežilo 38 %. Bežný príznak podiel posunie (ženy 72 %, muži 20 %). Únik ho posunie úplne na kraj (0 % / 100 %). Potom sa opýtaj: Mal by som túto informáciu pred udalosťou? Člun ani číslo tela – nie → vyhodiť.
Test pre všetky stĺpce naraz:
Rozdiel priemerov medzi skupinami¶
6. Pojmy strojového učenia¶
6.0 Od dát k číslu AP¶
Táto časť vysvetľuje, čo sa reálne deje, keď spustíš:
a dostanešAP per fold: [0.818 0.797 0.786 0.845 0.772] a Baseline AP: 0.8036 ± 0.0289.
Čo je baseline a odkiaľ sa vzal¶
baseline je premenná, ktorú si sám vytvoríš o riadok vyššie (Krok 2, bod 1 zadania – „referenčný model so všetkými príznakmi“):
baseline = Pipeline([
("prep", preprocess), # 1. krok: predspracovanie (z Kroku 1)
("clf", LogisticRegression(max_iter=1000)), # 2. krok: model
])
prep a výsledok ide do clf.
- preprocess = ColumnTransformer z Kroku 1 (doplní chýbajúce hodnoty, naškáluje čísla, one-hot pre sex a embarked).
- LogisticRegression = model, ktorý sa učí predikovať survived.
- „baseline“ (referenčný model) = najjednoduchšia verzia so všetkými 10 príznakmi a predvolenými nastaveniami. Je to „nula“, s ktorou porovnávaš všetko ostatné (výber príznakov, iné modely). Ak niečo nedosiahne lepšie AP ako baseline, nepomohlo.
- Po vytvorení je baseline nenaučený – len recept. Naučí sa až pri fit (alebo vo vnútri cross_val_score).
cross_val_score(baseline, X_train, y_train, cv=cv, scoring="average_precision") znamená:
„Zober tento recept, 5-krát ho natrénuj a vyhodnoť podľa rozdelenia cv na dátach X_train/y_train a vráť mi 5 čísel AP.“
Krok A – Čo je model (na príklade logistickej regresie)¶
Model je vzorec s neznámymi číslami (váhami). Logistická regresia pre Titanic vyzerá takto:
skóre = w₁·pclass + w₂·age + w₃·sibsp + w₄·parch + w₅·fare
+ w₆·sex_female + w₇·sex_male + w₈·embarked_C + w₉·embarked_Q + w₁₀·embarked_S
+ b
w₁ … w₁₀ sú váhy – jedna pre každý príznak,
- b je konštanta (posun),
- na začiatku tieto čísla model nepozná – musí sa ich naučiť.
Skóre môže byť akékoľvek číslo (−5, 0, 3,2 …). Aby z neho bola pravdepodobnosť 0 až 1, prejde funkciou sigmoid:
- skóre = 0 → pravdepodobnosť 0,5 (nevie), - veľké kladné skóre (napr. 3) → ~0,95 (skoro iste prežil), - veľké záporné skóre (napr. −3) → ~0,05 (skoro iste neprežil).Váhy, ktoré sa model naučil na tvojich dátach (baseline["clf"].coef_):
sex_male -1.297 ← muž → skóre klesne → nižšia šanca
sex_female +1.184 ← žena → skóre stúpne → vyššia šanca
pclass -0.745 ← vyššie číslo triedy (3.) → nižšia šanca
age -0.464 ← starší → nižšia šanca
...
parch +0.008 ← takmer žiadny vplyv
Krok B – Ako sa model trénuje (fit)¶
fit(X, y) = nájdi také váhy, aby model čo najlepšie trafil y. Pri trénovaní model vidí príznaky aj správne odpovede.
Zjednodušene:
1. Začne s váhami = 0 (pre každého predikuje 0,5).
2. Pre každého cestujúceho v trénovacích dátach spočíta pravdepodobnosť a porovná ju so skutočnosťou:
- Anna prežila (y = 1), model povedal 0,5 → chyba,
- Peter neprežil (y = 0), model povedal 0,5 → chyba.
3. Chybu sčíta za všetkých (tzv. log loss – trestá hlavne sebavedomé omyly, napr. „prežil na 95 %“, keď neprežil).
4. Mierne upraví váhy tým smerom, ktorým chyba klesá (napr. zistí, že ženy prežívali častejšie → zvýši w_sex_female).
5. Opakuje kroky 2–4, kým sa chyba prestane zmenšovať.
max_iter=1000= najviac 1000 takých opakovaní (100 niekedy nestačí → varovanie „did not converge“).- Regularizácia = k chybe sa pripočíta trest za veľké váhy → model nepreháňa a menej sa pretrénuje. Silu určuje
C(menšieC= silnejší trest). Preto treba škálovať – inak by trest závisel od jednotiek príznakov.
Po fit má model váhy uložené v sebe (coef_, intercept_) a vie predikovať:
[:, 1] = stĺpec pre triedu 1 (prežil). (Stĺpec 0 = pravdepodobnosť, že neprežil.)
Krok C – Ako sa vyhodnotí: precision, recall a AP¶
Model vráti pre každého pravdepodobnosť. Zoradíme ľudí od najvyššej po najnižšiu a pozrieme sa, kde sú tí, čo naozaj prežili.
Príklad so 6 ľuďmi (3 prežili):
| poradie | meno | pravdepodobnosť od modelu | skutočne prežil? |
|---|---|---|---|
| 1 | Anna | 0,95 | ✅ áno |
| 2 | Peter | 0,80 | ❌ nie |
| 3 | Mária | 0,70 | ✅ áno |
| 4 | Ján | 0,40 | ❌ nie |
| 5 | Eva | 0,30 | ✅ áno |
| 6 | Tomáš | 0,10 | ❌ nie |
Precision (presnosť) = z tých, ktorých som označil, koľko naozaj prežilo? Recall (návratnosť) = z tých, čo naozaj prežili, koľkých som už našiel?
AP sa počíta tak, že ideme zhora a pri každom človeku, ktorý naozaj prežil, zapíšeme precision v tom bode:
| zastavím sa pri | koľko som vzal | z nich prežilo | precision | recall |
|---|---|---|---|---|
| Anna (1.) | 1 | 1 | 1/1 = 1,000 | 1/3 |
| Mária (3.) | 3 | 2 | 2/3 = 0,667 | 2/3 |
| Eva (5.) | 5 | 3 | 3/5 = 0,600 | 3/3 |
AP = priemer týchto precision = (1,000 + 0,667 + 0,600) / 3 = 0,756
- Keby model dal všetkých troch prežitých na vrch (1., 2., 3.) → precision 1, 1, 1 → AP = 1,0 (dokonalé).
- Keby poradie bolo náhodné → AP ≈ podiel prežitých ≈ 0,38.
- Čím vyššie v poradí sú skutoční prežití, tým vyššie AP.
V sklearn:
from sklearn.metrics import average_precision_score
average_precision_score([1, 0, 1, 0, 1, 0], [0.95, 0.80, 0.70, 0.40, 0.30, 0.10]) # 0.756
AP nepotrebuje prah (napr. „nad 0,5 = prežil“) – hodnotí iba poradie. Preto sa model trénuje s predict_proba, nie s predict.
Krok D – Prečo 5 čísel: krížová validácia¶
Keby sme model hodnotili na tých istých ľuďoch, na ktorých sa učil, výsledok by bol prikrášlený (čiastočne si ich „zapamätal“). Preto ho hodnotíme na ľuďoch, ktorých pri trénovaní nevidel.
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42) rozdelí 1047 ľudí z X_train na 5 skupín po ~209. Potom cross_val_score urobí 5 kôl:
skupina1 skupina2 skupina3 skupina4 skupina5
kolo 1: [VAL] [trén] [trén] [trén] [trén] → AP = 0.818
kolo 2: [trén] [VAL] [trén] [trén] [trén] → AP = 0.797
kolo 3: [trén] [trén] [VAL] [trén] [trén] → AP = 0.786
kolo 4: [trén] [trén] [trén] [VAL] [trén] → AP = 0.845
kolo 5: [trén] [trén] [trén] [trén] [VAL] → AP = 0.772
V každom kole sa stane presne toto (pri Pipeline s predspracovaním):
- Zoberie sa čistá kópia pipeline (nič nenaučené).
- Trénovacia časť (~838 ľudí, 4 skupiny):
prepsa naučí mediány (age,fare), priemery a odchýlky na škálovanie, zoznam kategórií – iba z týchto 838,- dáta sa upravia (doplnenie, škálovanie, one-hot),
clf(logistická regresia) sa natrénuje = nájde váhy (Krok B). Vidí ajytýchto 838.- Validačná časť (~209 ľudí, 1 skupina):
prepich upraví naučenými hodnotami (nič nové sa neučí),- model pre každého z 209 vypočíta pravdepodobnosť prežitia – ich
ynevidí, - až potom sa pravdepodobnosti porovnajú so skutočným
ytýchto 209 → jedno AP (Krok C). - Model sa zahodí.
Výsledok: scores = [0.818, 0.797, 0.786, 0.845, 0.772] – 5 nezávislých odhadov, ako dobre model funguje na nových ľuďoch.
Prečo sú rôzne? V každom kole je vo validácii iná skupina ľudí – niektorá je pre model ľahšia (kolo 4: 0,845), iná ťažšia (kolo 5: 0,772). Je to náhoda rozdelenia, nie chyba.
Čo presne znamená [trén] a [VAL]¶
Predstav si, že 1047 ľudí z X_train rozdelíš do 5 skupín (stratifikovane, každá má ~38 % prežitých). Skutočné veľkosti v tvojich dátach:
| kolo | trénovacích ([trén]) |
validačných ([VAL]) |
podiel prežitých vo VAL |
|---|---|---|---|
| 1 | 837 | 210 | 0,381 |
| 2 | 837 | 210 | 0,381 |
| 3 | 838 | 209 | 0,383 |
| 4 | 838 | 209 | 0,383 |
| 5 | 838 | 209 | 0,383 |
[trén]= ľudia, na ktorých sa model v tomto kole učí. Dostane ich príznaky aj odpovede (y) a hľadá váhy.[VAL]= ľudia, na ktorých sa model v tomto kole skúša. Dostane len ich príznaky, sám odhadne pravdepodobnosť prežitia a až potom sa jeho odhady porovnajú so skutočnosťou → AP.
Ako skúška v škole: [trén] = príklady, ktoré si si precvičil aj s výsledkami, [VAL] = príklady na písomke, ktorých výsledky nepoznáš. Známka (AP) sa počíta len z písomky.
Príklad, ako to vyzerá pre pár ľudí vo validácii (model odhadne, potom sa porovná):
| cestujúci (index) | čo model dostane | model odhadne | skutočnosť (y) |
|---|---|---|---|
| 999 | žena, 3. tr., vek ?, Q | 0,56 | 1 (prežila) |
| 392 | žena, 2. tr., 24 r., C | 0,86 | 1 (prežila) |
| 628 | žena, 3. tr., 11 r., 4 súrodenci, S | 0,45 | 0 (neprežila) |
| 1165 | muž, 3. tr., 25 r., C | 0,21 | 0 (neprežil) |
| 604 | žena, 3. tr., 16 r., S | 0,69 | 1 (prežila) |
Z odhadov všetkých ~209 ľudí vo VAL a ich skutočných odpovedí sa vypočíta jedno AP (Krok C).
Časté nedorozumenia¶
- Je každé z 5 čísel jeden príznak? Nie. Každé číslo je jedno kolo (jeden fold). V každom kole model používa všetkých 10 príznakov naraz (tie, čo ostali po vyhodení a one-hot) a AP sa počíta z ~209 ľudí vo validácii.
- Delí sa 209 na 5 skupín? Nie. Na 5 skupín sa delí celých 1047 ľudí z
X_train. Jedna skupina má ~209 ľudí. V každom kole je 1 skupina validačná a 4 trénovacie. - Ktoré príznaky sa používajú? Tie, ktoré si nevyhodil v
drop_cols(pclass, sex, age, sibsp, parch, fare, embarked) → po predspracovaní 10 stĺpcov. Pri výbere príznakov (Krok 2) potom len vybrané k. - Každý človek je vo validácii presne raz (v jednom z 5 kôl) a 4-krát v trénovaní.
Krok E – AP a AP_SD (priemer a smerodajná odchýlka)¶
AP (scores.mean()) – priemer 5 čísel = hlavný výsledok:
AP_SD (scores.std(ddof=1)) – smerodajná odchýlka = ako veľmi sa 5 čísel líši od priemeru:
| fold | AP | odchýlka od priemeru | na druhú |
|---|---|---|---|
| 1 | 0,818 | +0,014 | 0,000207 |
| 2 | 0,797 | −0,007 | 0,000044 |
| 3 | 0,786 | −0,018 | 0,000310 |
| 4 | 0,845 | +0,041 | 0,001714 |
| 5 | 0,772 | −0,032 | 0,000999 |
| súčet | 0,003274 |
ddof=1 = deliť 5 − 1 = 4 namiesto 5 (štandard, keď máme len vzorku – 5 foldov).
Ako to čítať: 0.8036 ± 0.0289 = „model má AP okolo 0,80, ale podľa toho, akí ľudia sa trafia do validácie, sa výsledok bežne pohybuje približne medzi 0,77 a 0,83“.
Krok F – Ako porovnať dve konfigurácie / dva modely¶
| AP | AP_SD | |
|---|---|---|
| Logistic regression | 0,8043 | 0,0231 |
| Random forest | 0,8006 | 0,0266 |
| KNN | 0,7370 | 0,0387 |
- LogReg vs. Random forest: rozdiel 0,004 ≪ SD (~0,025) → nedá sa povedať, ktorý je lepší, rozdiel môže byť len náhoda rozdelenia.
- LogReg vs. KNN: rozdiel 0,067 > 2 × SD → KNN je naozaj horší.
Pravidlo: rozdiel menší ako SD = „rovnako dobré“. Rozdiel výrazne väčší ako SD = skutočný rozdiel. (Presnejšie sa dá porovnať fold po folde – koľko z 5 foldov bol jeden lepší, ako folds_better v cvičení 4.)
Krok G – Kde sa použije X_test¶
Všetky čísla v Krokoch 2–4 pochádzajú z validačných pätín X_train. X_test (262 ľudí) je zamknutý. V Kroku 5:
1. vyberieš najlepší postup podľa CV,
2. natrénuješ ho raz na celom X_train (fit),
3. vypočítaš AP raz na X_test – poctivý odhad, ako bude model fungovať na úplne nových ľuďoch.
| Slovensky | Anglicky | V kóde |
|---|---|---|
| príznak | feature | stĺpec v X |
| pozorovanie / záznam | sample / observation | riadok |
| cieľová premenná | target / label | y |
| trieda | class | hodnota y (0 / 1) |
X a y¶
X– vstupy (príznaky):pclass,sex,age, …y– výstup (cieľ):survived(1 = prežil, 0 = neprežil).- Model sa učí y = f(X). Veľké
X= tabuľka, maléy= jeden stĺpec. ynemá stĺpce akoX– je to jedna odpoveď na riadok.
Odkiaľ viem, že 1 = prežil? Z textu zadania („cieľová premenná survived (1 = prežil, 0 = neprežil)“), z y.unique(), z print(titanic.DESCR). Pri binárnej klasifikácii je zvyčajne 1 = to, čo hľadáme.
Dva významy slova „trieda“¶
| Čo to je | Hodnoty | |
|---|---|---|
| trieda cieľa | výsledok, ktorý predikujeme | 0 / 1 (v y) |
| trieda lístka | pclass |
1., 2., 3. trieda (v X) |
Model¶
Model = matematická funkcia s parametrami naučenými z dát. LLM a neurónky sú tiež modely, ale obrovské. Logistická regresia má len 10 váh + konštantu.
fit– trénovanie, vždy od nuly (staré váhy zahodí). Model vidí ajy– bez odpovedí by sa nemal z čoho učiť.- Po
fitsi model váhy pamätá, kým beží kernel.predict_probanetrénuje znova. - Po reštarte kernelu zmizne (natrvalo:
joblib.dump(model, "model.joblib")).
Trénovacia / testovacia množina¶
všetkých 1309
├── X_test (262) ← ZAMKNUTÉ, použijem iba raz v Kroku 5
└── X_train (1047) ← s týmito pracujem v Krokoch 2–4
X_train, X_test, y_train, y_test sú nové objekty; delia sa riadky (cestujúci), stĺpce ostávajú. X_model a y sa nezmenia.
- Riadky si nechajú pôvodné čísla (index) – X_train aj y_train majú rovnaké čísla vľavo → patria k sebe.
Krížová validácia (CV) a fold¶
Trénovaciu množinu rozdelíš na 5 častí (foldov). Model 5× natrénuješ na 4 častiach a vyhodnotíš na piatej (zakaždým inej). Výsledok = priemer 5 skóre.
kolo 1: [VAL] [trén] [trén] [trén] [trén]
kolo 2: [trén] [VAL] [trén] [trén] [trén]
...
kolo 5: [trén] [trén] [trén] [trén] [VAL]
y), 1/5 = 209 na validáciu (model dostane len príznaky, odhady sa porovnajú so skutočným y).
„Nevidené dáta“ v CV = validačná pätina z X_train, nie X_test. Test je druhá úroveň – poctivý odhad po všetkom výbere.
Stratifikácia, random_state, shuffle¶
stratify=y/StratifiedKFold– zachová pomer tried (38 % prežitých) v každej časti.random_state=42– rovnaká „náhoda“ pri každom spustení → rovnaké výsledky. Číslo môže byť akékoľvek, len vždy to isté (42 = zvyk).shuffle=True– zamieša riadky pred delením (Titanic je zoradený podľapclass– bez miešania by foldy boli rôzne).cvje len premenná s návodom, ako deliť – odovzdáš ju docross_val_score(..., cv=cv).
Únik informácií (data leakage)¶
Model sa nesmie nič naučiť z dát, na ktorých ho potom hodnotíš.
- ❌ medián / škálovanie / výber príznakov vypočítaný z celých dát a až potom CV,
- ✅ všetko ako kroky v Pipeline → v každom folde sa učí iba z trénovacej časti.
| ✅ Rob | ❌ Nerob |
|---|---|
Pipeline([("prep", ...), ("select", ...), ("clf", ...)]) |
preprocess.fit_transform(X) a až potom CV |
cross_val_score(pipe, X_train, y_train, cv=cv) |
vyberať príznaky na celých dátach |
GridSearchCV(pipe, ..., cv=cv).fit(X_train, y_train) |
čokoľvek trénovať/ladiť na X_test |
X_test iba raz v Kroku 5 |
meniť model podľa testu |
AP (Average Precision)¶
Metrika z cieľa úlohy. Model každému dá pravdepodobnosť prežitia; AP hodnotí, či skutočne prežitých zoradí vyššie.
- precision – z tých, o ktorých model tvrdí „prežil“, koľko naozaj prežilo,
- recall – z tých, čo naozaj prežili, koľkých model našiel,
- 1,0 = dokonalé, ~0,38 = náhodné (podiel pozitívnej triedy).
- v sklearn: scoring="average_precision".
scores.mean(), scores.std(ddof=1)¶
cross_val_score vráti 5 čísel (jedno za fold).
- .mean() – priemer → stĺpec AP,
- .std(ddof=1) – smerodajná odchýlka → AP_SD (ako veľmi sa foldy líšia). ddof=1 = delí n−1 (výberová SD).
- Rozdiely menšie ako SD (~0,02–0,03) môžu byť len náhoda.
Škálovanie (scaling)¶
Prepočítanie čísel na podobný rozsah. StandardScaler:
nová hodnota = (hodnota − priemer) / smerodajná odchýlka → priemer 0, rozptyl 1.
Príklad fare (priemer 33, SD 52): 33 → 0, 85 → 1, 8 → −0,5.
| Model | Škálovanie? | Prečo |
|---|---|---|
LogisticRegression (regularizácia) |
áno | penalizácia sčíta koeficienty, musia byť porovnateľné (prednáška 1, 2.8) |
| KNN, SVM | áno | merajú vzdialenosť |
| stromy, Random Forest, boosting | nie (neuškodí) | delenie podľa prahu jednej premennej (prednáška 2, 1.1) |
Vyskúšaj si škálovanie (ukážka, do riešenia netreba)¶
nums = X[["age", "fare", "parch"]].dropna()
scaled = StandardScaler().set_output(transform="pandas").fit_transform(nums)
print(nums.describe().round(2))
print(scaled.describe().round(2))
Čo ide dnu (vstup) a čo vyjde (výstup):
- X[["age", "fare", "parch"]] – vyberie 3 číselné stĺpce (dvojité [[ ]] = výsledok je tabuľka, nie jeden stĺpec).
- .dropna() – vyhodí riadky, kde niečo chýba (len pre ukážku; v riešení chýbajúce dopĺňa SimpleImputer).
- vstup nums – tabuľka s pôvodnými číslami (vek v rokoch, cena v librách, počet detí).
- StandardScaler() – vytvorí škálovač.
- .set_output(transform="pandas") – nech výsledok je pandas tabuľka (s názvami stĺpcov), nie holé numpy pole – len kvôli prehľadnosti.
- .fit_transform(nums) – fit = vypočíta priemer a SD každého stĺpca, transform = prepočíta každú hodnotu (x − priemer) / SD.
- výstup scaled – rovnaká tabuľka, rovnaké riadky aj stĺpce, len prepočítané čísla.
- .describe() – súhrnné štatistiky každého stĺpca (počet, priemer, SD, min, kvartily, max).
Výstup – pred škálovaním (nums):
age fare parch
count 1045.00 1045.00 1045.00
mean 29.85 36.69 0.42
std 14.39 55.73 0.84
min 0.17 0.00 0.00
max 80.00 512.33 6.00
scaled):
age fare parch
count 1045.00 1045.00 1045.00
mean -0.00 0.00 0.00 ← priemer každého stĺpca je 0
std 1.00 1.00 1.00 ← SD každého stĺpca je 1
min -2.06 -0.66 -0.50
max 3.49 8.54 6.64
age fare parch age fare parch
29.00 211.34 0 → -0.06 3.14 -0.50
0.92 151.55 2 → -2.01 2.06 1.88
2.00 151.55 2 → -1.94 2.06 1.88
Čo vďaka tomu vznikne: všetky príznaky sú v rovnakej mierke (okolo 0, väčšinou −2 až +3). Rozdiel „o 1“ znamená všade to isté: „o jednu smerodajnú odchýlku viac“.
Kde sa to používa: v riešení robí presne toto StandardScaler() vo vnútri preprocess (časť num) – automaticky v Pipeline, v každom folde len z trénovacích dát. Táto ukážka slúži iba na to, aby si videl, čo škálovanie robí.
cross_val_score vs. cross_validate¶
Obe robia rovnakú krížovú validáciu. cross_validate je podrobnejšia verzia – rozdiel je v tom, koľko informácií z nej potrebuješ vytiahnuť.
| Vlastnosť | cross_val_score |
cross_validate |
|---|---|---|
| návratová hodnota | ndarray (pole čísel) |
dict (slovník s poľami) |
| počet metrík | iba 1 | ľubovoľný počet naraz |
| čas behu | nie | áno (fit_time, score_time) |
| skóre na trénovacích dátach | nie | áno (return_train_score=True) |
| natrénované modely | nie | áno (return_estimator=True) |
| typické použitie | rýchla kontrola jedného skóre | podrobná diagnostika, stacking, viac metrík |
cross_val_score – stačí ti jedno pole čísel pre jednu metriku:
scores = cross_val_score(model, X_train, y_train, cv=cv, scoring="average_precision")
scores # array([0.818, 0.797, 0.786, 0.845, 0.772])
scores.mean()
cross_validate – vráti slovník; vždy obsahuje:
- test_score – skóre na validačnom folde (to isté, čo vráti cross_val_score),
- fit_time – ako dlho trvalo trénovanie (v každom folde),
- score_time – ako dlho trvalo vyhodnotenie.
res = cross_validate(model, X_train, y_train, cv=cv, scoring="average_precision")
res["test_score"] # array([...]) – 5 čísel AP
res["fit_time"] # array([...]) – sekundy
Kľúčové výhody cross_validate:
- viac metrík naraz:
res = cross_validate(model, X, y, cv=cv, scoring=["precision", "recall", "roc_auc"])
res["test_precision"], res["test_recall"], res["test_roc_auc"]
return_train_score=True → res["train_score"]) – kontrola pretrénovania (cvičenie 4, úloha 1.1: strom train 0,998 vs. val 0,763),
- natrénované modely (return_estimator=True → res["estimator"]) – potrebné pri stackingu v Kroku 4, aby sa dalo pozrieť dovnútra (váhy meta-modelu final_estimator_.coef_).
Konfigurácia vs. model¶
V Kroku 2 je model stále ten istý (logistická regresia), mení sa výber príznakov → hovoríme o konfiguráciách. Rôzne modely prídu v Kroku 3.
7. scikit-learn – predspracovanie a Pipeline¶
Tri stavebné kocky¶
1. Transformer – jedna úprava
imputer = SimpleImputer(strategy="median") # vytvor objekt
age_filled = imputer.fit_transform(X[["age"]]) # fit = nauč sa, transform = použi
| Objekt | Čo robí |
|---|---|
SimpleImputer(strategy="median") |
doplní chýbajúce čísla mediánom |
SimpleImputer(strategy="most_frequent") |
doplní najčastejšou hodnotou |
StandardScaler() |
škálovanie |
OneHotEncoder(handle_unknown="ignore") |
kategória → stĺpce 0/1 (sex → sex_female, sex_male) |
2. make_pipeline – viac úprav za sebou na tých istých stĺpcoch
num_steps = make_pipeline(SimpleImputer(strategy="median"), StandardScaler())
cat_steps = make_pipeline(SimpleImputer(strategy="most_frequent"), OneHotEncoder(handle_unknown="ignore"))
3. ColumnTransformer – rôzne úpravy pre rôzne stĺpce
preprocess = ColumnTransformer([
# (meno, úprava, stĺpce)
("num", num_steps, ["pclass", "age", "sibsp", "parch", "fare"]),
("cat", cat_steps, ["sex", "embarked"]),
])
"num" – meno (ľubovoľné), objaví sa ako predpona num__ v názvoch výstupných stĺpcov,
- num_steps – čo sa má so stĺpcami urobiť (doplniť medián → škálovať),
- ["pclass", ...] – na ktoré stĺpce.
Stĺpce, ktoré nie sú v žiadnom zozname, sa zahodia (predvolené remainder="drop").
Ukážka – čo vojde a čo vyjde (prvé 3 riadky X_train):
pclass sex age sibsp parch fare embarked
999 3 female NaN 0 0 7.7500 Q
392 2 female 24.0 1 0 27.7208 C
628 3 female 11.0 4 2 31.2750 S
num__pclass num__age num__sibsp num__parch num__fare cat__sex_female cat__sex_male cat__embarked_C cat__embarked_Q cat__embarked_S
999 0.82 -0.10 -0.48 -0.45 -0.50 1.0 0.0 0.0 1.0 0.0
392 -0.38 -0.41 0.51 -0.45 -0.09 1.0 0.0 1.0 0.0 0.0
628 0.82 -1.42 3.48 1.87 -0.02 1.0 0.0 0.0 0.0 1.0
age NaN pri 999 → doplnený medián (28 rokov) → po škálovaní −0,10,
- čísla naškálované (3. trieda = 0,82, 2. trieda = −0,38 …),
- sex → 2 stĺpce: sex_female = 1, sex_male = 0 (žena),
- embarked → 3 stĺpce: 999 nastúpil v Q → embarked_Q = 1, ostatné 0,
- tvar (1047, 10) – rovnaký počet riadkov, 10 stĺpcov.
Naučené hodnoty si pozrieš: preprocess.named_transformers_["num"][0].statistics_ → mediány [3, 28, 0, 0, 13.82] (pclass, age, sibsp, parch, fare).
V riešení
preprocess.fit_transform(...)samostatne nevoláš (únik!) – robí to Pipeline. Toto je len na pozretie.
Ako funguje Pipeline (podrobne)¶
Pipeline = výrobná linka. Dáta vojdú na začiatok a postupne prejdú všetkými krokmi. Výstup jedného kroku je vstup ďalšieho.
pipe = Pipeline([
("prep", preprocess), # krok 1: doplniť, škálovať, one-hot
("select", SelectKBest(f_classif, k=5)), # krok 2: nechať 5 najlepších príznakov
("clf", LogisticRegression(max_iter=1000)), # krok 3 (posledný): model
])
fit + transform) – tzv. transformery.
- Posledný krok je zvyčajne model (fit + predict / predict_proba).
Čo sa deje pri pipe.fit(X_train, y_train)¶
X_train (7 stĺpcov, NaN, text)
│
▼ prep.fit(X_train) ← NAUČÍ SA: mediány, priemery/SD, zoznam kategórií
▼ prep.transform(X_train) ← POUŽIJE: doplní, naškáluje, one-hot → 10 čísel
│
▼ select.fit(..., y_train) ← NAUČÍ SA: ktorých 5 príznakov je najlepších
▼ select.transform(...) ← POUŽIJE: nechá len tých 5 stĺpcov
│
▼ clf.fit(..., y_train) ← NAUČÍ SA: váhy modelu
Čo sa deje pri pipe.predict_proba(X_test)¶
X_test
│
▼ prep.transform(X_test) ← iba POUŽIJE naučené (mediány z TRAIN!), nič sa neučí
▼ select.transform(...) ← nechá tých istých 5 stĺpcov
▼ clf.predict_proba(...) ← pravdepodobnosti prežitia
Ručne bez Pipeline by to vyzeralo takto¶
# trénovanie
Xt = preprocess.fit_transform(X_train)
Xt = selector.fit_transform(Xt, y_train)
model.fit(Xt, y_train)
# predikcia
Xv = preprocess.transform(X_test)
Xv = selector.transform(Xv)
proba = model.predict_proba(Xv)[:, 1]
fit na testovacích dátach).
Prečo Pipeline bráni úniku informácií¶
V cross_val_score(pipe, X_train, y_train, cv=cv) sa v každom z 5 kôl zavolá:
- pipe.fit(trénovacia_časť) → mediány, škálovanie, výber príznakov aj model sa učia len z ~838 ľudí,
- pipe.predict_proba(validačná_časť) → ~209 ľudí sa iba upraví a ohodnotí.
Bez Pipeline by si ľahko spravil preprocess.fit_transform(X_train) pred CV – medián by sa vypočítal aj z validačných ľudí → únik.
Práca s krokmi¶
| Zápis | Čo vráti |
|---|---|
pipe["clf"] alebo pipe[-1] |
posledný krok (model) |
pipe["prep"] alebo pipe[0] |
prvý krok (predspracovanie) |
pipe[:-1] |
nová pipeline zo všetkých krokov okrem modelu |
pipe[:-1].get_feature_names_out() |
názvy príznakov, ktoré idú do modelu |
pipe["clf"].coef_ |
váhy natrénovaného modelu |
pipe.set_params(clf__C=0.1) |
zmení parameter kroku clf |
("select", "passthrough") |
krok sa preskočí |
Mená krokov + __ – keď GridSearchCV ladí "clf__C", znamená to „v kroku clf nastav parameter C“. "select" (bez __) znamená „vymeň celý krok select“.
Pipeline vs. make_pipeline: make_pipeline(A(), B()) je to isté, len mená krokov vymyslí sám ("a", "b" podľa názvu triedy malými písmenami). Pri ladení je praktickejší Pipeline s vlastnými menami.
Pipeline s modelom¶
model = Pipeline([
("prep", preprocess),
("clf", LogisticRegression(max_iter=1000)),
])
model.fit(X_train, y_train) # predspracuje + natrénuje
model.predict_proba(X_test) # predspracuje rovnako + predikuje
"prep", "clf" – mená krokov, vymyslíš si ich (clf = classifier). Hodia sa pri ladení (clf__C) a pri výbere kroku: pipe["select"].
- max_iter=1000 – max. počet krokov optimalizácie (100 niekedy nestačí → varovanie).
- pipe[:-1] – všetky kroky okrem modelu. pipe[:-1].get_feature_names_out() – názvy príznakov, ktoré idú do modelu.
Kontrola¶
out = preprocess.fit_transform(X_model)
print(out.shape) # (1309, 10)
print(preprocess.get_feature_names_out())
num__, cat__ = z ktorej časti ColumnTransformer príznak pochádza.
Medián vs. najčastejšia hodnota – prečo¶
- text (
embarked) – medián ani priemer nejde → najčastejšia hodnota, - čísla (
age,fare) – medián (neskreslia ho extrémy ako lístky za 512), - iné voľby (priemer) sú tiež OK, ak ich zdôvodníš.
8. Výber príznakov¶
Kde: prednáška 1, kapitola 3 (lectures/1/lecture_notes_L1b_PUB.md, ~r. 440–470).
| Prístup | Ako vyberá | sklearn |
|---|---|---|
| filter | každý príznak ohodnotí štatistickým testom samostatne, bez modelu | SelectKBest(f_classif, k=k) |
| wrapper | natrénuje model, vyhodí najslabší, opakuje, kým nezostane k | RFE(LogisticRegression(...), n_features_to_select=k) |
| embedded | výber počas trénovania – L1 stlačí slabé váhy na 0 | SelectFromModel(LogisticRegression(l1_ratio=1.0, solver="liblinear"), max_features=k, threshold=-np.inf) |
l1_ratio=1.0= L1 regularizácia (v sklearn 1.9 jepenalty="l1"zastarané).threshold=-np.inf– rozhoduje ibamax_features, aby ich bolo presne k.- Výber musí byť krok v Pipeline (
("select", ...)) – inak únik.
Podľa čoho rozhodujú¶
Filter – F-skóre (ANOVA): porovná priemer príznaku u prežitých (1) a neprežitých (0). Čím väčší rozdiel, tým vyššie F (rozdiel sa ešte porovná s rozhádzanosťou hodnôt v skupinách).
| Príznak | F | Prečo |
|---|---|---|
sex_male / sex_female |
381 | ženy 72 %, muži 20 % (rovnaké F – jeden je opak druhého) |
pclass |
103 | 1. tr. 62 %, 2. tr. 42 %, 3. tr. 27 % |
fare |
68 | priemer 23 vs. 48 |
embarked_C |
46 | Cherbourg 58 % vs. ~33 % |
age |
3,9 | priemer 30,5 vs. 28,3 |
sibsp |
0,3 | 0,50 vs. 0,46 |
Slabina filtra: porovnáva len priemery. age (prežívali hlavne malé deti) a sibsp (1 súrodenec 54 %, sám 34 %, 4+ ≈ 0–15 %) majú nízke F, hoci s prežitím súvisia.
Wrapper (RFE) – váhy logistickej regresie:
- znamienko+ zvyšuje šancu prežiť, − znižuje,
- najslabší = najmenšia váha v absolútnej hodnote,
- ranking_: 1 = zostal, vyššie = vyhodený skôr (parch = 6 → prvý, fare = 5 → druhý).
Embedded (L1): jedna L1 logistická regresia; slabé váhy stlačí na nulu (embarked_S = 0), nechá k najväčších.
Porovnávať váhy sa dá len preto, že sú príznaky naškálované.
Výpis skóre¶
pipe_f = Pipeline([("prep", preprocess), ("select", make_selector("filter (ANOVA F)", 5))]).fit(X_train, y_train)
print(pd.Series(pipe_f["select"].scores_, index=pipe_f["prep"].get_feature_names_out()).sort_values(ascending=False))
pipe_r = Pipeline([("prep", preprocess), ("select", make_selector("wrapper (RFE)", 5))]).fit(X_train, y_train)
print(pd.Series(pipe_r["select"].ranking_, index=pipe_r["prep"].get_feature_names_out()).sort_values())
pipe_l = Pipeline([("prep", preprocess), ("select", make_selector("embedded (L1)", 5))]).fit(X_train, y_train)
print(pd.Series(pipe_l["select"].estimator_.coef_[0], index=pipe_l["prep"].get_feature_names_out()).abs().sort_values(ascending=False))
scores_, ranking_, estimator_.coef_ – vlastnosti, ktoré si selektor zapamätá po fit (v dokumentácii sekcia Attributes).
Ukážkový výstup (5 príznakov):
FILTER - F score: WRAPPER - RFE ranking: EMBEDDED - |L1 coefficient|:
cat__sex_male 381.23 num__pclass 1 cat__sex_male 1.641
cat__sex_female 381.23 num__age 1 cat__sex_female 0.841
num__pclass 103.02 cat__sex_male 1 num__pclass 0.750
num__fare 68.16 cat__sex_female 1 cat__embarked_C 0.670
cat__embarked_C 46.27 cat__embarked_C 1 num__age 0.459
cat__embarked_S 26.70 num__sibsp 2 num__sibsp 0.301
num__parch 11.45 cat__embarked_Q 3 cat__embarked_Q 0.111
num__age 3.89 cat__embarked_S 4 num__fare 0.056
cat__embarked_Q 1.30 num__fare 5 num__parch 0.002
num__sibsp 0.30 num__parch 6 cat__embarked_S 0.000
Prečo sú tie tri print iné?¶
Lebo každá metóda rozhoduje inak, a preto si pamätá iný druh čísla. Rovnaký výpis pre všetky tri nejde, lebo napr. filter nemá žiadny model a teda nemá koeficienty.
| Metóda | Čo vypočíta | Kde si to uloží | Čo znamená číslo |
|---|---|---|---|
filter (SelectKBest) |
štatistický test pre každý príznak zvlášť | scores_ |
F-skóre – vyššie = lepšie |
wrapper (RFE) |
opakovane trénuje model a vyhadzuje | ranking_ |
poradie vyradenia – 1 = ostal, vyššie = vyhodený skôr |
embedded (SelectFromModel) |
natrénuje jeden model s L1 | estimator_.coef_ (váhy toho modelu) |
váha – väčšia (v abs. hodnote) = dôležitejší |
Preto:
- pri filtri sort_values(ascending=False) (najvyššie skóre hore),
- pri RFE sort_values() (najmenšie poradie = 1 hore),
- pri L1 .abs() (záporná váha −1,3 je rovnako silná ako +1,3) a potom zostupne.
estimator_ = model, ktorý si SelectFromModel vnútri natrénoval; .coef_[0] = jeho váhy (riadok 0, lebo pri binárnej klasifikácii je len jeden riadok váh).
Ako zistiť, čo si daný selektor pamätá: dokumentácia triedy → sekcia Attributes (napr. „sklearn SelectKBest“ → scores_, pvalues_), alebo [a for a in dir(pipe_f["select"]) if a.endswith("_") and not a.startswith("_")] – naučené vlastnosti v sklearn končia podčiarkovníkom.
Kľúčový rozdiel (5 príznakov)¶
- všetci vybrali:
pclass,sex_male,sex_female,embarked_C, - filter ako piaty
fare(sám o sebe silný), - wrapper + embedded
age– v modeli už jepclass,farenesie podobnú informáciu (drahý lístok = 1. trieda),ageprináša niečo nové (deti prvé).
9. Modely¶
| Model | Ako rozhoduje | Škálovanie |
|---|---|---|
| Logistic regression | váhy × príznaky, súčet → pravdepodobnosť; regularizácia (predvolene L2, C=1) bráni veľkým váham |
áno |
| Random forest | 100 rozhodovacích stromov, každý na náhodnej vzorke; výsledok = priemer | nie |
| KNN | nájde k najpodobnejších (predvolene 5); pravdepodobnosť = podiel prežitých medzi nimi | áno (vzdialenosť) |
| boosting (HistGB, XGBoost, LightGBM) | stromy postupne, každý opravuje chyby predošlých | nie |
Krok 3 požaduje: aspoň 3 klasifikátory s odlišným princípom, z toho lineárny s regularizáciou (cvičenie 3) a stromový skupinový (cvičenie 4).
10. Praktická úloha Titanic¶
Cieľ: max. AP pri predikcii survived. Porovnávanie cez CV, test iba na konci.
Krok 1 – Príprava dát¶
Bod 1 – prieskum
Výsledky: 1309 × 13; prežilo 38,2 %; chýbaage 263, fare 1, cabin 1014, embarked 2, boat 823, body 1188, home.dest 564.
Bod 2 – predspracovanie
| Stĺpec | Rozhodnutie |
|---|---|
pclass, age, sibsp, parch, fare |
nechať (číselné) |
sex, embarked |
nechať (kategorické) |
boat, body |
vyhodiť – únik (98 % / 0 % prežitých) |
name, ticket |
vyhodiť – takmer unikátne |
home.dest |
vyhodiť – voľný text, 43 % chýba |
cabin |
vyhodiť – 77 % chýba |
Pravidlá na vyhodenie:
- missing_% > ~70 → vyhodiť,
- text s unique ≈ počet riadkov → vyhodiť (pri číslach to nevadí – fare ostáva),
- crosstab ukáže ~0 % / 100 % a údaj vznikol až po udalosti → vyhodiť.
Prečo fare ostáva: chýba 1 hodnota, je to číslo, je známy pred plavbou a prežitie s ním postupne rastie (~20 % → ~60 %):
drop_cols = ["boat", "body", "name", "ticket", "home.dest", "cabin"]
X_model = X.drop(columns=drop_cols)
num_cols = ["pclass", "age", "sibsp", "parch", "fare"]
cat_cols = ["sex", "embarked"]
preprocess = ColumnTransformer([
("num", make_pipeline(SimpleImputer(strategy="median"), StandardScaler()), num_cols),
("cat", make_pipeline(SimpleImputer(strategy="most_frequent"), OneHotEncoder(handle_unknown="ignore")), cat_cols),
])
sex 2 + embarked 3).
Bod 3 – rozdelenie a CV
RANDOM_STATE = 42
X_train, X_test, y_train, y_test = train_test_split(
X_model, y, test_size=0.2, stratify=y, random_state=RANDOM_STATE
)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=RANDOM_STATE)
Train: (1047, 7), test: (262, 7), podiel prežitých 0,382 v oboch.
Dá sa vždy dosiahnuť rovnaký podiel v oboch častiach?¶
Ako stratifikácia funguje: train_test_split(..., stratify=y) nemieša všetkých dokopy, ale rozdelí každú triedu zvlášť v pomere 80 : 20:
| spolu | → train (80 %) | → test (20 %) | |
|---|---|---|---|
| neprežil (0) | 809 | 647 | 162 |
| prežil (1) | 500 | 400 | 100 |
| spolu | 1309 | 1047 | 262 |
| podiel prežitých | 0,382 | 400/1047 = 0,382 | 100/262 = 0,382 |
shuffle len určí, ktorí konkrétni ľudia z každej triedy pôjdu do trénovacej a ktorí do testovacej časti – počty z každej triedy sú dané vopred.
Je to vždy presne rovnaké? Nie úplne – len približne. Ľudí nemožno deliť na zlomky, takže sa zaokrúhľuje: - 809 × 0,2 = 161,8 → 162 do testu, 500 × 0,2 = 100 → presne 100. - Tu to vyšlo „náhodou“ takmer presne (0,3820 vs. 0,3817). Pri iných číslach sa podiely môžu líšiť o pár desatín percenta.
Kedy stratifikácia nejde alebo nepomôže:
- trieda má príliš málo pozorovaní – každá trieda musí mať aspoň 2 (inak ValueError: The least populated class in y has only 1 member), pri StratifiedKFold(n_splits=5) aspoň 5 (inak varovanie),
- pri regresii (cieľ je spojité číslo, napr. cena) – nie sú triedy; dá sa stratifikovať len cez pomocné intervaly,
- bez stratify by bol podiel náhodný – pri 262 ľuďoch v teste by mohol vyjsť napr. 0,35 alebo 0,41.
StratifiedKFold robí to isté pre 5 foldov – preto má každý validačný fold ~0,381–0,383 prežitých (tabuľka v kapitole 6.0).
Bod 4 – únik – iba markdown (pravidlá z kapitoly 6). Kód s Pipeline sa prvýkrát použije v Kroku 2 ako referenčný model (netreba robiť 2×).
Krok 2 – Výber príznakov¶
Bod 1 – referenčný model (všetkých 10 príznakov)
baseline = Pipeline([("prep", preprocess), ("clf", LogisticRegression(max_iter=1000))])
baseline_scores = cross_val_score(baseline, X_train, y_train, cv=cv, scoring="average_precision")
results.loc[len(results)] = ["krok 2", "LogReg, všetky príznaky", "AP", baseline_scores.mean()]
n_all = len(preprocess.fit(X_train).get_feature_names_out()) # 10
[0.818 0.797 0.786 0.845 0.772], AP = 0,8036 ± 0,0289.
results.loc[len(results)] = [...] – pridá riadok na koniec tabuľky results (bunka „Zaznamenávanie výsledkov“).
Bod 2 – metódy výberu
def make_selector(method, k):
if method == "filter (ANOVA F)":
return SelectKBest(f_classif, k=k)
if method == "wrapper (RFE)":
return RFE(LogisticRegression(max_iter=1000), n_features_to_select=k)
if method == "embedded (L1)":
return SelectFromModel(LogisticRegression(l1_ratio=1.0, solver="liblinear"),
max_features=k, threshold=-np.inf)
methods = ["filter (ANOVA F)", "wrapper (RFE)", "embedded (L1)"]
Body 3 + 4 – počty 3/5/8/všetky a CV
k_values = [3, 5, 8, n_all]
rows = []
for method in methods:
for k in k_values:
pipe = Pipeline([("prep", preprocess), ("select", make_selector(method, k)),
("clf", LogisticRegression(max_iter=1000))])
scores = cross_val_score(pipe, X_train, y_train, cv=cv, scoring="average_precision")
rows.append({"method": method, "k": k, "AP": scores.mean(), "AP_SD": scores.std(ddof=1)})
results.loc[len(results)] = ["krok 2", f"{method}, {k} príznakov", "AP", scores.mean()]
fs_results = pd.DataFrame(rows)
fs_table = fs_results.pivot(index="k", columns="method", values="AP")
Výsledky:
k embedded (L1) filter (ANOVA F) wrapper (RFE)
3 0.7483 0.7483 0.6765
5 0.7998 0.7907 0.7998
8 0.8043 0.7948 0.8041
10 0.8043 0.8043 0.8043
sex_male + sex_female zaberú 2 z 3 miest).
- k = 5: wrapper/embedded (0,800) > filter (0,791) – vybrali age namiesto fare.
- k ≥ 5: rozdiely < SD → výber preukázateľne nezlepšil AP, ale 5 príznakov stačí na ~rovnaký výkon.
- Riadok k = 10 musí byť rovnaký ako baseline (je to ten istý model). Ak nie je, spusti notebook znova (Run All).
Bod 5 – graf
fig, ax = plt.subplots(figsize=(8, 5))
for method in methods:
part = fs_results[fs_results["method"] == method]
ax.errorbar(part["k"], part["AP"], yerr=part["AP_SD"], marker="o", capsize=4, label=method)
ax.axhline(baseline_scores.mean(), color="grey", linestyle="--", label="baseline (všetky príznaky)")
ax.set_xticks(k_values)
ax.set_xlabel("Počet vybraných príznakov")
ax.set_ylabel("Validačné AP (5-fold CV)")
ax.set_title("Vplyv výberu príznakov na AP")
ax.legend(); ax.grid(alpha=0.3)
plt.tight_layout(); plt.show()
errorbar – čiara + „fúzy“ ± SD. Ak sa fúzy prekrývajú, rozdiel nie je preukázateľný.
Krok 3 – Optimalizácia modelov¶
Rozdiel oproti Kroku 2: viac modelov + ladenie hyperparametrov (Krok 2 = 1 model s predvolenými nastaveniami, menili sa príznaky).
Bod 1 – tri modely s predvolenými nastaveniami
models = {
"Logistic regression": LogisticRegression(max_iter=1000),
"Random forest": RandomForestClassifier(random_state=RANDOM_STATE, n_jobs=-1),
"KNN": KNeighborsClassifier(),
}
rows = []
for name, clf in models.items():
pipe = Pipeline([("prep", preprocess), ("clf", clf)])
scores = cross_val_score(pipe, X_train, y_train, cv=cv, scoring="average_precision")
rows.append({"model": name, "AP": scores.mean(), "AP_SD": scores.std(ddof=1)})
results.loc[len(results)] = ["krok 3", f"{name}, predvolené nastavenia", "AP", scores.mean()]
default_results = pd.DataFrame(rows).set_index("model")
for name, clf in models.items() – .items() vráti dvojice (kľúč, hodnota) zo slovníka.
Výsledky:
- LogReg ≈ Random forest (rozdiel ≪ SD). - KNN výrazne horší a najmenej stabilný – s 5 susedmi sú predikcie „hlučné“ (pravdepodobnosti len 0, 0,2, …, 1). Pomôže ladenien_neighbors.
- Random forest s plne rozvinutými stromami sa pretrénuje – pomôže max_depth, min_samples_leaf.
Bod 2 – ladenie hyperparametrov (GridSearchCV)
Parameter vs. hyperparameter
| Parameter | Hyperparameter | |
|---|---|---|
| čo to je | číslo, ktoré sa model naučí sám z dát | nastavenie, ktoré zvolíš ty pred trénovaním |
| príklad | váhy logistickej regresie (coef_) |
C, l1_ratio, n_neighbors, max_depth |
| kedy vzniká | pri fit |
pri vytvorení modelu: KNeighborsClassifier(n_neighbors=21) |
GridSearchCV dostane mriežku (zoznam hodnôt pre každý hyperparameter) a:
1. vyskúša každú kombináciu (napr. KNN: 5 hodnôt n_neighbors × 2 hodnoty weights = 10 kombinácií),
2. každú ohodnotí 5-násobnou CV (ako cross_val_score) → 10 × 5 = 50 trénovaní,
3. vyberie kombináciu s najvyšším priemerným AP,
4. tú natrénuje na celom X_train (refit=True, predvolené) → best_estimator_.
from sklearn.model_selection import GridSearchCV
searches = {
"Logistic regression": (
LogisticRegression(solver="saga", max_iter=5000),
{
"clf__C": [0.01, 0.1, 1, 10, 100], # sila regularizácie (menšie C = silnejšia)
"clf__l1_ratio": [0.0, 0.5, 1.0], # 0 = L2 (Ridge), 1 = L1 (Lasso), 0.5 = Elastic Net
},
),
"Random forest": (
RandomForestClassifier(n_estimators=300, random_state=RANDOM_STATE, n_jobs=-1),
{
"clf__max_depth": [None, 4, 6, 8], # max. hĺbka stromu (None = bez obmedzenia)
"clf__min_samples_leaf": [1, 3, 5, 10], # min. počet ľudí v liste
"clf__max_features": ["sqrt", 0.5], # koľko príznakov zvažuje pri delení
},
),
"KNN": (
KNeighborsClassifier(),
{
"clf__n_neighbors": [5, 11, 21, 31, 51], # počet susedov
"clf__weights": ["uniform", "distance"], # rovnaký hlas / bližší sused má väčší hlas
},
),
}
best_models = {}
rows = []
for name, (clf, grid) in searches.items():
pipe = Pipeline([("prep", preprocess), ("clf", clf)])
search = GridSearchCV(pipe, grid, cv=cv, scoring="average_precision", n_jobs=-1)
search.fit(X_train, y_train)
best_models[name] = search.best_estimator_
best_sd = search.cv_results_["std_test_score"][search.best_index_]
rows.append({"model": name, "AP": search.best_score_, "AP_SD": best_sd, "best_params": search.best_params_})
results.loc[len(results)] = ["krok 3", f"{name}, ladený {search.best_params_}", "AP", search.best_score_]
tuned_results = pd.DataFrame(rows).set_index("model")
print(tuned_results.round(4).to_string())
Čo ktorá časť robí:
- searches – slovník: názov → dvojica (model, mriežka).
- "clf__C" – hyperparameter v pipeline sa píše meno_kroku__parameter (dve podčiarkovníky): clf = meno kroku v Pipeline, C = parameter logistickej regresie.
- solver="saga" – jediný solver logistickej regresie, ktorý zvládne L1, L2 aj ich mix (l1_ratio).
- for name, (clf, grid) in searches.items() – rozbalí dvojicu na clf a grid.
- cv=cv, scoring="average_precision" – rovnaké foldy a metrika ako doteraz → výsledky sú porovnateľné.
- search.fit(X_train, y_train) – celé hľadanie, iba na trénovacích dátach.
- search.best_score_ – priemerné AP najlepšej kombinácie (z CV).
- search.best_params_ – najlepšia kombinácia.
- search.best_estimator_ – pipeline s najlepším nastavením natrénovaná na celom X_train; uložená v best_models pre Kroky 4 a 5.
- cv_results_["std_test_score"][best_index_] – SD najlepšej kombinácie (GridSearchCV počíta s ddof=0 → o niečo menšia než std(ddof=1)).
Trvá ~1 minútu.
Výsledky (tvoj beh):
AP AP_SD best_params
Logistic regression 0.8061 0.0195 {'clf__C': 0.1, 'clf__l1_ratio': 0.5}
Random forest 0.8268 0.0082 {'clf__max_depth': 6, 'clf__max_features': 'sqrt', 'clf__min_samples_leaf': 1}
KNN 0.7852 0.0118 {'clf__n_neighbors': 21, 'clf__weights': 'uniform'}
| Model | predvolené (bod 1) | po ladení | čo pomohlo |
|---|---|---|---|
| Logistic regression | 0,8043 | 0,8061 | takmer nič – jednoduchý model je už blízko optima; Elastic Net (l1_ratio=0.5) so silnejšou regularizáciou (C=0.1) |
| Random forest | 0,8006 | 0,8268 | obmedzenie hĺbky na 6 → stromy sa prestali učiť náhodné detaily (menej pretrénovania) |
| KNN | 0,7370 | 0,7852 | 21 susedov namiesto 5 → stabilnejšie pravdepodobnosti |
- Najlepší je Random forest (0,827). Rozdiel oproti LogReg (0,021) je ~ na úrovni SD – mierne lepší, nie drvivo.
- KNN aj po ladení zaostáva.
- Random forest s
max_features="sqrt"vyberá príznaky náhodne – výsledok môže závisieť aj od poradia stĺpcov vnum_cols; preto sa môže mierne líšiť od iného behu.
Pojmy z bodu 2¶
L1, L2, l1_ratio (regularizácia)
Regularizácia = k chybe modelu sa pri trénovaní pripočíta trest za veľké váhy. Model tak nepreháňa a menej sa pretrénuje (prednáška 1, kapitola 2).
| Trest | Čo robí s váhami | Iný názov | |
|---|---|---|---|
| L2 | súčet štvorcov váh (w₁² + w₂² + …) | zmenšuje všetky váhy, ale takmer nikdy nie na presnú 0 | Ridge |
| L1 | súčet absolútnych hodnôt váh (|w₁| + |w₂| + …) | slabé váhy stlačí presne na 0 → príznak sa prestane používať (výber príznakov) | Lasso |
| Elastic Net | mix oboch | kompromis | – |
l1_ratio= pomer L1 v mixe:0= čisté L2,1= čisté L1,0.5= pol na pol.C= opak sily trestu: maléC(0,01) = silný trest, malé váhy; veľkéC(100) = slabý trest, model sa môže viac prispôsobiť dátam.
KNN a „susedia“
KNN (k-nearest neighbors, k najbližších susedov) si pri fit iba zapamätá všetkých trénovacích ľudí. Pri predikcii pre nového človeka:
1. vypočíta vzdialenosť k všetkým trénovacím ľuďom (podľa naškálovaných príznakov – vek, trieda, pohlavie…),
2. vyberie k najbližších = susedov (najpodobnejších ľudí),
3. pravdepodobnosť prežitia = podiel prežitých medzi susedmi.
Príklad: k = 5, zo 5 najpodobnejších prežili 3 → pravdepodobnosť 3/5 = 0,6.
- málo susedov (5) – rozhoduje pár ľudí, výsledok skáče (pravdepodobnosti len 0; 0,2; 0,4; …), náhodní „čudní“ susedia veľa pokazia,
- viac susedov (21) – stabilnejší priemer z väčšej skupiny podobných ľudí,
- priveľa (napr. 500) – priemeruje aj nepodobných ľudí, model stráca detail,
weights="distance"– bližší sused má väčší hlas;"uniform"– všetci rovnako.
Preto KNN potrebuje škálovanie – inak by vzdialenosť určoval hlavne fare (stovky).
Pretrénovanie (overfitting)
Model sa naučí trénovacie dáta naspamäť – aj náhodné detaily a výnimky, ktoré na nových ľuďoch neplatia. Na trénovacích dátach vyzerá výborne, na nových horšie.
Príklad z cvičenia 4: rozhodovací strom bez obmedzenia hĺbky – trénovacie AUC 0,998, validačné 0,763. Strom vytvoril pravidlá typu „žena, 3. trieda, 27 rokov, lístok za 7,925, nastúpila v S → prežila“, ktoré sedia na jedného človeka, ale nezovšeobecňujú.
Ako sa mu bráni:
- obmedziť zložitosť: max_depth (hĺbka stromu), min_samples_leaf (list musí mať aspoň n ľudí),
- regularizácia: menšie C v logistickej regresii,
- viac susedov v KNN,
- spájanie veľa modelov (Random forest).
Opak = nedotrénovanie (underfitting) – model je príliš jednoduchý a nezachytí ani skutočné vzťahy (napr. strom s hĺbkou 1).
n_jobs – paralelné výpočty na CPU
n_jobs = koľko výpočtov naraz (paralelne) má sklearn spustiť.
- n_jobs=1 (alebo nezadané) – jedno po druhom,
- n_jobs=4 – 4 naraz,
- n_jobs=-1 – použi všetky dostupné logické procesory (najrýchlejšie, preto ho dávam),
- n_jobs=-2 – všetky okrem jedného (počítač ostane použiteľný na iné veci).
Ide o tvoj procesor (CPU) – počítač, na ktorom beží kernel notebooku. Tvoj je AMD Ryzen 7 8840HS: 8 fyzických jadier, 16 logických (vlákien, threads). n_jobs=-1 teda použije 16. Overenie:
import os, joblib
os.cpu_count() # 16 – logické procesory (threads)
joblib.cpu_count(only_physical_cores=True) # 8 – fyzické jadrá
GridSearchCV sa paralelne trénujú rôzne kombinácie/foldy; pri RandomForestClassifier rôzne stromy.
CPU alebo GPU? Iba CPU. scikit-learn grafickú kartu nepoužíva. GPU využívajú knižnice na neurónové siete (PyTorch, TensorFlow), prípadne XGBoost/LightGBM so špeciálnym nastavením. Pre malé tabuľkové dáta ako Titanic je CPU úplne dostačujúce.
Bod 3 – kombinácia s výberom príznakov
Pri optimalizácii môžete využiť výsledky výberu príznakov z predchádzajúceho kroku a ďalej kombinovať jednotlivé metódy výberu príznakov s klasifikátormi.
V Kroku 2 si výber príznakov skúšal len s logistickou regresiou. Teraz každému vyladenému modelu z bodu 2 pridáš krok "select" a skúsiš, či mu pomôže menej príznakov. Možností je 10: bez výberu (všetkých 10) + 3 metódy × 3 počty (3, 5, 8).
from sklearn.base import clone
# feature-selection options tried with every tuned model ("passthrough" = no selection, all 10 features)
selector_labels = ["všetky príznaky"]
selector_options = ["passthrough"]
for method in methods:
for k in [3, 5, 8]:
selector_labels.append(f"{method}, {k}")
selector_options.append(make_selector(method, k))
final_rows = []
for name, best in best_models.items():
pipe = Pipeline([
("prep", preprocess),
("select", "passthrough"),
("clf", clone(best["clf"])), # tuned model from point 2 (unfitted copy)
])
search = GridSearchCV(pipe, {"select": selector_options}, cv=cv, scoring="average_precision", n_jobs=-1)
search.fit(X_train, y_train)
best_models[name] = search.best_estimator_
final_rows.append({
"model": name,
"AP": search.best_score_,
"AP_SD": search.cv_results_["std_test_score"][search.best_index_],
"výber príznakov": selector_labels[search.best_index_],
"počet príznakov": len(search.best_estimator_[:-1].get_feature_names_out()),
"príznaky": list(search.best_estimator_[:-1].get_feature_names_out()),
"hyperparametre": {k.replace("clf__", ""): v for k, v in tuned_results.loc[name, "best_params"].items()},
})
results.loc[len(results)] = ["krok 3", f"{name}, ladený + {selector_labels[search.best_index_]}", "AP", search.best_score_]
final_results = pd.DataFrame(final_rows).set_index("model")
print(final_results[["AP", "AP_SD", "výber príznakov", "počet príznakov"]].round(4).to_string())
Čo ktorá časť robí:
- "passthrough" – špeciálna hodnota kroku v Pipeline = „preskoč tento krok“ (žiadny výber, idú všetky príznaky).
- selector_labels / selector_options – dva zoznamy v rovnakom poradí: čitateľný názov a samotný selektor. Názov potom nájdeš podľa best_index_.
- best["clf"] – z vyladenej pipeline z bodu 2 vyberie krok clf (model s najlepšími hyperparametrami).
- clone(...) – nenaučená kópia s rovnakými nastaveniami (napr. Random forest s max_depth=6), aby sa trénovala nanovo.
- {"select": selector_options} – mriežka má jediný „hyperparameter“: ktorý selektor použiť. GridSearchCV vyskúša všetkých 10 možností, každú cez 5-fold CV.
- search.best_estimator_[:-1].get_feature_names_out() – príznaky, ktoré idú do modelu v najlepšej konfigurácii.
- .replace("clf__", "") – z clf__max_depth spraví max_depth (krajší výpis).
Trvá ~1 minútu (najdlhšie RFE).
Očakávaný výstup (skúšobný beh):
AP AP_SD výber príznakov počet príznakov
Logistic regression 0.8061 0.0195 všetky príznaky 10
Random forest 0.827 0.008 všetky príznaky 10
KNN 0.7906 0.0... embedded (L1), 8 8
parch) pridávajú do vzdialenosti „šum“. Logistická regresia nepotrebným dá malú váhu a Random forest ich pri delení jednoducho nepoužije, preto im výber nepomáha.
Bod 4 – porovnanie modelov a konfigurácií
comparison = pd.DataFrame({
"predvolené": default_results["AP"],
"ladené": tuned_results["AP"],
"ladené + výber príznakov": final_results["AP"],
})
print(comparison.round(4))
ax = comparison.plot(kind="bar", figsize=(9, 5), rot=0, ylim=(0.70, 0.85))
ax.set_ylabel("Validačné AP (5-fold CV)")
ax.set_title("Porovnanie klasifikátorov")
ax.grid(axis="y", alpha=0.3)
plt.tight_layout()
plt.show()
pd.DataFrame({...}) – spojí tri série AP (z bodov 1, 2, 3) do jednej tabuľky; riadky sa spárujú podľa názvu modelu (index).
- comparison.plot(kind="bar") – pandas vie kresliť priamo: pre každý model 3 stĺpčeky vedľa seba.
- ylim=(0.70, 0.85) – rozsah osi y, aby boli malé rozdiely viditeľné.
Očakávaný výstup:
predvolené ladené ladené + výber príznakov
Logistic regression 0.8043 0.8061 0.8061
Random forest 0.8006 0.8268 0.8268
KNN 0.7370 0.7852 0.7906
Bod 5 – najlepšia konfigurácia každého klasifikátora
for name, row in final_results.iterrows():
print(f"{name}")
print(f" AP: {row['AP']:.4f} ± {row['AP_SD']:.4f}")
print(f" výber príznakov: {row['výber príznakov']} ({row['počet príznakov']})")
print(f" príznaky: {row['príznaky']}")
print(f" hyperparametre: {row['hyperparametre']}")
.iterrows() – prechádza tabuľku riadok po riadku; name = index (názov modelu), row = hodnoty riadku.
- f"{...:.4f}" – číslo na 4 desatinné miesta.
Výstup obsahuje pre každý model AP, použité príznaky a hyperparametre – presne to, čo zadanie chce zaznamenať. best_models teraz obsahuje tieto 3 najlepšie pipeline natrénované na X_train → použijú sa v Kroku 4 (voting / stacking) a Kroku 5.
Výsledok Kroku 3 (tvoj beh):
| Model | najlepšie AP | konfigurácia |
|---|---|---|
| Random forest | 0,8268 ± 0,008 | všetkých 10 príznakov, max_depth=6, max_features="sqrt", min_samples_leaf=1 |
| Logistic regression | 0,8061 ± 0,020 | všetkých 10 príznakov, C=0.1, l1_ratio=0.5 (Elastic Net) |
| KNN | 0,7906 ± 0,027 | embedded (L1), 8 príznakov, n_neighbors=21, weights="uniform" |
Krok 4 – Heterogénny skupinový model¶
Zostavte heterogénny skupinový model z aspoň troch klasifikátorov z Kroku 3, použite hlasovanie (soft voting) alebo stacking, experimentujte s výberom modelov, váhami a meta-modelom, vyhodnoťte rovnakou CV a AP a porovnajte s najlepším samostatným klasifikátorom.
Heterogénny = kombinuje modely rôznych typov (lineárny + stromy + susedia). Idea: ak sa modely mýlia inak, ich spojenie môže chyby vyrovnať (cvičenie 4, Krok 4).
| Spôsob | Ako kombinuje | sklearn |
|---|---|---|
| soft voting | priemer pravdepodobností základných modelov (s rovnakými alebo zadanými váhami) | VotingClassifier(..., voting="soft", weights=[...]) |
| stacking | ďalší model (meta-model) sa učí, akú váhu dať každému základnému modelu; učí sa z out-of-fold predikcií (vnútorná CV) | StackingClassifier(..., final_estimator=LogisticRegression(), cv=5) |
Príklad soft votingu pre jedného človeka: LR povie 0,60, RF 0,80, KNN 0,70 → voting = (0,60 + 0,80 + 0,70) / 3 = 0,70. S váhami [1, 2, 1] (RF má dvojitý hlas): (0,60 + 2·0,80 + 0,70) / 4 = 0,725.
Bunka 1 – AP základných modelov po foldoch (aby sa dalo porovnávať fold po folde):
from sklearn.model_selection import cross_validate
# AP of every tuned base model on the same 5 folds
fold_scores = {
name: cross_val_score(model, X_train, y_train, cv=cv, scoring="average_precision")
for name, model in best_models.items()
}
for name, scores in fold_scores.items():
print(f"{name:20s} {scores.round(4)} mean {scores.mean():.4f}")
best_single = max(fold_scores, key=lambda name: fold_scores[name].mean())
print("\nBest single model:", best_single)
{name: ... for name, model in best_models.items()} – dict comprehension: ako list comprehension, len vytvorí slovník (názov → 5 čísel AP).
- max(fold_scores, key=lambda name: fold_scores[name].mean()) – z názvov vyberie ten, ktorého priemerné AP je najvyššie. key= hovorí, podľa čoho porovnávať; lambda name: ... je malá funkcia (ako name => ... v JS).
Výstup:
Logistic regression [0.7946 0.7734 0.8169 0.8262 0.8193] mean 0.8061
Random forest [0.8332 0.8126 0.8251 0.8365 0.8263] mean 0.8268
KNN [0.8013 0.7472 0.8023 0.826 0.7761] mean 0.7906
Best single model: Random forest
Bunka 2 – voting a stacking, porovnanie s najlepším modelom:
from sklearn.ensemble import StackingClassifier, VotingClassifier
base = list(best_models.items()) # [(name, pipeline), ...] - format required by Voting/Stacking
ensembles = {
"Voting (LR + RF + KNN)": VotingClassifier(base, voting="soft"),
"Voting (LR + RF)": VotingClassifier(base[:2], voting="soft"),
"Voting (RF 2x weight)": VotingClassifier(base, voting="soft", weights=[1, 2, 1]),
"Stacking (meta LR)": StackingClassifier(base, final_estimator=LogisticRegression(),
stack_method="predict_proba", cv=5),
"Stacking (meta LR, C=0.1)": StackingClassifier(base, final_estimator=LogisticRegression(C=0.1),
stack_method="predict_proba", cv=5),
}
rows = []
for name, model in ensembles.items():
res = cross_validate(model, X_train, y_train, cv=cv, scoring="average_precision",
return_estimator=isinstance(model, StackingClassifier))
scores = res["test_score"]
fold_scores[name] = scores
diff = scores - fold_scores[best_single]
rows.append({
"model": name,
"AP": scores.mean(),
"AP_SD": scores.std(ddof=1),
"diff_vs_best": diff.mean(),
"folds_better": int((diff > 0).sum()),
})
results.loc[len(results)] = ["krok 4", name, "AP", scores.mean()]
if isinstance(model, StackingClassifier):
weights = np.mean([est.final_estimator_.coef_[0] for est in res["estimator"]], axis=0)
print(f"{name} - meta-model weights:", dict(zip(best_models, weights.round(3))))
ensemble_results = pd.DataFrame(rows).set_index("model")
print(f"\nBest single model: {best_single} (AP {fold_scores[best_single].mean():.4f})")
print(ensemble_results.round(4).to_string())
base = list(best_models.items()) – VotingClassifier aj StackingClassifier chcú zoznam dvojíc (meno, model). base[:2] = prvé dva (LR, RF).
- voting="soft" – priemer pravdepodobností (nie väčšina hlasov 0/1).
- weights=[1, 2, 1] – poradie ako v base (LR, RF, KNN); RF má dvojnásobný hlas.
- final_estimator=LogisticRegression() – meta-model; jeho vstupom sú 3 pravdepodobnosti (od LR, RF, KNN), výstupom finálna pravdepodobnosť.
- stack_method="predict_proba" – meta-model dostane pravdepodobnosti.
- cv=5 v stackingu – vnútorná CV: meta-model sa učí z predikcií, ktoré základné modely urobili na dátach, ktoré pri trénovaní nevideli (inak by sa naučil veriť najviac pretrénovanému modelu).
- cross_validate(..., return_estimator=...) – vonkajšia CV na rovnakých foldoch cv; pri stackingu vráti aj natrénované modely, aby sme si pozreli váhy meta-modelu.
- isinstance(model, StackingClassifier) – True, ak je model stacking.
- diff = scores - fold_scores[best_single] – rozdiel AP v každom folde oproti Random forestu.
- folds_better – v koľkých z 5 foldov ensemble prekonal najlepší model (ako v cvičení 4).
- final_estimator_.coef_[0] – naučené váhy meta-modelu; np.mean(..., axis=0) = priemer cez 5 vonkajších foldov.
- dict(zip(best_models, weights)) – spáruje názvy modelov s váhami.
Trvá ~40 s (stacking robí vnorenú CV).
Očakávaný výstup:
Stacking (meta LR) - meta-model weights: {'Logistic regression': 1.602, 'Random forest': 2.65, 'KNN': 1.254}
Stacking (meta LR, C=0.1) - meta-model weights: {'Logistic regression': 1.221, 'Random forest': 1.572, 'KNN': 1.322}
Best single model: Random forest (AP 0.8268)
AP AP_SD diff_vs_best folds_better
Voting (LR + RF + KNN) 0.8242 0.0177 -0.0025 3
Voting (LR + RF) 0.8221 0.0145 -0.0046 3
Voting (RF 2x weight) 0.8268 0.0145 0.0001 3
Stacking (meta LR) 0.8253 0.0155 -0.0015 3
Stacking (meta LR, C=0.1) 0.8247 0.0173 -0.0020 3
Tvoj výstup bol rovnaký. Ak sa vo výpise váh objaví np.float64(1.602), je to len spôsob, akým numpy 2 vypisuje čísla v slovníku – hodnota je 1,602. Krajší výpis: {k: float(v) for k, v in zip(best_models, weights.round(3))}.
Čo sú váhy [1, 2, 1] vo votingu¶
weights = koľko hlasov má každý model pri priemerovaní. Poradie je rovnaké ako v base – tu LR, RF, KNN:
- weights=[1, 1, 1] (alebo nezadané) – každý model má rovnaký hlas → obyčajný priemer,
- weights=[1, 2, 1] – Random forest má dvojnásobný hlas (je najlepší), LR a KNN po jednom.
Výpočet pre jedného človeka (LR 0,60, RF 0,80, KNN 0,70):
| výpočet | výsledok | |
|---|---|---|
| bez váh | (0,60 + 0,80 + 0,70) / 3 | 0,700 |
[1, 2, 1] |
(1·0,60 + 2·0,80 + 1·0,70) / (1 + 2 + 1) | 0,725 |
Delí sa súčtom váh (4), takže výsledok je stále pravdepodobnosť 0–1. Čím väčšiu váhu dostane RF, tým viac sa ensemble podobá samotnému RF – preto [1, 2, 1] vyšiel presne ako RF (0,8268).
Váhy vo votingu volíš ty ručne. Pri stackingu si ich meta-model naučí sám z dát (1,602 / 2,65 / 1,254) – to je hlavný rozdiel medzi voting a stacking.
Ako body zadania 4.1–4.5 pokrýva kód¶
| Bod zadania | Kde v kóde |
|---|---|
| 4.1 aspoň 3 základné klasifikátory z Kroku 3 | base = list(best_models.items()) – LR, RF, KNN |
| 4.2 hlasovanie alebo stacking | VotingClassifier(voting="soft") aj StackingClassifier |
| 4.3 experimenty s výberom modelov, váhami, meta-modelom | 3 modely vs. len LR + RF (base[:2]); váhy [1, 2, 1]; meta-model C=1 vs. C=0.1 |
| 4.4 rovnaká validačná stratégia a AP | cross_validate(..., cv=cv, scoring="average_precision") – tie isté foldy |
| 4.5 porovnanie s najlepším samostatným | diff_vs_best, folds_better voči best_single (Random forest) |
Interpretácia:
- Žiadny ensemble preukázateľne neprekonal Random forest. Rozdiely sú −0,005 až +0,0001 – oveľa menšie ako SD (~0,015) – a lepší je vždy len v 3 z 5 foldov (≈ náhoda).
- Najbližšie je voting s dvojnásobnou váhou RF (0,8268 = rovnako ako samotný RF) – čím viac váhy dostane RF, tým viac sa ensemble podobá RF.
- Stacking: meta-model dal najväčšiu váhu Random forestu (2,65), teda najlepšiemu modelu. LR a KNN dostali menšie váhy. So silnejšou regularizáciou meta-modelu (C=0.1) sa váhy vyrovnajú.
- Prečo ensemble nepomohol: modely sú silne korelované (všetky sa opierajú hlavne o pohlavie a triedu – mýlia sa na tých istých ľuďoch) a LR aj KNN sú slabšie než RF. Rovnaký jav ako v cvičení 4: rozmanitosť sama nestačí, model musí byť aj dostatočne dobrý.
Voliteľný graf k bodu 4.5 – porovnanie fold po folde:
compare = [best_single] + list(ensembles)
fig, ax = plt.subplots(figsize=(9, 5))
for name in compare:
style = "-o" if name == best_single else "--."
ax.plot(range(1, 6), fold_scores[name], style, label=name, linewidth=2.5 if name == best_single else 1)
ax.set_xticks(range(1, 6))
ax.set_xlabel("Fold")
ax.set_ylabel("Validačné AP")
ax.set_title("Najlepší samostatný model vs. skupinové modely (po foldoch)")
ax.legend(fontsize=8); ax.grid(alpha=0.3)
plt.tight_layout(); plt.show()
Ako čítať tento graf (tvoj výsledok):
- os x = 5 foldov (5 rôznych skupín ~209 ľudí vo validácii), os y = AP v danom folde, každá čiara = jeden model.
- Folds 1 a 2: modrá (RF) je nad všetkými ensemblami → tu bol lepší samotný Random forest (fold 1: 0,833 vs. 0,815–0,831).
- Folds 3, 4, 5: ensembly sú mierne nad RF (fold 4: ~0,845 vs. 0,836) → odtiaľ folds_better = 3.
- Raz vyhrá jeden, raz druhý a rozdiely sú ~0,005–0,015 → žiadny nie je konzistentne lepší.
- Všetky čiary idú hore-dole spolu (fold 2 dole, fold 4 hore) → kolísanie medzi foldmi (~0,04) je väčšie než rozdiely medzi modelmi (~0,01). Čo model dosiahne, závisí viac od toho, akí ľudia padli do validácie, než od toho, ktorý model použiješ.
- To, že sa čiary hýbu spolu, zároveň ukazuje, že modely sú korelované – mýlia sa na tých istých ľuďoch. Preto ich spojenie veľa neprinesie.
- Praktický záver: ensemble nie je preukázateľne lepší, Random forest je jednoduchší (jeden model) → do Kroku 5 rozumne ide Random forest (prípadne ten, kto má najvyššie priemerné AP – tu je to remíza RF a Voting (RF 2x weight)).
Korelácia predikcií sa dá overiť (ako v cvičení 4, úloha 4.1):
from sklearn.model_selection import cross_val_predict
oof = pd.DataFrame({
name: cross_val_predict(model, X_train, y_train, cv=cv, method="predict_proba")[:, 1]
for name, model in best_models.items()
})
oof.corr(method="spearman").round(3)
Záver do markdownu: Heterogénne skupinové modely (soft voting aj stacking z LR, RF a KNN) dosiahli AP 0,822–0,827, čo je na úrovni najlepšieho samostatného modelu Random forest (0,8268). Rozdiely sú menšie ako smerodajná odchýlka medzi foldmi a nie sú konzistentné (lepší v 3 z 5 foldov). Meta-model stackingu pridelil najväčšiu váhu Random forestu. Kombinácia nepomohla, lebo základné modely sú silne korelované a ostatné dva sú slabšie.
Krok 5 – Výber a záverečné vyhodnotenie¶
- Vyberte konfiguráciu s najvyššou validačnou AP. 2. Natrénujte ju (vrátane predspracovania a výberu príznakov) na celej trénovacej množine. 3. Vyhodnoťte na testovacej množine. 4. Vypočítajte AP, ROC-AUC, precision, recall a F1. 5. Zobrazte precision-recall krivku a maticu zámen. 6. Vytvorte záverečnú tabuľku.
Najdôležitejšie pravidlo: výber robíš iba podľa CV. Testovaciu množinu použiješ raz a po pohľade na výsledok už nič nemeníš (inak by test prestal byť poctivým odhadom).
Bunka 1 – výber podľa CV (bod 1)
# every candidate from Steps 3 and 4 with its 5 fold scores (fold_scores from Task 4)
cv_summary = pd.DataFrame({
"CV_AP": {name: s.mean() for name, s in fold_scores.items()},
"CV_SD": {name: s.std(ddof=1) for name, s in fold_scores.items()},
}).sort_values("CV_AP", ascending=False)
print(cv_summary.round(4))
all_candidates = {**best_models, **ensembles}
final_name = cv_summary["CV_AP"].idxmax()
print("\nSelected procedure:", final_name)
fold_scores – slovník z Kroku 4: 3 základné modely + 5 ensemblov, každý s 5 číslami AP.
- .sort_values("CV_AP", ascending=False) – zoradí od najlepšieho.
- {**best_models, **ensembles} – spojí dva slovníky do jedného (** = „rozbaľ obsah“).
- .idxmax() – názov riadku s najvyššou hodnotou (nie samotnú hodnotu).
Očakávaný výstup (prvé riadky):
CV_AP CV_SD
Voting (RF 2x weight) 0.8268 0.0145
Random forest 0.8268 0.0091
Stacking (meta LR) 0.8253 0.0155
...
Selected procedure: Voting (RF 2x weight)
Voting (RF 2x weight) (0,82682) vyhral nad Random forest (0,82676) o 0,00006 – prakticky remíza. Podľa pravidla zadania („najvyššia AP“) ide ďalej voting. (Rozumná alternatíva by bola zvoliť jednoduchší Random forest, keďže rozdiel je zanedbateľný – ale rozhodnutie musí padnúť teraz, pred testom, a zdôvodniť sa.)
Bunka 2 – trénovanie na celom X_train a test (body 2–4)
from sklearn.base import clone
from sklearn.metrics import (average_precision_score, f1_score, precision_score,
recall_score, roc_auc_score)
# fit the whole procedure (preprocessing + feature selection + models) on the whole training set
final_model = clone(all_candidates[final_name]).fit(X_train, y_train)
# the ONLY use of the test set
test_proba = final_model.predict_proba(X_test)[:, 1] # probability of survival
test_pred = final_model.predict(X_test) # class 0/1 (threshold 0.5)
test_metrics = {
"AP": average_precision_score(y_test, test_proba),
"ROC-AUC": roc_auc_score(y_test, test_proba),
"precision": precision_score(y_test, test_pred),
"recall": recall_score(y_test, test_pred),
"F1": f1_score(y_test, test_pred),
}
for metric, value in test_metrics.items():
print(f"{metric:10s} {value:.4f}")
results.loc[len(results)] = ["krok 5", f"{final_name} (test)", "AP", test_metrics["AP"]]
clone(...) – nenaučená kópia vybraného postupu; .fit(X_train, y_train) ho natrénuje na všetkých 1047 ľuďoch (v CV sa trénoval len na ~838). Pipeline zabezpečí, že sa predspracovanie aj výber príznakov naučia znova, len z X_train.
- predict_proba(X_test)[:, 1] – pravdepodobnosti → na AP a ROC-AUC (hodnotia poradie).
- predict(X_test) – triedy 0/1 (prah 0,5: pravdepodobnosť ≥ 0,5 → „prežil“) → na precision, recall, F1.
Metriky:
| Metrika | Z čoho | Otázka, na ktorú odpovedá |
|---|---|---|
| AP | pravdepodobnosti | Sú prežití v poradí hore? (hlavná metrika úlohy) |
| ROC-AUC | pravdepodobnosti | Ak vezmem náhodného prežitého a náhodného neprežitého, s akou pravdepodobnosťou dá model prežitému vyššie číslo? (0,5 = náhoda, 1 = dokonalé) |
| precision | triedy 0/1 | Z tých, ktorým model povedal „prežil“, koľko naozaj prežilo? |
| recall | triedy 0/1 | Z tých, čo naozaj prežili, koľkých model našiel? |
| F1 | triedy 0/1 | Jedno číslo, ktoré spája precision a recall (harmonický priemer: 2·P·R / (P + R)) |
Očakávaný výstup:
Bunka 3 – grafy (bod 5)
from sklearn.metrics import ConfusionMatrixDisplay, PrecisionRecallDisplay
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
PrecisionRecallDisplay.from_predictions(y_test, test_proba, name=final_name, ax=axes[0])
axes[0].axhline(y_test.mean(), color="grey", linestyle="--", label=f"náhodný model ({y_test.mean():.2f})")
axes[0].set_title("Precision-recall krivka (test)")
axes[0].legend()
ConfusionMatrixDisplay.from_predictions(y_test, test_pred, display_labels=["neprežil", "prežil"],
cmap="Blues", colorbar=False, ax=axes[1])
axes[1].set_title("Matica zámen (test, prah 0,5)")
plt.tight_layout()
plt.show()
plt.subplots(1, 2) – dva grafy vedľa seba (axes[0] vľavo, axes[1] vpravo).
- PrecisionRecallDisplay.from_predictions – nakreslí PR krivku zo skutočných y a pravdepodobností; v legende ukáže aj AP.
- axhline(y_test.mean()) – vodorovná čiara = precision náhodného modelu (podiel prežitých, 0,38).
- ConfusionMatrixDisplay.from_predictions – matica zámen zo skutočných a predikovaných tried.
Ako čítať PR krivku: ide sa zľava doprava, ako model postupne označuje viac ľudí za „prežil“ (znižuje prah). Vľavo (recall malý) označí len tých najistejších → precision vysoká (~1). Vpravo (recall 1 = našiel všetkých prežitých) musel označiť aj veľa neprežitých → precision klesne k 0,38. Čím vyššie a ďalej doprava krivka drží, tým lepšie. AP = plocha pod touto krivkou.
Ako čítať maticu zámen (očakávaná):
predikoval: neprežil predikoval: prežil
skutočne neprežil 146 (TN) 16 (FP)
skutočne prežil 26 (FN) 74 (TP)
Bunka 4 – záverečná tabuľka (bod 6)
if final_name in best_models:
configuration = f"{final_results.loc[final_name, 'výber príznakov']}, {final_results.loc[final_name, 'hyperparametre']}"
else:
configuration = final_name + " = " + "; ".join(
f"{name} ({final_results.loc[name, 'výber príznakov']}, {final_results.loc[name, 'hyperparametre']})"
for name in best_models
)
final_table = pd.DataFrame([{
"postup": final_name,
"CV AP": cv_summary.loc[final_name, "CV_AP"],
"CV SD": cv_summary.loc[final_name, "CV_SD"],
**{f"test {metric}": value for metric, value in test_metrics.items()},
}]).set_index("postup")
print(final_table.round(4).T)
print("\nKonfigurácia:", configuration)
if final_name in best_models – ak vyhral samostatný model, popis = jeho príznaky + hyperparametre; ak ensemble, vypíšu sa všetky jeho základné modely.
- "; ".join(...) – spojí texty do jedného, oddelené bodkočiarkou.
- **{f"test {metric}": value ...} – vloží do riadku tabuľky všetky testovacie metriky naraz (test AP, test ROC-AUC, …).
- .T – otočí tabuľku (riadky ↔ stĺpce), aby sa jeden riadok čítal pekne pod sebou.
Očakávaný výstup:
postup Voting (RF 2x weight)
CV AP 0.8268
CV SD 0.0145
test AP 0.8686
test ROC-AUC 0.8900
test precision 0.8222
test recall 0.7400
test F1 0.7789
Interpretácia: - Test AP (0,869) je vyššie než CV AP (0,827), dokonca vyššie než najlepší fold (0,845). Nie je to chyba ani únik (test sme nikde nepoužili): test má len 262 ľudí, takže výsledok na jednej malej skupine prirodzene kolíše – táto skupina vyšla pre model „ľahšia“. Model sa navyše pri teste učil z celých 1047 ľudí (v CV len z ~838). Dôležité je, že výsledok nie je horší – výber sa na CV nepretrénoval. Skutočný výkon na nových ľuďoch je realisticky niekde medzi (~0,83–0,87). - Precision 0,82 – keď model povie „prežil“, má pravdu v 82 % prípadov. - Recall 0,74 – našiel 74 zo 100 prežitých; 26 prežitých prehliadol (napr. muži, ktorí prežili – model sa opiera hlavne o pohlavie). - ROC-AUC 0,89 – model veľmi dobre odlišuje prežitých od neprežitých. - Precision, recall a F1 závisia od prahu 0,5; AP a ROC-AUC nie.
Záver do markdownu: Na základe krížovej validácie bol vybraný postup Voting (RF 2x weight) – soft voting vyladených modelov (logistická regresia, Random forest s dvojnásobnou váhou, KNN) s CV AP 0,8268 ± 0,0145 (prakticky zhodne s Random forestom 0,8268). Po natrénovaní na celej trénovacej množine dosiahol na odloženej testovacej množine AP 0,869, ROC-AUC 0,890, precision 0,822, recall 0,740 a F1 0,779. Testovacie AP je vyššie než CV odhad; pri malej testovacej množine (262 cestujúcich) je takéto kolísanie bežné a podstatné je, že výkon na nových dátach neklesol – výber postupu nebol pretrénovaný na validáciu. Po vyhodnotení na teste sme už výber ani nastavenia nemenili.
11. Cvičenie 4 a 5 – kľúčové pojmy¶
Cvičenie 4 – Skupinové metódy¶
- Bagging – modely sa učia nezávisle, každý na bootstrap vzorke; predikcie sa priemerujú → znižuje rozptyl (pretrénovanie hlbokých stromov). Strom: train AUC 0,998, val 0,763 → Bagging 0,889, Random forest 0,896.
- Random forest – bagging + pri každom delení náhodná podmnožina príznakov → stromy menej korelované. Zlepšovanie sa zastaví ~50–100 stromov.
- OOB (out-of-bag) – ~1/3 dát sa do bootstrap vzorky nedostane → odhad výkonu „zadarmo“.
- Boosting – modely postupne, každý opravuje chyby predošlých → znižuje vychýlenie.
learning_rate× počet iterácií ≈ konšt.; vysoký LR (1,0) sa rýchlo pretrénuje → early stopping. - XGBoost / LightGBM / HistGB – výkonom nerozlíšiteľné (rozdiely ≪ SD), lepšie než Random forest.
- Voting (soft) – priemer pravdepodobností s rovnakými váhami. Slabý model (LogReg) môže priemer zhoršiť.
- Stacking – meta-model sa učí váhy z out-of-fold predikcií. Koeficienty pri korelovaných modeloch ≠ dôležitosť.
- Rozmanitosť sama nestačí – model musí byť dostatočne dobrý a odlišný.
clone(model)– nová nenaučená kópia s rovnakými nastaveniami.
Cvičenie 5 – Nevyvážené dáta a anomálie¶
- Pomer 578 : 1 → model, ktorý vždy povie „legitímna“, má accuracy 0,998 a nenájde žiadny podvod. Sleduj recall, MCC, AP, maticu zámen.
- Váhovanie tried (
class_weight="balanced"), SMOTE (syntetické body minoritnej triedy), podvzorkovanie – všetky zvýšili recall 0,64 → 0,92; líšili sa počtom falošných poplachov (1 447 / 1 522 / 2 300). Odporúčanie:class_weight="balanced". imblearn.pipeline.Pipeline– SMOTE/podvzorkovanie len vofit(), test sa nemení.- Isolation Forest / One-Class SVM – detekcia anomálií bez označení. AP 0,17 / 0,25 (~100× lepšie než náhoda, ale ~3–4× horšie než model s označeniami). Zriedkavé ≠ anomálne.
- One-Class SVM: čas rastie kvadraticky; Isolation Forest takmer konštantne.