Megosztás a következőn keresztül:

Oktatóanyag: Az R használata csalásészlelési modell létrehozásához, kiértékeléséhez és pontozásához

Ez az oktatóanyag egy Synapse Data Science-munkafolyamat végpontok közötti példáját mutatja be a Microsoft Fabricben. Ebben a forgatókönyvben egy csalásészlelési modellt hozunk létre az R-ben, amely gépi tanulási algoritmusokat tanít be az előzményadatokra. Ezt követően a modell használatával észleljük a jövőbeli csalárd tranzakciókat.

Ez az oktatóanyag az alábbi lépéseket ismerteti:

  • Egyéni könyvtárak telepítése
  • Adatok betöltése
  • Az adatok megismerése és feldolgozása feltáró adatelemzéssel, valamint a Fabric Data Wrangler funkció használatának bemutatása
  • Gépi tanulási modellek betanítása a LightGBM használatával
  • A gépi tanulási modellek használata pontozáshoz és előrejelzésekhez

Előfeltételek

Követés jegyzetfüzetben

A jegyzetfüzet használatához az alábbi lehetőségek közül választhat:

  • Nyissa meg és futtassa a beépített jegyzetfüzetet a Synapse Data Science felületén
  • Jegyzetfüzet feltöltése a GitHubról a Synapse Data Science felületére

A beépített jegyzetfüzet megnyitása

Az oktatóanyagot a csalásészlelési-jegyzetfüzet minta kíséri.

  1. Az oktatóanyaghoz tartozó mintajegyzetfüzet megnyitásához kövesse a A rendszer előkészítése adatelemzési oktatóanyagokhozcímű témakörben található utasításokat.

  2. A kód futtatása előtt mindenképpen csatoljon egy tóházat a jegyzetfüzethez.

A jegyzetfüzet importálása a GitHubról

A AIsample - R Fraud Detection.ipynb jegyzetfüzet kíséri ezt az oktatóanyagot.

1. lépés: Egyéni kódtárak telepítése

A gépi tanulási modell fejlesztéséhez vagy az alkalmi adatelemzéshez előfordulhat, hogy gyorsan telepítenie kell egy egyéni kódtárat az Apache Spark-munkamenethez. A kódtárak telepítéséhez két lehetőség közül választhat.

  • Használja a beágyazott telepítési erőforrásokat, például a install.packages és devtools::install_version, hogy csak az aktuális jegyzetfüzetbe telepítsen.
  • Másik lehetőségként létrehozhat egy Fabric-környezetet, telepíthet nyilvános forrásokból származó kódtárakat, vagy feltölthet hozzá egyéni kódtárakat, majd a munkaterület rendszergazdája alapértelmezettként csatolhatja a környezetet a munkaterülethez. Ezután a környezet összes kódtára elérhetővé válik a munkaterület bármely jegyzetfüzetében és Spark-feladatdefiníciójában. További információ a környezetekről: környezet létrehozása, konfigurálása és használata a Microsoft Fabric.

Ebben az oktatóanyagban a install.version() használatával telepítse a kiegyensúlyozatlan tanulás kódtárat:

# Install dependencies
devtools::install_version("bnlearn", version = "4.8")
# Install imbalance for SMOTE
devtools::install_version("imbalance", version = "1.0.2.1")

2. lépés: Az adatok betöltése

A csalásészlelési adatkészlet 2013 szeptemberétől tartalmaz hitelkártya-tranzakciókat, amelyeket az európai kártyatulajdonosok két nap alatt hajtottak végre. Az adathalmaz csak numerikus szolgáltatásokat tartalmaz az eredeti funkciókra alkalmazott fő összetevő-elemzési (PCA) átalakítás miatt. A PCA az Time és a Amountkivételével minden funkciót átalakított. A bizalmasság védelme érdekében nem tudjuk megadni az eredeti szolgáltatásokat vagy az adathalmazsal kapcsolatos további háttérinformációkat.

Ezek a részletek az adathalmazt írják le:

  • A V1, V2, V3, ..., V28 funkciók a PCA-val beszerzett fő összetevők
  • A Time funkció a tranzakció és az adathalmaz első tranzakciója közötti eltelt másodperceket tartalmazza
  • A Amount funkció a tranzakció összege. Példafüggő, költségérzékeny tanuláshoz használhatja ezt a funkciót.
  • A Class oszlop a válasz (cél) változó. Csalás esetén 1 érték, más esetekben 0.

A 284 807 tranzakcióból csak 492 tranzakció hamis. Az adathalmaz rendkívül kiegyensúlyozatlan, mert a kisebb (csalással kapcsolatos) osztály az adatok körülbelül 0,172% részét teszi ki.

Ez a táblázat a creditcard.csv adatainak előnézetét mutatja be:

Idő V1 V2 V3 V4 V5 V6 V7 V8 V9 V10 V11 V12 V13 V14 V15 V16 V17 V18 V19 V20 V21 V22 V23 V24 V25 V26 V27 V28 Mennyiség Osztály
0 -1.3598071336738 -0.0727811733098497 2.53634673796914 1.37815522427443 -0.338320769942518 0.462387777762292 0.239598554061257 0.0986979012610507 0.363786969611213 0.0907941719789316 -0.551599533260813 -0.617800855762348 -0.991389847235408 -0.311169353699879 1.46817697209427 -0.470400525259478 0.207971241929242 0.0257905801985591 0.403992960255733 0.251412098239705 -0.018306777944153 0.277837575558899 -0.110473910188767 0.0669280749146731 0.128539358273528 -0.189114843888824 0.133558376740387 -0.0210530534538215 149.62 "0"
0 1.19185711131486 0.26615071205963 0.16648011335321 0.448154078460911 0.0600176492822243 -0.0823608088155687 -0.0788029833323113 0.0851016549148104 -0.255425128109186 -0.166974414004614 1,61272666105479 1.06523531137287 0.48909501589608 -0.143772296441519 0.635558093258208 0.463917041022171 -0.114804663102346 -0.183361270123994 -0.145783041325259 -0.0690831352230203 -0.225775248033138 -0.638671952771851 0.101288021253234 -0.339846475529127 0.167170404418143 0.125894532368176 -0.00898309914322813 0.0147241691924927 2,69 0

Töltse le az adathalmazt, és töltse fel a lakehouse-ba

Adja meg ezeket a paramétereket, hogy ezt a jegyzetfüzetet különböző adatkészletekkel használhassa:

IS_CUSTOM_DATA <- FALSE  # If TRUE, the dataset has to be uploaded manually

IS_SAMPLE <- FALSE  # If TRUE, use only rows of data for training; otherwise, use all data
SAMPLE_ROWS <- 5000  # If IS_SAMPLE is True, use only this number of rows for training

DATA_ROOT <- "/lakehouse/default"
DATA_FOLDER <- "Files/fraud-detection"  # Folder with data files
DATA_FILE <- "creditcard.csv"  # Data file name

Ez a kód letölti az adathalmaz nyilvánosan elérhető verzióját, majd egy Fabric lakehouse-ban tárolja.

Fontos

A futtatás előtt mindenképpen adjon hozzá egy lakehouse- a jegyzetfüzethez. Ellenkező esetben hibaüzenet jelenik meg.

if (!IS_CUSTOM_DATA) {
    # Download data files into a lakehouse if they don't exist
    library(httr)
    
    remote_url <- "https://synapseaisolutionsa.blob.core.windows.net/public/Credit_Card_Fraud_Detection"
    fname <- "creditcard.csv"
    download_path <- file.path(DATA_ROOT, DATA_FOLDER, "raw")

    dir.create(download_path, showWarnings = FALSE, recursive = TRUE)
    if (!file.exists(file.path(download_path, fname))) {
        r <- GET(file.path(remote_url, fname), timeout(30))
        writeBin(content(r, "raw"), file.path(download_path, fname))
    }
    message("Downloaded demo data files into lakehouse.")
}

Nyers dátumadatok olvasása a lakehouse-ból

Ez a kód nyers adatokat olvas be a lakehouse Files szakaszából:

data_df <- read.csv(file.path(DATA_ROOT, DATA_FOLDER, "raw", DATA_FILE))

3. lépés: Feltáró adatelemzés végrehajtása

Az adathalmaz magas szintű statisztikáinak megtekintéséhez használja a display parancsot:

display(as.DataFrame(data_df, numPartitions = 3L))

# Print dataset basic information
message(sprintf("records read: %d", nrow(data_df)))
message("Schema:")
str(data_df)

# If IS_SAMPLE is True, use only SAMPLE_ROWS of rows for training
if (IS_SAMPLE) {
    data_df = sample_n(data_df, SAMPLE_ROWS)
}

Az osztályok eloszlásának nyomtatása az adathalmazban:

# The distribution of classes in the dataset
message(sprintf("No Frauds %.2f%% of the dataset\n", round(sum(data_df$Class == 0)/nrow(data_df) * 100, 2)))
message(sprintf("Frauds %.2f%% of the dataset\n", round(sum(data_df$Class == 1)/nrow(data_df) * 100, 2)))

Ez az osztályeloszlás azt mutatja, hogy a tranzakciók többsége nem jogsértő. Ezért a túlillesztés elkerülése érdekében a modell betanítása előtt adatelőfeldolgozásra van szükség.

A csalárd és a nem jogsértő tranzakciók eloszlásának megtekintése

Tekintse meg a csalárd és a nem jogsértő tranzakciók eloszlását egy diagrammal, hogy megjelenítse az adathalmaz osztályegyensúlytalanságát:

library(ggplot2)

ggplot(data_df, aes(x = factor(Class), fill = factor(Class))) +
  geom_bar(stat = "count") +
  scale_x_discrete(labels = c("no fraud", "fraud")) +
  ggtitle("Class Distributions \n (0: No Fraud || 1: Fraud)") +
  theme(plot.title = element_text(size = 10))

Képernyőkép, amelyen a csalás sávdiagramja látható.

A diagram egyértelműen az adathalmaz egyensúlyhiányát mutatja:

Az öt szám összegzésének megjelenítése

A tranzakció összegéhez tartozó ötszámos összegzés (minimális pontszám, első kvartilis, medián, harmadik kvartilis és maximális pontszám) megjelenítése dobozdiagramokkal:

library(ggplot2)
library(dplyr)

ggplot(data_df, aes(x = as.factor(Class), y = Amount, fill = as.factor(Class))) +
  geom_boxplot(outlier.shape = NA) +
  scale_x_discrete(labels = c("no fraud", "fraud")) +
  ggtitle("Boxplot without Outliers") +
  coord_cartesian(ylim = quantile(data_df$Amount, c(0.05, 0.95)))

Képernyőkép, amely a tranzakció összegének meződiagramjait jeleníti meg osztály szerint felosztva.

A nagymértékben kiegyensúlyozatlan adatok esetében előfordulhat, hogy a dobozdiagramok nem mutatnak pontos megállapításokat. A Class egyensúlyhiány problémáját azonban először megoldhatja, majd ugyanazokat a diagramokat hozhatja létre a pontosabb elemzésekhez.

4. lépés: A modellek betanítása és kiértékelése

Itt betanít egy LightGBM-modellt a csalási tranzakciók besorolásához. Tanítasz egy LightGBM-modellt mind a kiegyensúlyozatlan adathalmazra, mind a kiegyensúlyozott adathalmazra. Ezután összehasonlítja mindkét modell teljesítményét.

Adathalmazok betanítása és tesztelése

A betanítás előtt ossza fel az adatokat a betanítási és tesztelési adatkészletekre:

# Split the dataset into training and test datasets
set.seed(42)
train_sample_ids <- base::sample(seq_len(nrow(data_df)), size = floor(0.85 * nrow(data_df)))

train_df <- data_df[train_sample_ids, ]
test_df <- data_df[-train_sample_ids, ]

SMOTE alkalmazása a betanítási adatkészletre

A kiegyensúlyozatlan besorolással probléma van. Túl kevés a kisebbségi osztály példája ahhoz, hogy egy modell hatékonyan megtanulja a döntési határt. A szintetikus kisebbségi túlmintavételezési technika (SMOTE) képes kezelni ezt a problémát. Az SMOTE a legelszántabb módszer a kisebbségi osztály új mintáinak szintetizálására. Az SMOTE-t az 1. lépésben telepített imbalance kódtár használatával érheti el.

Az SMOTE-t csak a betanítási adatkészletre alkalmazza a tesztadatkészlet helyett. Amikor a tesztadatokkal értékeli a modellt, szüksége van egy közelítésre a modell teljesítményének megítéléséhez a termelési környezetben nem látott adatokon. Az érvényes közelítés érdekében a tesztadatok az eredeti kiegyensúlyozatlan eloszlásra támaszkodnak, hogy a lehető legszorosabban képviseljék a gyártási adatokat.

# Apply SMOTE to the training dataset
library(imbalance)

# Print the shape of the original (imbalanced) training dataset
train_y_categ <- train_df %>% select(Class) %>% table
message(
    paste0(
        "Original dataset shape ",
        paste(names(train_y_categ), train_y_categ, sep = ": ", collapse = ", ")
    )
)

# Resample the training dataset by using SMOTE
smote_train_df <- train_df %>%
    mutate(Class = factor(Class)) %>%
    oversample(ratio = 0.99, method = "SMOTE", classAttr = "Class") %>%
    mutate(Class = as.integer(as.character(Class)))

# Print the shape of the resampled (balanced) training dataset
smote_train_y_categ <- smote_train_df %>% select(Class) %>% table
message(
    paste0(
        "Resampled dataset shape ",
        paste(names(smote_train_y_categ), smote_train_y_categ, sep = ": ", collapse = ", ")
    )
)

További információ az SMOTE-ről: csomag "egyensúlyhiány" és Az egyensúlyhiányos adatkészletek erőforrások használata a CRAN webhelyén.

A modell betanítása a LightGBM használatával

A LightGBM-modell betanítása a kiegyensúlyozatlan adatkészlettel és a kiegyensúlyozott (SMOTE-on keresztüli) adatkészlettel. Ezután hasonlítsa össze a teljesítményüket:

# Train LightGBM for both imbalanced and balanced datasets and define the evaluation metrics
library(lightgbm)

# Get the ID of the label column
label_col <- which(names(train_df) == "Class")

# Convert the test dataset for the model
test_mtx <- as.matrix(test_df)
test_x <- test_mtx[, -label_col]
test_y <- test_mtx[, label_col]

# Set up the parameters for training
params <- list(
    objective = "binary",
    learning_rate = 0.05,
    first_metric_only = TRUE
)

# Train for the imbalanced dataset
message("Start training with imbalanced data:")
train_mtx <- as.matrix(train_df)
train_x <- train_mtx[, -label_col]
train_y <- train_mtx[, label_col]
train_data <- lgb.Dataset(train_x, label = train_y)
valid_data <- lgb.Dataset.create.valid(train_data, test_x, label = test_y)
model <- lgb.train(
    data = train_data,
    params = params,
    eval = list("binary_logloss", "auc"),
    valids = list(valid = valid_data),
    nrounds = 300L
)

# Train for the balanced (via SMOTE) dataset   
message("\n\nStart training with balanced data:")
smote_train_mtx <- as.matrix(smote_train_df)
smote_train_x <- smote_train_mtx[, -label_col]
smote_train_y <- smote_train_mtx[, label_col]
smote_train_data <- lgb.Dataset(smote_train_x, label = smote_train_y)
smote_valid_data <- lgb.Dataset.create.valid(smote_train_data, test_x, label = test_y)
smote_model <- lgb.train(
    data = smote_train_data,
    params = params,
    eval = list("binary_logloss", "auc"),
    valids = list(valid = smote_valid_data),
    nrounds = 300L
)

A funkció fontosságának meghatározása

Határozza meg a kiegyensúlyozatlan adathalmazon betanított modell funkciójának fontosságát:

imp <- lgb.importance(model, percentage = TRUE)
ggplot(imp, aes(x = Frequency, y = reorder(Feature, Frequency), fill = Frequency)) +
  scale_fill_gradient(low="steelblue", high="tomato") +
  geom_bar(stat = "identity") +
  geom_text(aes(label = sprintf("%.4f", Frequency)), hjust = -0.1) +
  theme(axis.text.x = element_text(angle = 90)) +
  xlim(0, max(imp$Frequency) * 1.1)

Képernyőkép egy sávdiagramról, amely a kiegyensúlyozatlan modell funkciójának fontosságát mutatja.

A kiegyensúlyozott (SMOTE-n keresztüli) adatkészleten betanított modell esetében számítsa ki a funkció fontosságát:

smote_imp <- lgb.importance(smote_model, percentage = TRUE)
ggplot(smote_imp, aes(x = Frequency, y = reorder(Feature, Frequency), fill = Frequency)) +
  geom_bar(stat = "identity") +
  scale_fill_gradient(low="steelblue", high="tomato") +
  geom_text(aes(label = sprintf("%.4f", Frequency)), hjust = -0.1) +
  theme(axis.text.x = element_text(angle = 90)) +
  xlim(0, max(smote_imp$Frequency) * 1.1)

Képernyőkép egy sávdiagramról, amely a kiegyensúlyozott modell funkciójának fontosságát mutatja.

Az ilyen ábrázolások összehasonlítása egyértelműen azt mutatja, hogy a kiegyensúlyozott és kiegyensúlyozatlan betanítási adathalmazok jelentős jellemzőkben jelentős különbségeket mutatnak.

A modellek kiértékelése

Itt értékelheti ki a két betanított modellt:

  • model betanítása nyers, kiegyensúlyozatlan adatokra
  • smote_model betanították kiegyensúlyozott adatokon
preds <- predict(model, test_mtx[, -label_col])
smote_preds <- predict(smote_model, test_mtx[, -label_col])

Modellteljesítmény kiértékelése keveredési mátrix használatával

A keveredési mátrix a

  • valódi pozitív értékek (TP)
  • valódi negatívok (TN)
  • hamis pozitív értékek (FP)
  • hamis negatív esetek (FN)

a modell által előállított érték, amikor tesztadatokkal értékelik. Bináris besorolás esetén a modell egy 2x2 keveredési mátrixot ad vissza. Többosztályos besorolás esetén a modell egy nxn keveredési mátrixot ad vissza, amelyben n az osztályok száma.

  1. Használjon keveredési mátrixot a betanított gépi tanulási modellek teljesítményének összegzéséhez a tesztadatokon:

    plot_cm <- function(preds, refs, title) {
    library(caret)
    cm <- confusionMatrix(factor(refs), factor(preds))
    cm_table <- as.data.frame(cm$table)
    cm_table$Prediction <- factor(cm_table$Prediction, levels=rev(levels(cm_table$Prediction)))

    ggplot(cm_table, aes(Reference, Prediction, fill = Freq)) +
            geom_tile() +
            geom_text(aes(label = Freq)) +
            scale_fill_gradient(low = "white", high = "steelblue", trans = "log") +
            labs(x = "Prediction", y = "Reference", title = title) +
            scale_x_discrete(labels=c("0", "1")) +
            scale_y_discrete(labels=c("1", "0")) +
            coord_equal() +
            theme(legend.position = "none")
}

  2. A kiegyensúlyozatlan adathalmazon betanított modell keveredési mátrixának ábrázolása:

    # The value of the prediction indicates the probability that a transaction is fraud
# Use 0.5 as the threshold for fraud/no-fraud transactions
plot_cm(ifelse(preds > 0.5, 1, 0), test_df$Class, "Confusion Matrix (Imbalanced dataset)")

    A kiegyensúlyozatlan modell keveredési mátrixának képernyőképe.

  3. Ábrázolja a kiegyensúlyozott adathalmazon betanított modell keveredési mátrixát:

    plot_cm(ifelse(smote_preds > 0.5, 1, 0), test_df$Class, "Confusion Matrix (Balanced dataset)")

    A kiegyensúlyozott modell keveredési mátrixának képernyőképe.

Modellteljesítmény kiértékelése AUC-ROC és AUPRC-mértékekkel

A görbevevő működési jellemzője (AUC-ROC) alatti terület értékeli a bináris osztályozók teljesítményét. A AUC-ROC diagram a valódi pozitív ráta (TPR) és a hamis pozitív ráta (FPR) közötti kompromisszumot jeleníti meg.

Bizonyos esetekben célszerűbb kiértékelni az osztályozót a Precision-Recall Görbe (AUPRC) mérés alapján. Az AUPRC-görbe a következő arányokat egyesíti:

  • A pontosság vagy a pozitív prediktív érték (PPV)
  • Visszahívás vagy TPR
# Use the PRROC package to help calculate and plot AUC-ROC and AUPRC
install.packages("PRROC", quiet = TRUE)
library(PRROC)

A AUC-ROC és az AUPRC-metrikák kiszámítása

A két modell AUC-ROC és AUPRC-metrikáinak kiszámítása és ábrázolása.

Kiegyensúlyozatlan adatkészlet

Az előrejelzések kiszámítása:

fg <- preds[test_df$Class == 1]
bg <- preds[test_df$Class == 0]

A AUC-ROC görbe alatti terület nyomtatása:

# Compute AUC-ROC
roc <- roc.curve(scores.class0 = fg, scores.class1 = bg, curve = TRUE)
print(roc)

Ábrázolja a AUC-ROC görbét:

# Plot AUC-ROC
plot(roc)

A kiegyensúlyozatlan modell AUC-ROC görbéjének képernyőképe.

Az AUPRC-görbe nyomtatása:

# Compute AUPRC
pr <- pr.curve(scores.class0 = fg, scores.class1 = bg, curve = TRUE)
print(pr)

Az AUPRC-görbe ábrázolása:

# Plot AUPRC
plot(pr)

Képernyőkép a kiegyensúlyozatlan modell AUPRC-görbéjéről.

Kiegyensúlyozott (SMOTE-on keresztüli) adatkészlet

Az előrejelzések kiszámítása:

smote_fg <- smote_preds[test_df$Class == 1]
smote_bg <- smote_preds[test_df$Class == 0]

A AUC-ROC görbe nyomtatása:

# Compute AUC-ROC
smote_roc <- roc.curve(scores.class0 = smote_fg, scores.class1 = smote_bg, curve = TRUE)
print(smote_roc)

Ábrázolja a AUC-ROC görbét:

# Plot AUC-ROC
plot(smote_roc)

Egy gráfról készült képernyőkép, amely mutatja a kiegyensúlyozott modell AUC-ROC görbéjét.

Az AUPRC-görbe nyomtatása:

# Compute AUPRC
smote_pr <- pr.curve(scores.class0 = smote_fg, scores.class1 = smote_bg, curve = TRUE)
print(smote_pr)

Az AUPRC-görbe ábrázolása:

# Plot AUPRC
plot(smote_pr)

Képernyőkép egy gráfról, amely a kiegyensúlyozott modell AUPRC-görbéje.

A korábbi ábrák egyértelműen azt mutatják, hogy a kiegyensúlyozott adathalmazon betanított modell felülmúlja a kiegyensúlyozatlan adatkészleten betanított modellt, mind AUC-ROC, mind az AUPRC-pontszámok esetében. Ez az eredmény arra utal, hogy az SMOTE hatékonyan javítja a modell teljesítményét a nagymértékben kiegyensúlyozatlan adatok használatakor.

Kapcsolódó tartalom

  • Last updated on