Cvičenie 5 – Nevyvážené dáta a detekcia anomálií

Týždeň 5 · numpy, pandas, matplotlib, scikit-learn, imbalanced-learn · zdroj: pok-isi.fei.tuke.sk

Ako čítať túto stránku Pri každej úlohe je stručné zadanie, doplnené riešenie (miesta TODO), výstup z notebooku labs/5/notebooks/main.ipynb a odpovede na otázky na diskusiu vyvodené z týchto výsledkov.

Úvod a ciele

Prípady, ktoré nás najviac zaujímajú, sú často zriedkavé. Ak poznáme ich označenia, trénujeme klasifikátor na minoritnú triedu a hodnotíme ho vhodnými metrikami. Ak označenia nemáme, hľadáme pozorovania, ktoré sa od ostatných odlišujú (detekcia anomálií). Platí však: zriedkavý prípad nemusí byť anomáliou a anomália nemusí patriť do hľadanej triedy.

  1. Preskúmať zastúpenie tried a zachovať ich pomer pri rozdelení dát.
  2. Vysvetliť, prečo samotná accuracy_score pri nevyvážených triedach nestačí.
  3. Porovnať váhovanie tried, nadvzorkovanie a podvzorkovanie.
  4. Rozlíšiť klasifikáciu s učiteľom od detekcie anomálií bez učiteľa.
Váhovanie tried
Stratová funkcia dáva chybám na minoritnej triede vyššiu váhu (class_weight="balanced" → váha ∝ 1 / početnosť triedy). Dáta sa nemenia.
Nadvzorkovanie (SMOTE)
Vytvára syntetické pozorovania minoritnej triedy interpoláciou medzi susedmi. Iba na trénovacích dátach.
Podvzorkovanie
Náhodne zahodí pozorovania majoritnej triedy, kým sa triedy nevyrovnajú. Rýchle, ale stráca veľa informácie.
Detekcia anomálií
Model nevidí označenia, len hľadá neobvyklé pozorovania (IsolationForest, OneClassSVM). Skóre anomálie ≠ dôkaz podvodu.

Dátová sada

Credit Card Fraud Detection – 284 807 transakcií európskych držiteľov kariet (september 2013), z toho 492 podvodných (0,17 %). 29 číselných príznakov: V1–V28 (anonymizované PCA zložky) a Amount.

Načítanie dátPri spúšťaní bol openml.org nedostupný (spojenie vypršalo). Prvá bunka preto obsahuje try/except: najprv skúsi pôvodný fetch_openml, a ak zlyhá, načíta ten istý dataset z verejného zrkadla TensorFlow (creditcard.csv) a uloží ho do ~/scikit_learn_data. Stĺpec Time sa vynechá, aby príznaky zodpovedali OpenML verzii (29 príznakov). Počty riadkov aj tried sedia so zadaním.

Krok 1 – Nevyvážené dáta a význam správnej metriky

Úloha 1.1 – Analýza rozloženia tried

a) Načítať dáta a zobraziť počty tried.

import matplotlib.pyplot as plt
import pandas as pd
from pathlib import Path
from sklearn.datasets import fetch_openml, get_data_home

try:
    # fetch the Credit Card Fraud Detection dataset (downloaded once, then loaded from the local cache)
    data = fetch_openml("creditcard", version=1, as_frame=True)
    X = data.data
    y = (data.target == "1").astype(int)
except Exception as error:
    # fallback when openml.org is unreachable: the same dataset from the TensorFlow mirror,
    # cached locally; 'Time' is dropped because the OpenML version does not use it as a feature
    print(f"OpenML unavailable ({type(error).__name__}), loading the TensorFlow mirror instead")
    csv_path = Path(get_data_home()) / "creditcard.csv"
    if not csv_path.exists():
        pd.read_csv("https://storage.googleapis.com/download.tensorflow.org/data/creditcard.csv").to_csv(csv_path, index=False)
    df = pd.read_csv(csv_path)
    X = df.drop(columns=["Time", "Class"])
    y = df["Class"].astype(int)

class_counts = y.value_counts().sort_index()
class_share = class_counts / len(y) * 100
print(f"Number of records: {len(y)}, number of features: {X.shape[1]}")
print(f"Class counts: legitimate = {class_counts[0]}, fraud = {class_counts[1]}")
print(f"Imbalance ratio (legitimate : fraud): {class_counts[0] / class_counts[1]:.0f} : 1")

# plot the class distribution
fig, ax = plt.subplots(figsize=(5, 4))
bars = ax.bar(["legitimate (0)", "fraud (1)"], class_counts.values, color=["tab:blue", "tab:orange"])
ax.bar_label(bars, labels=[f"{count} ({share:.2f} %)" for count, share in zip(class_counts, class_share)])
ax.set_ylabel("Number of records")
ax.set_title("Class distribution - Credit Card Fraud Detection")
ax.margins(y=0.1)
plt.tight_layout()
plt.show()

Výstup

OpenML unavailable (URLError), loading the TensorFlow mirror instead
Number of records: 284807, number of features: 29
Class counts: legitimate = 284315, fraud = 492
Imbalance ratio (legitimate : fraud): 578 : 1
Rozloženie tried – stĺpec podvodov je takmer neviditeľný.
Rozloženie tried – stĺpec podvodov je takmer neviditeľný.

b) Stratifikované rozdelenie 80 : 20 a porovnanie podielu podvodov.

from sklearn.model_selection import train_test_split

# stratify=y keeps the class ratio of the whole dataset in both subsets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# number and share of frauds in the whole dataset and in both subsets - train and test
split_share = pd.DataFrame({
    "records": [len(y), len(y_train), len(y_test)],
    "frauds": [y.sum(), y_train.sum(), y_test.sum()],
    "fraud share (%)": [y.mean() * 100, y_train.mean() * 100, y_test.mean() * 100],
}, index=["whole dataset", "training set", "test set"])
print(split_share.round(3).to_string())

Výstup

               records  frauds  fraud share (%)
whole dataset   284807     492            0.173
training set    227845     394            0.173
test set         56962      98            0.172

c) Škálovanie StandardScaler – parametre iba z trénovacej množiny.

from sklearn.preprocessing import StandardScaler

# the scaler is fitted on the training set only and then applied to both sets
scaler = StandardScaler().set_output(transform="pandas")
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print(f"Training set: {X_train_scaled.shape}, test set: {X_test_scaled.shape}")

Výstup

Training set: (227845, 29), test set: (56962, 29)
Odpoveď
  • Pomer tried je 578 : 1 – na jeden podvod pripadá 578 legitímnych transakcií.
  • Vďaka stratify=y je podiel podvodov takmer rovnaký vo všetkých častiach: 0,173 % / 0,173 % / 0,172 %. Trénovacia množina má 394 podvodov, testovacia 98. Bez stratifikácie by sa pri tak malom počte mohol podiel v teste citeľne líšiť a hodnotenie by bolo nespoľahlivé.
  • Škálovanie je potrebné hlavne kvôli Amount (hodnoty až v desaťtisícoch) – logistická regresia aj RBF jadro sú citlivé na mierku príznakov.

Úloha 1.2 – Prečo samotná accuracy nestačí

DummyClassifier vždy predikuje majoritnú triedu, LogisticRegression bez úprav na nevyváženosť.

from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import ConfusionMatrixDisplay, accuracy_score

# DummyClassifier - ignores the features and always predicts the majority class
dummy_model = DummyClassifier(strategy="most_frequent").fit(X_train_scaled, y_train)
y_pred_dummy = dummy_model.predict(X_test_scaled)

# LogisticRegression - without any adjustment for the class imbalance
baseline_model = LogisticRegression(max_iter=1000).fit(X_train_scaled, y_train)
y_pred = baseline_model.predict(X_test_scaled)

print(f"Accuracy - DummyClassifier:    {accuracy_score(y_test, y_pred_dummy):.3f}")
print(f"Accuracy - LogisticRegression: {accuracy_score(y_test, y_pred):.3f}")

# confusion matrices of both models
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
for ax, (name, predictions) in zip(axes, [("DummyClassifier", y_pred_dummy), ("LogisticRegression", y_pred)]):
    ConfusionMatrixDisplay.from_predictions(y_test, predictions, display_labels=["legitimate", "fraud"], cmap="Blues", colorbar=False, ax=ax)
    ax.set_title(name)
plt.tight_layout()
plt.show()

Výstup

Accuracy - DummyClassifier:    0.998
Accuracy - LogisticRegression: 0.999
Matice zámen: vľavo Dummy, vpravo logistická regresia.
Matice zámen: vľavo Dummy, vpravo logistická regresia.
Odpoveď
  • Oba modely majú accuracy ~0,998–0,999, hoci Dummy neodhalí ani jeden podvod (všetkých 98 predikuje ako legitímne).
  • Accuracy Dummy modelu = podiel majoritnej triedy (1 − 0,0017). Pri takejto nevyváženosti je „vysoká“ accuracy zadarmo a rozdiel 0,001 medzi modelmi skrýva úplne odlišné správanie na podvodoch.

Úloha 1.3 – Hodnotenie výkonu pri nevyvážených triedach

Riešenie (doplnené TODO)

import pandas as pd
from imblearn.metrics import geometric_mean_score
from sklearn.metrics import accuracy_score, average_precision_score, matthews_corrcoef, recall_score, roc_auc_score

# predicted probabilities of the positive class (needed to calculate `roc_auc_score` and `average_precision_score`)
y_score_dummy = dummy_model.predict_proba(X_test_scaled)[:, 1]
y_score = baseline_model.predict_proba(X_test_scaled)[:, 1]

def evaluate(y_true, y_pred, y_score):
    """Return the metrics of one model as a dictionary."""
    return {
        "accuracy": accuracy_score(y_true, y_pred),
        # TODO 1: add the metrics computed from the predicted classes: recall_score,
        #         geometric_mean_score and matthews_corrcoef
        "recall": recall_score(y_true, y_pred),
        "g-mean": geometric_mean_score(y_true, y_pred),
        "MCC": matthews_corrcoef(y_true, y_pred),
        # TODO 2: add the metrics computed from the predicted probabilities: roc_auc_score
        #         and average_precision_score
        "ROC AUC": roc_auc_score(y_true, y_score),
        "AP": average_precision_score(y_true, y_score),
    }

# TODO 3: create a DataFrame with one row per model ("DummyClassifier", "LogisticRegression")
#         and one column per metric returned by evaluate()
metrics_table = pd.DataFrame({
    "DummyClassifier": evaluate(y_test, y_pred_dummy, y_score_dummy),
    "LogisticRegression": evaluate(y_test, y_pred, y_score),
}).T

print(metrics_table.round(3).to_string())

Výstup

                    accuracy  recall  g-mean   MCC  ROC AUC     AP
DummyClassifier        0.998   0.000   0.000  0.00    0.500  0.002
LogisticRegression     0.999   0.643   0.802  0.73    0.958  0.740
OtázkaPrečo má DummyClassifier vysokú accuracy, hoci neodhalí žiadny podvod? Ktoré metriky toto zlyhanie odhalia? Pri ktorých metrikách vyzerá logistická regresia takmer bezchybne a ktoré ukazujú, že časť podvodov prehliadne?
Odpoveď
  • Dummy: accuracy 0,998 len preto, že 99,83 % transakcií je legitímnych. Zlyhanie odhalia všetky ostatné metriky: recall = 0, g-mean = 0, MCC = 0, ROC AUC = 0,5 (náhodné poradie) a AP = 0,002 = podiel podvodov (úroveň náhodného modelu).
  • Logistická regresia vyzerá takmer bezchybne podľa accuracy (0,999) a ROC AUC (0,958). ROC AUC je pri nevyváženosti optimistická, lebo falošne pozitívna miera sa delí obrovským počtom legitímnych transakcií.
  • Problém ukazujú recall 0,643 (35 z 98 podvodov prehliadne – viac než tretina), MCC 0,73 a AP 0,740. G-mean 0,802 je tiež citeľne pod 1, lebo ho ťahá nadol recall pozitívnej triedy.
  • Pri nevyvážených dátach preto sledujeme hlavne recall, MCC a AP (PR krivku) a maticu zámen, nie accuracy.

Krok 2 – Ako sa vysporiadať s nevyváženým zastúpením tried

Úloha 2.1 – Váhovanie tried v logistickej regresii

Riešenie (doplnené TODO)

from sklearn.metrics import confusion_matrix

# TODO 1: train LogisticRegression(max_iter=1000, class_weight="balanced")
baseline_weighted = LogisticRegression(max_iter=1000, class_weight="balanced").fit(X_train_scaled, y_train)

# TODO 2: predict the classes and the probabilities of the positive class
y_pred_weighted = baseline_weighted.predict(X_test_scaled)
y_score_weighted = baseline_weighted.predict_proba(X_test_scaled)[:, 1]

# TODO 3: use evaluate() to add the metrics of the new model to metrics_table
metrics_table.loc["LogisticRegression (balanced)"] = evaluate(y_test, y_pred_weighted, y_score_weighted)

print(metrics_table.round(3).to_string())

# rows: actual classes (legitimate, fraud), columns: predicted classes (legitimate, fraud)
print("LogisticRegression:")
print(confusion_matrix(y_test, y_pred))
print("LogisticRegression (balanced):")
print(confusion_matrix(y_test, y_pred_weighted))

Výstup

                               accuracy  recall  g-mean    MCC  ROC AUC     AP
DummyClassifier                   0.998   0.000   0.000  0.000    0.500  0.002
LogisticRegression                0.999   0.643   0.802  0.730    0.958  0.740
LogisticRegression (balanced)     0.974   0.918   0.946  0.228    0.971  0.718
LogisticRegression:
[[56851    13]
 [   35    63]]
LogisticRegression (balanced):
[[55417  1447]
 [    8    90]]
OtázkaAko sa zmenili metriky a ako sa podľa matíc zámen zmenil počet odhalených podvodov a falošne pozitívnych predikcií?
Odpoveď
modelodhalené (TP)prehliadnuté (FN)falošné poplachy (FP)recallMCC
LogisticRegression6335130,6430,730
LogisticRegression (balanced)9081 4470,9180,228
  • Recall vzrástol z 0,643 na 0,918 – odhalených podvodov je o 27 viac a prehliadnutých klesne z 35 na 8.
  • Cena: falošné poplachy vzrastú z 13 na 1 447 (~110×). Precision klesne na 90 / 1 537 ≈ 5,9 % – z ~17 označených transakcií je len jedna podvod.
  • Preto klesne MCC (0,73 → 0,23) a accuracy (0,999 → 0,974), g-mean vzrastie (0,80 → 0,95), lebo vyvažuje recall oboch tried.
  • ROC AUC (0,958 → 0,971) a AP (0,740 → 0,718) sa zmenili len mierne – metriky poradia nezávisia od prahu. Váhovanie hlavne posunie rozhodovaciu hranicu v prospech minoritnej triedy, poradie transakcií sa mení málo.

Úloha 2.2 – Nadvzorkovanie metódou SMOTE

import matplotlib.pyplot as plt
from imblearn.over_sampling import SMOTE
from imblearn.pipeline import Pipeline

# resample the training set on its own to see what SMOTE does with the class counts
X_train_smote, y_train_smote = SMOTE(random_state=42).fit_resample(X_train_scaled, y_train)

class_counts = pd.DataFrame({
    "before SMOTE": y_train.value_counts().sort_index(),
    "after SMOTE": y_train_smote.value_counts().sort_index(),
})
class_counts.index = ["legitimate (0)", "fraud (1)"]
print(class_counts)
print(f"Imbalance ratio before: {class_counts.iloc[0, 0] / class_counts.iloc[1, 0]:.1f} : 1, "
      f"after: {class_counts.iloc[0, 1] / class_counts.iloc[1, 1]:.1f} : 1")

ax = class_counts.T.plot(kind="bar", figsize=(6, 4), rot=0)
ax.set_ylabel("Number of records")
ax.set_title("Training set class counts before and after SMOTE")
plt.tight_layout()
plt.show()

# the pipeline applies SMOTE only inside fit(); predict() leaves the test set untouched
pipe = Pipeline([
    ("smote", SMOTE(random_state=42)),
    ("clf", LogisticRegression(max_iter=1000)),
])
pipe.fit(X_train_scaled, y_train)

y_pred_smote = pipe.predict(X_test_scaled)
y_score_smote = pipe.predict_proba(X_test_scaled)[:, 1]

metrics_table.loc["LogisticRegression (SMOTE)"] = evaluate(y_test, y_pred_smote, y_score_smote)
print(metrics_table.round(3).to_string())

Výstup

                before SMOTE  after SMOTE
legitimate (0)        227451       227451
fraud (1)                394       227451
Imbalance ratio before: 577.3 : 1, after: 1.0 : 1
Počty tried v trénovacej množine pred a po SMOTE.
Počty tried v trénovacej množine pred a po SMOTE.
                               accuracy  recall  g-mean    MCC  ROC AUC     AP
DummyClassifier                   0.998   0.000   0.000  0.000    0.500  0.002
LogisticRegression                0.999   0.643   0.802  0.730    0.958  0.740
LogisticRegression (balanced)     0.974   0.918   0.946  0.228    0.971  0.718
LogisticRegression (SMOTE)        0.973   0.918   0.945  0.223    0.971  0.722
Odpoveď
  • SMOTE vytvoril 227 057 syntetických podvodov (z 394 na 227 451) – trénovacia množina je 1 : 1 a má dvojnásobnú veľkosť.
  • Výsledok je takmer totožný s váhovaním: recall 0,918 (90 z 98), ROC AUC 0,971, AP 0,722 (o niečo vyššie), ale o 75 falošných poplachov viac (1 522 vs. 1 447) a MCC 0,223.
  • Pre lineárny model má vyrovnanie tried cez SMOTE podobný účinok ako zmena váh – hlavne posunie hranicu. Syntetické body tu nepriniesli novú informáciu, len predĺžili trénovanie.
  • imblearn.pipeline.Pipeline aplikuje SMOTE iba vo fit(); pri predict() sa testovacie dáta nemenia – žiadny únik ani skreslené hodnotenie.

Úloha 2.3 – Náhodné podvzorkovanie a porovnanie prístupov

Riešenie (doplnené TODO)

from imblearn.under_sampling import RandomUnderSampler

# TODO 1: resample the training set with RandomUnderSampler(random_state=42)
X_train_under, y_train_under = RandomUnderSampler(random_state=42).fit_resample(X_train_scaled, y_train)

# class counts in the training set: original, after SMOTE (Task 2.2) and after the undersampling
class_counts = pd.DataFrame({
    "original": y_train.value_counts().sort_index(),
    "after SMOTE": y_train_smote.value_counts().sort_index(),
    "after undersampling": y_train_under.value_counts().sort_index(),
})
class_counts.index = ["legitimate (0)", "fraud (1)"]
print(class_counts)

ax = class_counts.T.plot(kind="bar", figsize=(7, 4), rot=0)
ax.set_ylabel("Number of records")
ax.set_title("Training set class counts before and after resampling")
plt.tight_layout()
plt.show()

# TODO 2: build a Pipeline with the steps "under" (RandomUnderSampler) and "clf" (LogisticRegression)
under_pipe = Pipeline([
    ("under", RandomUnderSampler(random_state=42)),
    ("clf", LogisticRegression(max_iter=1000)),
])
under_pipe.fit(X_train_scaled, y_train)

# TODO 3: predict the classes and the probabilities of the positive class
y_pred_under = under_pipe.predict(X_test_scaled)
y_score_under = under_pipe.predict_proba(X_test_scaled)[:, 1]

# TODO 4: use evaluate() to add the metrics of the new model to metrics_table
metrics_table.loc["LogisticRegression (undersampling)"] = evaluate(y_test, y_pred_under, y_score_under)

# all models of Steps 1 and 2 side by side
print(metrics_table.round(3).to_string())

# the numbers behind the decision: frauds caught (TP), frauds missed (FN) and false alarms (FP)
predictions = {
    "LogisticRegression": y_pred,
    "LogisticRegression (balanced)": y_pred_weighted,
    "LogisticRegression (SMOTE)": y_pred_smote,
    "LogisticRegression (undersampling)": y_pred_under,
}
rows = {}
for name, pred in predictions.items():
    tn, fp, fn, tp = confusion_matrix(y_test, pred).ravel()
    rows[name] = {"frauds caught (TP)": tp, "frauds missed (FN)": fn, "false alarms (FP)": fp}
print(pd.DataFrame(rows).T.to_string())

Výstup

                original  after SMOTE  after undersampling
legitimate (0)    227451       227451                  394
fraud (1)            394       227451                  394
Počty tried: pôvodne, po SMOTE a po podvzorkovaní.
Počty tried: pôvodne, po SMOTE a po podvzorkovaní.
                                    accuracy  recall  g-mean    MCC  ROC AUC     AP
DummyClassifier                        0.998   0.000   0.000  0.000    0.500  0.002
LogisticRegression                     0.999   0.643   0.802  0.730    0.958  0.740
LogisticRegression (balanced)          0.974   0.918   0.946  0.228    0.971  0.718
LogisticRegression (SMOTE)             0.973   0.918   0.945  0.223    0.971  0.722
LogisticRegression (undersampling)     0.959   0.918   0.939  0.181    0.976  0.653
                                    frauds caught (TP)  frauds missed (FN)  false alarms (FP)
LogisticRegression                                  63                  35                 13
LogisticRegression (balanced)                       90                   8               1447
LogisticRegression (SMOTE)                          90                   8               1522
LogisticRegression (undersampling)                  90                   8               2300
OtázkaNa základe výsledkov a odhadu nákladov na neodhalený podvod v porovnaní s preverením legitímnej transakcie odporučte jeden z prístupov.
Odpoveď
  • Podvzorkovanie zahodí 99,8 % legitímnych transakcií – model sa učí len zo 788 riadkov (394 + 394). Recall je rovnaký (90 / 98), ale falošných poplachov je najviac: 2 300, MCC 0,181 a AP 0,653 najnižšie. Najvyššie ROC AUC (0,976) je tu zavádzajúce – PR pohľad (AP) ukazuje, že poradie v hornej časti je horšie.
  • Všetky tri úpravy odhalia rovnakých 90 podvodov, takže rozhoduje počet falošných poplachov: balanced 1 447 < SMOTE 1 522 < undersampling 2 300.

Odhad nákladov (predpoklad: neodhalený podvod stojí ~100× viac než preverenie jednej transakcie, napr. 100 € vs. 1 €):

modelFN × 100FP × 1celkom
LogisticRegression3 500133 513
LogisticRegression (balanced)8001 4472 247
LogisticRegression (SMOTE)8001 5222 322
LogisticRegression (undersampling)8002 3003 100

Odporúčanie: class_weight="balanced". Pri rovnakom recalle má najmenej falošných poplachov, používa všetky trénovacie dáta, nevytvára syntetické pozorovania a je najjednoduchší a najrýchlejší. Oproti pôvodnému modelu odhalí o 27 podvodov viac za cenu 1 434 preverení navyše – oplatí sa, ak je neodhalený podvod drahší než ~53 preverení (1 434 / 27), čo pri podvodoch s kartami bežne platí. Ak by bolo preverovanie drahé (napr. blokovanie karty a telefonát), oplatí sa ešte doladiť rozhodovací prah podľa skutočných nákladov namiesto predvoleného 0,5.

Krok 3 – Detekcia anomálií pomocou Isolation Forest

Klasifikácia s učiteľomDetekcia anomálií bez učiteľa
Označenia pri trénovanímodel pozná triedymodel nevie, ktoré transakcie sú podvody
Cieľpredikovať konkrétnu triedunájsť pozorovania odlišné od bežných
Výstuppríslušnosť k triedeskóre na preverenie, nie dôkaz podvodu

IsolationForest náhodne delí dáta podľa náhodného príznaku a hodnoty. Neobvyklé pozorovania sa izolujú po menšom počte delení → kratšia priemerná cesta = vyššie skóre anomálie.

Úloha 3.1 – Trénovanie modelu Isolation Forest

from sklearn.ensemble import IsolationForest

# the model is fitted without the labels; contamination="auto" needs no estimate of the anomaly share
iso = IsolationForest(n_estimators=200, contamination="auto", random_state=42)
iso.fit(X_train)

# anomaly score: the higher the value, the more unusual the record
scores = -iso.score_samples(X_test)

# predict() applies a fixed threshold to the score: -1 = anomaly, 1 = normal record
preds = iso.predict(X_test)
n_flagged = (preds == -1).sum()
print(f"Records flagged as anomalies: {n_flagged} ({n_flagged / len(preds):.1%})")
print(f"Frauds among the flagged records: {y_test[preds == -1].sum()} of {y_test.sum()}")

Výstup

Records flagged as anomalies: 2151 (3.8%)
Frauds among the flagged records: 82 of 98
OtázkaKoľko označených pozorovaní je skutočne podvodných? Koľko podvodov model neoznačil za anomálne?
Odpoveď
  • Model označil 2 151 transakcií (3,8 %) za anomálne, hoci podvodov je v teste len 98 – označených je ~22× viac, než je podvodov.
  • Skutočne podvodných je medzi nimi 82 → precision ≈ 3,8 % (82 / 2 151). Zvyšných 2 069 sú neobvyklé, ale legitímne transakcie.
  • 16 podvodov (16 %) model za anomálne neoznačil – svojimi príznakmi vyzerajú ako bežné transakcie.
  • Recall 0,84 bez akýchkoľvek označení je slušný, ale cena je vysoká. Hranicu určuje contamination="auto" (pevný prah skóre 0,5 z pôvodného článku), nie skutočný podiel podvodov.
  • IsolationForest beží na neškálovanom X_train – stromy delia podľa jedného príznaku naraz, takže mierka im nevadí.

Úloha 3.2 – Vyhodnotenie poradia podľa skóre anomálie

import numpy as np
from sklearn.metrics import average_precision_score

def evaluate_scores(y_true, scores, top_share=0.01):
    """Evaluate the ranking of the records given by the anomaly scores."""
    n_top = int(len(scores) * top_share)
    # argsort sorts in ascending order, so the last n_top positions hold the highest scores
    top_idx = np.argsort(scores)[-n_top:]
    return {
        "avg_precision_score": average_precision_score(y_true, scores),
        "anomalies in top 1 %": int(y_true.iloc[top_idx].sum()),
    }

anomaly_share = y_test.mean()
results_iso = evaluate_scores(y_test, scores)

print(f"Anomaly share in the test set (avg_precision_score of a random ranking): {anomaly_share:.4f}")
print(f"avg_precision_score of Isolation Forest: {results_iso['avg_precision_score']:.3f}")
print(f"avg_precision_score of LogisticRegression (Step 1): {metrics_table.loc['LogisticRegression', 'AP']:.3f}")
print(f"Anomalies among the {int(len(scores) * 0.01)} most suspicious records: "
      f"{results_iso['anomalies in top 1 %']} of {y_test.sum()}")

Výstup

Anomaly share in the test set (avg_precision_score of a random ranking): 0.0017
avg_precision_score of Isolation Forest: 0.174
avg_precision_score of LogisticRegression (Step 1): 0.740
Anomalies among the 569 most suspicious records: 62 of 98
OtázkaKoľkokrát je AP modelu vyššia než podiel anomálií? Ako sa líši od modelu s označeniami? Aká časť podvodov je medzi 1 % najpodozrivejších?
Odpoveď
  • AP = 0,174 vs. podiel podvodov 0,0017 → približne 100× lepšie než náhodné poradie. Model bez označení teda zachytáva skutočný signál.
  • Logistická regresia, ktorá mala označenia, má AP 0,740 – ~4× vyššie. Učenie s učiteľom vie, ktorý druh odlišnosti znamená podvod; detektor anomálií označí akúkoľvek neobvyklosť (napr. veľké legitímne nákupy).
  • Medzi 569 najpodozrivejšími transakciami (1 %) je 62 z 98 podvodov = 63 %. Pri kapacite preveriť 1 % transakcií by tím odhalil takmer dve tretiny podvodov, pričom každá ~9. preverená transakcia by bola podvod (62 / 569 ≈ 11 %).
  • Zvyšných ~37 % podvodov nie je podľa príznakov odľahlých – zriedkavé ≠ anomálne.

Krok 4 – Detekcia anomálií pomocou One-Class SVM

OneClassSVM s RBF jadrom odhaduje (nelineárnu) hranicu oblasti, kde leží väčšina trénovacích bodov. Body mimo nej dostanú vyššie skóre anomálie. Trénovanie rastie s počtom bodov aspoň kvadraticky, preto len podvzorka 10 000 riadkov.

Úloha 4.1 – Trénovanie modelu One-Class SVM

from sklearn.svm import OneClassSVM

# the training time grows at least quadratically with the number of records, so the model is fitted
# on a random subsample; the RBF kernel is based on distances - use the scaled features from Task 1.1
X_train_sub = X_train_scaled.sample(n=10000, random_state=42)

# nu=0.05 - upper bound of roughly 5% on training points outside the boundary
ocsvm = OneClassSVM(kernel="rbf", nu=0.05, gamma="scale")
ocsvm.fit(X_train_sub)

# decision_function() is high for normal records, so the sign is flipped to get an anomaly score
scores_svm = -ocsvm.decision_function(X_test_scaled)

results_svm = evaluate_scores(y_test, scores_svm)
print(f"avg_precision_score of One-Class SVM: {results_svm['avg_precision_score']:.3f}")
print(f"Anomalies in the top 1 %: {results_svm['anomalies in top 1 %']} of {y_test.sum()}")

Výstup

avg_precision_score of One-Class SVM: 0.248
Anomalies in the top 1 %: 69 of 98
Odpoveď
  • One-Class SVM dosiahol AP 0,248 a medzi 1 % najpodozrivejších má 69 z 98 podvodov (70 %) – lepšie než Isolation Forest (0,174; 62), hoci videl len 10 000 riadkov (4,4 % trénovacej množiny).
  • RBF jadro pracuje so vzdialenosťami, preto sa používajú škálované príznaky X_train_scaled / X_test_scaled.
  • Trénovacia podvzorka obsahuje aj podvody (nefiltrujeme podľa označení) → ide o detekciu odľahlých pozorovaní, nie o novelty detection.

Úloha 4.2 – Porovnanie prístupov a čas trénovania

Riešenie (doplnené TODO)

import time

# quality of the ranking of both models on the same test set
comparison = pd.DataFrame({"IsolationForest": results_iso, "OneClassSVM": results_svm}).T
print(comparison.round(3).to_string())

def timed_fit(model, X):
    """Fit the model and return the training time in seconds."""
    start = time.perf_counter()
    model.fit(X)
    return time.perf_counter() - start

# training time for a growing number of records (random subsamples of the training set)
timing = {}
for n in [2000, 4000, 8000, 16000]:
    X_big = X_train_scaled.sample(n=n, random_state=42)
    # TODO: use timed_fit() to measure the training time of both models on X_big:
    #       IsolationForest(n_estimators=200, random_state=42) and
    #       OneClassSVM(kernel="rbf", nu=0.05, gamma="scale")
    t_iso = timed_fit(IsolationForest(n_estimators=200, random_state=42), X_big)
    t_svm = timed_fit(OneClassSVM(kernel="rbf", nu=0.05, gamma="scale"), X_big)
    timing[n] = {"IsolationForest (s)": t_iso, "OneClassSVM (s)": t_svm}

timing = pd.DataFrame(timing).T
timing.index.name = "records"
print(timing.round(2).to_string())

Výstup

                 avg_precision_score  anomalies in top 1 %
IsolationForest                0.174                  62.0
OneClassSVM                    0.248                  69.0
         IsolationForest (s)  OneClassSVM (s)
records                                      
2000                    0.30             0.01
4000                    0.17             0.05
8000                    0.20             0.19
16000                   0.23             0.73
Odpoveď
  • Kvalita poradia: One-Class SVM je v tomto behu lepší (AP 0,248 vs. 0,174; v top 1 % 69 vs. 62 podvodov). Oba sú však ďaleko za logistickou regresiou s označeniami (AP 0,740).
  • Čas – Isolation Forest je prakticky konštantný (~0,2 s) bez ohľadu na počet riadkov: každý strom sa učí len na podvzorke 256 bodov (max_samples="auto"). Prvá hodnota 0,30 s pri 2 000 riadkoch je len „zahrievanie“.
  • Čas – One-Class SVM rastie pri každom zdvojnásobení dát približne 4× (0,05 → 0,19 → 0,73 s) – teda kvadraticky. Extrapolácia na celých 227 845 riadkov: (227 845 / 16 000)² ≈ 200× → ~2,5 min v najlepšom prípade, prakticky viac (väčšia kernelová cache, pamäť, viac support vektorov). Isolation Forest by na celých dátach trval stále zlomok sekundy.
  • Záver: One-Class SVM dal lepšie poradie, ale za cenu podvzorkovania a zlej škálovateľnosti; Isolation Forest je rýchly, škáluje na celé dáta a nepotrebuje škálovanie príznakov. Ak sú označenia k dispozícii, klasifikácia s učiteľom je jasne lepšia; detekcia anomálií má zmysel, keď označenia chýbajú alebo hľadáme nové typy podvodov.

Zhrnutie na cvičenie

  • Pri pomere 578 : 1 dosiahne aj model, ktorý nič nerobí, accuracy 0,998. Hodnotíme recall, MCC, AP a maticu zámen.
  • Pôvodná LR prehliadne 35 z 98 podvodov. Váhovanie, SMOTE aj podvzorkovanie zvýšia recall na 0,918 (8 prehliadnutých), líšia sa počtom falošných poplachov: 1 447 / 1 522 / 2 300.
  • Odporúčanie: class_weight="balanced" – rovnaký recall, najmenej falošných poplachov, najjednoduchšie; ďalej prípadne doladiť prah podľa nákladov.
  • Detekcia anomálií bez označení: Isolation Forest AP 0,174 (top 1 %: 62 / 98), One-Class SVM AP 0,248 (69 / 98) – ~100–140× lepšie než náhoda, ale ~3–4× horšie než model s označeniami.
  • Isolation Forest škáluje takmer konštantne, One-Class SVM kvadraticky.
  • Zriedkavé ≠ anomálne: časť podvodov vyzerá ako bežné transakcie a veľa neobvyklých transakcií je legitímnych.

Doplňujúce úlohy (náčrt riešenia)

Tieto náčrty neboli spustené – slúžia ako východisko. Testovaciu množinu z hlavnej časti už nemeníme.

1. Kategorické príznaky a SMOTENC (Bank Marketing)

from imblearn.over_sampling import SMOTENC
from imblearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from ucimlrepo import fetch_ucirepo

bank = fetch_ucirepo(id=222)
Xb = bank.data.features.drop(columns=["duration"])
yb = (bank.data.targets.iloc[:, 0] == "yes").astype(int)
cat_b = Xb.select_dtypes("object").columns.tolist()
num_b = Xb.select_dtypes("number").columns.tolist()
Xb[cat_b] = Xb[cat_b].fillna("unknown")          # SMOTENC does not accept missing values

Xb_tr, Xb_te, yb_tr, yb_te = train_test_split(Xb, yb, test_size=0.2, stratify=yb, random_state=42)

def make_prep():
    return ColumnTransformer([
        ("cat", OneHotEncoder(handle_unknown="ignore"), cat_b),
        ("num", StandardScaler(), num_b),
    ])

plain = Pipeline([("prep", make_prep()), ("clf", LogisticRegression(max_iter=1000))])
# SMOTENC runs BEFORE one-hot encoding and only inside fit() (training data only)
smotenc = Pipeline([
    ("smote", SMOTENC(categorical_features=cat_b, random_state=42)),
    ("prep", make_prep()),
    ("clf", LogisticRegression(max_iter=1000)),
])

bank_table = pd.DataFrame({
    name: evaluate(yb_te, m.fit(Xb_tr, yb_tr).predict(Xb_te), m.predict_proba(Xb_te)[:, 1])
    for name, m in {"LogReg": plain, "LogReg (SMOTENC)": smotenc}.items()
}).T
print(bank_table.round(3))

2. Local Outlier Factor

from sklearn.neighbors import LocalOutlierFactor

# novelty=True -> score_samples() can be used on unseen (test) records
lof = LocalOutlierFactor(n_neighbors=20, novelty=True).fit(X_train_sub)
scores_lof = -lof.score_samples(X_test_scaled)

results_lof = evaluate_scores(y_test, scores_lof)
comparison.loc["LocalOutlierFactor"] = results_lof
print(comparison.round(3).to_string())
Ako sa LOF líšiLOF porovnáva lokálnu hustotu bodu s hustotou jeho k najbližších susedov – bod je anomálny, ak je v riedkej oblasti v porovnaní so svojím okolím. Isolation Forest meria, ako ľahko sa bod oddelí náhodnými rezmi (globálna izolovateľnosť), a One-Class SVM hľadá jednu hranicu okolo celej „normálnej“ oblasti. LOF preto lepšie nájde body, ktoré sú odľahlé len voči svojmu lokálnemu zhluku, ale je citlivý na voľbu n_neighbors a pri veľkých dátach pomalý (hľadanie susedov).

Doplňujúce zdroje