Lernprogramm: Erstellen, Trainieren und Bewerten eines Uplift-Modells

Artikel
02/06/2025

Dieses Lernprogramm zeigt ein End-to-End-Beispiel für einen Synapse Data Science-Workflow in Microsoft Fabric. Sie lernen, wie Sie Uplift-Modelle erstellen, trainieren und bewerten und Uplift-Modellierungstechniken anwenden.

Voraussetzungen

Erhalten Sie 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.

Vertrautheit mit Microsoft Fabric-Notizbüchern
Ein Lakehouse für dieses Notebook zum Speichern von Daten für dieses Beispiel. Weitere Informationen finden Sie unter Hinzufügen eines Seehauses zu Ihrem Notizbuch

Notebook für das Tutorial

Sie können in einem Notizbuch auf eine von zwei Arten folgen:

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

Öffnen des integrierten Notizbuchs

In diesem Tutorial wird das Beispielnotebook Uplift modeling verwendet.

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

In diesem Tutorial wird das Notebook AIsample – Uplift Modeling.ipynb verwendet.

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.

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

Fügen Sie unbedingt ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen.

Schritt 1: Laden der Daten

Datensatz

Das Criteo AI Lab hat das Dataset erstellt. Dieses Dataset verfügt über 13M-Zeilen. Jede Zeile stellt einen Benutzer dar. Jede Zeile verfügt über zwölf Features, einen Behandlungsindikator und zwei binäre Bezeichnungen, die „visit“ und „conversion“ beinhalten.

f0 – f11: Featurewerte (Dichte, Gleitkommawerte)
Behandlung: ob ein Benutzer zufällig für die Behandlung ausgewählt wurde (z. B. Werbung) (1 = Behandlung, 0 = Kontrollgruppe)
conversion: Hiermit wird angegeben, ob eine Konvertierung (z. B. Tätigung eines Kaufs) für Benutzende (binär, Kennzeichnung) aufgetreten ist.
visit: Hiermit wird angegeben, ob eine Konvertierung (z. B. Tätigung eines Kaufs) für Benutzende (binär, Kennzeichnung) aufgetreten ist.

Zitat

Datasetstartseite: https://ailab.criteo.com/criteo-uplift-prediction-dataset/

Für das für dieses Notizbuch verwendete Dataset ist dieses BibTex-Zitat erforderlich:

@inproceedings{Diemert2018,
author = {{Diemert Eustache, Betlei Artem} and Renaudin, Christophe and Massih-Reza, Amini},
title={A Large Scale Benchmark for Uplift Modeling},
publisher = {ACM},
booktitle = {Proceedings of the AdKDD and TargetAd Workshop, KDD, London,United Kingdom, August, 20, 2018},
year = {2018}
}

Tipp

Indem Sie die folgenden Parameter definieren, können Sie dieses Notizbuch ganz einfach auf verschiedene Datasets anwenden.

IS_CUSTOM_DATA = False  # If True, the user must upload the dataset manually
DATA_FOLDER = "Files/uplift-modelling"
DATA_FILE = "criteo-research-uplift-v2.1.csv"

# Data schema
FEATURE_COLUMNS = [f"f{i}" for i in range(12)]
TREATMENT_COLUMN = "treatment"
LABEL_COLUMN = "visit"

EXPERIMENT_NAME = "aisample-upliftmodelling"  # MLflow experiment name

Importieren von Bibliotheken

Vor der Verarbeitung müssen Sie erforderliche Spark- und SynapseML-Bibliotheken importieren. Sie müssen auch eine Datenvisualisierungsbibliothek importieren , z. B. Seaborn, eine Python-Datenvisualisierungsbibliothek. Eine Datenvisualisierungsbibliothek bietet eine allgemeine Schnittstelle zum Erstellen visueller Ressourcen in DataFrames und Arrays. Erfahren Sie mehr über Spark, SynapseMLund Seaborn.

import os
import gzip

import pyspark.sql.functions as F
from pyspark.sql.window import Window
from pyspark.sql.types import *

import numpy as np
import pandas as pd

import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.style as style
import seaborn as sns

%matplotlib inline

from synapse.ml.featurize import Featurize
from synapse.ml.core.spark import FluentAPI
from synapse.ml.lightgbm import *
from synapse.ml.train import ComputeModelStatistics

import mlflow

Herunterladen eines Datasets und Hochladen in Lakehouse

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

Wichtig

Stellen Sie sicher, dass Sie dem Notebook vor der Ausführung ein Lakehouse hinzufügen. Andernfalls tritt ein Fehler auf.

if not IS_CUSTOM_DATA:
    # Download demo data files into lakehouse if not exist
    import os, requests

    remote_url = "http://go.criteo.net/criteo-research-uplift-v2.1.csv.gz"
    download_file = "criteo-research-uplift-v2.1.csv.gz"
    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}/{DATA_FILE}"):
        r = requests.get(f"{remote_url}", timeout=30)
        with open(f"{download_path}/{download_file}", "wb") as f:
            f.write(r.content)
        with gzip.open(f"{download_path}/{download_file}", "rb") as fin:
            with open(f"{download_path}/{DATA_FILE}", "wb") as fout:
                fout.write(fin.read())
    print("Downloaded demo data files into lakehouse.")

Beginnen Sie mit der Aufzeichnung der Laufzeit dieses Notizbuchs.

# Record the notebook running time
import time

ts = time.time()

Einrichten der MLflow-Experimentverfolgung

Um die MLflow-Protokollierungsfunktionen zu erweitern, erfasst autologging während der Schulung automatisch die Werte von Eingabeparametern und Ausgabemetriken eines Machine Learning-Modells. Diese Informationen werden dann im Arbeitsbereich protokolliert, in dem die MLflow-APIs oder das entsprechende Experiment im Arbeitsbereich darauf zugreifen und visualisieren können. Besuchen Sie diese Ressource, um weitere Informationen zur automatischen Protokollierung zu finden.

# Set up the MLflow experiment
import mlflow

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

Anmerkung

Zum Deaktivieren der Microsoft Fabric-Autoprotokollierung in einer Notizbuchsitzung rufen Sie mlflow.autolog() auf, und legen Sie disable=Truefest.

Lesen von Daten aus dem Lakehouse

Lesen Sie Rohdaten aus dem Lakehouse Files Abschnitt und fügen Sie weitere Spalten für verschiedene Datumsteile hinzu. Die gleichen Informationen werden verwendet, um eine partitionierte Delta-Tabelle zu erstellen.

raw_df = spark.read.csv(f"{DATA_FOLDER}/raw/{DATA_FILE}", header=True, inferSchema=True).cache()

Schritt 2: Explorative Datenanalyse

Verwenden Sie den Befehl display, um allgemeine Statistiken zum Dataset anzuzeigen. Sie können auch die Diagrammansichten anzeigen, um Teilmengen des Datasets einfach zu visualisieren.

display(raw_df.limit(20))

Überprüfen Sie den Prozentsatz der Benutzer, die besucht werden, den Prozentsatz der Benutzer, die konvertiert werden, und den Prozentsatz der Besucher, die konvertiert werden.

raw_df.select(
    F.mean("visit").alias("Percentage of users that visit"),
    F.mean("conversion").alias("Percentage of users that convert"),
    (F.sum("conversion") / F.sum("visit")).alias("Percentage of visitors that convert"),
).show()

Die Analyse weist darauf hin, dass 4,9% von Benutzern aus der Behandlungsgruppe - Benutzer, die die Behandlung oder Werbung erhalten haben - den Online-Shop besucht haben. Nur 3,8% von Benutzern aus der Kontrollgruppe – Benutzer, die die Behandlung nie erhalten haben, denen sie nie angeboten wurde oder die nie der Werbung ausgesetzt wurden – haben dasselbe gemacht. Darüber hinaus haben 0,31% aller Benutzer aus der Behandlungsgruppe konvertiert oder einen Kauf getätigt, während nur 0,19% der Benutzer aus der Kontrollgruppe dies getan haben. Infolgedessen ist die Umwandlungsrate der Besucher, die einen Kauf getätigt haben, die auch Mitglieder der Behandlungsgruppe waren, 6,36%, verglichen mit nur 5,07%** für Benutzer der Kontrollgruppe. Basierend auf diesen Ergebnissen kann die Behandlung die Besuchsrate um etwa 1%verbessern und die Umwandlungsrate der Besucher um etwa 1,3%. Die Behandlung führt zu einer signifikanten Verbesserung.

Schritt 3: Definieren des Modells für Schulungen

Vorbereiten der Schulung und Testen der Datasets

Hier passen Sie einen Featurize-Transformator an das raw_df DataFrame an, um Features aus den angegebenen Eingabespalten zu extrahieren und diese Features in eine neue Spalte mit dem Namen featuresauszugeben.

Der resultierende DataFrame wird in einem neuen DataFrame mit dem Namen dfgespeichert.

transformer = Featurize().setOutputCol("features").setInputCols(FEATURE_COLUMNS).fit(raw_df)
df = transformer.transform(raw_df)

# Split the DataFrame into training and test sets, with a 80/20 ratio and a seed of 42
train_df, test_df = df.randomSplit([0.8, 0.2], seed=42)

# Print the training and test dataset sizes
print("Size of train dataset: %d" % train_df.count())
print("Size of test dataset: %d" % test_df.count())

# Group the training dataset by the treatment column, and count the number of occurrences of each value
train_df.groupby(TREATMENT_COLUMN).count().show()

Vorbereiten der Behandlungs- und Kontrolldatensätze

Nachdem Sie die Trainings- und Testdatasets erstellt haben, müssen Sie auch die Behandlungs- und Kontrolldatasets generieren, um die Machine Learning-Modelle zum Messen des Uplifts zu trainieren.

# Extract the treatment and control DataFrames
treatment_train_df = train_df.where(f"{TREATMENT_COLUMN} > 0")
control_train_df = train_df.where(f"{TREATMENT_COLUMN} = 0")

Nachdem Sie Ihre Daten vorbereitet haben, können Sie mit LightGBM ein Modell trainieren.

Upliftmodellierung: T-Learner mit LightGBM

Meta-Learners sind eine Reihe von Algorithmen, die auf Machine Learning-Algorithmen wie LightGBM und Xgboost basieren. Sie helfen bei der Schätzung des bedingten durchschnittlichen Behandlungseffekts (Conditional Average Treatment Effect, CATE). T-Learner ist ein Meta-Learner, der nicht auf ein einzelnes Modell setzt. Stattdessen verwendet T-Learner ein Modell pro Behandlungsvariable. Daher werden zwei Modelle entwickelt, und wir bezeichnen den Meta-Learner als T-Learner. T-Learner verwendet mehrere Machine Learning-Modelle, um das Problem der vollständigen Verwerfung der Behandlung zu überwinden, indem die Lernenden zuerst zu einer Aufteilung gezwungen werden.

mlflow.autolog(exclusive=False)

classifier = (
    LightGBMClassifier(dataTransferMode="bulk")
    .setFeaturesCol("features")  # Set the column name for features
    .setNumLeaves(10)  # Set the number of leaves in each decision tree
    .setNumIterations(100)  # Set the number of boosting iterations
    .setObjective("binary")  # Set the objective function for binary classification
    .setLabelCol(LABEL_COLUMN)  # Set the column name for the label
)

# Start a new MLflow run with the name "uplift"
active_run = mlflow.start_run(run_name="uplift")

# Start a new nested MLflow run with the name "treatment"
with mlflow.start_run(run_name="treatment", nested=True) as treatment_run:
    treatment_run_id = treatment_run.info.run_id  # Get the ID of the treatment run
    treatment_model = classifier.fit(treatment_train_df)  # Fit the classifier on the treatment training data

# Start a new nested MLflow run with the name "control"
with mlflow.start_run(run_name="control", nested=True) as control_run:
    control_run_id = control_run.info.run_id  # Get the ID of the control run
    control_model = classifier.fit(control_train_df)  # Fit the classifier on the control training data

Verwenden des Test-Datasets für eine Vorhersage

Hier verwenden Sie die zuvor definierten treatment_model und control_model, um den test_df-Testdatensatz zu transformieren. Anschließend berechnen Sie den vorhergesagten Auftrieb. Sie definieren den vorhergesagten Auftrieb als Unterschied zwischen dem vorhergesagten Behandlungsergebnis und dem vorhergesagten Kontrollergebnis. Je größer dieser Unterschied beim prognostizierten Anstieg ist, desto wirksamer ist die Maßnahme (z. B. Werbung) auf eine Einzelperson oder eine Untergruppe.

getPred = F.udf(lambda v: float(v[1]), FloatType())

# Cache the resulting DataFrame for easier access
test_pred_df = (
    test_df.mlTransform(treatment_model)
    .withColumn("treatment_pred", getPred("probability"))
    .drop("rawPrediction", "probability", "prediction")
    .mlTransform(control_model)
    .withColumn("control_pred", getPred("probability"))
    .drop("rawPrediction", "probability", "prediction")
    .withColumn("pred_uplift", F.col("treatment_pred") - F.col("control_pred"))
    .select(TREATMENT_COLUMN, LABEL_COLUMN, "treatment_pred", "control_pred", "pred_uplift")
    .cache()
)

# Display the first twenty rows of the resulting DataFrame
display(test_pred_df.limit(20))

Durchführen der Modellauswertung

Da der tatsächliche Auftrieb für jeden Einzelnen nicht beobachtet werden kann, müssen Sie den Auftrieb über eine Gruppe von Einzelpersonen messen. Sie verwenden eine Upliftkurve, die den tatsächlichen, kumulativen Uplift für die Population darstellt.

Die x-Achse stellt das Verhältnis der für die Behandlung ausgewählten Bevölkerung dar. Ein Wert von 0 schlägt keine Behandlungsgruppe vor - niemand wird der Behandlung ausgesetzt oder angeboten. Ein Wert von 1 weist auf eine vollständige Behandlungsgruppe hin – alle erhalten die Behandlung oder diese wird ihnen angeboten. Die y-Achse zeigt das Upliftmeasure an. Ziel ist es, die Größe der Behandlungsgruppe oder den Prozentsatz der Bevölkerung zu ermitteln, die angeboten oder der Behandlung ausgesetzt wäre (z. B. Werbung). Dieser Ansatz optimiert die Zielauswahl, um das Ergebnis zu optimieren.

Bewerten Sie zunächst die DataFrame-Testreihenfolge nach dem vorhergesagten Uplift. Der vorhergesagte Auftrieb ist der Unterschied zwischen dem vorhergesagten Behandlungsergebnis und dem vorhergesagten Kontrollergebnis.

# Compute the percentage rank of the predicted uplift values in descending order, and display the top twenty rows
test_ranked_df = test_pred_df.withColumn("percent_rank", F.percent_rank().over(Window.orderBy(F.desc("pred_uplift"))))

display(test_ranked_df.limit(20))

Berechnen Sie als Nächstes den kumulierten Prozentsatz der Besuche in den Behandlungs- und Kontrollgruppen.

# Calculate the number of control and treatment samples
C = test_ranked_df.where(f"{TREATMENT_COLUMN} == 0").count()
T = test_ranked_df.where(f"{TREATMENT_COLUMN} != 0").count()

# Add columns to the DataFrame to calculate the control and treatment cumulative sum
test_ranked_df = (
    test_ranked_df.withColumn(
        "control_label",
        F.when(F.col(TREATMENT_COLUMN) == 0, F.col(LABEL_COLUMN)).otherwise(0),
    )
    .withColumn(
        "treatment_label",
        F.when(F.col(TREATMENT_COLUMN) != 0, F.col(LABEL_COLUMN)).otherwise(0),
    )
    .withColumn(
        "control_cumsum",
        F.sum("control_label").over(Window.orderBy("percent_rank")) / C,
    )
    .withColumn(
        "treatment_cumsum",
        F.sum("treatment_label").over(Window.orderBy("percent_rank")) / T,
    )
)

# Display the first 20 rows of the dataframe
display(test_ranked_df.limit(20))

Berechnen Sie schließlich bei jedem Prozentsatz den Auftrieb der Gruppe als Differenz zwischen dem kumulierten Prozentsatz der Besuche zwischen der Behandlungs- und Kontrollgruppe.

test_ranked_df = test_ranked_df.withColumn("group_uplift", F.col("treatment_cumsum") - F.col("control_cumsum")).cache()
display(test_ranked_df.limit(20))

Zeichnen Sie nun die Aufwärtskurve für die Testdatensatzvorhersage. Sie müssen den PySpark DataFrame vor dem Zeichnen in einen Pandas DataFrame konvertieren.

def uplift_plot(uplift_df):
    """
    Plot the uplift curve
    """
    gain_x = uplift_df.percent_rank
    gain_y = uplift_df.group_uplift
    # Plot the data
    fig = plt.figure(figsize=(10, 6))
    mpl.rcParams["font.size"] = 8

    ax = plt.plot(gain_x, gain_y, color="#2077B4", label="Normalized Uplift Model")

    plt.plot(
        [0, gain_x.max()],
        [0, gain_y.max()],
        "--",
        color="tab:orange",
        label="Random Treatment",
    )
    plt.legend()
    plt.xlabel("Porportion Targeted")
    plt.ylabel("Uplift")
    plt.grid()

    return fig, ax


test_ranked_pd_df = test_ranked_df.select(["pred_uplift", "percent_rank", "group_uplift"]).toPandas()
fig, ax = uplift_plot(test_ranked_pd_df)

mlflow.log_figure(fig, "UpliftCurve.png")

Die x-Achse gibt das Verhältnis der für die Behandlung ausgewählten Bevölkerung wieder. Ein Wert von 0 schlägt keine Behandlungsgruppe vor - niemand wird der Behandlung ausgesetzt oder angeboten. Ein Wert von 1 deutet auf eine voll umfasste Behandlungsgruppe hin - alle werden der Behandlung ausgesetzt oder erhalten das Angebot zur Behandlung. Die y-Achse zeigt das Upliftmeasure an. Ziel ist es, die Größe der Behandlungsgruppe oder den Prozentsatz der Bevölkerung zu ermitteln, die angeboten oder der Behandlung ausgesetzt wäre (z. B. Werbung). Dieser Ansatz optimiert die Zielauswahl, um das Ergebnis zu optimieren.

# Compute the percentage rank of the predicted uplift values in descending order, and display the top twenty rows
test_ranked_df = test_pred_df.withColumn("percent_rank", F.percent_rank().over(Window.orderBy(F.desc("pred_uplift"))))

display(test_ranked_df.limit(20))

Berechnen Sie als Nächstes den kumulierten Prozentsatz der Besuche in den Behandlungs- und Kontrollgruppen.

# Calculate the number of control and treatment samples
C = test_ranked_df.where(f"{TREATMENT_COLUMN} == 0").count()
T = test_ranked_df.where(f"{TREATMENT_COLUMN} != 0").count()

# Add columns to the DataFrame to calculate the control and treatment cumulative sum
test_ranked_df = (
    test_ranked_df.withColumn(
        "control_label",
        F.when(F.col(TREATMENT_COLUMN) == 0, F.col(LABEL_COLUMN)).otherwise(0),
    )
    .withColumn(
        "treatment_label",
        F.when(F.col(TREATMENT_COLUMN) != 0, F.col(LABEL_COLUMN)).otherwise(0),
    )
    .withColumn(
        "control_cumsum",
        F.sum("control_label").over(Window.orderBy("percent_rank")) / C,
    )
    .withColumn(
        "treatment_cumsum",
        F.sum("treatment_label").over(Window.orderBy("percent_rank")) / T,
    )
)

# Display the first 20 rows of the dataframe
display(test_ranked_df.limit(20))

Berechnen Sie schließlich bei jedem Prozentsatz den Auftrieb der Gruppe als Differenz zwischen dem kumulierten Prozentsatz der Besuche zwischen der Behandlungs- und Kontrollgruppe.

test_ranked_df = test_ranked_df.withColumn("group_uplift", F.col("treatment_cumsum") - F.col("control_cumsum")).cache()
display(test_ranked_df.limit(20))

Zeichnen Sie nun die Aufwärtskurve für die Testdatensatzvorhersage. Sie müssen den PySpark DataFrame vor dem Zeichnen in einen Pandas DataFrame konvertieren.

def uplift_plot(uplift_df):
    """
    Plot the uplift curve
    """
    gain_x = uplift_df.percent_rank
    gain_y = uplift_df.group_uplift
    # Plot the data
    fig = plt.figure(figsize=(10, 6))
    mpl.rcParams["font.size"] = 8

    ax = plt.plot(gain_x, gain_y, color="#2077B4", label="Normalized Uplift Model")

    plt.plot(
        [0, gain_x.max()],
        [0, gain_y.max()],
        "--",
        color="tab:orange",
        label="Random Treatment",
    )
    plt.legend()
    plt.xlabel("Porportion Targeted")
    plt.ylabel("Uplift")
    plt.grid()

    return fig, ax


test_ranked_pd_df = test_ranked_df.select(["pred_uplift", "percent_rank", "group_uplift"]).toPandas()
fig, ax = uplift_plot(test_ranked_pd_df)

mlflow.log_figure(fig, "UpliftCurve.png")

Die Analyse und die Upliftkurve zeigen beide, dass die oberen 20 Prozent der Population gemäß Einstufung im Rahmen der Vorhersage einen großen Zuwachs aufweisen würden, wenn sie die Behandlung erhalten würden. Dies bedeutet, dass die obersten 20 Prozent der Bevölkerung die Gruppe der überzeugbaren Personen („Persuadables“) darstellen. Daher können Sie dann den Cutoff-Wert für die gewünschte Größe der Behandlungsgruppe auf 20%festlegen, um die Zielauswahlkunden für die größte Wirkung zu identifizieren.

cutoff_percentage = 0.2
cutoff_score = test_ranked_pd_df.iloc[int(len(test_ranked_pd_df) * cutoff_percentage)][
    "pred_uplift"
]

print("Uplift scores that exceed {:.4f} map to Persuadables.".format(cutoff_score))
mlflow.log_metrics(
    {"cutoff_score": cutoff_score, "cutoff_percentage": cutoff_percentage}
)

Schritt 4: Registrieren des endgültigen ML-Modells

Sie verwenden MLflow zum Nachverfolgen und Protokollieren aller Experimente für Behandlungs- und Kontrollgruppen. Diese Nachverfolgung und Protokollierung umfassen die entsprechenden Parameter, Metriken und Modelle. Diese Informationen werden unter dem Namen des Experiments im Arbeitsbereich zur späteren Verwendung protokolliert.

# Register the model
treatment_model_uri = "runs:/{}/model".format(treatment_run_id)
mlflow.register_model(treatment_model_uri, f"{EXPERIMENT_NAME}-treatmentmodel")

control_model_uri = "runs:/{}/model".format(control_run_id)
mlflow.register_model(control_model_uri, f"{EXPERIMENT_NAME}-controlmodel")

mlflow.end_run()

Zeigen Sie Ihre Experimente wie folgt an:

Wählen Sie im linken Bereich Ihren Arbeitsbereich aus.
Suchen Sie nach dem Experimentnamen (in diesem Fall aisample-upliftmodelling), und wählen Sie ihn aus.

Schritt 5: Speichern der Vorhersageergebnisse

Microsoft Fabric bietet PREDICT - eine skalierbare Funktion, die das Batch-Scoring in jedem Rechenmodul unterstützt. Sie ermöglicht es Kunden, Machine Learning-Modelle zu operationalisieren. Benutzer können Batchvorhersagen direkt aus einem Notizbuch oder der Elementseite für ein bestimmtes Modell erstellen. Besuchen Sie diese Ressource, um mehr über PREDICT zu erfahren und zu erfahren, wie SIE PREDICT in Microsoft Fabric verwenden.

# Load the model back
loaded_treatmentmodel = mlflow.spark.load_model(treatment_model_uri, dfs_tmpdir="Files/spark")
loaded_controlmodel = mlflow.spark.load_model(control_model_uri, dfs_tmpdir="Files/spark")

# Make predictions
batch_predictions_treatment = loaded_treatmentmodel.transform(test_df)
batch_predictions_control = loaded_controlmodel.transform(test_df)
batch_predictions_treatment.show(5)

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

# Determine the entire runtime
print(f"Full run cost {int(time.time() - ts)} seconds.")

Freigeben über

Lernprogramm: Erstellen, Trainieren und Bewerten eines Uplift-Modells

Voraussetzungen

Notebook für das Tutorial

Öffnen des integrierten Notizbuchs

Importieren des Notizbuchs aus GitHub

Schritt 1: Laden der Daten

Datensatz

Zitat

Importieren von Bibliotheken

Herunterladen eines Datasets und Hochladen in Lakehouse

Einrichten der MLflow-Experimentverfolgung

Lesen von Daten aus dem Lakehouse

Schritt 2: Explorative Datenanalyse

Schritt 3: Definieren des Modells für Schulungen

Vorbereiten der Schulung und Testen der Datasets

Vorbereiten der Behandlungs- und Kontrolldatensätze

Upliftmodellierung: T-Learner mit LightGBM

Verwenden des Test-Datasets für eine Vorhersage

Durchführen der Modellauswertung

Schritt 4: Registrieren des endgültigen ML-Modells

Schritt 5: Speichern der Vorhersageergebnisse

Feedback

Zusätzliche Ressourcen

Freigeben über

Lernprogramm: Erstellen, Trainieren und Bewerten eines Uplift-Modells

Voraussetzungen

Notebook für das Tutorial

Öffnen des integrierten Notizbuchs

Importieren des Notizbuchs aus GitHub

Schritt 1: Laden der Daten

Datensatz

Zitat

Importieren von Bibliotheken

Herunterladen eines Datasets und Hochladen in Lakehouse

Einrichten der MLflow-Experimentverfolgung

Lesen von Daten aus dem Lakehouse

Schritt 2: Explorative Datenanalyse

Schritt 3: Definieren des Modells für Schulungen

Vorbereiten der Schulung und Testen der Datasets

Vorbereiten der Behandlungs- und Kontrolldatensätze

Upliftmodellierung: T-Learner mit LightGBM

Verwenden des Test-Datasets für eine Vorhersage

Durchführen der Modellauswertung

Schritt 4: Registrieren des endgültigen ML-Modells

Schritt 5: Speichern der Vorhersageergebnisse

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen