Freigeben über

Tutorial: Erstellen, Auswerten und Bewerten eines Betrugserkennungsmodells

  • Artikel

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

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:

  1. Wechseln Sie zur Synapse Data Science-Startseite.

  2. Wählen Sie Beispiel verwenden aus.

  3. 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.

  4. 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

  1. 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)

  2. Drucken Sie einige grundlegende Informationen zum Datensatz:

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

Daten transformieren

  1. 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)

  2. 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

  1. 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.

  2. 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)

  3. 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.

  1. 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)

  2. 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

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

  2. 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

  1. 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

  2. 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()

  3. 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.

  1. 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)

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

  3. 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:

  1. 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

  2. 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})

  3. 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.

Screenshot of the tracked experiment.

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

Screenshot of logged model performance metrics and model parameters.

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.

  1. 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)

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

Zugehöriger Inhalt