Skip to content

← Späť na Lab 6

Praktická úloha 1 - Titanic (prežitie cestujúcich)

  1. Cieľ úlohy
  2. Dátová sada
  3. Zaznamenávanie výsledkov
  4. Postup
    1. Krok 1 - Príprava dát a návrh experimentu
    2. Krok 2 - Výber príznakov
    3. Krok 3 - Optimalizácia klasifikačných modelov
    4. Krok 4 - Heterogénny skupinový model
    5. Krok 5 - Výber a záverečné vyhodnotenie modelu
  5. Cheat-sheet

Cieľ úlohy

Dosiahnuť čo najvyššiu hodnotu metriky Average Precision (AP, plocha pod precision-recall krivkou v implementácii average_precision_score) pri predikcii prežitia cestujúcich (survived).

Modely optimalizujte a porovnávajte pomocou krížovej validácie. Testovaciu množinu použite výhradne na záverečné vyhodnotenie. Postupujte podľa nasledujúcich krokov.

%pip install numpy pandas matplotlib scikit-learn

Dátová sada

Titanic (OpenML) - cieľová premenná survived (1 = prežil, 0 = neprežil). Nasledujúca bunka dáta iba načíta, zvyšné spracovanie je súčasťou Kroku 1.

from sklearn.datasets import fetch_openml

titanic = fetch_openml(name="titanic", version=1, as_frame=True)
X = titanic.data
y = titanic.target.astype(int)

print(f"Shape: {X.shape}")
X.head()
Shape: (1309, 13)
pclass name sex age sibsp parch ticket fare cabin embarked boat body home.dest
0 1 Allen, Miss. Elisabeth Walton female 29.0000 0 0 24160 211.3375 B5 S 2 NaN St Louis, MO
1 1 Allison, Master. Hudson Trevor male 0.9167 1 2 113781 151.5500 C22 C26 S 11 NaN Montreal, PQ / Chesterville, ON
2 1 Allison, Miss. Helen Loraine female 2.0000 1 2 113781 151.5500 C22 C26 S NaN NaN Montreal, PQ / Chesterville, ON
3 1 Allison, Mr. Hudson Joshua Creighton male 30.0000 1 2 113781 151.5500 C22 C26 S NaN 135.0 Montreal, PQ / Chesterville, ON
4 1 Allison, Mrs. Hudson J C (Bessie Waldo Daniels) female 25.0000 1 2 113781 151.5500 C22 C26 S NaN NaN Montreal, PQ / Chesterville, ON

Zaznamenávanie výsledkov

Do tabuľky results počas celého postupu zaznamenávajte výsledky jednotlivých konfigurácií (krok, model/konfigurácia, metrika, hodnota).

import pandas as pd

# tabuľka na zaznamenávanie výsledkov - po každom kroku pridajte riadok, napr.:
# results.loc[len(results)] = ["krok 2", "filter, 5 príznakov", "AP", 0.71]
results = pd.DataFrame(columns=["krok", "model", "metrika", "hodnota"])
results
krok model metrika hodnota

Postup

Krok 1 - Príprava dát a návrh experimentu

  1. Preskúmajte rozmery dátovej sady, typy príznakov, počet chýbajúcich hodnôt v jednotlivých príznakoch a zastúpenie tried survived.
  2. Zabezpečte vhodné predspracovanie dát s ohľadom na ich charakter (chýbajúce hodnoty, kategorické príznaky) a použité klasifikačné modely.
  3. Pripravte trénovaciu a testovaciu množinu a vhodný postup krížovej validácie.
  4. Zabezpečte, aby pri predspracovaní, výbere príznakov a optimalizácii modelov nedochádzalo k úniku informácií.
# 1.Preskúmajte rozmery dátovej sady, typy príznakov, počet chýbajúcich hodnôt v jednotlivých príznakoch a zastúpenie tried `survived`.
# rozmery datovej sady
print(X.shape)
print("-" * 50)
# typy priznakov
print(X.info())
print("-" * 50)
# počet chýbajúcich hodnôt v jednotlivých príznakoch
print(X.isna().sum())
print("-" * 50)
# zastúpenie tried `survived`
print(y.value_counts(normalize=True))
print("-" * 50)

print((X.isna().mean() * 100).round(1).sort_values(ascending=False))

print("-" * 50)
print(X.nunique().sort_values(ascending=False))

print("-" * 50)
print(X["embarked"].value_counts(dropna=False))
print(X["sex"].value_counts(dropna=False))
print("-" * 50)
print("-" * 50)
print(pd.crosstab(X["boat"].notna(), y))
print(pd.crosstab(X["body"].notna(), y))
print("-" * 50)
print(pd.DataFrame({
    "dtype": X.dtypes,
    "missing_%": (X.isna().mean() * 100).round(1),
    "unique": X.nunique(),
}))
print("-" * 50)

print("-" * 50)
print(pd.crosstab(X["boat"].notna(), y, normalize="index").round(2))
print(pd.crosstab(X["body"].notna(), y, normalize="index").round(2))

print("-" * 50)
print(X[["parch", "fare"]].describe())
(1309, 13)
--------------------------------------------------
<class 'pandas.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 13 columns):
 #   Column     Non-Null Count  Dtype   
---  ------     --------------  -----   
 0   pclass     1309 non-null   int64   
 1   name       1309 non-null   str     
 2   sex        1309 non-null   category
 3   age        1046 non-null   float64 
 4   sibsp      1309 non-null   int64   
 5   parch      1309 non-null   int64   
 6   ticket     1309 non-null   str     
 7   fare       1308 non-null   float64 
 8   cabin      295 non-null    str     
 9   embarked   1307 non-null   category
 10  boat       486 non-null    str     
 11  body       121 non-null    float64 
 12  home.dest  745 non-null    str     
dtypes: category(2), float64(3), int64(3), str(5)
memory usage: 115.2 KB
None
--------------------------------------------------
pclass          0
name            0
sex             0
age           263
sibsp           0
parch           0
ticket          0
fare            1
cabin        1014
embarked        2
boat          823
body         1188
home.dest     564
dtype: int64
--------------------------------------------------
survived
0    0.618029
1    0.381971
Name: proportion, dtype: float64
--------------------------------------------------
body         90.8
cabin        77.5
boat         62.9
home.dest    43.1
age          20.1
embarked      0.2
fare          0.1
name          0.0
pclass        0.0
sibsp         0.0
sex           0.0
parch         0.0
ticket        0.0
dtype: float64
--------------------------------------------------
name         1307
ticket        929
home.dest     369
fare          281
cabin         186
body          121
age            98
boat           27
parch           8
sibsp           7
pclass          3
embarked        3
sex             2
dtype: int64
--------------------------------------------------
embarked
S      914
C      270
Q      123
NaN      2
Name: count, dtype: int64
sex
male      843
female    466
Name: count, dtype: int64
--------------------------------------------------
--------------------------------------------------
survived    0    1
boat              
False     800   23
True        9  477
survived    0    1
body              
False     688  500
True      121    0
--------------------------------------------------
              dtype  missing_%  unique
pclass        int64        0.0       3
name            str        0.0    1307
sex        category        0.0       2
age         float64       20.1      98
sibsp         int64        0.0       7
parch         int64        0.0       8
ticket          str        0.0     929
fare        float64        0.1     281
cabin           str       77.5     186
embarked   category        0.2       3
boat            str       62.9      27
body        float64       90.8     121
home.dest       str       43.1     369
--------------------------------------------------
--------------------------------------------------
survived     0     1
boat                
False     0.97  0.03
True      0.02  0.98
survived     0     1
body                
False     0.58  0.42
True      1.00  0.00
--------------------------------------------------
             parch         fare
count  1309.000000  1308.000000
mean      0.385027    33.295479
std       0.865560    51.758668
min       0.000000     0.000000
25%       0.000000     7.895800
50%       0.000000    14.454200
75%       0.000000    31.275000
max       9.000000   512.329200
# 2. Zabezpečte vhodné predspracovanie dát s ohľadom na ich charakter (chýbajúce hodnoty, kategorické príznaky) a použité klasifikačné modely.
# vyber stlpcov
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

drop_cols=["body", "boat", "name", "ticket", "cabin", "home.dest"]
X_model=X.drop(columns=drop_cols)
num_cols=["pclass", "parch", "age", "sibsp","fare"]
cat_cols=["sex", "embarked"]

print(X_model.shape)
print("-" * 50)
print(X_model.isna().sum())
print("-" * 50)

# predspracovanie
preprocess = ColumnTransformer([
  # numerical: fill missing with median, then scale (needed by the regularized linear model)
    ("num", make_pipeline(SimpleImputer(strategy="median"), StandardScaler()), num_cols),
    # categorical: fill missing with the most frequent value, then one-hot encode
    ("cat", make_pipeline(SimpleImputer(strategy="most_frequent"), OneHotEncoder(handle_unknown="ignore")), cat_cols),
])
print("-" * 50)

print("-" * 50)

# public = [a for a in dir(y) if not a.startswith("_")]
# print(public)print(titanic.DESCR)
(1309, 7)
--------------------------------------------------
pclass        0
sex           0
age         263
sibsp         0
parch         0
fare          1
embarked      2
dtype: int64
--------------------------------------------------
--------------------------------------------------
--------------------------------------------------

Predspracovanie

  • Odstránené príznaky:
  • boat, body – únik cieľovej premennej: cestujúci so záznamom v boat prežili v 98 % prípadov, so záznamom v body v 0 % (údaje vznikli až po nešťastí),
  • name, ticket – takmer unikátne hodnoty, home.dest – voľný text,
  • cabin – ~77 % chýbajúcich hodnôt.
  • Použité príznaky: číselné pclass, age, sibsp, parch, fare, kategorické sex, embarked.
  • Chýbajúce hodnoty: age (263) a fare (1) dopĺňame mediánom, embarked (2) najčastejšou hodnotou.
  • Kategorické príznaky kódujeme one-hot (OneHotEncoder).
  • Číselné príznaky štandardizujeme (StandardScaler), pretože to vyžaduje lineárny model s regularizáciou (Prednáška 1, sekcia 2.8). Stromovým modelom škálovanie neprekáža (Prednáška 2, sekcia 1.1).
  • Predspracovanie bude prvým krokom v Pipeline, takže sa v každom folde krížovej validácie učí iba z trénovacej časti.
# 3. Pripravte trénovaciu a testovaciu množinu a vhodný postup krížovej validácie.
from sklearn.model_selection import StratifiedKFold, train_test_split

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)

print(f"Train: {X_train.shape}, test: {X_test.shape}")
print(f"Survival share - train: {y_train.mean():.3f}, test: {y_test.mean():.3f}")
Train: (1047, 7), test: (262, 7)
Survival share - train: 0.382, test: 0.382

Dáta delíme v pomere 80 : 20. Vďaka stratify=y je podiel prežitých (~38 %) rovnaký v trénovacej aj testovacej časti a random_state=42 zaručí rovnaké rozdelenie pri každom spustení. Testovaciu množinu použijeme iba na záverečné vyhodnotenie v Kroku 5. Modely porovnávame 5-násobnou stratifikovanou krížovou validáciou (StratifiedKFold, shuffle=True) na trénovacej množine. Rovnaké foldy používame vo všetkých krokoch, aby boli výsledky porovnateľné.

# 4. Zabezpečte, aby pri predspracovaní, výbere príznakov a optimalizácii modelov nedochádzalo k úniku informácií.

Krok 2 - Výber príznakov

Preskúmajte vplyv výberu príznakov na klasifikačnú výkonnosť.

  1. Vytvorte referenčný klasifikačný model využívajúci všetky dostupné príznaky po predspracovaní.
  2. Použite aspoň dve rôzne metódy výberu príznakov z prístupov filter, wrapper a embedded.
  3. Pre každú metódu preskúmajte nasledujúce počty vybraných príznakov:
  4. 3 príznaky
  5. 5 príznakov
  6. 8 príznakov
  7. všetky príznaky
  8. Pomocou krížovej validácie porovnajte jednotlivé konfigurácie podľa metriky AP.
  9. Zobrazte graf závislosti validačného skóre od počtu vybraných príznakov pre použité metódy.

Výber príznakov musí byť súčasťou validačného postupu. Vybrané príznaky sa nesmú určovať na celej dátovej sade pred krížovou validáciou.

# 2.1
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import Pipeline

baseline = Pipeline([
  ("prep", preprocess),
  ("clf", LogisticRegression(max_iter=1000))
])

baseline_scores = cross_val_score(baseline, X_train, y_train, scoring="average_precision")

print(f"AP per fold: {baseline_scores.round(3)}")
print(f"Baseline AP: {baseline_scores.mean():.4f} ± {baseline_scores.std(ddof=1):.4f}")

results.loc[len(results)] = ["krok 2", "LogReg, všetky príznaky", "AP", baseline_scores.mean()]

# number of features after preprocessing (one-hot creates more columns)
n_all = len(preprocess.fit(X_train).get_feature_names_out())
print("Number of features after preprocessing:", n_all)
AP per fold: [0.818 0.797 0.786 0.845 0.772]
Baseline AP: 0.8036 ± 0.0289
Number of features after preprocessing: 10
# 2.2 Použite aspoň dve rôzne metódy výberu príznakov z prístupov filter, wrapper a embedded.
import numpy as np
from sklearn.feature_selection import RFE, SelectFromModel, SelectKBest, f_classif

def make_selector(method, k):
  """Return a feature selector that keeps k features."""
  if method == "filter (ANOVA F)":
    # scores every feature by a statistical test, keeps the k best
    return SelectKBest(f_classif, k=k)
  if method == "wrapper (RFE)":
        # repeatedly fits the model and removes the weakest feature
        return RFE(LogisticRegression(max_iter=1000), n_features_to_select=k)
  if method == "embedded (L1)":
      # L1-regularized model, keeps the k features with the largest |coefficient|
      return SelectFromModel(LogisticRegression(l1_ratio=1.0, solver="liblinear"),
                               max_features=k, threshold=-np.inf)

methods = ["filter (ANOVA F)", "wrapper (RFE)", "embedded (L1)"]

# quick check: every method with 5 features
for method in methods:
  pipe = Pipeline([
    ("prep", preprocess),
    ("select", make_selector(method, 5)),
    ("clf", LogisticRegression(max_iter=1000)),
  ])

  pipe.fit(X_train, y_train)
  print(f"{method:18s} → {list(pipe[:-1].get_feature_names_out())}")

pipe_f = Pipeline([("prep", preprocess), ("select", make_selector("filter (ANOVA F)", 5))]).fit(X_train, y_train)
print("FILTER - F score:")
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("\nWRAPPER - RFE ranking (1 = kept):")
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("\nEMBEDDED - |L1 coefficient|:")
print(pd.Series(pipe_l["select"].estimator_.coef_[0], index=pipe_l["prep"].get_feature_names_out()).abs().sort_values(ascending=False))
filter (ANOVA F)   → ['num__pclass', 'num__fare', 'cat__sex_female', 'cat__sex_male', 'cat__embarked_C']
wrapper (RFE)      → ['num__pclass', 'num__age', 'cat__sex_female', 'cat__sex_male', 'cat__embarked_C']
embedded (L1)      → ['num__pclass', 'num__age', 'cat__sex_female', 'cat__sex_male', 'cat__embarked_C']
FILTER - F score:
cat__sex_male      381.225175
cat__sex_female    381.225175
num__pclass        103.020647
num__fare           68.159077
cat__embarked_C     46.270475
cat__embarked_S     26.698427
num__parch          11.448584
num__age             3.893880
cat__embarked_Q      1.304881
num__sibsp           0.299589
dtype: float64

WRAPPER - RFE ranking (1 = kept):
num__pclass        1
num__age           1
cat__sex_male      1
cat__sex_female    1
cat__embarked_C    1
num__sibsp         2
cat__embarked_Q    3
cat__embarked_S    4
num__fare          5
num__parch         6
dtype: int64

EMBEDDED - |L1 coefficient|:
cat__sex_male      1.640752
cat__sex_female    0.840767
num__pclass        0.750265
cat__embarked_C    0.669806
num__age           0.459141
num__sibsp         0.300694
cat__embarked_Q    0.110882
num__fare          0.055873
num__parch         0.001953
cat__embarked_S    0.000000
dtype: float64
# 3. Pre každú metódu preskúmajte nasledujúce počty vybraných príznakov:
  #  - 3 príznaky
  #  - 5 príznakov
  #  - 8 príznakov
  #  - všetky príznaky

k_values = [3, 5, 8, n_all]          # n_all = 10 (all features after preprocessing)

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)
print(fs_results.round(4).to_string(index=False))

# the same numbers as a table: rows = number of features, columns = method
fs_table = fs_results.pivot(index="k", columns="method", values="AP")
print()
print(fs_table.round(4))
print(f"\nBaseline (all features, no selection): {baseline_scores.mean():.4f}")
          method  k     AP  AP_SD
filter (ANOVA F)  3 0.7483 0.0280
filter (ANOVA F)  5 0.7907 0.0316
filter (ANOVA F)  8 0.7948 0.0346
filter (ANOVA F) 10 0.8043 0.0231
   wrapper (RFE)  3 0.6765 0.0392
   wrapper (RFE)  5 0.7998 0.0214
   wrapper (RFE)  8 0.8041 0.0219
   wrapper (RFE) 10 0.8043 0.0231
   embedded (L1)  3 0.7483 0.0280
   embedded (L1)  5 0.7998 0.0214
   embedded (L1)  8 0.8043 0.0229
   embedded (L1) 10 0.8043 0.0231

method  embedded (L1)  filter (ANOVA F)  wrapper (RFE)
k                                                     
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

Baseline (all features, no selection): 0.8036
# 4. Pomocou krížovej validácie porovnajte jednotlivé konfigurácie podľa metriky AP.
#           method  k     AP  AP_SD
# filter (ANOVA F)  3 0.7483 0.0280
# filter (ANOVA F)  5 0.7907 0.0316
# filter (ANOVA F)  8 0.7948 0.0346
# filter (ANOVA F) 10 0.8043 0.0231
#    wrapper (RFE)  3 0.6765 0.0392
#    wrapper (RFE)  5 0.7998 0.0214
#    wrapper (RFE)  8 0.8041 0.0219
#    wrapper (RFE) 10 0.8043 0.0231
#    embedded (L1)  3 0.7483 0.0280
#    embedded (L1)  5 0.7998 0.0214
#    embedded (L1)  8 0.8043 0.0229
#    embedded (L1) 10 0.8043 0.0231

# method  embedded (L1)  filter (ANOVA F)  wrapper (RFE)
# k                                                     
# 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

# Baseline (all features, no selection): 0.8036
# 5. Zobrazte graf závislosti validačného skóre od počtu vybraných príznakov pre použité metódy.

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 5))

for method in methods:
    part = fs_results[fs_results["method"] == method]
    # line = mean AP, error bars = standard deviation over the 5 folds
    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()

png

Krok 3 - Optimalizácia klasifikačných modelov

Vytvorte a optimalizujte viacero klasifikačných modelov s cieľom maximalizovať validačnú hodnotu AP.

  1. Použite aspoň tri klasifikátory založené na odlišných princípoch učenia, pričom aspoň jeden musí byť lineárny model s regularizáciou (Cvičenie 3) a aspoň jeden stromový skupinový model (Cvičenie 4).
  2. Optimalizujte relevantné hyperparametre jednotlivých klasifikátorov pomocou krížovej validácie.
  3. 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.
  4. Porovnajte dosiahnuté validačné hodnoty AP jednotlivých modelov a ich konfigurácií.
  5. Zaznamenajte najlepšiu konfiguráciu každého klasifikátora vrátane použitých príznakov a hyperparametrov.
# 3. Vytvorte a optimalizujte viacero klasifikačných modelov s cieľom maximalizovať validačnú hodnotu AP.
# 1. Použite aspoň tri klasifikátory založené na odlišných princípoch učenia, pričom aspoň jeden musí byť lineárny model s regularizáciou (Cvičenie 3) a aspoň jeden stromový skupinový model (Cvičenie 4).
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier

models = {
    # linear model with L2 regularization (default), strength set by C
    "Logistic regression": LogisticRegression(max_iter=1000),
    # tree ensemble - many decision trees, prediction = average
    "Random forest": RandomForestClassifier(random_state=RANDOM_STATE, n_jobs=-1),
    # k nearest neighbours - looks at the most similar passengers in the training data
    "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")
print(default_results.round(4))
                         AP   AP_SD
model                              
Logistic regression  0.8043  0.0231
Random forest        0.8006  0.0266
KNN                  0.7370  0.0387
# 2. Optimalizujte relevantné hyperparametre jednotlivých klasifikátorov pomocou krížovej validácie.
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())
                         AP   AP_SD                                                                     best_params
model                                                                                                              
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'}
# 3. 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.
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())
                         AP   AP_SD   výber príznakov  počet príznakov
model                                                                 
Logistic regression  0.8061  0.0195   všetky príznaky               10
Random forest        0.8268  0.0082   všetky príznaky               10
KNN                  0.7906  0.0268  embedded (L1), 8                8
# 4. Porovnajte dosiahnuté validačné hodnoty AP jednotlivých modelov a ich konfigurácií.
comparison = pd.DataFrame({
  "default": default_results["AP"],
  "tuned": tuned_results['AP'],
  "tuned + feature selection": 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()
                     default   tuned  tuned + feature selection
model                                                          
Logistic regression   0.8043  0.8061                     0.8061
Random forest         0.8006  0.8268                     0.8268
KNN                   0.7370  0.7852                     0.7906

png

# 5. Zaznamenajte najlepšiu konfiguráciu každého klasifikátora vrátane použitých príznakov a hyperparametrov.
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']}")
Logistic regression
  AP:              0.8061 ± 0.0195
  výber príznakov: všetky príznaky (10)
  príznaky:        ['num__pclass', 'num__parch', 'num__age', 'num__sibsp', 'num__fare', 'cat__sex_female', 'cat__sex_male', 'cat__embarked_C', 'cat__embarked_Q', 'cat__embarked_S']
  hyperparametre:  {'C': 0.1, 'l1_ratio': 0.5}
Random forest
  AP:              0.8268 ± 0.0082
  výber príznakov: všetky príznaky (10)
  príznaky:        ['num__pclass', 'num__parch', 'num__age', 'num__sibsp', 'num__fare', 'cat__sex_female', 'cat__sex_male', 'cat__embarked_C', 'cat__embarked_Q', 'cat__embarked_S']
  hyperparametre:  {'max_depth': 6, 'max_features': 'sqrt', 'min_samples_leaf': 1}
KNN
  AP:              0.7906 ± 0.0268
  výber príznakov: embedded (L1), 8 (8)
  príznaky:        ['num__pclass', 'num__age', 'num__sibsp', 'num__fare', 'cat__sex_female', 'cat__sex_male', 'cat__embarked_C', 'cat__embarked_Q']
  hyperparametre:  {'n_neighbors': 21, 'weights': 'uniform'}

Krok 4 - Heterogénny skupinový model

Pokúste sa zlepšiť klasifikačnú výkonnosť kombinovaním viacerých odlišných klasifikátorov.

  1. Zostavte heterogénny skupinový model využívajúci aspoň tri základné klasifikátory z Kroku 3.
  2. Použite hlasovanie na základe predikovaných pravdepodobností alebo skladanie modelov (stacking).
  3. Experimentujte s výberom základných klasifikátorov a prípadne s ich váhami alebo konfiguráciou meta-modelu.
  4. Vyhodnoťte skupinový model pomocou rovnakej validačnej stratégie a metriky AP.
  5. Porovnajte jeho výsledok s najlepším samostatným klasifikátorom.
# 4. Pokúste sa zlepšiť klasifikačnú výkonnosť kombinovaním viacerých odlišných klasifikátorov.

# 4.1. Zostavte heterogénny skupinový model využívajúci aspoň tri základné klasifikátory z Kroku 3.
from sklearn.model_selection import cross_validate

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)
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
# 4.2. Použite hlasovanie na základe predikovaných pravdepodobností alebo skladanie modelov (stacking).
from sklearn.ensemble import StackingClassifier, VotingClassifier
base = list(best_models.items())
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())
Stacking (meta LR) - meta-model weights: {'Logistic regression': np.float64(1.602), 'Random forest': np.float64(2.65), 'KNN': np.float64(1.254)}
Stacking (meta LR, C=0.1) - meta-model weights: {'Logistic regression': np.float64(1.222), 'Random forest': np.float64(1.574), 'KNN': np.float64(1.318)}

Best single model: Random forest (AP 0.8268)
                               AP   AP_SD  diff_vs_best  folds_better
model                                                                
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.8248  0.0172       -0.0020             3
# 4.3. Experimentujte s výberom základných klasifikátorov a prípadne s ich váhami alebo konfiguráciou meta-modelu.
# - experimenty s modelmi, váhami a meta-modelom    3 modely vs. len LR + RF (base[:2]), váhy [1, 2, 1], meta-model s C=1 vs. C=0.1
# 4.4. Vyhodnoťte skupinový model pomocou rovnakej validačnej stratégie a metriky AP.
# - rovnaká CV a AP cross_validate(..., cv=cv, scoring="average_precision")

# Heterogénne skupinové modely (soft voting aj stacking z LR, RF a KNN, s rôznym výberom modelov, váhami a nastavením meta-modelu) dosiahli AP 0,822 až 0,827, teda na úrovni najlepšieho samostatného modelu Random forest (0,8268). Rozdiely (−0,005 až +0,0001) sú menšie ako smerodajná odchýlka medzi foldmi a nie sú konzistentné, keďže ensemble bol lepší iba v 3 z 5 foldov. Meta-model stackingu pridelil najväčšiu váhu Random forestu. Kombinácia nepomohla, pretože základné modely sú silne korelované a logistická regresia aj KNN sú slabšie ako Random forest.
# 4.5. Porovnajte jeho výsledok s najlepším samostatným klasifikátorom.
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()

png

Krok 5 - Výber a záverečné vyhodnotenie modelu

  1. Na základe validačných výsledkov vyberte konfiguráciu s najvyššou dosiahnutou hodnotou AP.
  2. Vybraný postup vrátane predspracovania a výberu príznakov natrénujte na celej trénovacej množine.
  3. Vyhodnoťte výsledný model na odloženej testovacej množine.
  4. Vypočítajte metriky AP, ROC-AUC, precision, recall a F1.
  5. Zobrazte precision-recall krivku a maticu zámen.
  6. Vytvorte záverečnú tabuľku obsahujúcu najlepšie validačné skóre, testovacie skóre a výslednú konfiguráciu modelu.
# 5.1. Na základe validačných výsledkov vyberte konfiguráciu s najvyššou dosiahnutou hodnotou AP.
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)
                            CV_AP   CV_SD
Voting (RF 2x weight)      0.8268  0.0145
Random forest              0.8268  0.0092
Stacking (meta LR)         0.8253  0.0155
Stacking (meta LR, C=0.1)  0.8248  0.0172
Voting (LR + RF + KNN)     0.8242  0.0177
Voting (LR + RF)           0.8221  0.0145
Logistic regression        0.8061  0.0218
KNN                        0.7906  0.0300

Selected procedure: Voting (RF 2x weight)
# 5.2. Vybraný postup vrátane predspracovania a výberu príznakov natrénujte na celej trénovacej množine.
# 5.3. Vyhodnoťte výsledný model na odloženej testovacej množine.
# 5.4. Vypočítajte metriky AP, ROC-AUC, precision, recall a F1.
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),
}

# Metrika   Z čoho  Na čo odpovedá
# AP    pravdepodobnosti    Sú prežití v poradí hore?
# ROC-AUC   pravdepodobnosti    S akou pravdepodobnosťou dá model náhodnému prežitému vyššie číslo ako náhodnému neprežitému?
# precision 0/1 (prah 0,5)  Z tých, o ktorých model tvrdí „prežil“, koľko naozaj prežilo?
# recall    0/1 Z tých, čo naozaj prežili, koľkých našiel?
# F1    0/1 Precision a recall spojené do jedného čísla

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"]]
AP         0.8686
ROC-AUC    0.8900
precision  0.8222
recall     0.7400
F1         0.7789
# 5.5. Zobrazte precision-recall krivku a maticu zámen.
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()

png

# 5.6. Vytvorte záverečnú tabuľku obsahujúcu najlepšie validačné skóre, testovacie skóre a výslednú konfiguráciu modelu.
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)
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

Konfigurácia: Voting (RF 2x weight) = Logistic regression (všetky príznaky, {'C': 0.1, 'l1_ratio': 0.5}); Random forest (všetky príznaky, {'max_depth': 6, 'max_features': 'sqrt', 'min_samples_leaf': 1}); KNN (embedded (L1), 8, {'n_neighbors': 21, 'weights': 'uniform'})


Top