Cvičenie 5 – Nevyvážené dáta a detekcia anomálií
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.
- Preskúmať zastúpenie tried a zachovať ich pomer pri rozdelení dát.
- Vysvetliť, prečo samotná
accuracy_scorepri nevyvážených triedach nestačí. - Porovnať váhovanie tried, nadvzorkovanie a podvzorkovanie.
- Rozlíšiť klasifikáciu s učiteľom od detekcie anomálií bez učiteľa.
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.Vytvára syntetické pozorovania minoritnej triedy interpoláciou medzi susedmi. Iba na trénovacích dátach.
Náhodne zahodí pozorovania majoritnej triedy, kým sa triedy nevyrovnajú. Rýchle, ale stráca veľa informácie.
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.
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
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)
- Pomer tried je 578 : 1 – na jeden podvod pripadá 578 legitímnych transakcií.
- Vďaka
stratify=yje 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
- 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
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?- 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]]
| model | odhalené (TP) | prehliadnuté (FN) | falošné poplachy (FP) | recall | MCC |
|---|---|---|---|---|---|
| LogisticRegression | 63 | 35 | 13 | 0,643 | 0,730 |
| LogisticRegression (balanced) | 90 | 8 | 1 447 | 0,918 | 0,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
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
- 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.Pipelineaplikuje SMOTE iba vofit(); pripredict()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
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
- 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 €):
| model | FN × 100 | FP × 1 | celkom |
|---|---|---|---|
| LogisticRegression | 3 500 | 13 | 3 513 |
| LogisticRegression (balanced) | 800 | 1 447 | 2 247 |
| LogisticRegression (SMOTE) | 800 | 1 522 | 2 322 |
| LogisticRegression (undersampling) | 800 | 2 300 | 3 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ľom | Detekcia anomálií bez učiteľa | |
|---|---|---|
| Označenia pri trénovaní | model pozná triedy | model nevie, ktoré transakcie sú podvody |
| Cieľ | predikovať konkrétnu triedu | nájsť pozorovania odlišné od bežných |
| Výstup | príslušnosť k triede | skó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
- 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. IsolationForestbeží na neškálovanomX_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
- 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
- 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
- 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)
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())n_neighbors a pri veľkých dátach pomalý (hľadanie susedov).Doplňujúce zdroje
- Chawla et al. (2002): SMOTE: Synthetic Minority Over-sampling Technique
- He & Garcia (2009): Learning from Imbalanced Data
- Saito & Rehmsmeier (2015): The Precision-Recall Plot Is More Informative than the ROC Plot…
- Dal Pozzolo et al. (2015): Calibrating Probability with Undersampling for Unbalanced Classification
- Liu, Ting & Zhou (2008): Isolation Forest
- Schölkopf et al. (2001): Estimating the Support of a High-Dimensional Distribution
- Zhao, Nasrullah & Li (2019): PyOD: A Python Toolbox for Scalable Outlier Detection
- Zadanie: pok-isi.fei.tuke.sk/05-nevyvazenost-anomalie.html