Tutorial Teil 4: Durchführen des Batch-Scorings und Speichern von Vorhersagen in einem Lakehouse

In diesem Lernprogramm wird gezeigt, wie Sie das registrierte LightGBMClassifier-Modell importieren, das Sie in Teil 3 erstellt haben. In diesem Lernprogramm wurde das MLflow Modellregister von Microsoft Fabric verwendet, um das Modell zu trainieren und anschließend Batchvorhersagen für ein Test-Dataset durchzuführen, das aus einem Lakehouse geladen wurde.

Mit Microsoft Fabric können Sie Machine Learning-Modelle mit der skalierbaren VORHERSAGE-Funktion operationalisieren. Diese Funktion unterstützt die Bewertung von Datensätzen in jeder Berechnungs-Engine. Sie können Batchvorhersagen direkt aus einem Microsoft Fabric-Notizbuch oder von der Elementseite eines bestimmten Modells generieren. Weitere Informationen zur PROGNOSE-Funktion finden Sie in dieser Ressource.

Verwenden Sie Version 1 des trainierten LightGBM-Modells, um Batchvorhersagen für das Test-Dataset zu generieren. Diese Version zeigte die beste Leistung bei allen trainierten Machine Learning-Modellen. Sie laden das Test-Dataset in einen Spark DataFrame und erstellen ein MLFlowTransformer-Objekt, um Batchvorhersagen zu generieren. Anschließend können Sie die VORHERSAGE-Funktion mit einer der folgenden Techniken aufrufen:

• Transformator-API von SynapseML
• Spark SQL-API
• Benutzerdefinierte PySpark-Funktion (UDF)

Voraussetzungen

• Erhalten Sie ein Microsoft Fabric-Abonnement. Oder registrieren Sie sich für eine kostenlose Microsoft Fabric-Testversion.

• Melden Sie sich bei Microsoft Fabrican.

• Wechseln Sie zu Fabric, indem Sie den Benutzeroberflächenschalter auf der unteren linken Seite Ihrer Startseite verwenden.

  

Dies ist Teil 4 einer fünfteiligen Lernprogrammreihe. Um dieses Lernprogramm abzuschließen, müssen Sie zuerst Folgendes erledigen:

• Teil 1: Einspeisen von Daten in ein Microsoft Fabric Lakehouse mit Apache Spark.
• Teil 2: Erkunden und Visualisieren von Daten mithilfe von Microsoft Fabric-Notizbüchern, um mehr über die Daten zu erfahren.
• Teil 3: Trainieren und Registrieren von Machine Learning Modellen.

Notebook für das Tutorial

4-predict.ipynb ist das Notizbuch, das dieses Lernprogramm begleitet.

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

Wichtig

Fügen Sie dasselbe Seehaus an, das Sie in den anderen Teilen dieser Serie verwendet haben.

Laden der Testdaten

Laden Sie im folgenden Codeausschnitt die Testdaten, die Sie in Teil 3 gespeichert haben:

df_test = spark.read.format("delta").load("Tables/df_test")
display(df_test)

VORHERSAGEN mit der Transformator-API

Um die Transformator-API von SynapseML zu verwenden, müssen Sie zuerst ein MLFlowTransformer-Objekt erstellen.

Instanziieren des MLFlowTransformer-Objekts

Das MLFlowTransformer -Objekt dient als Wrapper um das MLFlow-Modell, das Sie in Teil 3 registriert haben. Es ermöglicht Ihnen, Batchvorhersagen für einen bestimmten DataFrame zu generieren. Um das MLFlowTransformer-Objekt zu instanziieren, müssen Sie die folgenden Parameter angeben:

• Die DataFrame-Testspalten, die das Modell als Eingabe benötigt (in diesem Fall benötigt das Modell alle)
• Ein Name für die neue Ausgabespalte (in diesem Fall Vorhersagen)
• Der richtige Modellname und die Modellversion zum Generieren der Vorhersagen (in diesem Fall lgbm_sm und Version 1)

Der folgende Codeausschnitt behandelt die folgenden Schritte:

from synapse.ml.predict import MLFlowTransformer

model = MLFlowTransformer(
    inputCols=list(df_test.columns),
    outputCol='predictions',
    modelName='lgbm_sm',
    modelVersion=1
)

Nachdem Sie nun über das MLFlowTransformer-Objekt verfügen, können Sie es verwenden, um Batchvorhersagen zu generieren, wie im folgenden Codeausschnitt gezeigt:

import pandas

predictions = model.transform(df_test)
display(predictions)

VORHERSAGEN mit der Spark SQL-API

Der folgende Codeausschnitt verwendet die Spark SQL-API, um die PROGNOSE-Funktion aufzurufen:

from pyspark.ml.feature import SQLTransformer 

# Substitute "model_name", "model_version", and "features" below with values for your own model name, model version, and feature columns
model_name = 'lgbm_sm'
model_version = 1
features = df_test.columns

sqlt = SQLTransformer().setStatement( 
    f"SELECT PREDICT('{model_name}/{model_version}', {','.join(features)}) as predictions FROM __THIS__")

# Substitute "X_test" below with your own test dataset
display(sqlt.transform(df_test))

PREDICT mit einer benutzerdefinierten Funktion (UDF)

Der folgende Codeausschnitt verwendet einen PySpark UDF, um die PROGNOSE-Funktion aufzurufen:

from pyspark.sql.functions import col, pandas_udf, udf, lit

# Substitute "model" and "features" below with values for your own model name and feature columns
my_udf = model.to_udf()
features = df_test.columns

display(df_test.withColumn("predictions", my_udf(*[col(f) for f in features])))

Sie können auch VORHERSAGE-Code von der Elementseite eines Modells generieren. Weitere Informationen zur PROGNOSE-Funktion finden Sie in dieser Ressource.

Schreiben von Modellvorhersageergebnissen in das Lakehouse

Nachdem Sie Batchvorhersagen generiert haben, schreiben Sie die Modellvorhersageergebnisse zurück in das Lakehouse, wie im folgenden Codebeispiel dargestellt.

# Save predictions to lakehouse to be used for generating a Power BI report
table_name = "customer_churn_test_predictions"
predictions.write.format('delta').mode("overwrite").save(f"Tables/{table_name}")
print(f"Spark DataFrame saved to delta table: {table_name}")

Nächster Schritt

Weiter zu:

Teil 5: Erstellen eines Power BI-Berichts zum Visualisieren von Vorhersagen