Tutorial: Erstellen, Auswerten und Bewerten eines Betrugserkennungsmodells

Artikel
02/01/2024

Dieses Tutorial stellt ein umfassendes Beispiel für einen Synapse-Data Science-Workflow in Microsoft Fabric vor. Dieses Szenario erstellt ein Betrugserkennungsmodell mithilfe von maschinellen Lernalgorithmen, die auf historische Daten trainiert wurden. Anschließend wird das Modell verwendet, um zukünftige betrügerische Transaktionen zu erkennen.

Dieses Tutorial umfasst die folgenden Schritte:

Installieren von benutzerdefinierten Bibliotheken
Laden der Daten
Verstehen und Verarbeiten der Daten durch explorative Datenanalyse
Trainieren eines Machine Learning-Modells mit Scikit-Learn und Nachverfolgen von Experimenten mit den automatischen Protokollierungsfunktionen von MLflow und Fabric
Speichern und Registrieren des Machine Learning-Modells mit der höchsten Leistung
Laden des Machine Learning-Modells zum Bewerten und Erstellen von Vorhersagen

Voraussetzungen

Erwerben Sie ein Microsoft Fabric-Abonnement. Registrieren Sie sich alternativ für eine kostenlose Microsoft Fabric-Testversion.
Melden Sie sich bei Microsoft Fabric an.
Wechseln Sie mithilfe des Umschalters für die Benutzeroberfläche auf der linken Seite Ihrer Startseite zur Synapse Data Science-Umgebung.

Erstellen Sie bei Bedarf ein Microsoft Fabric-Lakehouse, wie in Erstellen eines Lakehouse in Microsoft Fabric beschrieben.

Notebook für das Tutorial

Für das Notebook können Sie eine der folgenden Optionen wählen:

Öffnen Sie das integrierte Notebook in der Data Science-Umgebung, und führen Sie es aus
Laden Sie Ihr Notebook von GitHub in die Data Science-Umgebung hoch

Öffnen des integrierten Notebooks

Das Beispiel Betrugserkennung ist das Notebook, das dieses Tutorial begleitet.

So öffnen Sie das integrierte Beispiel-Notebook für das Tutorial in der Synapse Data Science-Umgebung:

Wechseln Sie zur Synapse Data Science-Startseite.
Wählen Sie Beispiel verwenden aus.
Wählen Sie das zugehörige Beispiel aus:
- Wählen Sie es auf der Standardregisterkarte End-to-End-Workflows (Python) aus, wenn es sich bei dem Beispiel um ein Python-Tutorial handelt.
- Wählen Sie es auf der Registerkarte End-to-End-Workflows (R) aus, wenn es sich bei dem Beispiel um ein R-Tutorial handelt.
- Wählen Sie es auf der Registerkarte Schnelltutorials aus, wenn es sich bei dem Beispiel um ein Schnelltutorial handelt.
Fügen Sie ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen.

Importieren des Notebooks von GitHub

AIsample - Fraud Detection.ipynb ist das Notebook, das dieses Tutorial begleitet.

Befolgen Sie zum Öffnen des zugehörigen Notebooks für dieses Tutorial die Anweisungen unter Vorbereiten Ihres Systems für Data Science-Tutorials zum Importieren des Notebooks in Ihren Arbeitsbereich.

Wenn Sie den Code lieber von dieser Seite kopieren und einfügen möchten, können Sie auch ein neues Notebook erstellen.

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 eines Machine Learning-Modells oder für Ad-hoc-Datenanalysen müssen Sie u. U. schnell eine benutzerdefinierte Bibliothek für Ihre Apache Spark-Sitzung installieren. Sie haben zwei Optionen zum Installieren von Bibliotheken.

Verwenden Sie die Inline-Installationsfunktionen (%pip oder %conda) Ihres Notebooks zum Erstellen einer Bibliothek nur in Ihrem aktuellen Notebook.
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 Notebooks 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 Tutorial %pip install zum Installieren der imblearn-Bibliothek in Ihrem Notebook.

Hinweis

Der PySpark-Kernel startet neu, nachdem %pip install gelaufen ist. Installieren Sie die benötigten Bibliotheken, bevor Sie andere Zellen ausführen.

# Use pip to install imblearn
%pip install imblearn

Schritt 2: Laden der Daten

Das Dataset zur Betrugserkennung enthält Kreditkartentransaktionen vom September 2013, die europäische Karteninhaber im Laufe von zwei Tagen getätigt haben. Das Dataset enthält nur numerische Features, weil eine PCA-Transformation (Principal Component Analysis) auf die ursprünglichen Features angewendet wurde. Die PCA hat alle Features mit Ausnahme von Time und Amount umgewandelt. Zum Schutz der Vertraulichkeit können wir weder die ursprünglichen Features noch weitere Hintergrundinformationen zu den Daten zur Verfügung stellen.

Diese Details beschreiben das Dataset:

Die Features V1, V2, V3, ..., V28 sind die Hauptkomponenten, die mit PCA abgerufen werden
Das Feature Time enthält die Sekunden, die zwischen der jeweiligen Transaktion und der ersten Transaktion im Dataset vergangen sind
Das Feature Amount ist der Transaktionsbetrag. Sie können dieses Feature für beispielabhängiges kostensensitives Lernen verwenden
Die Spalte Class ist die Antwortvariable (Zielvariable). Sie hat den Wert 1 für Betrug und andernfalls den Wert 0

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

Diese Tabelle zeigt eine Vorschau der creditcard.csv-Daten:

Time	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"

Herunterladen des Datensatzes und Hochladen in Lakehouse

Durch Definieren dieser Parameter können Sie dieses Notebook auf verschiedene Datasets anwenden:

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 ihn 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 Prozess der Experimentnachverfolgung speichert alle relevanten experimentbezogenen Informationen für jedes ausgeführte Experiment. Manchmal haben Sie beim Ausführen eines bestimmten Experiments keine Möglichkeit, bessere Ergebnisse zu erzielen. In diesen Fällen sollten Sie das Experiment beenden und es mit einem neuen versuchen.

Die Synapse Data Science-Umgebung in Microsoft Fabric enthält ein Feature für die automatische Protokollierung. Dieses Feature reduziert die Menge an erforderlichem Code erheblich, um die Parameter, Metriken und Elemente eines Machine Learning-Modells während des Trainings automatisch zu protokollieren. Das Feature erweitert die automatischen Protokollierungsfunktionen von MLflow. Es ist eng in die Data Science-Umgebung integriert.

Mit der automatischen Protokollierung kann man die Leistung verschiedener Modelle und Experimente problemlos nachverfolgen, ohne dass eine manuelle Nachverfolgung erforderlich ist. Weitere Informationen finden Sie unter Automatische Protokollierung in Microsoft Fabric.

Rufen Sie zum Deaktivieren der automatischen Microsoft Fabric-Protokollierung in einer Notebooksitzung mlflow.autolog() auf und legen Sie disable=True fest:

# 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 Lakehouse:

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 allgemeinen Statistiken. Dann wandeln Sie zum Transformieren der Daten die Spalten in die richtigen Typen um und konvertieren sie aus einem Spark-DataFrame in einen Pandas-DataFrame, um die Visualisierung zu vereinfachen. Schließlich untersuchen und visualisieren Sie die Klassenverteilungen in den Daten.

Rohdaten anzeigen

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

Drucken Sie einige grundlegende Informationen zum Datensatz:

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

Daten transformieren

Wandeln Sie die Spalten des Datasets 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()
```

Untersuchen der Klassenverteilung im Datensatz

Zeigt die Klassenverteilung im Datensatz 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 Klassenverteilung des Datasets zurück: 99,83 % No Frauds und 0,17 % Frauds. Diese Klassenverteilung zeigt, dass die meisten Transaktionen nicht betrugsfrei sind. Daher ist eine Datenvorverarbeitung vor dem Modelltraining erforderlich, um eine Überanpassung zu vermeiden.

Verwenden Sie ein Diagramm, um das Klassenungleichgewicht im Datensatz anzuzeigen, indem Sie die Verteilung betrügerischer und nicht betrügerischer 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)

Zeigen Sie die fünfzahlige Zusammenfassung (Mindestbewertung, erstes Quartil, Median, drittes Quartil und maximale Punktzahl) für den Transaktionsbetrag mit Boxplots 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 unausgeglichenen Daten zeigen diese Boxplots möglicherweise keine genauen Erkenntnisse. Sie können jedoch zuerst das Problem des Class-Ungleichgewichts beheben und dann dieselben Diagramme erstellen, um genauere Erkenntnisse zu erhalten.

Schritt 4: Trainieren und Auswerten der Modelle

Hier trainieren Sie ein LightGBM-Modell zum Klassifizieren betrügerischer Transaktionen. Sie trainieren ein LightGBM-Modell sowohl für das unausgeglichene Dataset als auch für das ausgeglichene Dataset. Anschließend vergleichen Sie die Leistung beider Modelle.

Erstellen von Trainings- und Testdatensätzen

Teilen Sie die Daten vor dem Training in die Trainings- und Testdatensätze 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 die Trainingsdaten

Die imblearn-Bibliothek verwendet den SMOTE-Ansatz (Synthetic Minority Oversampling Technique), um das Problem der unausgeglichenen Klassifizierung anzugehen. Eine unausgewogene Klassifizierung tritt auf, wenn es zu wenige Beispiele für die Minderheitsklasse für ein Modell gibt, um die Entscheidungsgrenze effektiv zu erlernen. SMOTE ist der am häufigsten verwendete Ansatz, um neue Stichproben für die Minderheitenklasse zu synthetisieren.

Wenden Sie SMOTE nur auf das Trainingsdataset und nicht auf das Testdataset 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. Für eine fundierte Annäherung stützen sich Ihre Testdaten auf die ursprüngliche unausgeglichene Verteilung, um die Produktionsdaten so genau wie möglich abzubilden.

# 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 können Sie wertvolle Erkenntnisse aus großen Mengen strukturierter, unstrukturierter und sich schnell verändernder Daten gewinnen.

Beim Trainieren von Machine Learning-Modellen mit Apache Spark in Microsoft Fabric gibt es mehrere Optionen: Apache Spark MLlib, SynapseML und andere 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 für die Organisation und Steuerung aller zugehörigen Machine Learning-Ausführungen. Eine Ausführung entspricht einer einzelnen Ausführung des Modellcodes. Die Nachverfolgung von Machine Learning-Experimenten beinhaltet die Verwaltung aller Experimente und ihrer Komponenten, z. B. Parameter, Metriken, Modelle und anderer Artefakte.

Für die Experimentverfolgung können Sie alle erforderlichen Komponenten eines bestimmten maschinellen Lernexperiments organisieren. Darüber hinaus können Sie mit gespeicherten Experimenten auch frühere Ergebnisse problemlos reproduzieren. Weitere Informationen über Experimente mit maschinellem Lernen finden Sie unter Experimente mit maschinellem Lernen in Microsoft Fabric.

Legen Sie zum Aktualisieren Sie der Konfiguration für die automatische Protokollierung von MLflow exclusive=False fest, um weitere Metriken, Parameter und Dateien nachzuverfolgen:
```
mlflow.autolog(exclusive=False)
```

Trainieren Sie zwei Modelle mit LightGBM. Ein Modell behandelt das unausgeglichene Dataset und das andere Modell das ausgeglichene 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),
        ],
    )

Bestimmen der Featurerelevanz für das Training

Bestimmen Sie die Featurerelevanz für das Modell, das Sie für den unausgeglichenen Datensatz 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")

Bestimmen Sie die Featurerelevanz für das Modell, das Sie mit den ausgeglichenen Daten trainiert haben. SMOTE hat die ausgeglichenen Daten generiert:

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")

Beim Trainieren eines Modells mit dem unausgeglichenen Dataset weisen die wichtigen Features erhebliche Unterschiede zu einem Modell auf, das mit dem ausgeglichenen Dataset trainiert wurde.

Auswerten der Modelle

Hier werten Sie die beiden trainierten Modelle aus:

model mit unausgeglichenen Rohdaten trainiert
smote_model mit ausgeglichenen Rohdaten trainiert

Metriken des Computemodells

Definieren Sie eine Funktion prediction_to_spark, die Vorhersagen ausführt und die Vorhersageergebnisse in einen Spark-DataFrame konvertiert. Sie können dann Modellstatistiken für die Vorhersageergebnisse 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_model auszuführen:

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

Berechnet 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)

Bewerten der Modellleistung mit einer Wahrheitsmatrix

Eine Konfusionsmatrix enthält die Anzahl von

True Positives (TP)
True Negatives (TN)
False Positives (FP)
False Negatives (FN)

die ein Modell bei der Bewertung mit Testdaten erzeugt. Bei der Binärklassifizierung gibt das Modell eine 2x2-Konfusionsmatrix aus. Bei der Klassifizierung mit mehreren Klassen gibt das Modell eine nxn-Konfusionsmatrix aus, wobei n die Anzahl der Klassen ist.

Verwenden Sie eine Wahrheitsmatrix, um die Leistung 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 Wahrheitsmatrix 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")

Stellen Sie die Wahrheitsmatrix für die Vorhersagen von model (trainiert auf rohen, unausgeglichenen Daten) graphisch dar:

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 Area Under the Curve Receiver Operating Characteristic (AUC-ROC) bewertet die Leistung binärer Klassifizierer. Das AUC-ROC-Diagramm, visualisiert den Kompromiss zwischen der True-Positive-Rate (TPR) und der False-Positive-Rate (FPR).

In einigen Fällen empfiehlt es sich, den Klassifizierer basierend auf dem AUPRC-Measure (Area Under the Precision-Recall Curve) zu bewerten. Die AUPRC-Kurve kombiniert diese Raten kombiniert:

Die Genauigkeit, oder positiver Vorhersagewert (PPV)
Der Recall oder TPR

Um die Leistung mit den AUC-ROC- und AUPRC-Measures zu bewerten:

Definieren Sie eine Funktion, welche die Measures AUC-ROC und AUPRC 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 mit unausgeglichenen 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 mit ausgeglichenen 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 mit den ausgeglichenen Daten trainiert wurde, gibt höhere AUC-ROC- und AUPRC-Werte im Vergleich zum Modell zurück, das mit den unausgeglichenen Daten trainiert wurde. Basierend auf diesen Measures scheint SMOTE ein effektives Verfahren zur Verbesserung der Modellleistung bei der Arbeit mit stark unausgeglichenen Daten zu sein.

Wie in der nächsten Abbildung dargestellt, wird jedes Experiment zusammen mit seinem jeweiligen Namen protokolliert. Sie können die Parameter und Leistungsmetriken des Experiments in Ihrem Arbeitsbereich nachverfolgen.

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

Sie können Version 1 auswählen, um die Metriken für das Modell anzuzeigen, das für den unausgeglichenen Datensatz trainiert wurde. Beim Vergleich der Metriken ist AUROC für das Modell, das mit dem ausgeglichenen Dataset trainiert wurde, höher. Diese Ergebnisse deuten darauf hin, dass dieses Modell besser zur Vorhersage von 0-Klassen als 0 und besser zur Vorhersage von 1-Klassen als 1 geeignet ist.

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 erlaubt es Benutzern, Machine Learning-Modelle mit der skalierbaren Funktion PREDICT zu operationalisieren. Diese Funktion unterstützt die Batchbewertung (oder den Batchrückschluss) in jeder Compute-Engine.

Man kann Batchvorhersagen direkt über ein Microsoft Fabric-Notebook oder die Elementseite eines Modells generieren. Weitere Informationen PREDICT finden Sie unter Modellbewertung mit PREDICT in Microsoft Fabric.

Laden Sie das Modell mit der besseren Leistung (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 der Vorhersagen im Lakehouse:

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

Freigeben über

Tutorial: Erstellen, Auswerten und Bewerten eines Betrugserkennungsmodells

Voraussetzungen

Notebook für das Tutorial

Öffnen des integrierten Notebooks

Importieren des Notebooks von GitHub

Schritt 1: Installieren von benutzerdefinierten Bibliotheken

Schritt 2: Laden der Daten

Herunterladen des Datensatzes und Hochladen in Lakehouse

Einrichten der MLflow-Experimentnachverfolgung

Lesen von Rohdaten aus dem Lakehouse

Schritt 3: Durchführen einer explorativen Datenanalyse

Rohdaten anzeigen

Daten transformieren

Untersuchen der Klassenverteilung im Datensatz

Schritt 4: Trainieren und Auswerten der Modelle

Erstellen von Trainings- und Testdatensätzen

Anwenden von SMOTE auf die Trainingsdaten

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

Bestimmen der Featurerelevanz für das Training

Auswerten der Modelle

Metriken des Computemodells

Bewerten der Modellleistung mit einer Wahrheitsmatrix

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

Schritt 5: Registrieren der Modelle

Schritt 6: Speichern der Vorhersageergebnisse

Feedback

Zusätzliche Ressourcen

Freigeben über

Tutorial: Erstellen, Auswerten und Bewerten eines Betrugserkennungsmodells

Voraussetzungen

Notebook für das Tutorial

Öffnen des integrierten Notebooks

Importieren des Notebooks von GitHub

Schritt 1: Installieren von benutzerdefinierten Bibliotheken

Schritt 2: Laden der Daten

Herunterladen des Datensatzes und Hochladen in Lakehouse

Einrichten der MLflow-Experimentnachverfolgung

Lesen von Rohdaten aus dem Lakehouse

Schritt 3: Durchführen einer explorativen Datenanalyse

Rohdaten anzeigen

Daten transformieren

Untersuchen der Klassenverteilung im Datensatz

Schritt 4: Trainieren und Auswerten der Modelle

Erstellen von Trainings- und Testdatensätzen

Anwenden von SMOTE auf die Trainingsdaten

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

Bestimmen der Featurerelevanz für das Training

Auswerten der Modelle

Metriken des Computemodells

Bewerten der Modellleistung mit einer Wahrheitsmatrix

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

Schritt 5: Registrieren der Modelle

Schritt 6: Speichern der Vorhersageergebnisse

Zugehöriger Inhalt

Feedback

Zusätzliche Ressourcen