Cvičenie 5 - Nevyvážené dáta a detekcia anomálií¶
Týždeň: 5 | Predpoklady:Pipeline, scikit-learn, imbalanced-learn
Príprava prostredia Anchor¶
V aktivovanom virtuálnom prostredí spustite nasledujúci príkaz:
Zdrojový kód
O čom je cvičenie Anchor¶
V mnohých dátových sadách sú prípady, ktoré nás najviac zaujímajú, zastúpené len zriedkavo. Ak poznáme ich označenia, môžeme model trénovať na rozpoznávanie minoritnej triedy a jeho výkon hodnotiť vhodnými metrikami. Ak prislúchajúce označenia pri trénovaní nemáme k dispozícii, môžeme skúmať, ktoré pozorovania sa od ostatných odlišujú. Cvičenie ukáže oba prístupy a načrtne aj ich hranice - zriedkavý prípad nemusí byť anomáliou a anomália nemusí patriť do triedy, ktorú hľadáme.
Ciele Anchor¶
- Preskúmať zastúpenie tried v dátovej sade a zachovať ich pomer pri rozdelení dát.
- Vysvetliť, prečo samotná metrika
accuracy_scorenepostačuje na hodnotenie modelu pri nevyvážených triedach. - Porovnať prístupy založené na váhovaní tried, nadvzorkovaní a podvzorkovaní podľa ich vplyvu na rozpoznávanie minoritnej triedy.
- Rozlíšiť klasifikáciu s učiteľom od detekcie anomálií bez učiteľa a vysvetliť, prečo zriedkavá trieda nemusí byť anomálna.
Dátová sada
Na tomto cvičení budeme pracovať s dátovou sadou Credit Card Fraud Detection, ktorá obsahuje 284 807 transakcií platobnými kartami európskych držiteľov zo septembra 2013. Cieľová premenná Class označuje, či bola transakcia podvodná. Ide o binárnu klasifikáciu s výrazne nevyváženými triedami, podvodných transakcií je iba 492 (0,17%).
Dátová sada obsahuje 29 číselných príznakov. Príznaky V1 až V28 sú z dôvodu ochrany osobných údajov anonymizované a vznikli transformáciou pôvodných údajov metódou PCA. Príznak Amount vyjadruje sumu transakcie.
Dátovú sadu načítame z repozitára OpenML funkciou fetch_openml. Pri prvom načítaní sa stiahne približne 70 MB dát, ktoré sa uložia do lokálnej vyrovnávacej pamäte. Ďalšie načítania sú už rýchle a fungujú aj bez pripojenia na internet.
Postup Anchor¶
Krok 1: Nevyvážené dáta a význam správnej evaluačnej metriky Anchor¶
Nevyvážená dátová sada sa v klasifikačnej úlohe vyznačuje výrazným rozdielom v početnosti pozorovaní jednotlivých tried cieľovej premennej. Trieda s vyššou početnosťou sa označuje ako majoritná, naopak trieda s nižšou početnosťou ako minoritná. S nerovnováhou tried sa stretávame napríklad pri diagnostike zriedkavých ochorení, detekcii podvodných transakcií, identifikácii závažných softvérových zlyhaní či odhaľovaní chybných výrobkov.
V tomto kroku preskúmame rozloženie tried v dátovej sade Credit Card Fraud Detection a overíme, či sa ich pomer zachoval aj po rozdelení dát. Následne ukážeme, ako môže nevhodná hodnotiaca metrika vytvárať skreslený obraz o výkonnosti modelu, najmä ak model nedostatočne identifikuje pozorovania minoritnej triedy. Zistenia následne využijeme v Kroku 2 pri výbere postupov na riešenie nerovnováhy tried.
Úloha 1.1 - Analýza rozloženia tried v dátovej sade Anchor¶
a) Načítajte dáta a zobrazte početnosť jednotlivých tried.
Spustite nasledujúci kód, ktorý načíta dátovú sadu a vykreslí počet pozorovaní v jednotlivých triedach. Všimnite si, že stĺpec podvodných transakcií je v grafe takmer neviditeľný.
Zdrojový kód
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.datasets import fetch_openml
# 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)
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()
b) Rozdeľte dáta a porovnajte zastúpenie tried.
Spustite nasledujúci kód, ktorý rozdelí pôvodnú dátovú sadu na trénovaciu a testovaciu množinu v pomere 80:20. Následne vypíše počet a podiel podvodných transakcií v pôvodnej dátovej sade aj v oboch vzniknutých množinách.
Zdrojový kód
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())
Parameter stratify=y pri rozdelení dát približne zachová podiel tried v trénovacej aj testovacej množine. Bez stratifikácie môže niektorá z množín obsahovať nedostatočný počet pozorovaní minoritnej triedy, čo sťažuje trénovanie modelu alebo spoľahlivé hodnotenie jeho výkonu.
c) Predspracujte dáta.
Spustite nasledujúci kód, ktorý všetky príznaky naškáluje pomocou StandardScaler. Príznaky V1 až V28 majú podobný rozsah hodnôt, príznak Amount však nadobúda hodnoty až v desaťtisícoch. Parametre škálovania sa určia výlučne z trénovacej množiny a následne sa použijú na obe množiny. Tým sa zabráni úniku informácií z testovacích dát do procesu trénovania.
Zdrojový kód
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}")
Dokumentácia: fetch_openml, train_test_split, StandardScaler
Úloha 1.2 - Prečo samotná metrika accuracy_score nestačí Anchor¶
Spustite nasledujúci kód, ktorý natrénuje dva modely a porovná ich pomocou metriky accuracy_score - podielu správne klasifikovaných pozorovaní:
DummyClassifier(strategy="most_frequent")- vytvorí referenčný model, ktorý ignoruje príznaky a vždy predikuje majoritnú triedu.LogisticRegression- vytvorí model logistickej regresie bez úprav zohľadňujúcich nevyváženosť tried. Maximálny počet iterácií je zvýšený na 1 000, aby optimalizácia skonvergovala.
Kód pre oba natrénované modely vykreslí aj maticu zámen. Porovnajte ju s hodnotou accuracy_score a všimnite si, ako modely klasifikujú pozorovania minoritnej triedy.
Zdrojový kód
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()
Dokumentácia: DummyClassifier, accuracy_score, ConfusionMatrixDisplay
Úloha 1.3 - Hodnotenie výkonu pri nevyvážených triedach Anchor¶
Metrika accuracy_score neukáže, ako dobre model rozpoznáva minoritnú triedu. Výkon oboch modelov preto posúďte aj pomocou ďalších metrík:
recall_scorevyjadruje podiel skutočne pozitívnych pozorovaní, ktoré model správne identifikoval.geometric_mean_scorespája návratnosť pozitívnej triedy so schopnosťou správne rozpoznať negatívnu triedu. Ak model zlyháva pri jednej z nich, hodnota metriky je nízka.matthews_corrcoefzohľadňuje všetky štyri hodnoty matice zámen. Hodnota 1 znamená bezchybnú klasifikáciu. Naopak, hodnota 0 vyjadruje, že medzi predikovanými a skutočnými triedami nie je korelácia.roc_auc_scoreaaverage_precision_scorehodnotia schopnosť modelu zoradiť pozorovania podľa predikovaného skóre bez voľby konkrétneho rozhodovacieho prahu. Pri modeli, ktorý všetkým pozorovaniam priradí rovnaké skóre, je hodnota metrikyroc_auc_scorerovná 0,5 a hodnota metrikyaverage_precision_scoresa rovná podielu pozitívnej triedy.
Doplňte časti označené TODO v pripravenej kostre kódu. Funkcia evaluate má vrátiť všetky uvedené metriky a tabuľka metrics_table má obsahovať jeden riadok pre každý model z Úlohy 1.2.
Zdrojový kód
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": ...,
"g-mean": ...,
"MCC": ...,
# TODO 2: add the metrics computed from the predicted probabilities: roc_auc_score
# and average_precision_score
"ROC AUC": ...,
"AP": ...,
}
# TODO 3: create a DataFrame with one row per model ("DummyClassifier", "LogisticRegression")
# and one column per metric returned by evaluate()
metrics_table = ...
print(metrics_table.round(3).to_string())
Porovnajte oba modely. Prečo má DummyClassifier vysokú hodnotu accuracy_score, hoci neodhalí žiadnu podvodnú transakciu? Ktoré z ďalších metrík toto zlyhanie odhalia? Pri ktorých metrikách vyzerá logistická regresia takmer bezchybne a ktoré ukazujú, že časť podvodných transakcií prehliadne?
Dokumentácia: recall_score, geometric_mean_score, matthews_corrcoef, roc_auc_score, average_precision_score
Krok 2: Ako sa vysporiadať s nevyváženým zastúpením tried Anchor¶
V Kroku 1 ste videli, že model logistickej regresie neodhalil viac než tretinu podvodných transakcií. V tomto kroku preskúmate postupy, ktoré môžu zlepšiť rozpoznávanie tejto menej početnej triedy.
Nerovnováhu tried možno zohľadniť úpravou procesu učenia, zmenou zloženia trénovacích dát alebo použitím skupinových a hybridných metód. Na tomto cvičení sa zameriate na tri postupy, konkrétne:
- Váhovanie tried - upravuje stratovú funkciu tak, aby chyby pri pozorovaniach minoritnej triedy mali vyššiu váhu.
- Nadvzorkovanie - zameriava sa na zvyšovanie počtu pozorovaní minoritnej triedy.
- Podvzorkovanie - znižuje počet pozorovaní majoritnej triedy.
Výsledné modely porovnáte s pôvodným modelom pomocou metrík z Kroku 1. Osobitnú pozornosť venujete metrike recall_score a počtu falošne pozitívnych predikcií.
Úloha 2.1 - Váhovanie tried v logistickej regresii Anchor¶
Natrénujte model prostredníctvom LogisticRegression s nastavením class_weight="balanced". Toto nastavenie priraďuje triedam váhy podľa ich početnosti v trénovacích dátach. Model vyhodnoťte na rovnakej testovacej množine funkciou evaluate z Úlohy 1.3 a získané hodnoty metrík pridajte ako nový riadok do tabuľky metrics_table.
Doplňte časti kódu označené komentárom TODO v kostre nižšie.
Zdrojový kód
from sklearn.metrics import confusion_matrix
# TODO 1: train LogisticRegression(max_iter=1000, class_weight="balanced")
baseline_weighted = ...
# TODO 2: predict the classes and the probabilities of the positive class
y_pred_weighted = ...
y_score_weighted = ...
# TODO 3: use evaluate() to add the metrics of the new model to metrics_table
metrics_table.loc["LogisticRegression (balanced)"] = ...
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))
Porovnajte hodnoty metrík s výsledkami z Úlohy 1.3. Pomocou matíc zámen určte, ako sa zmenil počet odhalených podvodných transakcií a počet falošne pozitívnych predikcií.
Dokumentácia: LogisticRegression (hyperparameter class_weight), confusion_matrix
Úloha 2.2 - Nadvzorkovanie minoritnej triedy metódou SMOTE Anchor¶
V predchádzajúcej úlohe ste upravili váhy tried bez zmeny trénovacích dát. Teraz vyskúšajte nadvzorkovanie - metóda SMOTE vytvára nové pozorovania minoritnej triedy interpoláciou medzi existujúcimi pozorovaniami.
Aplikujte SMOTE z knižnice imbalanced-learn výlučne na trénovaciu množinu. Na takto upravených dátach opäť natrénujte model logistickej regresie a vyhodnoťte ho na pôvodnej, neupravenej testovacej množine. Porovnajte výsledky s modelmi z Úloh 1.2 a 2.1.
Zdrojový kód
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())
Poznámka
SMOTE vytvára syntetické pozorovania interpoláciou medzi existujúcimi pozorovaniami, preto je vhodný pre číselné príznaky, aké obsahuje táto dátová sada. Pri jednorázovo zakódovaných kategorických príznakoch by interpolácia mohla vytvoriť hodnoty, ktoré nepredstavujú platnú kategóriu. Pre dátové sady s číselnými aj kategorickými príznakmi je určený variant SMOTENC (pozri doplňujúce úlohy).
Úloha 2.3 - Náhodné podvzorkovanie a porovnanie prístupov Anchor¶
Pomocou RandomUnderSampler znížte počet pozorovaní majoritnej triedy iba v trénovacej množine. Na upravených dátach opäť natrénujte model logistickej regresie a vyhodnoťte ho na nezmenenej testovacej množine.
Doplňte časti kódu označené komentárom TODO v kostre nižšie.
Zdrojový kód
from imblearn.under_sampling import RandomUnderSampler
# TODO 1: resample the training set with RandomUnderSampler(random_state=42)
X_train_under, y_train_under = ...
# 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 = ...
# TODO 3: predict the classes and the probabilities of the positive class
y_pred_under = ...
y_score_under = ...
# TODO 4: use evaluate() to add the metrics of the new model to metrics_table
metrics_table.loc["LogisticRegression (undersampling)"] = ...
# 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())
Na 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. Svoje rozhodnutie zdôvodnite.
Dokumentácia: RandomUnderSampler, Pipeline
Krok 3: Detekcia anomálií pomocou Isolation Forest Anchor¶
V Krokoch 1 a 2 ste trénovali klasifikačný model pomocou označených pozorovaní. V Krokoch 3 a 4 preskúmate odlišný postup - klasifikačnému algoritmu pri trénovaní neposkytnete informáciu o tom, ktoré transakcie sú podvodné. Jeho úlohou bude určiť, ktoré transakcie sa svojimi príznakmi odlišujú od ostatných. Tento postup sa nazýva detekcia anomálií.
| Označenia pri trénovaní | Model pozná skutočné triedy trénovacích pozorovaní. | Model nedostane označenie, či je transakcia podvodná. | | Cieľ modelu | Naučiť sa predikovať konkrétnu triedu. | Určiť pozorovania, ktoré sa odlišujú od bežných transakcií. | | Interpretácia výstupu | Predikcia vyjadruje príslušnosť ku konkrétnej triede. | Vysoké skóre anomálie označuje transakciu na preverenie; samo osebe nedokazuje podvod. |
Podvodná transakcia teda nemusí dostať vysoké skóre anomálie a neobvyklá transakcia nemusí byť podvodná. Skutočné označenia použijete po trénovaní na overenie, do akej miery sa transakcie označené modelom za neobvyklé prekrývajú s podvodnými.
Použijete rovnakú trénovaciu a testovaciu množinu ako v Krokoch 1 a 2, takže výsledky oboch prístupov možno priamo porovnať. Podvodné transakcie tvoria len malý podiel dátovej sady. Overíte, či ich možno identifikovať na základe odlišnosti príznakov bez toho, aby model pri trénovaní poznal označenia tried. Zriedkavosť triedy však sama osebe nezaručuje, že jej pozorovania budú anomálne.
IsolationForest vytvára súbor stromov, ktoré opakovane a náhodne vyberajú príznak aj hodnotu, podľa ktorej rozdelia pozorovania. Pozorovania, ktoré sa od ostatných výraznejšie odlišujú, sa zvyčajne izolujú po menšom počte rozdelení. Skóre modelu vychádza z priemernej dĺžky ciest v stromoch - kratšie cesty naznačujú vyššiu mieru anomálnosti.
Úloha 3.1 - Trénovanie modelu Isolation Forest Anchor¶
Spustite nasledujúci kód, ktorý natrénuje IsolationForest iba na príznakoch X_train, bez použitia označeníy_train. Pre pozorovania v testovacej množine vypočíta skóre anomálie scores a určí, koľko z nich model označí za anomálne. Všimnite si, ako kód upravuje znamienko skóre, aby vyššia hodnota znamenala vyššiu mieru anomálnosti.
Zdrojový kód
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()}")
Porovnajte počet testovacích pozorovaní označených za anomálne s počtom podvodných transakcií v testovacej množine. Koľko označených pozorovaní je skutočne podvodných? Koľko podvodných transakcií model neoznačil za anomálne? Pri vyhodnotení použite označenia y_test, ktoré model pri trénovaní nepoznal.
Poznámka
Parameter contamination v modeli IsolationForest určuje hranicu, podľa ktorej metóda predict() označí pozorovanie za anomálne (-1) alebo bežné (1). Nemení skóre vrátené metódou score_samples(), ani poradie pozorovaní podľa tohto skóre.
V cvičení používame contamination="auto", takže hranicu neurčujeme podľa známeho podielu podvodných transakcií. Ten poznáme vďaka označeniam a využijeme ho až pri interpretácii výsledkov. Ak by bol pred trénovaním k dispozícii nezávislý odhad očakávaného podielu anomálií, mohol by slúžiť na nastavenie parametra contamination.
Dokumentácia: IsolationForest
Úloha 3.2 - Vyhodnotenie poradia podľa skóre anomálie Anchor¶
Pomocou označení y_test overte, či model priraďuje podvodným transakciám vyššie skóre anomálie než ostatným. Pri hodnotení použite spojité skóre scores, nie výsledné označenia preds:
average_precision_scorezhrnie kvalitu poradia naprieč rozhodovacími prahmi. Výsledok porovnajte s podielom podvodných transakcií v testovacej množine, ktorý predstavuje orientačnú základnú úroveň, a s hodnotou modelu logistickej regresie z Kroku 1, ktorý mal pri trénovaní označenia k dispozícii.- Počet podvodných transakcií medzi 1% transakcií s najvyšším skóre ukáže, koľko podvodov by sa dostalo do výberu pri obmedzenej kapacite na následné preverenie.
Spustite nasledujúci kód, ktorý obe hodnoty vypočíta vo funkcii evaluate_scores (použijeme ju aj v Kroku 4). Vypíše aj počet vybraných transakcií a celkový počet podvodných transakcií v testovacej množine, aby sa výsledok dal správne interpretovať.
Zdrojový kód
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()}")
Koľkokrát je avg_precision_score modelu vyššie než podiel anomálií v testovacej množine? Ako sa líši od hodnoty modelu, ktorý mal pri trénovaní označenia k dispozícii? Aká časť všetkých podvodných transakcií sa nachádza medzi 1% najpodozrivejších pozorovaní?
Dokumentácia: average_precision_score, numpy.argsort
Krok 4: Detekcia anomálií pomocou One-Class SVM Anchor¶
Kým IsolationForest posudzuje, ako rýchlo možno pozorovanie izolovať náhodným delením príznakov, OneClassSVM odhaduje hranicu oblasti, v ktorej sa nachádza väčšina trénovacích pozorovaní. Pozorovaniam mimo tejto oblasti priraďuje vyššiu mieru anomálnosti. Pri použití hyperparametra kernel='rbf' môže hranica nadobúdať aj nelineárny tvar. Či to povedie k lepšiemu rozpoznávaniu podvodných transakcií, overíte na testovacích dátach.
Tento prístup je však výpočtovo náročný - čas trénovania rastie s počtom pozorovaní prinajlepšom kvadraticky. Model preto natrénujete iba na náhodnej podvzorke trénovacej množiny. Porovnanie s IsolationForest zahŕňa výkon modelov aj nároky na ich trénovanie.
Úloha 4.1 - Trénovanie modelu One-Class SVM Anchor¶
Spustite nasledujúci kód, ktorý natrénuje model prostredníctvom OneClassSVM s hyperparametrom kernel='rbf' na náhodnej podvzorke 10 000 trénovacích pozorovaní, bez použitia označení y_train. Výsledok vyhodnotí na rovnakej testovacej množine pomocou funkcie evaluate_scores z Úlohy 3.2.
Hodnota hyperparametra kernel='rbf' zohľadňuje vzdialenosti medzi pozorovaniami, preto kód používa štandardizované príznaky X_train_scaled a X_test_scaled z Úlohy 1.1. Parametre štandardizácie boli určené výlučne z trénovacej množiny.
Zdrojový kód
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()}")
Poznámka
Pri detekcii odľahlých pozorovaní môže trénovacia množina obsahovať aj neobvyklé prípady - model sa ich snaží odlíšiť od prevládajúcich vzorov. Pri detekcii nových vzorov ( z angl. novelty detection) sa model trénuje na pozorovaniach považovaných za bežné a následne posudzuje nové, dovtedy nevidené vzorky. V tomto cvičení trénovaciu množinu nefiltrujeme podľa označení, takže obsahuje aj podvodné transakcie. Pracujeme preto so scenárom detekcie odľahlých pozorovaní, hoci model vyhodnocujeme na samostatnej testovacej množine. Podvodná transakcia pritom nemusí byť podľa svojich príznakov odľahlá.
Dokumentácia: OneClassSVM
Úloha 4.2 - Vyhodnotenie použitých prístupov na detekciu odľahlých bodov Anchor¶
Model IsolationForest bol natrénovaný na celej trénovacej množine, model OneClassSVM na jej podvzorke. Oba boli vyhodnotené na rovnakej testovacej množine. Porovnajte ich výsledky z predchádzajúcich úloh - zahrňte aj analýzu počtu podvodných transakcií medzi 1% transakcií s najvyšším skóre anomálie.
Aby ste videli, prečo sa OneClassSVM trénoval iba na podvzorke, zmerajte čas trénovania oboch modelov pri postupne rastúcom počte vstupných pozorovaní. Vstupy vytvorte náhodným výberom zo štandardizovanej trénovacej množiny. Testovaciu množinu pri tomto meraní nepoužívajte.
Doplňte časti kódu označené komentárom TODO v kostre nižšie.
Zdrojový kód
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 = ...
t_svm = ...
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())
Doplňujúce úlohy Anchor¶
- Kategorické príznaky a nadvzorkovanie. Metóda
SMOTEinterpoluje medzi číselnými hodnotami, preto nie je vhodná pre kategorické príznaky. Načítajte dátovú sadu Bank Marketing z Cvičenia 2 (fetch_ucirepo(id=222), vyžaduje balíčekucimlrepo), ktorá kombinuje číselné a kategorické príznaky, a odstráňte príznakduration. Trénovaciu množinu nadvzorkujte metódouSMOTENC, pričom pomocou parametracategorical_featuresurčte kategorické príznaky. Nadvzorkovanie vykonajte pred jednorázovým zakódovaním a iba na trénovacích dátach. Vytvorené pozorovania potom predspracujte rovnakým spôsobom ako pôvodné dáta a natrénujte klasifikátorLogisticRegression. Na nezmenenej testovacej množine porovnajte hodnoty hodnotiacich metrík s modelom natrénovaným bez nadvzorkovania. - Detekcia podľa lokálnej hustoty. Vyskúšajte
LocalOutlierFactorako tretiu metódu. Nastavte hodnotu hyperparametranovelty=True, aby ste mohli vypočítať skóre pre testovacie pozorovania, ktoré model pri trénovaní nevidel. Model natrénujte bez označeníy_trainna podvzorkeX_train_subz Úlohy 4.1 a na rovnakej testovacej množine porovnajte hodnoty dosiahnutých evaluačných metrík a počet podvodných transakcií medzi 1% najvyššie hodnotených transakcií s výsledkami modelovIsolationForestaOneClassSVM. Vysvetlite, ako sa posudzovanie lokálnej hustoty líši od princípu zvyšných dvoch metód.
Doplňujúce zdroje Anchor¶
- Chawla, N. V., Bowyer, K. W., Hall, L. O., & Kegelmeyer, W. P. (2002). SMOTE: Synthetic Minority Over-sampling Technique.
- He, H., & Garcia, E. A. (2009). Learning from Imbalanced Data.
- Saito, T., & Rehmsmeier, M. (2015). The Precision-Recall Plot Is More Informative than the ROC Plot When Evaluating Binary Classifiers on Imbalanced Datasets.
- Dal Pozzolo, A., Caelen, O., Johnson, R. A., & Bontempi, G. (2015). Calibrating Probability with Undersampling for Unbalanced Classification.
- Liu, F. T., Ting, K. M., & Zhou, Z.-H. (2008). Isolation Forest.
- Schölkopf, B., Platt, J. C., Shawe-Taylor, J., Smola, A. J., & Williamson, R. C. (2001). Estimating the Support of a High-Dimensional Distribution.
- Quinn, J. A., & Sugiyama, M. (2014). A Least-Squares Approach to Anomaly Detection in Static and Sequential Data.
- Zhao, Y., Nasrullah, Z., & Li, Z. (2019). PyOD: A Python Toolbox for Scalable Outlier Detection.