Lernprogramm: Erstellen, Bewerten und Auswerten eines Betrugserkennungsmodells

Artikel
01/31/2025

Dieses Lernprogramm zeigt ein End-to-End-Beispiel für einen Synapse Data Science-Workflow in Microsoft Fabric. Das Szenario erstellt ein Betrugserkennungsmodell mit Machine Learning-Algorithmen, die auf historischen Daten trainiert wurden. Anschließend wird das Modell verwendet, um zukünftige betrügerische Transaktionen zu erkennen.

In diesem Lernprogramm werden die folgenden Schritte behandelt:

Installieren von benutzerdefinierten Bibliotheken
Laden der Daten
Verstehen und Verarbeiten der Daten durch explorative Datenanalyse
Verwenden sie scikit-learn, um ein Machine Learning-Modell zu trainieren und Experimente mit den Features MLflow und Fabric Autologging nachzuverfolgen
Speichern und Registrieren des Machine Learning-Modells mit der höchsten Leistung
Laden des Machine Learning-Modells zum Bewerten und Erstellen von Vorhersagen

Voraussetzungen

Holen Sie sich ein Microsoft Fabric-Abonnement. Oder registrieren Sie sich für eine kostenlose Microsoft Fabric-Testversion.
Melden Sie sich bei Microsoft Fabrican.
Verwenden Sie den Erfahrungsschalter auf der unteren linken Seite Ihrer Startseite, um zu Fabric zu wechseln.

Erstellen Sie bei Bedarf ein Microsoft Fabric Lakehouse, wie in Erstellen eines Lakehouses in Microsoft Fabricbeschrieben.

Ein Notebook für das Tutorial

Sie können eine der folgenden Optionen wählen, um ein Notebook für das Tutorial zu verwenden.

Öffnen sie das integrierte Notizbuch, und führen Sie es aus.
Laden Sie Ihr Notizbuch von GitHub hoch.

Öffnen des integrierten Notizbuchs

Das Beispielnotebook für Betrugserkennung begleitet dieses Tutorial.

Um das Beispielnotizbuch für dieses Lernprogramm zu öffnen, befolgen Sie die Anweisungen in Vorbereiten Ihres Systems für Data Science-Lernprogramme.
Fügen Sie ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen.

Importieren des Notizbuchs aus GitHub

Das Beispielnotebook AIsample - Fraud Detection.ipynb begleitet dieses Tutorial.

Zum Öffnen des zugehörigen Notizbuchs für dieses Lernprogramm folgen Sie den Anweisungen in Vorbereiten Ihres Systems für Data Science-Lernprogramme, um das Notizbuch in Ihren Arbeitsbereich zu importieren.
Wenn Sie den Code lieber von dieser Seite kopieren und einfügen möchten, können Sie ein neues Notizbucherstellen.
Fügen Sie unbedingt ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen.

Schritt 1: Installieren von benutzerdefinierten Bibliotheken

Für die Entwicklung von Machine Learning-Modell oder ad-hoc-Datenanalysen müssen Sie möglicherweise schnell eine benutzerdefinierte Bibliothek für Ihre Apache Spark-Sitzung installieren. Sie haben zwei Optionen zum Installieren von Bibliotheken.

Verwenden Sie die Inlineinstallationsfunktionen (%pip oder %conda) Ihres Notizbuchs, um eine Bibliothek nur in Ihrem aktuellen Notizbuch zu installieren.
Alternativ können Sie eine Fabric-Umgebung erstellen, Bibliotheken aus öffentlichen Quellen installieren oder benutzerdefinierte Bibliotheken darauf hochladen, und dann kann Ihr Arbeitsbereichsadministrator die Umgebung als Standard für den Arbeitsbereich anfügen. Alle Bibliotheken in der Umgebung werden dann für die Verwendung in allen Notizbüchern und Spark-Auftragsdefinitionen im Arbeitsbereich verfügbar. Weitere Informationen zu Umgebungen finden Sie unter Erstellen, Konfigurieren und Verwenden einer Umgebung in Microsoft Fabric.

Verwenden Sie für dieses Lernprogramm %pip install, um die imblearn-Bibliothek in Ihrem Notizbuch zu installieren.

Anmerkung

Der PySpark-Kernel wird neu gestartet, nachdem %pip install ausgeführt wurde. Installieren Sie die erforderlichen Bibliotheken, bevor Sie andere Zellen ausführen.

# Use pip to install imblearn
%pip install imblearn

Schritt 2: Laden der Daten

Das Datenset zur Betrugserkennung enthält Kreditkartentransaktionen ab September 2013, die europäische Karteninhaber im Laufe von zwei Tagen getätigt haben. Das Dataset enthält nur numerische Features, da eine PCA-Transformation (Principal Component Analysis) auf die ursprünglichen Features angewendet wurde. PCA hat alle Features mit Ausnahme von Time und Amounttransformiert. Um die Vertraulichkeit zu schützen, können wir die ursprünglichen Features oder mehr Hintergrundinformationen zum Dataset nicht bereitstellen.

Diese Details beschreiben das Dataset:

Die V1, V2, V3, ..., V28 Merkmale sind die Hauptkomponenten, die durch PCA gewonnen werden.
Das feature Time enthält die verstrichenen Sekunden zwischen einer Transaktion und der ersten Transaktion im Dataset.
Das Merkmal Amount ist der Transaktionsbetrag. Sie können diese Funktion für beispielabhängiges, kostensensitives Lernen verwenden.
Die spalte Class ist die Antwortvariable (Zielvariable). Sie hat den Wert 1 für Betrug, andernfalls 0

Nur 492 Transaktionen, von 284.807 Transaktionen insgesamt, sind betrügerisch. Das Dataset ist sehr unausgeglichen, da die Minderheitsklasse (betrügerische) nur etwa 0,172% der Daten ausmacht.

Diese Tabelle zeigt eine Vorschau der creditcard.csv Daten:

Zeit	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	Betrag	Klasse
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"

Laden Sie das Dataset herunter und laden Sie es in das Seehaus hoch.

Definieren Sie diese Parameter, damit Sie dieses Notizbuch mit verschiedenen Datasets verwenden können:

IS_CUSTOM_DATA = False  # If True, the dataset has to be uploaded manually

TARGET_COL = "Class"  # Target column name
IS_SAMPLE = False  # If True, use only <SAMPLE_ROWS> 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_FOLDER = "Files/fraud-detection/"  # Folder with data files
DATA_FILE = "creditcard.csv"  # Data file name

EXPERIMENT_NAME = "aisample-fraud"  # MLflow experiment name

Dieser Code lädt eine öffentlich verfügbare Version des Datasets herunter und speichert sie dann in einem Fabric Lakehouse.

Wichtig

Denken Sie daran, ein Lakehouse zum Notebook hinzuzufügen, bevor Sie es ausführen. Andernfalls wird eine Fehlermeldung angezeigt.

if not IS_CUSTOM_DATA:
    # Download data files into the lakehouse if they're not already there
    import os, requests

    remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/Credit_Card_Fraud_Detection"
    fname = "creditcard.csv"
    download_path = f"/lakehouse/default/{DATA_FOLDER}/raw"

    if not os.path.exists("/lakehouse/default"):
        raise FileNotFoundError("Default lakehouse not found, please add a lakehouse and restart the session.")
    os.makedirs(download_path, exist_ok=True)
    if not os.path.exists(f"{download_path}/{fname}"):
        r = requests.get(f"{remote_url}/{fname}", timeout=30)
        with open(f"{download_path}/{fname}", "wb") as f:
            f.write(r.content)
    print("Downloaded demo data files into lakehouse.")

Einrichten der MLflow-Experimentnachverfolgung

Der Experimentverfolgungsprozess speichert alle relevanten experimentbezogenen Informationen für jedes experimentbezogene Experiment, das Sie ausführen. Manchmal haben Sie keine Möglichkeit, bessere Ergebnisse zu erzielen, wenn Sie ein bestimmtes Experiment ausführen. In diesen Fällen sollten Sie das Experiment beenden und ein neues ausprobieren.

Die Data Science-Erfahrung von Synapse in Microsoft Fabric enthält ein Feature für die automatische Protokollierung. Dieses Feature reduziert die Menge an Code, die zum automatischen Protokollieren der Parameter, Metriken und Elemente eines Machine Learning-Modells während der Schulung erforderlich ist. Das Feature erweitert die Automatischprotokollierungsfunktionen von MLflow. Sie verfügt über eine tiefe Integration in die Data Science-Erfahrung.

Mit der automatischen Protokollierung können Sie die Leistung verschiedener Modelle und Experimente ganz einfach nachverfolgen und vergleichen, ohne dass die manuelle Nachverfolgung erforderlich ist. Weitere Informationen finden Sie unter Autologging in Microsoft Fabric.

Zum Deaktivieren der automatischen Protokollierung in Microsoft Fabric während einer Notizbuchsitzung, rufen Sie mlflow.autolog() auf und legen Sie disable=Truefest.

# Set up MLflow for experiment tracking
import mlflow

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True)  # Disable MLflow autologging

Lesen von Rohdaten aus dem Lakehouse

Dieser Code liest Rohdaten aus dem Seehaus:

df = (
    spark.read.format("csv")
    .option("header", "true")
    .option("inferSchema", True)
    .load(f"{DATA_FOLDER}/raw/{DATA_FILE}")
    .cache()
)

Schritt 3: Durchführen einer explorativen Datenanalyse

In diesem Abschnitt untersuchen Sie zunächst die Rohdaten und allgemeine Statistiken. Um die Daten zu transformieren, wandeln Sie die Spalten in die richtigen Typen um, und konvertieren Sie sie aus dem Spark DataFrame in einen Pandas DataFrame, um die Visualisierung zu vereinfachen. Schließlich untersuchen und visualisieren Sie die Klassenverteilungen in den Daten.

Anzeigen der Rohdaten

Erkunden Sie die Rohdaten, und zeigen Sie allgemeine Statistiken mit dem Befehl display an. Weitere Informationen zur Datenvisualisierung finden Sie unter Notizbuchvisualisierung in Microsoft Fabric.
```
display(df)
```

Drucken Sie einige grundlegende Informationen zum Dataset:

# Print dataset basic information
print("records read: " + str(df.count()))
print("Schema: ")
df.printSchema()

Transformieren der Daten

Wandeln Sie die Datensatzspalten in die richtigen Typen um.

import pyspark.sql.functions as F

df_columns = df.columns
df_columns.remove(TARGET_COL)

# Ensure that TARGET_COL is the last column
df = df.select(df_columns + [TARGET_COL]).withColumn(TARGET_COL, F.col(TARGET_COL).cast("int"))

if IS_SAMPLE:
    df = df.limit(SAMPLE_ROWS)

Konvertieren Sie den Spark DataFrame in einen Pandas DataFrame, um die Visualisierung und Verarbeitung zu vereinfachen:
```
df_pd = df.toPandas()
```

Erkunden der Klassenverteilung im Dataset

Zeigen Sie die Klassenverteilung im Dataset an:
```
# The distribution of classes in the dataset
print('No Frauds', round(df_pd['Class'].value_counts()[0]/len(df_pd) * 100,2), '% of the dataset')
print('Frauds', round(df_pd['Class'].value_counts()[1]/len(df_pd) * 100,2), '% of the dataset')
```
Der Code gibt diese Datasetklassenverteilung zurück: 99,83% No Frauds und 0,17% Frauds. Diese Klassenverteilung zeigt, dass die meisten Transaktionen nicht betrügend sind. Daher ist die Vorverarbeitung von Daten vor der Modellschulung erforderlich, um eine Überanpassung zu vermeiden.

Verwenden Sie ein Diagramm, um das Klassenungleichgewicht in den Daten darzustellen, indem Sie die Verteilung der betrügerischen und nicht-betrügerischen Transaktionen anzeigen.

import seaborn as sns
import matplotlib.pyplot as plt

colors = ["#0101DF", "#DF0101"]
sns.countplot(x='Class', data=df_pd, palette=colors) 
plt.title('Class Distributions \n (0: No Fraud || 1: Fraud)', fontsize=10)

Zeige die fünfzahlige Zusammenfassung (Mindestwert, erstes Quartil, Median, drittes Quartil und Maximalwert) für den Transaktionsbetrag mit Box-Plots an.
```
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,5))
s = sns.boxplot(ax = ax1, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=True) # Remove outliers from the plot
s = sns.boxplot(ax = ax2, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=False) # Keep outliers from the plot
plt.show()
```
Bei stark ungleichgewichtierten Daten zeigen Boxplots möglicherweise keine genauen Erkenntnisse. Sie können jedoch zuerst das Class Ungleichgewichtsproblem behandeln und dann dieselben Plots erstellen, um genauere Erkenntnisse zu erhalten.

Schritt 4: Trainieren und Bewerten der Modelle

Hier trainieren Sie ein LightGBM-Modell, um die Betrugstransaktionen zu klassifizieren. Sie trainieren ein LightGBM-Modell sowohl für das ungleichgewichtierte Dataset als auch für das ausgewogene Dataset. Anschließend vergleichen Sie die Leistung beider Modelle.

Vorbereiten von Schulungs- und Testdatensätzen

Teilen Sie vor dem Training die Daten in die Schulungs- und Testdatensets auf:

# Split the dataset into training and testing sets
from sklearn.model_selection import train_test_split

train, test = train_test_split(df_pd, test_size=0.15)
feature_cols = [c for c in df_pd.columns.tolist() if c not in [TARGET_COL]]

Anwenden von SMOTE auf das Schulungsdatenset

Die bibliothek imblearn verwendet den SMOTE-Ansatz (Synthetic Minority Oversampling Technique), um das Problem der Ungleichgewichtklassifizierung zu beheben. Die ungleichgewichtige Klassifikation erfolgt, wenn zu wenige Beispiele für die Minderheitsklasse verfügbar sind, damit ein Modell die Entscheidungsgrenze effektiv erlernen kann. SMOTE ist der am häufigsten verwendete Ansatz, um neue Proben für die Minderheitsklasse zu synthetisieren.

Wenden Sie SMOTE nur auf das Schulungsdatenset anstelle des Testdatensatzes an. Wenn Sie das Modell mit den Testdaten bewerten, benötigen Sie eine Annäherung an die Leistung des Modells für unbekannte Daten in der Produktion. Bei einer gültigen Annäherung basieren Ihre Testdaten auf der ursprünglichen Ungleichgewichtverteilung, um Produktionsdaten so genau wie möglich darzustellen.

# Apply SMOTE to the training data
import pandas as pd
from collections import Counter
from imblearn.over_sampling import SMOTE

X = train[feature_cols]
y = train[TARGET_COL]
print("Original dataset shape %s" % Counter(y))

sm = SMOTE(random_state=42)
X_res, y_res = sm.fit_resample(X, y)
print("Resampled dataset shape %s" % Counter(y_res))

new_train = pd.concat([X_res, y_res], axis=1)

Weitere Informationen zu SMOTE finden Sie auf der scikit-learn-Referenzseite für die SMOTE-Methode und im scikit-learn-Benutzerhandbuch zum Übersampling.

Trainieren von Machine Learning-Modellen und Ausführen von Experimenten

Apache Spark, in Microsoft Fabric, ermöglicht maschinelles Lernen mit Big Data. Mit Apache Spark erhalten Sie wertvolle Einblicke aus großen Mengen strukturierter, unstrukturierter und schneller Daten.

Sie haben mehrere verfügbare Optionen zum Trainieren von Machine Learning-Modellen mit Apache Spark in Microsoft Fabric: Apache Spark MLlib, SynapseML und anderen Open-Source-Bibliotheken. Weitere Informationen finden Sie unter Trainieren von Machine Learning-Modellen in Microsoft Fabric.

Ein Machine Learning Experiment dient als primäre Einheit der Organisation und Kontrolle für alle zugehörigen Machine Learning-Ausführungen. Ein Lauf entspricht einer einzelnen Ausführung des Modellcodes. Machine Learning Experimentverfolgung umfasst die Verwaltung aller Experimente und deren Komponenten, z. B. Parameter, Metriken, Modelle und andere Artefakte.

Zum Nachverfolgen von Experimenten können Sie alle erforderlichen Komponenten eines bestimmten maschinellen Lernexperiments organisieren. Darüber hinaus können Sie frühere Ergebnisse mit gespeicherten Experimenten problemlos reproduzieren. Weitere Informationen zu Machine Learning-Experimenten finden Sie unter Maschinelle Lernexperimente in Microsoft Fabric.

Um mehr Metriken, Parameter und Dateien zu verfolgen, setzen Sie exclusive=False, um die MLflow-Autoprotokollierungskonfiguration zu aktualisieren.
```
mlflow.autolog(exclusive=False)
```

Trainieren Sie zwei Modelle mit LightGBM. Ein Modell behandelt das ungleichgewichtige Dataset und das andere Modell behandelt das ausgewogene Dataset (über SMOTE). Vergleichen Sie dann die Leistung der beiden Modelle.

import lightgbm as lgb

model = lgb.LGBMClassifier(objective="binary") # Imbalanced dataset
smote_model = lgb.LGBMClassifier(objective="binary") # Balanced dataset

# Train LightGBM for both imbalanced and balanced datasets and define the evaluation metrics
print("Start training with imbalanced data:\n")
with mlflow.start_run(run_name="raw_data") as raw_run:
    model = model.fit(
        train[feature_cols],
        train[TARGET_COL],
        eval_set=[(test[feature_cols], test[TARGET_COL])],
        eval_metric="auc",
        callbacks=[
            lgb.log_evaluation(10),
        ],
    )

print(f"\n\nStart training with balanced data:\n")
with mlflow.start_run(run_name="smote_data") as smote_run:
    smote_model = smote_model.fit(
        new_train[feature_cols],
        new_train[TARGET_COL],
        eval_set=[(test[feature_cols], test[TARGET_COL])],
        eval_metric="auc",
        callbacks=[
            lgb.log_evaluation(10),
        ],
    )

Ermitteln Sie die Merkmalswichtigkeit für die Schulung

Bestimmen Sie die Feature-Wichtigkeit für das Modell, das Sie auf dem ungleichgewichtierten Dataset trainiert haben:

with mlflow.start_run(run_id=raw_run.info.run_id):
    importance = lgb.plot_importance(
        model, title="Feature importance for imbalanced data"
    )
    importance.figure.savefig("feauture_importance.png")
    mlflow.log_figure(importance.figure, "feature_importance.png")

Ermitteln Sie die Feature-Wichtigkeit für das Modell, das Sie für ausgewogene Daten trainiert haben. SMOTE generierte die ausgewogenen Daten:

with mlflow.start_run(run_id=smote_run.info.run_id):
    smote_importance = lgb.plot_importance(
        smote_model, title="Feature importance for balanced (via SMOTE) data"
    )
    smote_importance.figure.savefig("feauture_importance_smote.png")
    mlflow.log_figure(smote_importance.figure, "feauture_importance_smote.png")

Um ein Modell mit dem ungleichgewichtierten Dataset zu trainieren, weisen die wichtigen Merkmale erhebliche Unterschiede im Vergleich zu einem Modell auf, das mit dem ausgewogenen Dataset trainiert wurde.

Modelle auswerten

Hier bewerten Sie die beiden trainierten Modelle:

model mit unausgeglichenen Rohdaten trainiert
smote_model mit ausgeglichenen Rohdaten trainiert

Berechnen von Modellmetriken

Definieren Sie eine prediction_to_spark-Funktion, die Vorhersagen ausführt, und konvertiert die Vorhersageergebnisse in einen Spark DataFrame. Anschließend können Sie Modellstatistiken zu den Vorhersageergebnissen mit SynapseML-berechnen.

from pyspark.sql.functions import col
from pyspark.sql.types import IntegerType, DoubleType

def prediction_to_spark(model, test):
    predictions = model.predict(test[feature_cols], num_iteration=model.best_iteration_)
    predictions = tuple(zip(test[TARGET_COL].tolist(), predictions.tolist()))
    dataColumns = [TARGET_COL, "prediction"]
    predictions = (
        spark.createDataFrame(data=predictions, schema=dataColumns)
        .withColumn(TARGET_COL, col(TARGET_COL).cast(IntegerType()))
        .withColumn("prediction", col("prediction").cast(DoubleType()))
    )

    return predictions

Verwenden Sie die prediction_to_spark-Funktion, um Vorhersagen mit den beiden Modellen model und smote_modeldurchzuführen:

predictions = prediction_to_spark(model, test)
smote_predictions = prediction_to_spark(smote_model, test)
predictions.limit(10).toPandas()

Berechnen von Metriken für die beiden Modelle:

from synapse.ml.train import ComputeModelStatistics

metrics = ComputeModelStatistics(
    evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
).transform(predictions)

smote_metrics = ComputeModelStatistics(
    evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction"
).transform(smote_predictions)
display(metrics)

Modellleistung mit einer Verwirrungsmatrix bewerten

Eine Konfusionsmatrix zeigt die Anzahl von

True Positive-Ergebnissen (TP)
True Negative-Ergebnissen (TN)
False Positive-Ergebnissen (FP)
False Negative-Ergebnissen (FN)

das ein Modell erzeugt, wenn es mit Testdaten bewertet wird. Bei der binären Klassifizierung gibt das Modell eine 2x2 Verwirrungsmatrix zurück. Bei der Klassifizierung mehrerer Klassen gibt das Modell eine nxn Verwirrungsmatrix zurück, wobei n die Anzahl der Klassen ist.

Verwenden Sie eine Verwirrungsmatrix, um die Leistungen der trainierten Machine Learning-Modelle für die Testdaten zusammenzufassen:

# Collect confusion matrix values
cm = metrics.select("confusion_matrix").collect()[0][0].toArray()
smote_cm = smote_metrics.select("confusion_matrix").collect()[0][0].toArray()
print(cm)

Stellen Sie die Konfusionsmatrix für die Vorhersagen von smote_model (trainiert für ausgeglichene Daten) graphisch dar:

# Plot the confusion matrix
import seaborn as sns

def plot(cm):
    """
    Plot the confusion matrix.
    """
    sns.set(rc={"figure.figsize": (5, 3.5)})
    ax = sns.heatmap(cm, annot=True, fmt=".20g")
    ax.set_title("Confusion Matrix")
    ax.set_xlabel("Predicted label")
    ax.set_ylabel("True label")
    return ax

with mlflow.start_run(run_id=smote_run.info.run_id):
    ax = plot(smote_cm)
    mlflow.log_figure(ax.figure, "ConfusionMatrix.png")

Erstellen Sie die Konfusionsmatrix für die Vorhersagen von model (trainiert auf rohen, unausgeglichenen Daten).

with mlflow.start_run(run_id=raw_run.info.run_id):
    ax = plot(cm)
    mlflow.log_figure(ax.figure, "ConfusionMatrix.png")

Bewerten der Modellleistung mit AUC-ROC- und AUPRC-Measures

Das Measure AUC-ROC (Area Under the Curve Receiver Operating Characteristic) bewertet die Leistung binärer Klassifizierer zu bewerten. Das diagramm AUC-ROC visualisiert den Kompromiss zwischen der tatsächlich positiven Rate (TPR) und der falsch positiven Rate (FPR).

In einigen Fällen ist es sinnvoller, den Klassifizierer basierend auf dem Maß "Fläche unter der Precision-Recall Kurve (AUPRC)" zu bewerten. Die AUPRC-Kurve kombiniert diese Raten:

Die Genauigkeit oder der positive Vorhersagewert (PPV)
Der Recall, oder TPR

Um die Leistung mit den AUC-ROC- und AUPRC-Maßstäben zu bewerten:

Definieren Sie eine Funktion, die die AUC-ROC- und AUPRC-Measures zurückgibt:

from pyspark.ml.evaluation import BinaryClassificationEvaluator

def evaluate(predictions):
    """
    Evaluate the model by computing AUROC and AUPRC with the predictions.
    """

    # Initialize the binary evaluator
    evaluator = BinaryClassificationEvaluator(rawPredictionCol="prediction", labelCol=TARGET_COL)

    _evaluator = lambda metric: evaluator.setMetricName(metric).evaluate(predictions)

    # Calculate AUROC, baseline 0.5
    auroc = _evaluator("areaUnderROC")
    print(f"The AUROC is: {auroc:.4f}")

    # Calculate AUPRC, baseline positive rate (0.172% in the data)
    auprc = _evaluator("areaUnderPR")
    print(f"The AUPRC is: {auprc:.4f}")

    return auroc, auprc

Protokollieren Sie die AUC-ROC- und AUPRC-Metriken für das Modell, das Sie auf ungleichgewichtigen Daten trainiert haben:

with mlflow.start_run(run_id=raw_run.info.run_id):
    auroc, auprc = evaluate(predictions)
    mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
    mlflow.log_params({"Data_Enhancement": "None", "DATA_FILE": DATA_FILE})

Protokollieren Sie die AUC-ROC- und AUPRC-Metriken für das Modell, das Sie für ausgewogene Daten trainiert haben:

with mlflow.start_run(run_id=smote_run.info.run_id):
    auroc, auprc = evaluate(smote_predictions)
    mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc})
    mlflow.log_params({"Data_Enhancement": "SMOTE", "DATA_FILE": DATA_FILE})

Das Modell, das auf den ausgeglichenen Daten trainiert wurde, gibt höhere AUC-ROC und AUPRC-Werte im Vergleich zum Modell zurück, das auf die ungleichgewichtigen Daten trainiert wurde. Basierend auf diesen Maßnahmen scheint SMOTE ein effektives Verfahren zur Verbesserung der Modellleistung bei der Arbeit mit stark ungleichgewichtierten Daten zu sein.

Wie die nächste Abbildung zeigt, wird jedes Experiment mit seinem jeweiligen Namen protokolliert. Sie können die Experimentparameter und Leistungsmetriken in Ihrem Arbeitsbereich nachverfolgen.

Diese Abbildung zeigt die Leistungsmetriken für das Modell, das auf dem ausgewogenen Dataset trainiert wurde (in Version 2):

Sie können Version 1 auswählen, um die Metriken für das Modell anzuzeigen, das auf dem ungleichgewichtierten Dataset trainiert wurde. Wenn Sie die Metriken vergleichen, ist der AUROC für das Modell, das mit dem ausgewogenen Dataset trainiert wurde, höher. Diese Ergebnisse deuten darauf hin, dass dieses Modell besser geeignet ist, 0 Klassen als 0vorherzusagen und 1 Klassen als 1vorherzusagen.

Schritt 5: Registrieren der Modelle

Verwenden Sie MLflow, um die beiden Modelle zu registrieren:

# Register the model
registered_model_name = f"{EXPERIMENT_NAME}-lightgbm"

raw_model_uri = "runs:/{}/model".format(raw_run.info.run_id)
mlflow.register_model(raw_model_uri, registered_model_name)

smote_model_uri = "runs:/{}/model".format(smote_run.info.run_id)
mlflow.register_model(smote_model_uri, registered_model_name)

Schritt 6: Speichern der Vorhersageergebnisse

Microsoft Fabric ermöglicht Es Benutzern, Machine Learning-Modelle mit der PREDICT skalierbaren Funktion zu operationalisieren. Diese Funktion unterstützt das Batch-Scoring (oder Stapelinferenzierung) in jeder Rechen-Engine.

Sie können Batchvorhersagen direkt aus dem Microsoft Fabric-Notizbuch oder von der Elementseite eines Modells generieren. Weitere Informationen zu PREDICTfinden Sie unter Modellbewertung mit PREDICT in Microsoft Fabric.

Laden Sie das leistungsstärkere Modell (Version 2) für die Batchbewertung, und generieren Sie die Vorhersageergebnisse:

from synapse.ml.predict import MLFlowTransformer

spark.conf.set("spark.synapse.ml.predict.enabled", "true")

model = MLFlowTransformer(
    inputCols=feature_cols,
    outputCol="prediction",
    modelName=f"{EXPERIMENT_NAME}-lightgbm",
    modelVersion=2,
)

test_spark = spark.createDataFrame(data=test, schema=test.columns.to_list())

batch_predictions = model.transform(test_spark)

Speichern von Vorhersagen im Lakehouse:

# Save the predictions to the lakehouse
batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")

Teilen über

Lernprogramm: Erstellen, Bewerten und Auswerten eines Betrugserkennungsmodells

Voraussetzungen

Ein Notebook für das Tutorial

Öffnen des integrierten Notizbuchs

Importieren des Notizbuchs aus GitHub

Schritt 1: Installieren von benutzerdefinierten Bibliotheken

Schritt 2: Laden der Daten

Laden Sie das Dataset herunter und laden Sie es in das Seehaus hoch.

Einrichten der MLflow-Experimentnachverfolgung

Lesen von Rohdaten aus dem Lakehouse

Schritt 3: Durchführen einer explorativen Datenanalyse

Anzeigen der Rohdaten

Transformieren der Daten

Erkunden der Klassenverteilung im Dataset

Schritt 4: Trainieren und Bewerten der Modelle

Vorbereiten von Schulungs- und Testdatensätzen

Anwenden von SMOTE auf das Schulungsdatenset

Trainieren von Machine Learning-Modellen und Ausführen von Experimenten

Ermitteln Sie die Merkmalswichtigkeit für die Schulung

Modelle auswerten

Berechnen von Modellmetriken

Modellleistung mit einer Verwirrungsmatrix bewerten

Bewerten der Modellleistung mit AUC-ROC- und AUPRC-Measures

Schritt 5: Registrieren der Modelle

Schritt 6: Speichern der Vorhersageergebnisse

Feedback

Zusätzliche Ressourcen

Teilen über

Lernprogramm: Erstellen, Bewerten und Auswerten eines Betrugserkennungsmodells

Voraussetzungen

Ein Notebook für das Tutorial

Öffnen des integrierten Notizbuchs

Importieren des Notizbuchs aus GitHub

Schritt 1: Installieren von benutzerdefinierten Bibliotheken

Schritt 2: Laden der Daten

Laden Sie das Dataset herunter und laden Sie es in das Seehaus hoch.

Einrichten der MLflow-Experimentnachverfolgung

Lesen von Rohdaten aus dem Lakehouse

Schritt 3: Durchführen einer explorativen Datenanalyse

Anzeigen der Rohdaten

Transformieren der Daten

Erkunden der Klassenverteilung im Dataset

Schritt 4: Trainieren und Bewerten der Modelle

Vorbereiten von Schulungs- und Testdatensätzen

Anwenden von SMOTE auf das Schulungsdatenset

Trainieren von Machine Learning-Modellen und Ausführen von Experimenten

Ermitteln Sie die Merkmalswichtigkeit für die Schulung

Modelle auswerten

Berechnen von Modellmetriken

Modellleistung mit einer Verwirrungsmatrix bewerten

Bewerten der Modellleistung mit AUC-ROC- und AUPRC-Measures

Schritt 5: Registrieren der Modelle

Schritt 6: Speichern der Vorhersageergebnisse

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen