Tutorial: Erstellen, Trainieren und Auswerten eines Upliftmodells

  • Artikel

In diesem Tutorial wird ein End-to-End-Beispiel für einen Synapse Data Science-Workflow in Microsoft Fabric vorgestellt. Sie erfahren, wie Sie Upliftmodelle erstellen, trainieren und auswerten und Upliftmodellierungstechniken anwenden.

Voraussetzungen

Notebook für das Tutorial

Sie können in einem Notebook eine von zwei Methoden befolgen:

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

Öffnen des integrierten Notebooks

Das Beispielnotebook für die Uplift-Modellierung liegt diesem Tutorial bei. Besuchen Sie Um das integrierte Beispiel-Notizbuch des Tutorials in Synapse Data Science zu öffnen:1. Wechseln Sie zur Synapse Data Science-Startseite. 1. Wählen Sie Beispiel verwenden aus. 1. Wählen Sie das entsprechende Beispiel aus:* Auf der Standard-Registerkarte End-to-End-Workflows (Python), wenn das Beispiel für ein Python-Tutorial ist. * 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 Schnelltutorial aus, wenn es sich bei dem Beispiel um ein Schnelltutorial handelt.1. Fügen Sie ein Lakehouse an das Notebook an, bevor Sie mit der Ausführung von Code beginnen. für weitere Informationen zum Zugriff auf integrierte Beispiel-Notebooks für Lernprogramme.

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:

    1. Wählen Sie es auf der Standardregisterkarte End-to-End-Workflows (Python) aus, wenn es sich bei dem Beispiel um ein Python-Tutorial handelt
    2. Wählen Sie es auf der Registerkarte End-to-End-Workflows (R) aus, wenn es sich bei dem Beispiel um ein R-Tutorial handelt
    3. Wählen Sie es auf der Registerkarte Schnelltutorial 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

Das Notebook AIsample – Uplift Modeling.ipynb begleitet dieses Tutorial.

Um das zugehörige Notebook für dieses Tutorial zu öffnen, befolgen Sie die Anweisungen unter Vorbereiten Ihres Systems für Data-Science-Tutorials zum Importieren des Notebooks in Ihren Arbeitsbereich.

Sie können ein neues Notebook erstellen, wenn Sie lieber den Code 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

Dataset

Das Criteo AI Lab hat den Datensatz erstellt. Dieser Datensatz hat 13 Millionen Zeilen. Jede Zeile stellt einen Benutzer dar. Jede Zeile besteht aus 12 Merkmalen, einem Behandlungsindikator und zwei binären Etiketten, die Besuch und Umwandlung enthalten.

f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 Behandlungskonvertierung

  • f0 – f11: Featurewerte (dichte, gleitende Werte)
  • Behandlung: Gibt an, ob ein Benutzer zufällig auf die Behandlung ausgerichtet war (z. B. Werbung) (1 = Behandlung, 0 = Kontrolle)
  • Konvertierung: Gibt an, ob eine Konvertierung aufgetreten ist (z. B. einen Kauf getätigt) für einen Benutzer (binär, Bezeichnung)
  • Besuch: Gibt an, ob eine Konvertierung (z. B. ein Kauf) für einen Benutzer stattgefunden hat (binär, Etikett)

Quellenangaben

Der für dieses Notebook verwendete Datensatz erfordert dieses BibTex-Zitat:

@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

Durch Definieren der folgenden Parameter können Sie dieses Notebook problemlos 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

Importbibliotheken

Vor der Verarbeitung müssen Sie die erforderlichen Spark- und SynapseML-Bibliotheken importieren. Sie müssen auch eine Datenvisualisierungsbibliothek importieren, zum Beispiel Seaborn, eine Python-Datenvisualisierungsbibliothek. Eine Datenvisualisierungsbibliothek bietet eine High-Level-Schnittstelle zur Erstellung visueller Ressourcen auf DataFrames und Arrays. Erfahren Sie mehr über Spark, SynapseML und 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

Fügen Sie ein Lakehouse zum Notebook hinzu, bevor Sie ihn ausführen. Andernfalls kommt es zu einem Fehler.

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

Starten Sie die Aufzeichnung der Laufzeit, die zum Ausführen dieses Notebooks benötigt wird.

# Record the notebook running time
import time

ts = time.time()

Einrichten der MLflow-Experimentnachverfolgung

Zur Erweiterung der MLflow-Protokollierungs-Funktionen erfasst das Autologging automatisch die Werte von Eingabeparametern und Ausgabemetriken eines Machine Learning-Modells während seines Trainings. Diese Informationen werden dann im Arbeitsbereich protokolliert, wo sie mithilfe der MLflow-APIs oder der entsprechenden Experimente im Arbeitsbereich angezeigt und visualisiert werden 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

Hinweis

Um die automatische Microsoft Fabric-Protokollierung in einer Notebooksitzung zu deaktivieren, rufen Sie mlflow.autolog() auf und legen Sie disable=True fest.

Lesen von Daten aus dem Lakehouse

Lesen Sie die Rohdaten aus dem Abschnitt Dateien des Lakehouse und fügen Sie weitere Spalten für verschiedene Datumsbereiche hinzu. Dieselben Informationen werden zum Erstellen einer partitionierten Delta-Tabelle verwendet.

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

Schritt 2: Explorative Datenanalyse

Verwenden Sie den display Befehl, um Statistiken über den Datensatz auf höchster Ebene anzuzeigen. Sie können außerdem die Chart-Ansichten anzeigen, um Teilmengen des DataSets einfach zu visualisieren.

display(raw_df.limit(20))

Untersuchen Sie den Prozentsatz der Besucher, den Prozentsatz der Nutzer, die konvertieren, und den Prozentsatz der Besucher, die konvertieren.

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 % der Benutzer aus der Behandlungsgruppe – Benutzer, die die Behandlung erhalten haben oder Werbung – den Online-Store besucht haben. Nur 3,8 % der Benutzer aus der Kontrollgruppe – Benutzer, die nie die Behandlung erhalten oder nie angeboten oder Werbung ausgesetzt wurden – haben dasselbe getan. Darüber hinaus wurden 0,31 % aller Benutzer aus der Behandlungsgruppe konvertiert oder gekauft – während nur 0,19 % der Benutzer aus der Kontrollgruppe dies getan haben. Infolgedessen beträgt 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 % und die Umwandlungsrate der Besucher um etwa 1,3 % verbessern. Die Behandlung führt zu einer signifikanten Verbesserung.

Schritt 3: Entwickeln und Trainieren des Modells

Bereiten Sie das Traning vor und testen Sie die DataSets

Hier passen Sie einen Featurize-Transformator an den 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 df gespeichert.

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

Bereiten Sie die DataSets für die Behandlung und Kontrolle vor

Nachdem Sie das und die Test-DataSets erstellt haben, müssen Sie auch die Behandlungs- und Kontrolldatensätze bilden, um die Machine-Learning-Modelle zur Messung 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-Learner sind eine Reihe von Algorithmen, die auf Algorithmen für maschinelles Lernen wie LightGBM, Xgboost usw. aufbauen. Sie helfen bei der Schätzung des bedingten durchschnittlichen Behandlungseffekts oder CATE. T-Learner ist ein Meta-Learner, der nicht nur ein einziges Modell verwendet. Stattdessen verwendet T-Learner ein Modell pro Behandlungsvariable. Daher werden zwei Modelle entwickelt und wir bezeichnen den Metalerner als T-Learner. T-Learner verwendet mehrere Machine Learning-Modelle, um das Problem des vollständigen Verwerfens der Behandlung zu überwinden, indem der Lerner gezwungen wird, sie zunächst aufzuteilen.

mlflow.autolog(exclusive=False)

classifier = (
    LightGBMClassifier()
    .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 Sie den Testdatensatz für eine Vorhersage

Hier verwenden Sie das treatment_model und control_model, die beide zuvor definiert wurden, um den test_df-Testdatensatz zu transformieren. Anschließend berechnen Sie den vorhergesagten Uplift. Sie definieren den vorhergesagten Uplift als die Differenz zwischen dem vorhergesagten Behandlungsergebnis und dem vorhergesagten Kontrollergebnis. Je größer dieser vorhergesagte Unterschied ist, desto größer ist die Wirksamkeit der Behandlung (z. B. der Werbung) für eine Person 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 Uplift nicht für jeden Einzelnen beobachtet werden kann, müssen Sie den Uplift über eine Gruppe von Personen messen. Sie verwenden eine Uplift-Kurve, die den realen, kumulativen Uplift in der Bevölkerung aufzeigt.

Screenshot eines Diagramms, das eine normalisierte Uplift-Modellkurve im Vergleich zu einer zufälligen Behandlung zeigt.

Die x-Achse stellt den Anteil der für die Behandlung ausgewählten Bevölkerung dar. Ein Wert von 0 bedeutet, dass es keine Behandlungsgruppe gibt – niemand ist der Behandlung ausgesetzt oder bekommt sie angeboten. Ein Wert von 1 deutet auf eine vollständige Behandlungsgruppe hin – jeder ist der Behandlung ausgesetzt bzw. bekommt sie angeboten. Die y-Achse zeigt das Maß für den Uplift. Ziel ist es, die Größe der Behandlungsgruppe zu ermitteln, d. h. den Prozentsatz der Bevölkerung, der der Behandlung (z. B. durch Werbung) ausgesetzt ist oder angeboten wird. Dieser Ansatz optimiert die Zielauswahl, um das Ergebnis zu optimieren.

Ordnen Sie zunächst die Reihenfolge der Test-DataFrames nach dem vorhergesagten Uplift. Der vorhergesagte Uplift ist die Differenz 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 dann den kumulativen Prozentsatz der Besuche in der Behandlungs- und der Kontrollgruppe.

# 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 Uplift der Gruppe als Differenz zwischen dem kumulativen Prozentsatz der Besuche zwischen der Behandlungs- und der 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 Uplift-Kurve für die Vorhersage des Testdatensatzes. Sie müssen den PySpark-DataFrame vor dem Zeichnen in einen Panda 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")

Screenshot eines Diagramms, das eine normalisierte Uplift-Modellkurve im Vergleich zu einer zufälligen Behandlung zeigt.

Die x-Achse stellt den Anteil der für die Behandlung ausgewählten Bevölkerung dar. Ein Wert von 0 bedeutet, dass es keine Behandlungsgruppe gibt – niemand ist der Behandlung ausgesetzt oder bekommt sie angeboten. Ein Wert von 1 deutet auf eine vollständige Behandlungsgruppe hin – jeder ist der Behandlung ausgesetzt bzw. bekommt sie angeboten. Die y-Achse zeigt das Maß für den Uplift. Ziel ist es, die Größe der Behandlungsgruppe zu ermitteln, d. h. den Prozentsatz der Bevölkerung, der der Behandlung (z. B. durch Werbung) ausgesetzt ist oder angeboten wird. Dieser Ansatz optimiert die Zielauswahl, um das Ergebnis zu optimieren.

Ordnen Sie zunächst die Reihenfolge der Test-DataFrames nach dem vorhergesagten Uplift. Der vorhergesagte Uplift ist die Differenz 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 dann den kumulativen Prozentsatz der Besuche in der Behandlungs- und der Kontrollgruppe.

# 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 Uplift der Gruppe als Differenz zwischen dem kumulativen Prozentsatz der Besuche zwischen der Behandlungs- und der 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 Uplift-Kurve für die Vorhersage des Testdatensatzes. Sie müssen den PySpark-DataFrame vor dem Zeichnen in einen Panda 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")

Screenshot eines Diagramms, das eine normalisierte Uplift-Modellkurve im Vergleich zu einer zufälligen Behandlung zeigt.

Sowohl die Analyse als auch die Uplift-Kurve zeigen, dass die obersten 20 % der Bevölkerung gemäß der Vorhersage einen großen Gewinn haben würden, wenn sie die Behandlung erhielten. Das bedeutet, dass die oberen 20 % der Bevölkerung die Gruppe der Überzeugungstäter darstellen. Daher können Sie die Trennungswertbewertung für die gewünschte Größe der Zielgruppe auf 20 % festlegen, um die Zielkunden 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, um alle Experimente sowohl für die Behandlungs- als auch für die Kontrollgruppe zu verfolgen und zu protokollieren. Diese Verfolgung und Protokollierung umfasst 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()

So zeigen Sie Ihre Experimente an:

  1. Wählen Sie im linken Fensterbereich Ihren Arbeitsbereich aus.
  2. Suchen und wählen Sie den Namen des Experiments, in diesem Fall aisample-upliftmodelling.

Screenshot, der die Ergebnisse des Modellierungsexperiments für den Uplift einer Stichprobe zeigt.

Schritt 5: Speichern der Vorhersageergebnisse

Microsoft Fabric bietet PREDICT – eine skalierbare Funktion, die Batch Scoring in jeder Compute Engine unterstützt. Es ermöglicht Kunden, Modelle des maschinellen Lernens zu operationalisieren. Benutzer können Batchvorhersagen direkt aus einem Notebook oder der Elementseite für ein bestimmtes Modell erstellen. Besuchen Sie diese Ressource, um mehr über PREDICT zu erfahren und um zu lernen, wie Sie PREDICT in Microsoft Fabric verwenden können.

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

Zugehöriger Inhalt