Skip to content

← Späť

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

  1. Ako prísť na to, čo napísať (všeobecný postup)
  2. Jupyter notebook – základy
  3. Python syntax
  4. Ako zistiť, čo objekt vie (metódy, vlastnosti, dokumentácia)
  5. pandas – prieskum dát
  6. Pojmy strojového učenia
  7. scikit-learn – predspracovanie a Pipeline
  8. Výber príznakov (filter, wrapper, embedded)
  9. Modely
  10. Praktická úloha Titanic – postup krok za krokom
  11. 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:

  1. Povedz vlastnými slovami, čo zadanie chce. Vypíš si kľúčové slová.
  2. V ktorej premennej sú dáta? Príznaky → X, cieľ (odpoveď) → y.
  3. Prelož operáciu do angličtiny. „počet chýbajúcich hodnôt“ → count missing values.
  4. Nájdi príkaz:
  5. Google: „pandas how to …“ / „sklearn …“ (takmer vždy prvý výsledok),
  6. našepkávač: X. + Tab a píš začiatok slova,
  7. staré cvičenia (Ctrl+F v labs/*/notebooks/main.ipynb) – praktická úloha je skúška z cvičení,
  8. prednášky v lectures/.
  9. Vyskúšaj. Ak vypíše <bound method ...>, pridaj ().
  10. help(...) – pozri, či má metóda parameter na to, čo ešte chceš.
  11. 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

y.value_counts?        # musí byť SAMO na riadku, ideálne v samostatnej bunke
- 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 install xgboost lightgbm
%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:

callable(X.isna)    # True  → so zátvorkami
callable(X.shape)   # False → bez zátvoriek

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)

methods = [a for a in public if callable(getattr(X, a))]
je to isté ako:
methods = []
for a in public:
    if callable(getattr(X, a)):
        methods.append(a)
Čítaj: „daj mi a 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.columns vráti pandas Index; .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)
Vlastnosti ako .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!). shape nie 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))]
Alebo: 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(...)

  1. Prvý riadok (signatúra) – najdôležitejší: parametre a ich predvolené hodnoty. value_counts(normalize=False, sort=True, ascending=False, bins=None, dropna=True)
  2. Krátky popis – čo metóda robí.
  3. Parameters – čo robí každý parameter (normalize : bool, default False — If True ... relative frequencies).
  4. Returns – čo dostaneš späť.
  5. 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ú v y.

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
Volaj až po vyhodení nepotrebných stĺpcov. Pri malom datasete je OK napísať zoznamy ručne.

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
Výsledok pre Titanic:

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:

for col in X.columns:
    print(col, y.groupby(X[col].isna()).mean().round(2).to_dict())

Rozdiel priemerov medzi skupinami

X_train.assign(survived=y_train).groupby("survived")[["fare", "sibsp", "age"]].mean()
          fare  sibsp    age
survived
0        22.65   0.50  30.47
1        47.53   0.46  28.34


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íš:

scores = cross_val_score(baseline, X_train, y_train, cv=cv, scoring="average_precision")
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
])
- Pipeline = „linka“ krokov, ktoré sa vykonajú za sebou. Dáta vojdú na začiatok, prejdú 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:

pravdepodobnosť prežitia = 1 / (1 + e^(−skóre))
- 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šie C = 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ť:

model.predict_proba(X_nove)[:, 1]   # pravdepodobnosť prežitia pre každého
[:, 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):

  1. Zoberie sa čistá kópia pipeline (nič nenaučené).
  2. Trénovacia časť (~838 ľudí, 4 skupiny):
  3. prep sa naučí mediány (age, fare), priemery a odchýlky na škálovanie, zoznam kategórií – iba z týchto 838,
  4. dáta sa upravia (doplnenie, škálovanie, one-hot),
  5. clf (logistická regresia) sa natrénuje = nájde váhy (Krok B). Vidí aj y týchto 838.
  6. Validačná časť (~209 ľudí, 1 skupina):
  7. prep ich upraví naučenými hodnotami (nič nové sa neučí),
  8. model pre každého z 209 vypočíta pravdepodobnosť prežitia – ich y nevidí,
  9. až potom sa pravdepodobnosti porovnajú so skutočným y týchto 209 → jedno AP (Krok C).
  10. 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:

(0.818 + 0.797 + 0.786 + 0.845 + 0.772) / 5 = 4.018 / 5 = 0.8036

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

SD = √( 0,003274 / (5 − 1) ) = √0,000818 ≈ 0,029
(Z čísel zaokrúhlených na 3 desatinné miesta vyjde 0,0286; notebook počíta s presnými hodnotami, preto ukáže 0,0289.) 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.
  • y nemá stĺpce ako X – 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í aj y – bez odpovedí by sa nemal z čoho učiť.
  • Po fit si model váhy pamätá, kým beží kernel. predict_proba netré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]
Jeden fold: 4/5 = 838 riadkov na trénovanie (vidí 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ľa pclass – bez miešania by foldy boli rôzne).
  • cv je len premenná s návodom, ako deliť – odovzdáš ju do cross_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
Výstup – po škálovaní (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
Prvé 3 riadky pred → po:
 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
- Vek 29 je takmer priemerný (29,85) → po škálovaní ≈ 0. - Bábätko (0,92 roka) je ďaleko pod priemerom → −2,01. - Lístok za 211 je o ~3 SD drahší než priemer → 3,14.

Č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"]
- trénovacie skóre (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"]),
])
Každý riadok v zozname je trojica (meno, úprava, zoznam stĺpcov): - "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):

out = preprocess.fit_transform(X_train)
Vstup (7 stĺpcov, text aj čísla, chýbajúce hodnoty):
     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
Výstup (10 stĺpcov, len čísla, nič nechýba):
     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
Čo sa stalo: - 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
])
- Každý krok je dvojica (meno, objekt). Meno si vymyslíš. - Všetky kroky okrem posledného musia vedieť upravovať dáta (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
Kľúčové: pri predikcii sa nič nové neučí – test sa upraví presne rovnako ako trénovacie dáta, hodnotami naučenými z trénovacích dát.

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]
Pipeline robí presne toto, ale v jednom objekte – a hlavne sa nedá pomýliť (napr. omylom zavolať 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())
Predpony 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 je penalty="l1" zastarané).
  • threshold=-np.inf – rozhoduje iba max_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:

skóre = −1,30·sex_male + 1,18·sex_female − 0,75·pclass − 0,46·age + … + 0,008·parch
- 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
Vybraných 5 = prvých 5 v každom zozname.

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ž je pclass, fare nesie podobnú informáciu (drahý lístok = 1. trieda), age prináš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

X.shape
X.info()
X.isna().sum()
y.value_counts(normalize=True)
Výsledky: 1309 × 13; prežilo 38,2 %; chýba age 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 %):

pd.crosstab(pd.qcut(X["fare"], 4), y, normalize="index").round(2)

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),
])
Po predspracovaní: 10 príznakov (5 číselných + 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)
Výsledok: 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
Výsledok: AP per fold [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
- k = 3: citeľne horšie (málo informácií; 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:

                         AP   AP_SD
Logistic regression  0.8043  0.0231
Random forest        0.8006  0.0266
KNN                  0.7370  0.0387
- 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 ladenie n_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 v num_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á
Pri 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
- LogReg a Random forest: výber nepomohol – najlepšie sú so všetkými 10 príznakmi (s výberom o ~0,001–0,002 horšie, v rámci náhody). - KNN: výber pomohol (0,785 → 0,791). KNN meria vzdialenosť cez všetky príznaky rovnako – nepotrebné príznaky (napr. 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
Záver: ladenie hyperparametrov pomohlo viac ako výber príznakov. Najviac získal Random forest (+0,026) a KNN (+0,054). Najlepší model je Random forest (~0,827); o ~0,02 lepší než logistická regresia, čo je rozdiel približne na úrovni SD.

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())
Čo ktorá časť robí: - 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()
Hrubá čiara = Random forest, tenké prerušované = ensembly. Čiary sa krížia (v niektorých foldoch je lepší ensemble, v iných RF) → rozdiel nie je konzistentný. Je vidieť aj to, že fold 2 je pre všetky modely najťažší – kolísanie medzi foldmi je väčšie než rozdiely medzi modelmi.

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)
Hodnoty blízko 1 = modely zoraďujú ľudí veľmi podobne → ich spojenie prinesie málo nového.

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

  1. 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:

AP         0.8686
ROC-AUC    0.8900
precision  0.8222
recall     0.7400
F1         0.7789

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)
- TN 146 – správne povedal „neprežil“, - TP 74 – správne povedal „prežil“, - FP 16 – povedal „prežil“, ale neprežil (falošný poplach), - FN 26 – povedal „neprežil“, ale prežil (prehliadnutý). - precision = TP / (TP + FP) = 74 / 90 = 0,822, recall = TP / (TP + FN) = 74 / 100 = 0,740.

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 vo fit(), 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.

Top