Skip to content

← Späť

POK-ISI Lab 2

Files

Cvičenie 2 - Výber príznakov a redukcia dimenzionality

  1. Príprava prostredia
  2. O čom je cvičenie
  3. Ciele
  4. Postup
    1. Krok 1: Výber príznakov
      1. Úloha 1.1 - Filtračná metóda ANOVA F-test
      2. Úloha 1.2 - Wrapper metóda RFE
      3. Úloha 1.3 - Embedded metóda Random Forest
      4. Úloha 1.4 - Vyhodnotenie metód výberu príznakov
      5. Úloha 1.5 - Kontrolovaný experiment: kedy výber príznakov pomáha
    2. Krok 2: Redukcia dimenzionality
      1. Úloha 2.1 - Počet komponentov a ich rozptyl
      2. Úloha 2.2 - Vizualizácia a posúdenie oddeliteľnosti tried
      3. Úloha 2.3 - Vizuálna oddeliteľnosť a prediktívny signál
    3. Krok 3: Nelineárne metódy redukcie dimenzionality
      1. Úloha 3.1 - Projekcia pomocou t-SNE
      2. Úloha 3.2 - Projekcia pomocou UMAP
      3. Úloha 3.3 - Porovnanie PCA, t-SNE a UMAP
  5. Doplňujúce úlohy (bonus)
  6. Doplňujúce zdroje

Týždeň: 2 | Predpoklady:scikit-learn, umap-learn

Príprava prostredia Anchor

V aktivovanom virtuálnom prostredí spustite nasledujúci príkaz:

Zdrojový kód

python -m pip install numpy pandas matplotlib scikit-learn "umap-learn<0.6" ucimlrepo certifi

O čom je cvičenie Anchor

Reálne dátové súbory často obsahujú desiatky príznakov, pričom nie všetky prinášajú užitočnú informáciu - niektoré sú redundantné, iné predstavujú šum. V tomto cvičení preskúmate tri hlavné prístupy k výberu príznakov - filter, wrapper a embedded. Následne použijete PCA na lineárnu redukciu dimenzionality a pomocou metód t-SNE a UMAP vizualizujete vysokorozmerné dáta. Dôraz sa bude klásť na kritické porovnanie metód a posúdenie, do akej miery redukované reprezentácie zachovávajú užitočný signál a pôvodnú štruktúru dát.

Ciele Anchor

  1. Rozlíšiť a implementovať filter, wrapper a embedded metódy pre výber príznakov.
  2. Použiť PCA na lineárnu redukciu dimenzionality.
  3. Vizualizovať vysokorozmerné dáta pomocou t-SNE a UMAP a porovnať ich s lineárnou PCA projekciou.
  4. Kriticky posúdiť, kedy redukcia dimenzionality zachováva užitočný signál a kedy môže viesť k zavádzajúcej interpretácii dát.

Dátová sada

V tomto cvičení použijeme UCI Bank Marketing Dataset, ktorý obsahuje 45 211 záznamov a 16 príznakov opisujúcich telefonické marketingové kampane portugalskej banky. Cieľová premenná y označuje, či si klient upísal termínovaný vklad, pričom pozitívna trieda tvorí približne 11,7 % záznamov. Príznak duration odstránime, pretože v čase predikcie ešte nie je známy a predstavoval by únik informácií. Dátovú sadu načítame pomocou knižnice ucimlrepo.

macOS: chyba SSL: CERTIFICATE_VERIFY_FAILED pri sťahovaní dát

Ak načítanie dát skončí chybou CERTIFICATE_VERIFY_FAILED (typicky na macOS s Pythonom nainštalovaným z python.org), spustite pred načítaním dát nasledujúci kód, ktorý nastaví certifikáty z balíčka certifi. Trvalé riešenie je opísané v návode Nastavenie vývojového prostredia v časti Časté problémy.

import os
import certifi

# use the certificate bundle from certifi for HTTPS downloads
os.environ["SSL_CERT_FILE"] = certifi.where()

Zdrojový kód

from ucimlrepo import fetch_ucirepo
import pandas as pd

# fetch Bank Marketing data from ucimlrepo
raw_bank_data = fetch_ucirepo(id=222)
X = raw_bank_data.data.features.copy()
y = (raw_bank_data.data.targets["y"] == "yes").astype(int)

print(f"Shape of raw data: {X.shape}")
print(f"Features: {X.columns.tolist()}")
print(f"\nColumn dtypes: \n{X.dtypes}")

# drop the "duration" feature (data leak)
X = X.drop(columns=["duration"])
print(f"\nShape after dropping attribute 'duration': {X.shape}")

class_distribution = y.value_counts(normalize=True) * 100
print(f"\nClass distribution (%): \n{class_distribution.round(2)}")

Poznámka

Ak nemáte prístup ku knižnici ucimlrepo, napríklad z dôvodu obmedzení firewallu, dátovú sadu si môžete stiahnuť priamo zo stránky UCI Machine Learning Repository. V záložke Dataset Files vyberte súbor bank-full.csv a načítajte ho nasledujúcim kódom, ktorý nahrádza celý predchádzajúci blok. Súbor sa od verzie z ucimlrepo líši v troch aspektoch: chýbajúce hodnoty sú v ňom zapísané ako text "unknown" (nie ako NaN), stĺpec day_of_week sa v ňom volá day a cieľová premenná y je súčasťou tabuľky.

Zdrojový kód

import numpy as np
import pandas as pd

# load Bank Marketing data from the downloaded file
raw_bank_data = pd.read_csv("bank-full.csv", sep=";")

# make the file consistent with the ucimlrepo version: "unknown" -> NaN, day -> day_of_week
raw_bank_data = raw_bank_data.replace("unknown", np.nan).rename(columns={"day": "day_of_week"})

X = raw_bank_data.drop(columns=["y", "duration"])  # "duration" is dropped because of data leakage
y = (raw_bank_data["y"] == "yes").astype(int)

Postup Anchor

Krok 1: Výber príznakov Anchor

Hlavnou myšlienkou techník pre výber príznakov je identifikovať premenné, ktoré sú pre riešenú úlohu relevantné, a zároveň odstrániť redundantné alebo málo informatívne vstupy. Vhodne zvolená podmnožina príznakov môže skrátiť čas trénovania, znížiť riziko pretrénovania a zlepšiť interpretovateľnosť modelu. V tomto kroku preskúmate tri základné prístupy:

  • filter metódy - hodnotia príznaky pomocou štatistických kritérií nezávisle od konkrétneho modelu,
  • wrapper metódy - porovnávajú podmnožiny príznakov podľa výkonu zvoleného modelu,
  • embedded metódy - uskutočňujú výber príznakov priamo počas trénovania modelu.

Pred samotným výberom rozdeľte dáta na trénovaciu a testovaciu množinu a následne zakódujte kategorické premenné. Dbajte na to, aby rozdelenie dát prebehlo ešte pred samotným fitovaním kódovania, aby sa informácie z testovacej množiny nepreniesli do predspracovania ani výberu príznakov.

Zdrojový kód

from sklearn.compose import ColumnTransformer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder, StandardScaler

# split the original data into training and test sets
X_train_raw, X_test_raw, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# identify categorical and numerical columns using training data only
categorical_cols = X_train_raw.select_dtypes(exclude="number").columns.tolist()
numerical_cols = X_train_raw.select_dtypes(include="number").columns.tolist()

# preprocessing pipeline:
preprocessor = ColumnTransformer(
    transformers=[
        ("categorical", OneHotEncoder(handle_unknown="ignore", sparse_output=False), categorical_cols),
        ("numerical", StandardScaler(), numerical_cols)
    ],
    verbose_feature_names_out=False
)

# return the transformed data directly as pandas DataFrames
preprocessor.set_output(transform="pandas")

X_train = preprocessor.fit_transform(X_train_raw)
X_test = preprocessor.transform(X_test_raw)

# check both possible representations of missing values
print("Number of NaN values in raw training data:", X_train_raw.isna().sum().sum())
print("Columns containing the literal string 'unknown':",
      [column for column in categorical_cols if X_train_raw[column].astype(str).str.lower().eq("unknown").any()])

# NaN categorical values are represented by columns such as job_nan
encoded_nan_cols = [column for column in X_train.columns if column.lower().endswith("_nan")]

print("Columns representing NaN after OneHotEncoder:", encoded_nan_cols)
print("Shape X_train:", X_train.shape, "| X_test:", X_test.shape)
print("\nFirst transformed columns:")
print(X_train.columns.tolist()[:20])

Úloha 1.1 - Filtračná metóda ANOVA F-test Anchor

Pomocou funkcie f_classif vypočítajte ANOVA F-test štatistiku pre každý zakódovaný príznak. Následne pomocou SelectKBest vyberte desať príznakov s najvyšším skóre a vypíšte ich.

Zdrojový kód

from sklearn.feature_selection import SelectKBest, f_classif

# select the 10 features with the strongest statistical relationship to the target variable
selector = SelectKBest(score_func=f_classif, k=10)
selector.fit(X_train, y_train)

top_features_filter = X_train.columns[selector.get_support()]
print("Selected features:")
print(top_features_filter.tolist())

Poznámka

Po one-hot kódovaní je každá kategória pôvodnej kategorickej premennej reprezentovaná samostatným binárnym stĺpcom. Premenná job sa napríklad rozdelí na príznaky ako job_admin alebo job_technician. ANOVA F-test preto nehodnotí premennú job ako jeden celok, ale každú jej zakódovanú kategóriu samostatne. Do výsledného výberu sa tak môžu dostať iba niektoré kategórie pôvodnej premennej.

Filter navyše nezohľadňuje redundanciu medzi príznakmi. Vo výbere sa preto spolu objaví housing_no aj housing_yes, hoci ide o dva stĺpce nesúce presne tú istú informáciu (jeden je doplnkom druhého).

Upozornenie

Funkcia f_classif hodnotí každý príznak samostatne. Nezachytáva preto interakcie medzi príznakmi ani ich spoločný prínos pre konkrétny model. Vysoké F-skóre navyše nepreukazuje kauzálny vzťah a nízke umiestnenie v rebríčku automaticky neznamená, že príznak je štatisticky nevýznamný alebo nepoužiteľný.

Dokumentácia: SelectKBest, f_classif

Úloha 1.2 - Wrapper metóda RFE Anchor

Pomocou metódy Recursive Feature Elimination (RFE) vyberte desať príznakov. Ako základný klasifikátor použite logistickú regresiu s nasledujúcou konfiguráciou LogisticRegression(max_iter=1000).

RFE opakovane trénuje model a postupne odstraňuje najmenej dôležité príznaky na základe veľkosti jeho koeficientov. Metódu preto aplikujte na škálované dáta. Bez škálovania by porovnanie koeficientov ovplyvňovali rozdielne rozsahy vstupných premenných, napríklad spojitého príznaku balance a binárnych príznakov vytvorených one-hot kódovaním.

Uveďte zoznam spoločných príznakov a stručne vysvetlite, prečo môžu RFE a ANOVA F-test vybrať odlišné príznaky.

Tip

V dokumentácii nájdite triedu sklearn.feature_selection.RFE, vytvorte jej inštanciu s LogisticRegression(max_iter=1000) ako klasifikátorom a n_features_to_select=10, natrénujte ju na X_train/y_train a z booleovského atribútu .support_ (rovnaký princíp ako .get_support() v Úlohe 1.1) vyberte mená ponechaných stĺpcov z X_train.columns. Výsledok uložte do premennej top_features_rfe, ktorú následne využijete aj v Úlohe 1.4.

Svoje riešenie doplňte do nasledujúcej kostry kódu - časti na doplnenie sú označené komentárom TODO.

Zdrojový kód

from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

# TODO 1: create RFE with LogisticRegression(max_iter=1000) as the estimator and
#         n_features_to_select=10, then fit it on X_train and y_train
rfe = ...

# TODO 2: select the names of the kept columns from X_train.columns using the boolean mask rfe.support_
top_features_rfe = ...
print("Selected features:")
print(top_features_rfe.tolist())

# TODO 3: find the features selected by both the ANOVA F-test (top_features_filter) and RFE
common_features = ...
print(f"\nFeatures selected by both methods ({len(common_features)}):")
print(common_features)

Dokumentácia: RFE

Úloha 1.3 - Embedded metóda Random Forest Anchor

Natrénujte model prostredníctvom RandomForestClassifier(n_estimators=200, random_state=42, n_jobs=-1) a na základe jeho atribútu feature_importances_ vyberte desať najdôležitejších príznakov (uložte ich do premennej top_features_embedded, ktorú taktiež použije v Úlohe 1.4). Výsledky zobrazte pomocou horizontálneho stĺpcového grafu zoradeného od najnižšej po najvyššiu dôležitosť.

Upozornenie

Ak parameter random_state nie je pevne nastavený, výsledky sa môžu pri každom spustení líšiť, a to vrátane poradia a zoznamu vybraných príznakov. Dôvodom je náhodný charakter algoritmu RandomForestClassifier, ktorý pri vytváraní jednotlivých stromov náhodne vyberá vzorky aj podmnožiny príznakov.

RandomForestClassifier na rozdiel od logistickej regresie nevyžaduje škálovanie vstupných príznakov. Po zakódovaní kategorických premenných preto môžeme dáta použiť bez ich ďalšej úpravy.

Poznámka

Atribút feature_importances_ vyjadruje, ako výrazne jednotlivé príznaky znižovali priemernú nečistotu (Mean Decrease in Impurity, MDI) v stromoch modelu. Táto metóda môže zvýhodňovať spojité premenné a príznaky s veľkým počtom hodnôt. Výsledky preto interpretujte opatrne – vysoká dôležitosť neznamená, že príznak má kauzálny vplyv na cieľovú premennú.

Navyše, hodnoty feature_importances_ nie sú priamo porovnateľné s ukazovateľom gain v knižniciach XGBoost a LightGBM.

Tip

Kvalita dát má často väčší vplyv na spoľahlivosť modelu než samotný výber alebo ladenie samotného algoritmu.

Svoje riešenie doplňte do nasledujúcej kostry kódu - časti na doplnenie sú označené komentárom TODO.

Zdrojový kód

import matplotlib.pyplot as plt
import pandas as pd
from sklearn.ensemble import RandomForestClassifier

# TODO 1: train RandomForestClassifier(n_estimators=200, random_state=42, n_jobs=-1) on X_train and y_train
rf = ...

# TODO 2: create a pd.Series from rf.feature_importances_ indexed by X_train.columns,
#         sort it in ascending order and keep only the 10 most important features
top_importances = ...
top_features_embedded = top_importances.index

# TODO 3: plot top_importances as a horizontal bar chart (label the x axis and add a title)

print("Selected features (from the most important):")
print(top_features_embedded[::-1].tolist())

Dokumentácia: RandomForestClassifier

Úloha 1.4 - Vyhodnotenie metód výberu príznakov Anchor

Doteraz ste získali tri zoznamy vybraných príznakov (top_features_filter, top_features_rfe, top_features_embedded), ale ešte ste neoverili, či výber skutočne zachoval využiteľný prediktívny signál. Natrénujte rovnaký klasifikátor (LogisticRegression) na štandardizovaných dátach so všetkými príznakmi (tzv. referenčný model) a s každou z troch desaťprvkových podmnožín. Pre každý model na testovacej množine vyhodnoťte roc_auc_score a average_precision_score a zmerajte čas trénovania klasifikátora.

Zdrojový kód

import time
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score, average_precision_score

feature_sets = {
    "All features (baseline)": list(X_train.columns),
    "Filter (ANOVA)": list(top_features_filter),
    "Wrapper (RFE)": list(top_features_rfe),
    "Embedded (Random Forest)": list(top_features_embedded),
}

for label, cols in feature_sets.items():
    # TODO: for each feature set:
    # 1. Start measuring time with time.perf_counter().
    # 2. Fit LogisticRegression(max_iter=1000) on X_train[cols] and y_train.
    # 3. Stop measuring time (classifier training only).
    # 4. Compute roc_auc_score and average_precision_score from predict_proba on X_test[cols].
    # 5. Print the label, both metrics and the training time.
    ...

print("\nAgreement between methods (number of shared features out of 10):")
print("Filter ∩ RFE:", len(set(top_features_filter) & set(top_features_rfe)))
print("Filter ∩ Random Forest:", len(set(top_features_filter) & set(top_features_embedded)))
print("RFE ∩ Random Forest:", len(set(top_features_rfe) & set(top_features_embedded)))

Poznámka

Pri výrazne nevyváženom zastúpení tried v dátovej sade (približne 11,7 % pozitívnych prípadov) poskytuje metrika average_precision_score vhodný doplnok k metrike roc_auc_score, pretože citlivejšie zachytáva výkon modelu pri minoritnej triede. Vychádza z hodnôt precision a recall, zatiaľ čo roc_auc_score zohľadňuje aj mieru falošne pozitívnych prípadov, ktorá môže byť pri veľkom počte negatívnych prípadov zavádzajúco nízka.

Upozornenie

V tejto ukážke porovnávame štyri klasifikačné modely na rovnakej testovacej množine. Na demonštračné účely je takýto postup postačujúci. Ak však podľa týchto výsledkov vyberieme najlepší model, testovacie dáta už nepriamo ovplyvnia naše rozhodnutie a výsledné skóre môže pôsobiť optimistickejšie.

Pri dôslednom hodnotení by sme preto mali modely porovnať pomocou krížovej validácie na trénovacej množine. Testovaciu množinu následne použijeme iba raz - na záverečné vyhodnotenie vybraného modelu.

Výber príznakov musí prebiehať v každom kroku krížovej validácie, preto musí byť spolu s klasifikátorom zahrnutý do reťazca spracovania (Pipeline). Ak by sme príznaky vybrali iba raz, ešte pred spustením krížovej validácie, do ich výberu by sa nepriamo premietli aj dáta určené na validáciu. Tým by došlo k úniku informácií medzi tréningovými a validačnými dátami.

Dokumentácia: LogisticRegression, roc_auc_score, average_precision_score

Úloha 1.5 - Kontrolovaný experiment: kedy výber príznakov pomáha Anchor

V Úlohe 1.4 žiadna z troch desaťprvkových podmnožín neprekonala referenčný model so všetkými príznakmi. To neznamená, že výber príznakov je zbytočný. Dátová sada Bank Marketing má po kódovaní len približne 50 príznakov a väčšina z nich nesie aspoň slabý signál, takže v nej nie je veľa čistého šumu, ktorý by sa oplatilo odfiltrovať.

Výber príznakov sa najvýraznejšie prejaví vtedy, keď dáta obsahujú veľa neinformatívnych príznakov (šumu) a málo pozorovaní. Na reálnych dátach takúto situáciu nevieme presne kontrolovať, pretože nevieme, ktoré príznaky sú skutočne šum. Preto pomocou funkcie make_classification vytvoríme syntetickú dátovú sadu s 1 500 pozorovaniami a 500 príznakmi, z ktorých je iba 10 informatívnych. Keďže parameter shuffle=False ponechá informatívne príznaky v prvých desiatich stĺpcoch, vieme pri každej metóde presne spočítať, koľko šumových stĺpcov prepustila.

Spustite nasledujúci kód, ktorý na týchto dátach porovná referenčný model so všetkými 500 príznakmi s modelmi natrénovanými na desiatich príznakoch vybraných filtračnou, wrapper a embedded metódou. Pri každom modeli sledujte ROC AUC na testovacej množine a počet vybraných šumových stĺpcov.

Zdrojový kód

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.feature_selection import SelectKBest, f_classif, RFE, SelectFromModel
from sklearn.ensemble import RandomForestClassifier

# shuffle=False keeps the informative columns at indices [0, n_informative), so we can verify exactly
# how many noise columns each method lets through. 500 columns with only 10 informative ones and just
# 1500 rows is the classic curse-of-dimensionality scenario: a model trained on everything overfits the
# noise, while good feature selection ranks the noise below the real signal.
n_features_synth, n_informative_synth = 500, 10
X_synth, y_synth = make_classification(
    n_samples=1500,
    n_features=n_features_synth,
    n_informative=n_informative_synth,
    n_redundant=0,
    n_repeated=0,
    n_clusters_per_class=2,
    weights=[0.85, 0.15],
    flip_y=0.02,
    class_sep=1.0,
    shuffle=False,
    random_state=42,
)

X_tr_synth, X_te_synth, y_tr_synth, y_te_synth = train_test_split(
    X_synth, y_synth, test_size=0.3, random_state=42, stratify=y_synth
)

# scaling is fitted on the training part only, the same rule as in the main part of the exercise
synth_scaler = StandardScaler().fit(X_tr_synth)
X_tr_synth = synth_scaler.transform(X_tr_synth)
X_te_synth = synth_scaler.transform(X_te_synth)

def evaluate_synth(cols, label):
    """Train LogisticRegression on the given columns and report test ROC AUC + how many noise columns were used."""
    clf = LogisticRegression(max_iter=2000)
    clf.fit(X_tr_synth[:, cols], y_tr_synth)
    auc = roc_auc_score(y_te_synth, clf.predict_proba(X_te_synth[:, cols])[:, 1])
    n_noise_selected = sum(c >= n_informative_synth for c in cols)
    print(f"{label}: AUC = {auc:.4f}, columns = {len(cols)} ({n_noise_selected} of them noise)")
    return auc

# reference model: all 500 columns (490 of them noise)
evaluate_synth(list(range(n_features_synth)), "All columns (baseline)")

# filter: ANOVA F-test scores every column independently
filter_selector = SelectKBest(score_func=f_classif, k=n_informative_synth).fit(X_tr_synth, y_tr_synth)
evaluate_synth(np.where(filter_selector.get_support())[0], "Filter (ANOVA)")

# wrapper: RFE with a logistic regression (drops the weakest column in every step, 490 refits)
rfe_selector = RFE(LogisticRegression(max_iter=2000), n_features_to_select=n_informative_synth).fit(X_tr_synth, y_tr_synth)
evaluate_synth(np.where(rfe_selector.get_support())[0], "Wrapper (RFE)")

# embedded: Random Forest importances. threshold=-np.inf makes max_features the only limit, so exactly
# 10 columns are kept (the default threshold is the mean importance and could return fewer columns).
rf_selector = RandomForestClassifier(n_estimators=300, random_state=42, n_jobs=-1).fit(X_tr_synth, y_tr_synth)
embedded_selector = SelectFromModel(rf_selector, max_features=n_informative_synth, threshold=-np.inf, prefit=True)
evaluate_synth(np.where(embedded_selector.get_support())[0], "Embedded (Random Forest)")

Poznámka

Pri 500 príznakoch a približne 1 000 trénovacích pozorovaniach sa model so všetkými príznakmi ľahko pretrénuje - naučí sa náhodné vzťahy v šumových stĺpcoch, ktoré sa na testovacích dátach nezopakujú. Tento jav sa označuje ako prekliatie dimenzionality ( curse of dimensionality). Metódy výberu príznakov zoradia väčšinu šumových stĺpcov pod skutočný signál, a preto model natrénovaný na menšej podmnožine generalizuje lepšie.

Prečo výber príznakov v tomto experimente pomohol, kým v Úlohe 1.4 nie, a čo z toho vyplýva pre voľbu počtu vybraných príznakov, prediskutujeme na cvičení.

Dokumentácia: make_classification, SelectFromModel

Krok 2: Redukcia dimenzionality Anchor

Redukcia dimenzionality je proces znižovania počtu premenných opisujúcich dáta pri zachovaní čo najväčšej časti ich podstatnej štruktúry. Môže zjednodušiť následné modelovanie, skrátiť čas trénovania, potlačiť časť šumu a umožniť vizualizáciu vysokodimenzionálnych dát v 2D alebo 3D.

Jednou z najznámejších metód redukcie dimenzionality je analýza hlavných komponentov ( Principal Component Analysis, PCA). Na rozdiel od výberu príznakov, pri ktorom sa zachováva podmnožina pôvodných príznakov, PCA vytvára nové, navzájom nekorelované komponenty ako lineárne kombinácie pôvodných príznakov. Komponenty sú zoradené podľa podielu rozptylu dát, ktorý vysvetľujú.

V tomto kroku určíte, koľko komponentov je potrebných na zachovanie zvoleného podielu celkového rozptylu, a preskúmate, či sú triedy cieľovej premennej v zredukovanom priestore vizuálne odlíšiteľné. PCA nezohľadňuje cieľovú premennú, preto vysoký podiel vysvetleného rozptylu automaticky neznamená dobrú separáciu tried ani vyšší klasifikačný výkon.

Keďže výsledok PCA závisí od číselného rozsahu jednotlivých premenných, numerické príznaky je pred jej použitím spravidla potrebné štandardizovať. Parametre škálovania aj transformácie PCA sa pri vyhodnocovaní modelu musia určiť výlučne z trénovacích dát a následne aplikovať na testovacie dáta. Tým sa zabráni úniku informácií z testovacej množiny.

Úloha 2.1 - Počet komponentov a ich rozptyl Anchor

Aplikujte metódu PCA na predspracované trénovacie dáta X_train a vytvorte dve ich redukované reprezentácie:

  • s 2 hlavnými komponentmi (X_train_pca_2),
  • s 10 hlavnými komponentmi (X_train_pca_10).

Natrénované transformácie uložte do premenných pca_2 a pca_10 (na tieto názvy sa odkazuje kód v ďalších úlohách). Každú z nich následne aplikujte aj na testovacie dáta X_test. Výsledky uložte do premenných X_test_pca_2 a X_test_pca_10. Uveďte rozmery pôvodnej a oboch transformovaných dátových matíc. Vykreslite závislosť kumulatívneho podielu vysvetleného rozptylu (explained_variance_ratio_) od počtu hlavných komponentov. Následne určte najmenší počet komponentov potrebný na zachovanie aspoň 95% celkového rozptylu.

Zdrojový kód

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

# apply PCA to train data
pca_full = PCA()
pca_full.fit(X_train)

cumulative_variance = np.cumsum(pca_full.explained_variance_ratio_)
component_counts = np.arange(1, len(cumulative_variance) + 1)

# plot cumulative explained variance ratio
plt.plot(component_counts, cumulative_variance)
plt.axhline(y=0.95, color="red", linestyle="--", label="95% variance")
plt.xlabel("Number of principal components")
plt.ylabel("Cumulative explained variance ratio")
plt.grid(alpha=0.3)
plt.legend()
plt.show()

# TODO: add logic to create X_train_pca_2 and X_test_pca_2

Poznámka

Počet hlavných komponentov je obmedzený počtom vstupných príznakov aj počtom trénovacích pozorovaní. Na vytvorenie 10 komponentov preto musí dátová sada po predspracovaní obsahovať aspoň 10 príznakov a aspoň 10 pozorovaní. Ak požadujeme 10 informatívnych komponentov s nenulovým rozptylom, potrebujeme minimálne 11 trénovacích pozorovaní. PCA totiž dáta pred výpočtom centruje, čím sa maximálny počet takýchto komponentov zníži o jeden vzľadom na celkový počet pozorovaní.

Poznámka

V X_train sú štandardizované iba numerické príznaky (rozptyl 1). Binárne stĺpce vzniknuté one-hot kódovaním ostali v hodnotách 0 a 1, ich rozptyl je najviac 0.25, a preto majú v PCA menšiu váhu než numerické príznaky. Pre účely cvičenia je to postačujúce, no treba to mať na pamäti pri interpretácii výsledkov, napríklad pri počte komponentov potrebných na 95 % rozptylu.

Dokumentácia: PCA

Úloha 2.2 - Vizualizácia a posúdenie oddeliteľnosti tried Anchor

Zobrazte trénovacie dáta X_train_pca_2 v 2D bodovom grafe. Osi označte podľa príslušných hlavných komponentov a pozorovania farebne odlíšte podľa skutočnej triedy.

Zo súborov X_train_pca_2 a y_train vytvorte spoločnú stratifikovanú podvzorku 5 000 pozorovaní s pevne nastaveným random_state. Rovnakú podvzorku použite na vizualizáciu aj na orientačné posúdenie oddeliteľnosti tried pomocou metriky silhouette_score. Výsledok stručne interpretujte v kontexte zobrazeného grafu.

Zdrojový kód

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import silhouette_score

# convert data to NumPy arrays for positional indexing
X_pca = np.asarray(X_train_pca_2)
y_array = np.asarray(y_train)

# create a reproducible stratified subsample
all_idx = np.arange(len(X_pca))

if len(all_idx) > 5000:
    sample_idx, _ = train_test_split(all_idx, train_size=5000, stratify=y_array, random_state=42)
else:
    sample_idx = all_idx

X_pca_sample = X_pca[sample_idx]
y_sample = y_array[sample_idx]

# evaluate class separation in the 2D PCA projection
score = silhouette_score(X_pca_sample, y_sample)
print(f"Silhouette score: {score:.4f}")

# define class labels and colors
class_labels = {
    0: "No",
    1: "Yes"
}

class_colors = {
    0: "tab:blue",
    1: "tab:red"
}

# visualize the PCA projection
plt.figure(figsize=(8, 6))

for class_value in np.unique(y_sample):
    mask = y_sample == class_value
    plt.scatter(X_pca_sample[mask, 0], X_pca_sample[mask, 1], label=class_labels.get(class_value, str(class_value)),
                color=class_colors.get(class_value), alpha=0.4, s=12)

# include the explained variance in the axis labels
plt.xlabel(f"First principal component ({pca_2.explained_variance_ratio_[0]:.1%} explained variance)")
plt.ylabel(f"Second principal component ({pca_2.explained_variance_ratio_[1]:.1%} explained variance)")
plt.title("PCA projection of training data")
plt.legend(title="Class")
plt.grid(alpha=0.2)
plt.tight_layout()
plt.show()

Poznámka

silhouette_score vyjadruje iba geometrické oddelenie tried v 2D PCA priestore, nie klasifikačný výkon. Pri nevyvážených triedach môže byť jeho hodnota skreslená, preto ju interpretujte len orientačne.

Dokumentácia: silhouette_score

Úloha 2.3 - Vizuálna oddeliteľnosť a prediktívny signál Anchor

Nízka hodnota metriky silhouette_score v úlohe 2.2 naznačuje slabé oddelenie tried v priestore prvých dvoch hlavných komponentov. Neznamená však, že pôvodné dáta neobsahujú informácie využiteľné na klasifikáciu.

Na overenie použite klasifikátor LogisticRegression. Pre každú z nasledujúcich reprezentácií vytvorte samostatnú inštanciu klasifikátora, natrénujte ju na príslušných trénovacích dátach a výsledný model vyhodnoťte na zodpovedajúcej testovacej množine, konkrétne:

  • všetky predspracované príznaky - X_train a X_test,
  • prvé 2 hlavné komponenty - X_train_pca_2 a X_test_pca_2,
  • prvých 10 hlavných komponentov - X_train_pca_10 a X_test_pca_10.

Pre každú reprezentáciu vypočítajte roc_auc_score na príslušnej testovacej množine. Výsledky porovnajte a vysvetlite, prečo slabá vizuálna oddeliteľnosť tried v 2D projekcii nemusí znamenať absenciu prediktívneho signálu vo vyššom rozmere.

Zdrojový kód

import pandas as pd

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score

def evaluate_auc(X_train_rep, X_test_rep):
    """Train LogisticRegression and return its test ROC AUC."""
    classifier = LogisticRegression(max_iter=1000)
    classifier.fit(X_train_rep, y_train)

    y_score = classifier.predict_proba(X_test_rep)[:, 1]
    return roc_auc_score(y_test, y_score)

# evaluate the three data representations
auc_all = evaluate_auc(X_train, X_test)
auc_pca_2 = evaluate_auc(X_train_pca_2, X_test_pca_2)
auc_pca_10 = evaluate_auc(X_train_pca_10, X_test_pca_10)

# calculate the cumulative explained variance
variance_pca_2 = pca_2.explained_variance_ratio_.sum()
variance_pca_10 = pca_10.explained_variance_ratio_.sum()

# summarize the results
results = pd.DataFrame({
    "Representation": [
        "All preprocessed features",
        "PCA – 2 components",
        "PCA – 10 components"
    ],
    "Explained variance": [
        1.0,
        variance_pca_2,
        variance_pca_10
    ],
    "ROC AUC": [
        auc_all,
        auc_pca_2,
        auc_pca_10
    ]
})

print("Comparison of data representations:")
print(results.to_string(index=False, formatters={"Explained variance": "{:.2%}".format, "ROC AUC": "{:.4f}".format}))

print(f"\nSilhouette score in the 2D PCA projection: {score:.4f}")
print("\nComparison with the full representation:")
print(f"PCA – 2 components:  {auc_pca_2 - auc_all:+.4f} ROC AUC")
print(f"PCA – 10 components: {auc_pca_10 - auc_all:+.4f} ROC AUC")

best_representation = results.loc[results["ROC AUC"].idxmax(), "Representation"]
print(f"\nHighest ROC AUC: {best_representation}")

Upozornenie

Slabá oddeliteľnosť tried v 2D projekcii nemusí znamenať, že dáta neobsahujú prediktívny signál. PCA zachováva smery s najväčším rozptylom, nie smery, ktoré najlepšie rozlišujú jednotlivé triedy. Rozdiely v hodnotách metriky roc_auc_score preto naznačujú, do akej miery redukcia rozmernosti ovplyvnila prediktívny výkon klasifikátora.

Dokumentácia: LogisticRegression, roc_auc_score

Krok 3: Nelineárne metódy redukcie dimenzionality Anchor

PCA je lineárna metóda, ktorá hľadá smery s najväčším rozptylom a pri zvolenom počte komponentov minimalizuje chybu lineárnej rekonštrukcie dát. Nemusí však zachytiť zložitejšiu nelineárnu štruktúru.

Metódy t-SNE a UMAP vytvárajú nelineárne nízkodimenzionálne reprezentácie a zameriavajú sa najmä na zachovanie lokálnych vzťahov medzi pozorovaniami. Blízke body vo výslednej projekcii by preto mali zodpovedať pozorovaniam, ktoré si boli podobné aj vo vstupnom priestore. Globálne vzdialenosti medzi skupinami však treba interpretovať opatrne, predovšetkým pri t-SNE.

V tomto kroku porovnáte projekcie vytvorené pomocou PCA, t-SNE a UMAP. Zamerajte sa na lokálnu štruktúru dát, prekrývanie tried a stabilitu výsledkov pri zmene parametrov. Keďže t-SNE ani UMAP pri tvorbe projekcie nepoužívajú cieľovú premennú, farebné označenie tried slúži iba na následnú interpretáciu.

Úloha 3.1 - Projekcia pomocou t-SNE Anchor

Na rovnakej stratifikovanej podvzorke ako v úlohe 2.2 vytvorte dvojrozmernú projekciu pomocou metódy t-SNE. Použite parametre n_components=2, perplexity=30, init="pca", learning_rate="auto" a random_state=42.

Metódu aplikujte priamo na plný predspracovaný priestor príznakov X_train, nie na výstup PCA. Použitie rovnakej podvzorky umožní porovnať projekcie PCA a t-SNE na totožných pozorovaniach. Výslednú projekciu zobrazte v 2D bodovom grafe a pozorovania farebne odlíšte podľa skutočnej triedy.

Zdrojový kód

import numpy as np
import matplotlib.pyplot as plt

from sklearn.manifold import TSNE

# use the same observations as in Task 2.2
X_sample_full = np.asarray(X_train)[sample_idx]

# t-SNE
tsne = TSNE(n_components=2, perplexity=30, init="pca", learning_rate="auto", random_state=42)
X_tsne = tsne.fit_transform(X_sample_full)

# define class labels and colors
class_labels = {
    0: "No",
    1: "Yes"
}

class_colors = {
    0: "tab:blue",
    1: "tab:red"
}

# visualize the t-SNE projection
plt.figure(figsize=(8, 6))

for class_value in np.unique(y_sample):
    mask = y_sample == class_value
    plt.scatter(X_tsne[mask, 0], X_tsne[mask, 1], label=class_labels.get(class_value, str(class_value)),
                color=class_colors.get(class_value), alpha=0.4, s=12)

plt.xlabel("t-SNE dimension 1")
plt.ylabel("t-SNE dimension 2")
plt.title("t-SNE projection of training data")
plt.legend(title="Class")
plt.grid(alpha=0.2)
plt.tight_layout()
plt.show()

Dokumentácia: t-SNE

Úloha 3.2 - Projekcia pomocou UMAP Anchor

Spustite nasledujúci kód, ktorý na rovnakej podvzorke X_sample_full vytvorí pomocou metódy UMAP dvojrozmernú projekciu dát a zobrazí ju v 2D bodovom grafe s pozorovaniami farebne odlíšenými podľa skutočnej triedy.

Vizualizácia zámerne používa rovnaké farby, veľkosť bodov, priehľadnosť a rozmery grafu ako v úlohe 3.1, aby bolo možné projekcie t-SNE a UMAP priamo porovnať.

Zdrojový kód

import umap

# create the 2D UMAP projection
umap_model = umap.UMAP(n_components=2, n_neighbors=15, min_dist=0.1, metric="euclidean", random_state=42)
X_umap = umap_model.fit_transform(X_sample_full)

# visualize the UMAP projection with the same style as in Task 3.1
plt.figure(figsize=(8, 6))

for class_value in np.unique(y_sample):
    mask = y_sample == class_value
    plt.scatter(X_umap[mask, 0], X_umap[mask, 1], label=class_labels.get(class_value, str(class_value)),
                color=class_colors.get(class_value), alpha=0.4, s=12)

plt.xlabel("UMAP dimension 1")
plt.ylabel("UMAP dimension 2")
plt.title("UMAP projection of training data")
plt.legend(title="Class")
plt.grid(alpha=0.2)
plt.tight_layout()
plt.show()

Dokumentácia: UMAP – API

Úloha 3.3 - Porovnanie PCA, t-SNE a UMAP Anchor

Projekcie X_pca_sample, X_tsne a X_umap zobrazte vedľa seba v troch 2D bodových grafoch. Keďže všetky vznikli z rovnakej podvzorky, použite rovnaké farby tried, veľkosť bodov a priehľadnosť.

Pre každú projekciu vypočítajte metriku trustworthiness vzhľadom na pôvodné predspracované príznaky X_sample_full. Vo všetkých prípadoch použite n_neighbors=15, aby boli výsledky porovnateľné.

Porovnajte vizuálnu štruktúru projekcií a dosiahnuté hodnoty metriky. Určte, ktorá metóda najlepšie zachovala lokálne susedstvá pôvodných dát. Nezabudnite, že metrika trustworthiness hodnotí zachovanie lokálnej štruktúry, nie oddeliteľnosť tried.

Zdrojový kód

import numpy as np
import matplotlib.pyplot as plt

from sklearn.manifold import trustworthiness

n_neighbors_check = 15

# ensure a consistent array representation
X_original = np.asarray(X_sample_full)
y_plot = np.asarray(y_sample)

projections = {
    "PCA": np.asarray(X_pca_sample),
    "t-SNE": np.asarray(X_tsne),
    "UMAP": np.asarray(X_umap)
}

# verify that all representations contain the same observations
for name, X_projection in projections.items():
    assert len(X_projection) == len(X_original), f"{name} does not contain the same number of observations."

# calculate trustworthiness for each projection
trustworthiness_scores = {
    name: trustworthiness(X_original, X_projection, n_neighbors=n_neighbors_check) for name, X_projection in projections.items()
}

# define consistent labels and colors
class_labels = {
    0: "No",
    1: "Yes"
}

class_colors = {
    0: "tab:blue",
    1: "tab:red"
}

# visual comparison
fig, axes = plt.subplots(1, 3, figsize=(18, 5))

for ax, (name, X_projection) in zip(axes, projections.items()):
    for class_value in np.unique(y_plot):
        mask = y_plot == class_value
        ax.scatter(X_projection[mask, 0], X_projection[mask, 1], label=class_labels.get(class_value, str(class_value)),
                   color=class_colors.get(class_value), alpha=0.4, s=10)

    ax.set_title(f"{name}\n Trustworthiness = {trustworthiness_scores[name]:.4f}")
    ax.set_xlabel(f"{name} dimension 1")
    ax.set_ylabel(f"{name} dimension 2")
    ax.grid(alpha=0.2)

# legend
handles, labels = axes[0].get_legend_handles_labels()
fig.legend(handles, labels, title="Class", loc="upper center", ncol=len(labels), bbox_to_anchor=(0.5, 1.05))

plt.tight_layout()
plt.show()

# numerical comparison
print(f"Trustworthiness (n_neighbors={n_neighbors_check}):")

for name, score in trustworthiness_scores.items():
    print(f"{name}: {score:.4f}")

best_method = max(trustworthiness_scores,key=trustworthiness_scores.get)
print(f"\nHighest trustworthiness: {best_method} ({trustworthiness_scores[best_method]:.4f})")

Poznámka

Citlivosť projekcií t-SNE a UMAP na zmenu hyperparametrov (perplexity, n_neighbors, min_dist) a ich stabilitu pri rôznych hodnotách random_state preskúmate v doplňujúcich úlohách 1 až 3.

Upozornenie

Vizuálne najpresvedčivejšia projekcia nemusí dôverne zachovávať štruktúru pôvodných dát. Prístupy t-SNE a UMAP sa zameriavajú najmä na lokálne vzťahy a v závislosti od nastavenia hyperparametrov môžu vytvoriť zdanlivo kompaktné a oddelené zhluky. Takéto zhluky preto nemožno automaticky považovať za dôkaz prirodzenej klastrovej štruktúry.

PCA optimalizuje iné kritérium - zachovanie rozptylu a minimalizáciu chyby lineárnej rekonštrukcie - preto môže vytvoriť vizuálne menej výraznú projekciu. Pri porovnaní metód zohľadnite grafy aj hodnotu metriky trustworthiness. Tá objektívnejšie hodnotí zachovanie lokálnych susedstiev pri zvolenom n_neighbors, neposkytuje však úplné hodnotenie celkovej kvality projekcie. Metrika trustworthiness navyše penalizuje iba „falošných susedov“, teda body, ktoré sú v projekcii blízko, hoci v pôvodnom priestore blízko neboli. Opačnú chybu, keď projekcia rozdelí body, ktoré si boli v pôvodnom priestore blízke, nezachytáva (na to slúži metrika continuity).

Dokumentácia: trustworthiness

Doplňujúce úlohy (bonus) Anchor

  1. Aplikujte t-SNE s viacerými hodnotami parametra perplexity (napr. 5, 30 a 50). Výsledné projekcie porovnajte z hľadiska tvaru, kompaktnosti a vzájomného oddelenia zhlukov. Zdôvodnite, ktoré pozorované štruktúry považujete za stabilné a naopak, ktoré môžu byť iba dôsledkom konkrétneho nastavenia algoritmu.
  2. Preskúmajte vplyv parametrov n_neighbors a min_dist na výslednú UMAP projekciu. Zvoľte aspoň tri vhodné kombinácie ich hodnôt a vysvetlite, ako ovplyvňujú zachovanie lokálnych susedstiev, globálne usporiadanie dát a kompaktnosť zhlukov.
  3. Spustite t-SNE alebo UMAP opakovane s rovnakými parametrami, ale s rôznymi hodnotami random_state. Identifikujte vlastnosti projekcie, ktoré zostávajú stabilné, a tie, ktoré sa medzi behmi menia. Diskutujte, čo z toho vyplýva pre interpretáciu dvojrozmerných vizualizácií.
  4. Aplikujte vybranú redukčnú metódu na neškálované dáta a na dáta upravené pomocou StandardScaler alebo inej vhodnej transformácie. Porovnajte výsledky a vysvetlite, prečo má škála jednotlivých príznakov na danú metódu vplyv.
  5. Natrénujte klasifikátor na pôvodných dátach a na dátach redukovaných pomocou PCA alebo UMAP. Redukčnú metódu fitujte iba na trénovacích dátach a testovacie dáta transformujte už natrénovaným modelom. t-SNE použite iba na vizualizáciu a vysvetlite, prečo implementácia v scikit-learn nie je vhodná pre tento train/test postup.
  6. V redukovanom priestore identifikujte pozorovania, ktoré sa nachádzajú ďaleko od svojej triedy alebo v blízkosti iného zhluku. Preskúmajte ich pôvodné príznaky a navrhnite možné vysvetlenie ich polohy. Ide o odľahlé hodnoty, hraničné prípady alebo potenciálne chybné označenia?

Doplňujúce zdroje Anchor


Top