Oktatóanyag: Felemelő modell létrehozása, betanítása és kiértékelése
Ez az oktatóanyag a Synapse Adattudomány munkafolyamatának végpontok közötti példáját mutatja be a Microsoft Fabricben. Megtudhatja, hogyan hozhat létre, taníthat be és értékelhet felemeléses modelleket, és hogyan alkalmazhat felemeléses modellezési technikákat.
Előfeltételek
- A Microsoft Fabric-jegyzetfüzetek ismerete
- A jelen példában szereplő adatok tárolására szolgáló tóház ehhez a jegyzetfüzethez. További információ: Tóház hozzáadása a jegyzetfüzethez
Követés jegyzetfüzetben
A jegyzetfüzetekben kétféleképpen követheti a lépéseket:
- Nyissa meg és futtassa a beépített jegyzetfüzetet a Synapse Adattudomány felületen
- Jegyzetfüzet feltöltése a GitHubról a Synapse Adattudomány felületére
A beépített jegyzetfüzet megnyitása
A minta Uplift-modellező jegyzetfüzet ezt az oktatóanyagot kíséri. Látogasson el az oktatóanyag beépített mintajegyzetfüzetének megnyitásához a Synapse Adattudomány felületén:1. Nyissa meg a Synapse Adattudomány kezdőlapját. 1. Válassza a Minta használata lehetőséget. 1. Válassza ki a megfelelő mintát:* Az alapértelmezett Végpontok közötti munkafolyamatok (Python) lapon, ha a minta Egy Python-oktatóanyaghoz készült. * A Végpontok közötti munkafolyamatok (R) lapon, ha a minta egy R-oktatóanyaghoz készült. * A Gyors oktatóanyagok lapon, ha a minta egy gyors oktatóanyaghoz készült.1. A kód futtatása előtt csatoljon egy lakehouse-t a jegyzetfüzethez . további információ a beépített mintajegyzetfüzetek eléréséről oktatóanyagokhoz.
Az oktatóanyag beépített mintajegyzetfüzetének megnyitása a Synapse Adattudomány felületén:
Nyissa meg a Synapse Adattudomány kezdőlapját
Válassza a Minta használata lehetőséget
Válassza ki a megfelelő mintát:
- Az alapértelmezett Végpontok közötti munkafolyamatok (Python) lapon, ha a minta Egy Python-oktatóanyaghoz készült
- A végpontok közötti munkafolyamatok (R) lapról, ha a minta R-oktatóanyaghoz készült
- A Gyors oktatóanyagok lapon, ha a minta egy gyors oktatóanyaghoz készült
Lakehouse csatolása a jegyzetfüzethez a kód futtatása előtt
A jegyzetfüzet importálása a GitHubról
Az AIsample - Uplift Modeling.ipynb jegyzetfüzet ezt az oktatóanyagot kíséri.
Az oktatóanyaghoz mellékelt jegyzetfüzet megnyitásához kövesse a Rendszer előkészítése adatelemzési oktatóanyagokhoz című témakör utasításait, és importálja a jegyzetfüzetet a munkaterületre.
Új jegyzetfüzetet akkor hozhat létre, ha inkább erről a lapról másolja és illessze be a kódot.
A kód futtatása előtt mindenképpen csatoljon egy lakehouse-t a jegyzetfüzethez .
1. lépés: Az adatok betöltése
Adathalmaz
A Criteo AI Lab hozta létre az adathalmazt. Az adathalmaz 13 M sorból áll. Minden sor egy felhasználót jelöl. Minden sor 12 jellemzővel, kezelési mutatóval és két bináris címkével rendelkezik, amelyek tartalmazzák a látogatást és az átalakítást.
f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 kezelés átalakítás
- f0 – f11: funkcióértékek (sűrű, lebegő értékek)
- kezelés: hogy egy felhasználó véletlenszerűen kezelte-e (például reklám) (1 = kezelés, 0 = kontroll)
- átalakítás: történt-e átalakítás (például vásárlás) egy felhasználó számára (bináris, címke)
- látogatás: történt-e átalakítás (például vásárlás) egy felhasználó számára (bináris, címke)
Idézés
- Adathalmaz kezdőlapja: https://ailab.criteo.com/criteo-uplift-prediction-dataset/
A jegyzetfüzethez használt adatkészlethez ehhez a BibTex-idézetre van szükség:
@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.
A következő paraméterek definiálásával ezt a jegyzetfüzetet egyszerűen alkalmazhatja különböző adathalmazokra.
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
Kódtárak importálása
A feldolgozás előtt importálnia kell a szükséges Spark- és SynapseML-kódtárakat. Emellett importálnia kell egy adatvizualizációs kódtárat is – például Seabornt, egy Python-adatvizualizációs tárat. Az adatvizualizációs kódtár magas szintű felületet biztosít a vizualizációs erőforrások DataFrame-eken és tömbökön való létrehozásához. További információ a Sparkról, a SynapseML-ről és a Seabornról.
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
Adatkészlet letöltése és feltöltése a lakehouse-ba
Ez a kód letölti az adathalmaz nyilvánosan elérhető verzióját, majd egy Fabric lakehouse-ban tárolja az adaterőforrást.
Fontos
A futtatás előtt győződjön meg arról, hogy hozzáad egy lakehouse-t a jegyzetfüzethez. Ennek elmulasztása hibát fog eredményezni.
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.")
Kezdje el rögzíteni a jegyzetfüzet futtatókörnyezetét.
# Record the notebook running time
import time
ts = time.time()
Az MLflow-kísérlet nyomon követésének beállítása
Az MLflow naplózási képességeinek bővítése érdekében az automatikus naplózás automatikusan rögzíti a gépi tanulási modell bemeneti paramétereinek és kimeneti metrikáinak értékeit a betanítás során. Ezt az információt ezután a rendszer naplózza a munkaterületre, ahol az MLflow API-k vagy a munkaterület megfelelő kísérlete elérheti és megjelenítheti azokat. Az automatikus kereséssel kapcsolatos további információkért látogasson el erre az erőforrásra.
# Set up the MLflow experiment
import mlflow
mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True) # Disable MLflow autologging
Feljegyzés
Ha le szeretné tiltani a Microsoft Fabric automatikus keresését egy jegyzetfüzet-munkamenetben, hívja fel mlflow.autolog() és állítsa be disable=True.
Adatok olvasása a lakehouse-ból
Olvasson nyers adatokat a Lakehouse Files szakaszból, és adjon hozzá további oszlopokat a különböző dátumrészekhez. Ugyanezeket az információkat használják particionált deltatábla létrehozásához.
raw_df = spark.read.csv(f"{DATA_FOLDER}/raw/{DATA_FILE}", header=True, inferSchema=True).cache()
2. lépés: Feltáró adatelemzés
A paranccsal megtekintheti az display adathalmaz magas szintű statisztikáit. A Diagram nézetekkel egyszerűen megjelenítheti az adathalmaz részhalmazait.
display(raw_df.limit(20))
Vizsgálja meg a meglátogatott felhasználók százalékos arányát, az átalakító felhasználók százalékos arányát és az átalakító látogatók százalékos arányát.
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()
Az elemzés azt jelzi, hogy a kezelési csoport felhasználóinak 4,9%-a - a kezelésben részesült felhasználók, vagy a reklám - felkereste az online áruházat. A kontrollcsoport felhasználóinak csak 3,8%-a - azok a felhasználók, akik soha nem kapták meg a kezelést, vagy soha nem kínálták fel vagy nem tettek közzé reklámot - ugyanezt tették. Emellett a kezelési csoport összes felhasználójának 0,31%-a konvertált vagy vásárolt – míg a kontrollcsoport felhasználóinak csak 0,19%-a tette ezt meg. Ennek eredményeképpen a vásárlást végző látogatók konverziós aránya, akik szintén a kezelési csoport tagjai voltak, 6,36%, szemben a kontrollcsoport felhasználóinak csupán 5,07%-ával**. Ezen eredmények alapján a kezelés körülbelül 1%-kal javíthatja a látogatási arányt, a látogatók konverziós rátája pedig körülbelül 1,3%-kal. A kezelés jelentős javuláshoz vezet.
3. lépés: A betanítási modell meghatározása
A betanítás előkészítése és az adathalmazok tesztelése
Itt egy Featurize transzformátort illeszthet a raw_df DataFrame-hez, hogy kinyerje a funkciókat a megadott bemeneti oszlopokból, és ezeket a funkciókat egy új, nevesített featuresoszlopba adja ki.
Az eredményként kapott DataFrame egy új dataFrame-ben dflesz tárolva.
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()
A kezelési és ellenőrzési adatkészletek előkészítése
A betanítási és tesztelési adathalmazok létrehozása után a kezelési és vezérlési adatkészleteket is meg kell alkotnia, hogy betanítsa a gépi tanulási modelleket a felemelés mérésére.
# 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")
Most, hogy előkészítette az adatokat, folytathatja a modell betanítása a LightGBM használatával.
Uplift modeling: T-Learner with LightGBM
A metatanulók olyan algoritmusok, amelyek olyan gépi tanulási algoritmusokra épülnek, mint a LightGBM, az Xgboost stb. Segítenek megbecsülni a feltételes átlagos kezelési hatást, vagyis a CATE-t. A T-learner egy olyan metatanuló, amely nem használ egyetlen modellt. A T-learner ehelyett kezelési változónként egy modellt használ. Ezért két modellt fejlesztünk ki, és t-learnerként hivatkozunk a metatanulóra. A T-learner több gépi tanulási modellt használ a kezelés teljes elvetésével kapcsolatos probléma megoldásához, mivel arra kényszeríti a tanulót, hogy először ossza fel azt.
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
A tesztadatkészlet használata előrejelzéshez
Itt a treatment_model korábban definiált és control_modela tesztadatkészlet átalakítására test_df is használhatja. Ezután kiszámítja az előrejelzett felemelkedést. Az előrejelzett felemelést az előrejelzett kezelési eredmény és az előrejelzett kontrolleredmény közötti különbségként definiálja. Minél nagyobb ez az előrejelzett felemelési különbség, annál nagyobb a kezelés hatékonysága (például reklám) egy adott személyen vagy alcsoporton.
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))
Modell kiértékelése
Mivel a tényleges felemelés nem figyelhető meg minden egyes személy esetében, meg kell mérnie a felemelést egy egyének egy csoportja felett. Egy Uplift-görbét használ, amely a valós, összesített felemelkedést ábrázolja a populációban.
Az x tengely a kezeléshez kiválasztott populáció arányát jelöli. A 0 érték azt sugallja, hogy nincs kezelési csoport - senki sem van kitéve, vagy felajánlotta a kezelést. Az 1 érték egy teljes kezelési csoportot javasol - mindenki ki van téve a kezelésnek, vagy felajánlják. Az y tengely a felfelé mutató mértéket jeleníti meg. A cél a kezelési csoport méretének vagy a kezelésnek felajánlható vagy a kezelésnek kitett populáció százalékos arányának megkeresése (például reklámozás). Ez a megközelítés optimalizálja a célválasztást az eredmény optimalizálása érdekében.
Először rangsorolja a DataFrame-teszt sorrendjét az előrejelzett felemelés alapján. Az előrejelzett felemelkedés az előrejelzett kezelési eredmény és az előrejelzett kontrolleredmény közötti különbség.
# 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))
Ezután számítsa ki a látogatások összesített százalékos arányát mind a kezelési, mind a kontrollcsoportokban.
# 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))
Végül minden egyes százalékban számítsa ki a csoport emelkedését a kezelési és kontrollcsoportok közötti látogatások összesített százalékos aránya közötti különbségként.
test_ranked_df = test_ranked_df.withColumn("group_uplift", F.col("treatment_cumsum") - F.col("control_cumsum")).cache()
display(test_ranked_df.limit(20))
Most ábrázolja a tesztadatkészlet előrejelzéséhez tartozó felemelési görbét. A PySpark DataFrame-et a ábrázolás előtt Pandas DataFrame-gé kell konvertálnia.
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")
Az x tengely a kezeléshez kiválasztott populáció arányát jelöli. A 0 érték azt sugallja, hogy nincs kezelési csoport - senki sem van kitéve, vagy felajánlotta a kezelést. Az 1 érték egy teljes kezelési csoportot javasol - mindenki ki van téve a kezelésnek, vagy felajánlják. Az y tengely a felfelé mutató mértéket jeleníti meg. A cél a kezelési csoport méretének vagy a kezelésnek felajánlható vagy a kezelésnek kitett populáció százalékos arányának megkeresése (például reklámozás). Ez a megközelítés optimalizálja a célválasztást az eredmény optimalizálása érdekében.
Először rangsorolja a DataFrame-teszt sorrendjét az előrejelzett felemelés alapján. Az előrejelzett felemelkedés az előrejelzett kezelési eredmény és az előrejelzett kontrolleredmény közötti különbség.
# 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))
Ezután számítsa ki a látogatások összesített százalékos arányát mind a kezelési, mind a kontrollcsoportokban.
# 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))
Végül minden egyes százalékban számítsa ki a csoport emelkedését a kezelési és kontrollcsoportok közötti látogatások összesített százalékos aránya közötti különbségként.
test_ranked_df = test_ranked_df.withColumn("group_uplift", F.col("treatment_cumsum") - F.col("control_cumsum")).cache()
display(test_ranked_df.limit(20))
Most ábrázolja a tesztadatkészlet előrejelzéséhez tartozó felemelési görbét. A PySpark DataFrame-et a ábrázolás előtt Pandas DataFrame-gé kell konvertálnia.
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")
Az elemzés és a felemelési görbe is azt mutatja, hogy a felső 20%-os populáció, ahogy az előrejelzés, nagy nyereség lenne, ha megkapják a kezelést. Ez azt jelenti, hogy a lakosság 20%-a képviseli a meggyőzhető csoportokat. Ezért beállíthatja a kezelési csoport kívánt méretére vonatkozó kivágási pontszámot 20%-ra, hogy azonosítsa a célkiválasztási ügyfeleket a legnagyobb hatás érdekében.
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}
)
4. lépés: A végső ml-modell regisztrálása
Az MLflow használatával nyomon követheti és naplózhatja a kezelési és a kontrollcsoportok összes kísérletét. Ez a nyomon követés és naplózás tartalmazza a megfelelő paramétereket, metrikákat és modelleket. Ezeket az adatokat a rendszer a kísérlet neve alatt naplózza a munkaterületen későbbi használatra.
# 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()
A kísérletek megtekintése:
- A bal oldali panelen válassza ki a munkaterületet.
- Keresse meg és válassza ki a kísérlet nevét, ebben az esetben az aisample-upliftmodelling nevet.
5. lépés: Az előrejelzési eredmények mentése
A Microsoft Fabric a PREDICT függvényt kínálja, amely bármely számítási motorban támogatja a kötegelt pontozást. Lehetővé teszi az ügyfelek számára a gépi tanulási modellek üzembe helyezése. A felhasználók közvetlenül egy jegyzetfüzetből vagy egy adott modell elemlapjáról hozhatnak létre kötegelt előrejelzéseket. Ebből az erőforrásból többet is megtudhat a PREDICT-ről, és megtudhatja, hogyan használhatja a PREDICT-t a Microsoft Fabricben.
# 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.")
Kapcsolódó tartalom
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: