Samouczek: tworzenie, trenowanie i ocenianie modelu uplift

Artykuł
04/29/2024

Ten samouczek przedstawia pełny przykład przepływu pracy usługi Synapse Nauka o danych w usłudze Microsoft Fabric. Dowiesz się, jak tworzyć, trenować i oceniać modele uplift oraz stosować techniki modelowania uplift.

Wymagania wstępne

Uzyskaj subskrypcję usługi Microsoft Fabric. Możesz też utworzyć konto bezpłatnej wersji próbnej usługi Microsoft Fabric.
Zaloguj się do usługi Microsoft Fabric.
Użyj przełącznika środowiska po lewej stronie głównej, aby przełączyć się na środowisko usługi Synapse Nauka o danych.

Znajomość notesów usługi Microsoft Fabric
Usługa Lakehouse dla tego notesu do przechowywania danych na potrzeby tego przykładu. Aby uzyskać więcej informacji, odwiedź stronę Dodawanie magazynu lakehouse do notesu

Postępuj zgodnie z instrukcjami w notesie

Możesz wykonać czynności opisane w notesie na jeden z dwóch sposobów:

Otwórz i uruchom wbudowany notes w środowisku usługi Synapse Nauka o danych
Przekazywanie notesu z usługi GitHub do środowiska usługi Synapse Nauka o danych

Otwieranie wbudowanego notesu

W tym samouczku dołączymy przykładowy notes modelowania uplift. Odwiedź stronę Aby otworzyć wbudowany notes przykładowy samouczka w środowisku usługi Synapse Nauka o danych:1. Przejdź do strony głównej usługi Synapse Nauka o danych. 1. Wybierz pozycję Użyj przykładu. 1. Wybierz odpowiedni przykład:* Z domyślnej karty Kompleksowe przepływy pracy (Python), jeśli przykład dotyczy samouczka języka Python. * Na karcie Kompleksowe przepływy pracy (R), jeśli przykład dotyczy samouczka języka R. * Na karcie Szybkie samouczki , jeśli przykład jest przeznaczony do szybkiego samouczka.1. Przed rozpoczęciem uruchamiania kodu dołącz usługę Lakehouse do notesu . Aby uzyskać więcej informacji na temat uzyskiwania dostępu do wbudowanych przykładowych notesów dla samouczków.

Aby otworzyć wbudowany notes przykładowy samouczka w środowisku usługi Synapse Nauka o danych:

Przejdź do strony głównej usługi Synapse Nauka o danych
Wybieranie pozycji Użyj przykładu
Wybierz odpowiedni przykład:
1. Na domyślnej karcie Kompleksowe przepływy pracy (Python), jeśli przykład dotyczy samouczka dotyczącego języka Python
2. Na karcie Kompleksowe przepływy pracy (R), jeśli przykład dotyczy samouczka języka R
3. Jeśli przykład jest przeznaczony do szybkiego samouczka, na karcie Szybkie samouczki
Dołącz usługę Lakehouse do notesu przed rozpoczęciem uruchamiania kodu

Importowanie notesu z usługi GitHub

Notes AIsample — Uplift Modeling.ipynb towarzyszy temu samouczkowi.

Aby otworzyć towarzyszący notes na potrzeby tego samouczka, postępuj zgodnie z instrukcjami w temacie Przygotowywanie systemu do celów nauki o danych, aby zaimportować notes do obszaru roboczego.

Jeśli chcesz skopiować i wkleić kod z tej strony, możesz utworzyć nowy notes .

Przed rozpoczęciem uruchamiania kodu pamiętaj, aby dołączyć usługę Lakehouse do notesu .

Krok 1. Ładowanie danych

Zestaw danych

Laboratorium Criteo AI lab utworzyło zestaw danych. Ten zestaw danych zawiera 13 mln wierszy. Każdy wiersz reprezentuje jednego użytkownika. Każdy wiersz ma 12 cech, wskaźnik leczenia i dwie etykiety binarne, które obejmują wizytę i konwersję.

f0 – f11: wartości cech (gęste, zmiennoprzecinkowe)
leczenie: czy użytkownik był losowo przeznaczony do leczenia (na przykład reklamy) (1 = leczenie, 0 = kontrola)
konwersja: czy nastąpiła konwersja (na przykład dokonano zakupu) dla użytkownika (binarnego, etykiety)
odwiedź: czy nastąpiła konwersja (na przykład dokonano zakupu) dla użytkownika (binarne, etykieta)

Odsyłacz bibliograficzny

Strona główna zestawu danych: https://ailab.criteo.com/criteo-uplift-prediction-dataset/

Zestaw danych używany na potrzeby tego notesu wymaga tego cytatu bibTex:

@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}
}

Napiwek

Definiując następujące parametry, można łatwo zastosować ten notes w różnych zestawach danych.

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

Importowanie bibliotek

Przed przetworzeniem należy zaimportować wymagane biblioteki Spark i SynapseML. Należy również zaimportować bibliotekę wizualizacji danych — na przykład Seaborn, bibliotekę wizualizacji danych języka Python. Biblioteka wizualizacji danych udostępnia interfejs wysokiego poziomu umożliwiający tworzenie zasobów wizualnych na obiektach DataFrame i tablicach. Dowiedz się więcej na temat platform Spark, SynapseML i 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

Pobieranie zestawu danych i przekazywanie do usługi Lakehouse

Ten kod pobiera publicznie dostępną wersję zestawu danych, a następnie przechowuje ten zasób danych w usłudze Fabric lakehouse.

Ważne

Przed jego uruchomieniem upewnij się, że do notesu dodano usługę Lakehouse . Niepowodzenie w tym celu spowoduje wystąpienie błędu.

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

Rozpocznij rejestrowanie środowiska uruchomieniowego tego notesu.

# Record the notebook running time
import time

ts = time.time()

Konfigurowanie śledzenia eksperymentów MLflow

Aby rozszerzyć możliwości rejestrowania MLflow, automatyczne rejestrowanie automatycznie przechwytuje wartości parametrów wejściowych i metryk wyjściowych modelu uczenia maszynowego podczas trenowania. Te informacje są następnie rejestrowane w obszarze roboczym, w którym interfejsy API MLflow lub odpowiedni eksperyment w obszarze roboczym mogą uzyskiwać do niego dostęp i wizualizować je. Odwiedź ten zasób, aby uzyskać więcej informacji na temat automatycznego rejestrowania.

# Set up the MLflow experiment
import mlflow

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

Uwaga

Aby wyłączyć automatyczne rejestrowanie usługi Microsoft Fabric w sesji notesu, wywołaj mlflow.autolog() i ustaw polecenie disable=True.

Odczytywanie danych z jeziora

Przeczytaj nieprzetworzone dane z sekcji Pliki lakehouse i dodaj więcej kolumn dla różnych części dat. Te same informacje są używane do tworzenia partycjonowanej tabeli różnicowej.

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

Krok 2. Eksploracyjna analiza danych

Użyj polecenia , display aby wyświetlić ogólne statystyki dotyczące zestawu danych. Możesz również wyświetlić widoki wykresów, aby łatwo wizualizować podzestawy zestawu danych.

display(raw_df.limit(20))

Sprawdź procent użytkowników, którzy odwiedzają, procent użytkowników, którzy konwertują, oraz procent odwiedzających, którzy konwertują.

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

Analiza wskazuje, że 4,9% użytkowników z grupy leczenia - użytkowników, którzy otrzymali leczenie lub reklamę - odwiedziło sklep internetowy. Tylko 3,8% użytkowników z grupy kontrolnej - użytkowników, którzy nigdy nie otrzymali leczenia, lub nigdy nie były oferowane lub narażone na reklamy - zrobiły to samo. Ponadto 0,31% wszystkich użytkowników z grupy badanej przekonwertowało lub dokonało zakupu - podczas gdy tylko 0,19% użytkowników z grupy kontrolnej to zrobiło. W rezultacie wskaźnik konwersji odwiedzających, którzy dokonali zakupu, którzy byli również członkami grupy leczenia, wynosi 6,36%, w porównaniu do tylko 5,07%** dla użytkowników grupy kontrolnej. Na podstawie tych wyników leczenie może potencjalnie poprawić wskaźnik wizyty o około 1%, a współczynnik konwersji odwiedzających o około 1,3%. Leczenie prowadzi do znacznej poprawy.

Krok 3. Definiowanie modelu na potrzeby trenowania

Przygotowywanie trenowania i testowania zestawów danych

W tym miejscu dopasujesz funkcję przekształcania Featurize do raw_df ramki danych, aby wyodrębnić funkcje z określonych kolumn wejściowych i wyprowadź te funkcje do nowej kolumny o nazwie features.

Wynikowa ramka danych jest przechowywana w nowej ramce danych o nazwie df.

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

Przygotowywanie zestawów danych leczenia i kontroli

Po utworzeniu zestawów danych trenowania i testowania należy również utworzyć zestawy danych leczenia i sterowania, aby wytrenować modele uczenia maszynowego w celu mierzenia wzrostu.

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

Po przygotowaniu danych możesz przejść do trenowania modelu za pomocą rozwiązania LightGBM.

Modelowanie uplift: T-Learning z lightGBM

Metauczeń to zestaw algorytmów, oparty na algorytmach uczenia maszynowego, takich jak LightGBM, Xgboost itp. Pomagają oszacować efekt leczenia średniego warunkowego lub CATE. T-learning to metauczeń, który nie korzysta z jednego modelu. Zamiast tego T-learning używa jednego modelu na zmienną leczenia. W związku z tym dwa modele są opracowywane i odnosimy się do metauczeń jako T-learning. T-learning używa wielu modeli uczenia maszynowego do przezwyciężenia problemu całkowitego odrzucenia leczenia, zmuszając ucznia do pierwszego podziału na niego.

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

Korzystanie z zestawu danych testowych na potrzeby przewidywania

W tym miejscu użyjesz zdefiniowanych wcześniej elementów treatment_model i control_model, aby przekształcić test_df testowy zestaw danych. Następnie obliczysz przewidywany wzrost. Przewidywany wzrost jest definiowany jako różnica między przewidywanym wynikiem leczenia a przewidywanym wynikiem kontroli. Im większa przewidywała różnicę w podnoszeniu, tym większa skuteczność leczenia (na przykład reklama) na pojedynczej lub podgrupie.

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

Przeprowadzanie oceny modelu

Ponieważ rzeczywisty wzrost nie może być obserwowany dla każdej osoby, musisz zmierzyć wzrost nad grupą osób. Używasz krzywej uplift, która wykreśla rzeczywisty, skumulowany wzrost w całej populacji.

Oś x reprezentuje stosunek populacji wybranej do leczenia. Wartość 0 sugeruje brak grupy leczenia - nikt nie jest narażony na leczenie lub oferowane. Wartość 1 sugeruje pełną grupę leczenia - każdy jest narażony na leczenie lub oferowane. Na osi y jest wyświetlana miara podniesiona. Celem jest znalezienie wielkości grupy leczenia lub procent populacji, która byłaby oferowana lub narażona na leczenie (na przykład reklamy). To podejście optymalizuje wybór docelowy, aby zoptymalizować wynik.

Najpierw należy sklasyfikować kolejność testowej ramki danych według przewidywanego wzrostu. Przewidywany wzrost jest różnicą między przewidywanym wynikiem leczenia a przewidywanym wynikiem kontroli.

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

Następnie oblicz skumulowany procent wizyt w grupach leczenia i grup kontrolnych.

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

Na koniec, przy każdym procentzie, oblicz wzrost grupy jako różnicę między skumulowanym procentem wizyt między grupami leczenia i grup kontrolnych.

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

Teraz wykreślij krzywą wzrostu dla przewidywania zestawu danych testowych. Przed wykreśleniem należy przekonwertować ramkę danych PySpark na ramkę danych Biblioteki Pandas.

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

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

Następnie oblicz skumulowany procent wizyt w grupach leczenia i grup kontrolnych.

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

Na koniec, przy każdym procentzie, oblicz wzrost grupy jako różnicę między skumulowanym procentem wizyt między grupami leczenia i grup kontrolnych.

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

Teraz wykreślij krzywą wzrostu dla przewidywania zestawu danych testowych. Przed wykreśleniem należy przekonwertować ramkę danych PySpark na ramkę danych Biblioteki Pandas.

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

Analiza i krzywa podnoszenia w górę pokazują, że w pierwszej 20% populacji, w rankingu według przewidywania, byłby duży zysk, gdyby otrzymał leczenie. Oznacza to, że 20% pierwszej liczby ludności reprezentuje grupę persudables. W związku z tym można ustawić wynik redukcji dla żądanego rozmiaru grupy leczenia na 20%, aby zidentyfikować docelowych klientów wyboru w celu uzyskania największego wpływu.

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

Krok 4. Rejestrowanie końcowego modelu uczenia maszynowego

Używasz biblioteki MLflow do śledzenia i rejestrowania wszystkich eksperymentów zarówno dla grup leczenia, jak i grup kontrolnych. To śledzenie i rejestrowanie obejmuje odpowiednie parametry, metryki i modele. Te informacje są rejestrowane pod nazwą eksperymentu w obszarze roboczym do późniejszego użycia.

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

Aby wyświetlić eksperymenty:

Na panelu po lewej stronie wybierz swój obszar roboczy.
Znajdź i wybierz nazwę eksperymentu, w tym przypadku aisample-upliftmodelling.

Krok 5. Zapisywanie wyników przewidywania

Usługa Microsoft Fabric oferuje funkcję PREDICT — skalowalną funkcję, która obsługuje ocenianie wsadowe w dowolnym aucie obliczeniowym. Umożliwia klientom operacjonalizacja modeli uczenia maszynowego. Użytkownicy mogą tworzyć przewidywania wsadowe bezpośrednio z notesu lub strony elementu dla określonego modelu. Odwiedź ten zasób, aby dowiedzieć się więcej na temat funkcji PREDICT i dowiedzieć się, jak używać funkcji PREDICT w usłudze Microsoft Fabric.

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

Udostępnij za pośrednictwem

Samouczek: tworzenie, trenowanie i ocenianie modelu uplift

Wymagania wstępne

Postępuj zgodnie z instrukcjami w notesie

Otwieranie wbudowanego notesu

Importowanie notesu z usługi GitHub

Krok 1. Ładowanie danych

Zestaw danych

Odsyłacz bibliograficzny

Importowanie bibliotek

Pobieranie zestawu danych i przekazywanie do usługi Lakehouse

Konfigurowanie śledzenia eksperymentów MLflow

Odczytywanie danych z jeziora

Krok 2. Eksploracyjna analiza danych

Krok 3. Definiowanie modelu na potrzeby trenowania

Przygotowywanie trenowania i testowania zestawów danych

Przygotowywanie zestawów danych leczenia i kontroli

Modelowanie uplift: T-Learning z lightGBM

Korzystanie z zestawu danych testowych na potrzeby przewidywania

Przeprowadzanie oceny modelu

Krok 4. Rejestrowanie końcowego modelu uczenia maszynowego

Krok 5. Zapisywanie wyników przewidywania

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

Samouczek: tworzenie, trenowanie i ocenianie modelu uplift

Wymagania wstępne

Postępuj zgodnie z instrukcjami w notesie

Otwieranie wbudowanego notesu

Importowanie notesu z usługi GitHub

Krok 1. Ładowanie danych

Zestaw danych

Odsyłacz bibliograficzny

Importowanie bibliotek

Pobieranie zestawu danych i przekazywanie do usługi Lakehouse

Konfigurowanie śledzenia eksperymentów MLflow

Odczytywanie danych z jeziora

Krok 2. Eksploracyjna analiza danych

Krok 3. Definiowanie modelu na potrzeby trenowania

Przygotowywanie trenowania i testowania zestawów danych

Przygotowywanie zestawów danych leczenia i kontroli

Modelowanie uplift: T-Learning z lightGBM

Korzystanie z zestawu danych testowych na potrzeby przewidywania

Przeprowadzanie oceny modelu

Krok 4. Rejestrowanie końcowego modelu uczenia maszynowego

Krok 5. Zapisywanie wyników przewidywania

Powiązana zawartość

Opinia

Dodatkowe zasoby