Kurz: Vytvoření, vyhodnocení a hodnocení modelu detekce podvodů
Tento kurz představuje ucelený příklad pracovního postupu pro datové vědy Synapse v Microsoft Fabric. Scénář vytváří model detekce podvodů s algoritmy strojového učení natrénovanými na historických datech. Pak model použije k detekci budoucích podvodných transakcí.
Tento kurz se věnuje těmto krokům:
- Instalace vlastních knihoven
- Načtení dat
- Pochopení a zpracování dat prostřednictvím průzkumné analýzy dat
- Použití knihovny scikit-learn k trénování modelu strojového učení a sledování experimentů s funkcemi automatickéhologování MLflow a Fabric
- Uložení a registrace modelu strojového učení, který má nejvyšší výkon
- Načtení modelu strojového učení pro bodování a provádění předpovědí
Požadavky
Získejte předplatné Microsoft Fabric. Nebo si zaregistrujte bezplatnou zkušební verzi Microsoft Fabric.
Přihlaste se k Microsoft Fabric.
Pomocí přepínače zážitků v levém dolním rohu vaší domovské stránky přepněte na Fabric.
- V případě potřeby vytvořte lakehouse v Microsoft Fabric, jak je popsáno v tématu Vytvoření lakehouse v Microsoft Fabric.
Sledujte v poznámkovém bloku
V zápisníku si můžete vybrat jednu z těchto možností, jak postupovat:
- Otevřete a spusťte integrovaný poznámkový blok.
- Nahrajte poznámkový blok z GitHubu.
Otevření integrovaného poznámkového bloku
Tento kurz doprovází ukázkový poznámkový blok pro detekci podvodů.
Pokud chcete otevřít ukázkový poznámkový blok pro tento kurz, postupujte podle pokynů v Příprava systému na kurzy datových věd.
Ujistěte se, že připojíte lakehouse k poznámkovému bloku , než začnete spouštět kód.
Import poznámkového bloku z GitHubu
Tento kurz doprovází AIsample - Fraud Detection.ipynb notebook.
Pokud chcete otevřít doprovodný poznámkový blok pro tento kurz, postupujte podle pokynů v kapitolách Příprava systému na kurzy datových věd k importování poznámkového bloku do pracovního prostoru.
Pokud chcete raději zkopírovat a vložit kód z této stránky, můžete vytvořit nový poznámkový blok.
Než začnete spouštět kód, nezapomeňte k poznámkovému bloku připojit lakehouse.
Krok 1: Instalace vlastních knihoven
Pro vývoj modelů strojového učení nebo ad hoc analýzu dat možná budete muset rychle nainstalovat vlastní knihovnu pro relaci Apache Sparku. Máte dvě možnosti instalace knihoven.
- Pomocí funkcí vložené instalace (
%pip
nebo%conda
) poznámkového bloku nainstalujte knihovnu jenom v aktuálním poznámkovém bloku. - Alternativně můžete vytvořit prostředí Fabric, nainstalovat knihovny z veřejných zdrojů nebo do něj nahrát vlastní knihovny, a pak může správce pracovního prostoru toto prostředí připojit jako výchozí pro pracovní prostor. Všechny knihovny v prostředí se pak zpřístupní pro použití v poznámkových blocích a definicích úloh Sparku v pracovním prostoru. Další informace o prostředích najdete v tématu vytvoření, konfigurace a použití prostředí v Microsoft Fabric.
Pro účely tohoto kurzu použijte %pip install
k instalaci knihovny imblearn
do poznámkového bloku.
Poznámka
Po spuštění %pip install
se jádro PySpark restartuje. Před spuštěním jiných buněk nainstalujte potřebné knihovny.
# Use pip to install imblearn
%pip install imblearn
Krok 2: Načtení dat
Datová sada pro detekci podvodů obsahuje transakce kreditních karet od září 2013, které evropské držitelé karet provedli během dvou dnů. Datová sada obsahuje pouze číselné funkce z důvodu transformace analýzy hlavních komponent (PCA) použité na původní funkce. PcA transformovala všechny funkce s výjimkou Time
a Amount
. Kvůli ochraně důvěrnosti nemůžeme poskytnout původní vlastnosti ani více doplňujících informací o datové sadě.
Tyto podrobnosti popisují datovou sadu:
- Funkce
V1
,V2
,V3
, ...,V28
jsou hlavní komponenty získané pomocí PCA. - Funkce
Time
obsahuje uplynulé sekundy mezi transakcí a první transakcí v datové sadě. - Funkce
Amount
je částka transakce. Tuto funkci můžete použít pro učení závislé na příkladech a citlivé na náklady. - Sloupec
Class
je proměnná odpovědi (cíl). Má hodnotu1
pro podvod a0
jinak
Podvodná jsou pouze 492 transakcí z celkového počtu 284 807 transakcí. Datová sada je velmi nevyvážená, protože menšinová (podvodná) třída tvoří jen asi 0,172% dat.
Tabulka ukazuje náhled dat creditcard.csv:
Čas | V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | V10 | V11 | V12 | V13 | V14 | V15 | V16 | V17 | V18 | V19 | V20 | V21 | V22 | V23 | V24 | V25 | V26 | V27 | V28 | Množství | Třída |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0 | -1.3598071336738 | -0.0727811733098497 | 2.53634673796914 | 1.37815522427443 | -0.338320769942518 | 0.462387777762292 | 0.239598554061257 | 0.0986979012610507 | 0.363786969611213 | 0.0907941719789316 | -0.551599533260813 | -0.617800855762348 | -0.991389847235408 | -0.311169353699879 | 1.46817697209427 | -0.470400525259478 | 0.207971241929242 | 0.0257905801985591 | 0.403992960255733 | 0.251412098239705 | -0.018306777944153 | 0.277837575558899 | -0.110473910188767 | 0.0669280749146731 | 0.128539358273528 | -0.189114843888824 | 0.133558376740387 | -0.0210530534538215 | 149.62 | 0 |
0 | 1.19185711131486 | 0.26615071205963 | 0.16648011335321 | 0.448154078460911 | 0.0600176492822243 | -0.0823608088155687 | -0.0788029833323113 | 0.0851016549148104 | -0.255425128109186 | -0.166974414004614 | 1.61272666105479 | 1.06523531137287 | 0.48909501589608 | -0.143772296441519 | 0.635558093258208 | 0.463917041022171 | -0.114804663102346 | -0.183361270123994 | -0.145783041325259 | -0.0690831352230203 | -0.225775248033138 | -0.638671952771851 | 0.101288021253234 | -0.339846475529127 | 0.167170404418143 | 0.125894532368176 | -0.00898309914322813 | 0.0147241691924927 | 2,69 | "0" |
Stáhněte datovou sadu a nahrajte ji do lakehouse.
Definujte tyto parametry, abyste mohli tento poznámkový blok používat s různými datovými sadami:
IS_CUSTOM_DATA = False # If True, the dataset has to be uploaded manually
TARGET_COL = "Class" # Target column name
IS_SAMPLE = False # If True, use only <SAMPLE_ROWS> rows of data for training; otherwise, use all data
SAMPLE_ROWS = 5000 # If IS_SAMPLE is True, use only this number of rows for training
DATA_FOLDER = "Files/fraud-detection/" # Folder with data files
DATA_FILE = "creditcard.csv" # Data file name
EXPERIMENT_NAME = "aisample-fraud" # MLflow experiment name
Tento kód stáhne veřejně dostupnou verzi datové sady a pak ji uloží do objektu Fabric Lakehouse.
Důležitý
Ujistěte se, že do poznámkového bloku přidáte lakehouse, než ho spustíte. V opačném případě se zobrazí chyba.
if not IS_CUSTOM_DATA:
# Download data files into the lakehouse if they're not already there
import os, requests
remote_url = "https://synapseaisolutionsa.blob.core.windows.net/public/Credit_Card_Fraud_Detection"
fname = "creditcard.csv"
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}/{fname}"):
r = requests.get(f"{remote_url}/{fname}", timeout=30)
with open(f"{download_path}/{fname}", "wb") as f:
f.write(r.content)
print("Downloaded demo data files into lakehouse.")
Nastavení sledování experimentů MLflow
Proces sledování experimentu ukládá všechny relevantní informace související s experimenty pro každý spuštěný experiment. Někdy nemáte způsob, jak získat lepší výsledky při spuštění konkrétního experimentu. V takových případech byste měli experiment zastavit a vyzkoušet nový.
prostředí Synapse pro datovou vědu v Microsoft Fabric zahrnuje funkci automatického logování. Tato funkce snižuje množství kódu potřebného k automatickému protokolování parametrů, metrik a položek modelu strojového učení během trénování. Tato funkce rozšiřuje možnosti automatického logování v MLflow. Má hlubokou integraci do prostředí pro datové vědy.
Díky automatickému přihlašování můžete snadno sledovat a porovnávat výkon různých modelů a experimentů bez nutnosti ručního sledování. Další informace naleznete v tématu automatické protokolování v Microsoft Fabric.
Pokud chcete v relaci poznámkového bloku zakázat automatické protokolování Microsoft Fabric, zavolejte mlflow.autolog()
a nastavte disable=True
:
# Set up MLflow for experiment tracking
import mlflow
mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True) # Disable MLflow autologging
Čtení nezpracovaných dat z jezera
Tento kód čte nezpracovaná data z jezera:
df = (
spark.read.format("csv")
.option("header", "true")
.option("inferSchema", True)
.load(f"{DATA_FOLDER}/raw/{DATA_FILE}")
.cache()
)
Krok 3: Provádění průzkumné analýzy dat
V této části nejprve prozkoumáte nezpracovaná data a statistiky vysoké úrovně. Pokud pak chcete data transformovat, přetypovat sloupce na správné typy a převést je z datového rámce Sparku na datový rámec pandas, aby se daly snadněji vizualizovat. Nakonec prozkoumáte a vizualizujete distribuce tříd v datech.
Zobrazení nezpracovaných dat
Prozkoumejte nezpracovaná data a zobrazte statistiky vysoké úrovně pomocí příkazu
display
. Další informace o vizualizaci dat najdete v tématu Vizualizace poznámkového bloku v Microsoft Fabric.display(df)
Vytiskněte některé základní informace o datové sadě:
# Print dataset basic information print("records read: " + str(df.count())) print("Schema: ") df.printSchema()
Transformujte data
Přetypujte sloupce datové sady do správných typů:
import pyspark.sql.functions as F df_columns = df.columns df_columns.remove(TARGET_COL) # Ensure that TARGET_COL is the last column df = df.select(df_columns + [TARGET_COL]).withColumn(TARGET_COL, F.col(TARGET_COL).cast("int")) if IS_SAMPLE: df = df.limit(SAMPLE_ROWS)
Převeďte datový rámec Sparku na datový rámec pandas pro snadnější vizualizaci a zpracování:
df_pd = df.toPandas()
Prozkoumání distribuce tříd v datové sadě
Zobrazení distribuce třídy v datové sadě:
# The distribution of classes in the dataset print('No Frauds', round(df_pd['Class'].value_counts()[0]/len(df_pd) * 100,2), '% of the dataset') print('Frauds', round(df_pd['Class'].value_counts()[1]/len(df_pd) * 100,2), '% of the dataset')
Kód vrátí distribuci této třídy datové sady: 99.83%
No Frauds
a 0.17%Frauds
. Tato distribuce tříd ukazuje, že většina transakcí nejsou podvodné. Před trénováním modelu se proto vyžaduje předběžné zpracování dat, aby se zabránilo přeurčení.Pomocí grafu můžete zobrazit nerovnováhu tříd v datové sadě zobrazením distribuce podvodných a nefraudulentních transakcí:
import seaborn as sns import matplotlib.pyplot as plt colors = ["#0101DF", "#DF0101"] sns.countplot(x='Class', data=df_pd, palette=colors) plt.title('Class Distributions \n (0: No Fraud || 1: Fraud)', fontsize=10)
Zobrazte pětičíselný souhrn (minimální skóre, první kvartil, medián, třetí kvartil a maximální skóre) pro částku transakce pomocí krabicových grafů.
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,5)) s = sns.boxplot(ax = ax1, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=True) # Remove outliers from the plot s = sns.boxplot(ax = ax2, x="Class", y="Amount", hue="Class",data=df_pd, palette="PRGn", showfliers=False) # Keep outliers from the plot plt.show()
U vysoce nevyvážených dat nemusí krabicové grafy zobrazovat přesné přehledy. Nejprve ale můžete vyřešit problém
Class
nerovnováhy a pak vytvořit stejné grafy pro přesnější přehledy.
Krok 4: Trénování a vyhodnocení modelů
Tady vytrénujete model LightGBM tak, aby klasifikovaly transakce podvodu. Model LightGBM vytrénujete na nevyrovnanou datovou sadu i na vyvážené datové sadě. Pak porovnáte výkon obou modelů.
Příprava trénovacích a testovacích datových sad
Před trénováním rozdělte data do trénovacích a testovacích datových sad:
# Split the dataset into training and testing sets
from sklearn.model_selection import train_test_split
train, test = train_test_split(df_pd, test_size=0.15)
feature_cols = [c for c in df_pd.columns.tolist() if c not in [TARGET_COL]]
Použijte SMOTE na trénovací datovou sadu
Knihovna imblearn
používá přístup SMOTE (Synthetic Minority Oversampling Technique) k řešení problému nevyvážené klasifikace. Nevyvážená klasifikace nastane, když je k dispozici příliš málo příkladů menšinové třídy, aby se model efektivně naučil rozhodovací hranici. SMOTE je nejčastěji používaný přístup k syntetizaci nových vzorků pro menšinovou třídu.
Použijte SMOTE pouze na trénovací datovou sadu místo testovací datové sady. Při vyhodnocování modelu pomocí testovacích dat potřebujete aproximaci výkonu modelu u nezoznaných dat v produkčním prostředí. Pro platnou aproximaci se testovací data spoléhají na původní nevyvážené rozdělení, aby co nejpřesněji představovala produkční data.
# Apply SMOTE to the training data
import pandas as pd
from collections import Counter
from imblearn.over_sampling import SMOTE
X = train[feature_cols]
y = train[TARGET_COL]
print("Original dataset shape %s" % Counter(y))
sm = SMOTE(random_state=42)
X_res, y_res = sm.fit_resample(X, y)
print("Resampled dataset shape %s" % Counter(y_res))
new_train = pd.concat([X_res, y_res], axis=1)
Další informace o SMOTE najdete na referenční stránce scikit-learn pro metodu SMOTE a ve uživatelské příručce scikit-learn o zdrojích pro převzorkování.
Trénování modelů strojového učení a spouštění experimentů
Apache Spark v Microsoft Fabric umožňuje strojové učení s velkými objemy dat. Díky Apache Sparku můžete získat cenné přehledy z velkých objemů strukturovaných, nestrukturovaných a rychle se pohyblivých dat.
Máte několik dostupných možností pro trénování modelů strojového učení pomocí Apache Sparku v Microsoft Fabric: Apache Spark MLlib, SynapseML a dalších opensourcových knihoven. Další informace najdete v tématu Trénování modelů strojového učení v Microsoft Fabric.
Experiment strojového učení slouží jako primární jednotka organizace a řízení všech souvisejících spuštění strojového učení. Jeden běh odpovídá jedinému spuštění kódu modelu. Strojové učení sledování experimentů zahrnuje správu všech experimentů a jejich součástí, jako jsou parametry, metriky, modely a další artefakty.
Pro sledování experimentů můžete uspořádat všechny požadované součásti konkrétního experimentu strojového učení. Kromě toho můžete snadno reprodukovat minulé výsledky pomocí uložených experimentů. Další informace o experimentech strojového učení najdete v tématu experimenty strojového učení v Microsoft Fabric.
Pokud chcete sledovat další metriky, parametry a soubory, nastavte
exclusive=False
pro aktualizaci konfigurace automatického protokolování MLflow:mlflow.autolog(exclusive=False)
Trénování dvou modelů pomocí LightGBM Jeden model zpracovává nevyrovnanou datovou sadu a druhý model zpracovává vyváženou datovou sadu (přes SMOTE). Pak porovnejte výkon těchto dvou modelů.
import lightgbm as lgb model = lgb.LGBMClassifier(objective="binary") # Imbalanced dataset smote_model = lgb.LGBMClassifier(objective="binary") # Balanced dataset
# Train LightGBM for both imbalanced and balanced datasets and define the evaluation metrics print("Start training with imbalanced data:\n") with mlflow.start_run(run_name="raw_data") as raw_run: model = model.fit( train[feature_cols], train[TARGET_COL], eval_set=[(test[feature_cols], test[TARGET_COL])], eval_metric="auc", callbacks=[ lgb.log_evaluation(10), ], ) print(f"\n\nStart training with balanced data:\n") with mlflow.start_run(run_name="smote_data") as smote_run: smote_model = smote_model.fit( new_train[feature_cols], new_train[TARGET_COL], eval_set=[(test[feature_cols], test[TARGET_COL])], eval_metric="auc", callbacks=[ lgb.log_evaluation(10), ], )
Určení důležitosti funkcí pro trénování
Určete důležitost funkcí pro model, který jste natrénovali na nevyrovnané datové sadě:
with mlflow.start_run(run_id=raw_run.info.run_id): importance = lgb.plot_importance( model, title="Feature importance for imbalanced data" ) importance.figure.savefig("feauture_importance.png") mlflow.log_figure(importance.figure, "feature_importance.png")
Určete důležitost vlastnosti pro model, který jste vytrénovali na vyvážených datech. SMOTE vygenerovala vyvážená data:
with mlflow.start_run(run_id=smote_run.info.run_id): smote_importance = lgb.plot_importance( smote_model, title="Feature importance for balanced (via SMOTE) data" ) smote_importance.figure.savefig("feauture_importance_smote.png") mlflow.log_figure(smote_importance.figure, "feauture_importance_smote.png")
Při trénování modelu s nevyrovnanou datovou sadou mají důležité funkce významné rozdíly v porovnání s modelem natrénovaným s vyváženou datovou sadou.
Vyhodnocení modelů
Tady vyhodnotíte dva vytrénované modely:
-
model
natrénované na surových, nevyvážených datech -
smote_model
natrénované na vyvážená data
Metriky výpočetního modelu
Definujte funkci
prediction_to_spark
, která provádí předpovědi a převádí výsledky předpovědi na datový rámec Sparku. Pomocí synapseMLpak můžete vypočítat statistiky modelu pro predikce.from pyspark.sql.functions import col from pyspark.sql.types import IntegerType, DoubleType def prediction_to_spark(model, test): predictions = model.predict(test[feature_cols], num_iteration=model.best_iteration_) predictions = tuple(zip(test[TARGET_COL].tolist(), predictions.tolist())) dataColumns = [TARGET_COL, "prediction"] predictions = ( spark.createDataFrame(data=predictions, schema=dataColumns) .withColumn(TARGET_COL, col(TARGET_COL).cast(IntegerType())) .withColumn("prediction", col("prediction").cast(DoubleType())) ) return predictions
Pomocí funkce
prediction_to_spark
můžete provádět předpovědi se dvěma modely,model
asmote_model
:predictions = prediction_to_spark(model, test) smote_predictions = prediction_to_spark(smote_model, test) predictions.limit(10).toPandas()
Výpočetní metriky pro dva modely:
from synapse.ml.train import ComputeModelStatistics metrics = ComputeModelStatistics( evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction" ).transform(predictions) smote_metrics = ComputeModelStatistics( evaluationMetric="classification", labelCol=TARGET_COL, scoredLabelsCol="prediction" ).transform(smote_predictions) display(metrics)
Vyhodnocení výkonu modelu pomocí konfuzní matice
konfuzní matice zobrazuje počet
- pravdivě pozitivní (TP)
- pravé negativy (TN)
- falešně pozitivní (FP)
- falešně negativní případy (FN)
při vyhodnocování pomocí testovacích dat vytvoří model. Pro binární klasifikaci model vrátí konfuzní matici 2x2
. Pro vícetřídovou klasifikaci model vrátí nxn
konfuzní matici, kde n
je počet tříd.
Pomocí konfuzní matice můžete shrnout výkony natrénovaných modelů strojového učení na testovacích datech:
# Collect confusion matrix values cm = metrics.select("confusion_matrix").collect()[0][0].toArray() smote_cm = smote_metrics.select("confusion_matrix").collect()[0][0].toArray() print(cm)
Vykreslete konfuzní matici pro předpovědi
smote_model
(trénováno na vyvážených datech):# Plot the confusion matrix import seaborn as sns def plot(cm): """ Plot the confusion matrix. """ sns.set(rc={"figure.figsize": (5, 3.5)}) ax = sns.heatmap(cm, annot=True, fmt=".20g") ax.set_title("Confusion Matrix") ax.set_xlabel("Predicted label") ax.set_ylabel("True label") return ax with mlflow.start_run(run_id=smote_run.info.run_id): ax = plot(smote_cm) mlflow.log_figure(ax.figure, "ConfusionMatrix.png")
Vykreslujte konfuzní matici pro předpovědi
model
(natrénované na nezpracovaných, nevyvážených datech):with mlflow.start_run(run_id=raw_run.info.run_id): ax = plot(cm) mlflow.log_figure(ax.figure, "ConfusionMatrix.png")
Vyhodnocení výkonu modelu pomocí AUC-ROC a měr AUPRC
Měření plochy pod křivkou charakteristik přijímače (AUC-ROC) vyhodnocuje výkon binárních klasifikátorů. Graf AUC-ROC vizualizuje kompromis mezi skutečnou kladnou mírou (TPR) a falešně pozitivní mírou (FPR).
V některých případech je vhodnější vyhodnotit váš klasifikátor na základě měření plochy pod křivkou Precision-Recall (AUPRC). Křivka AUPRC kombinuje tyto míry:
- Přesnost nebo kladná prediktivní hodnota (PPV)
- Odvolání nebo TPR
Vyhodnotit výkon pomocí měr AUC-ROC a AUPRC:
Definujte funkci, která vrací míry AUC-ROC a AUPRC:
from pyspark.ml.evaluation import BinaryClassificationEvaluator def evaluate(predictions): """ Evaluate the model by computing AUROC and AUPRC with the predictions. """ # Initialize the binary evaluator evaluator = BinaryClassificationEvaluator(rawPredictionCol="prediction", labelCol=TARGET_COL) _evaluator = lambda metric: evaluator.setMetricName(metric).evaluate(predictions) # Calculate AUROC, baseline 0.5 auroc = _evaluator("areaUnderROC") print(f"The AUROC is: {auroc:.4f}") # Calculate AUPRC, baseline positive rate (0.172% in the data) auprc = _evaluator("areaUnderPR") print(f"The AUPRC is: {auprc:.4f}") return auroc, auprc
Zaznamenejte metriky AUC-ROC a AUPRC pro model, který jste vytrénovali na nevyvážených datech.
with mlflow.start_run(run_id=raw_run.info.run_id): auroc, auprc = evaluate(predictions) mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc}) mlflow.log_params({"Data_Enhancement": "None", "DATA_FILE": DATA_FILE})
Zaznamenávejte metriky AUC-ROC a AUPRC pro model, který jste trénovali na vyvážených datech.
with mlflow.start_run(run_id=smote_run.info.run_id): auroc, auprc = evaluate(smote_predictions) mlflow.log_metrics({"AUPRC": auprc, "AUROC": auroc}) mlflow.log_params({"Data_Enhancement": "SMOTE", "DATA_FILE": DATA_FILE})
Model natrénovaný na vyvážených datech vrací vyšší hodnoty AUC-ROC a AUPRC v porovnání s modelem natrénovaným na nevyvážených datech. Na základě těchto opatření se SMOTE jeví jako účinná technika pro zvýšení výkonu modelu při práci s vysoce nevyváženými daty.
Jak ukazuje následující obrázek, všechny experimenty se zaprotokolují s příslušným názvem. V pracovním prostoru můžete sledovat parametry experimentu a metriky výkonu.
Tento obrázek ukazuje metriky výkonu pro model natrénovaný na vyvážené datové sadě (v verze 2):
Pokud chcete zobrazit metriky pro model natrénovaný na nevyrovnané datové sadě, můžete vybrat verze 1. Při porovnání metrik je AUROC vyšší pro model natrénovaný s vyváženou datovou sadou. Tyto výsledky ukazují, že tento model je lepší ve správném predikování tříd 0
jako 0
a tříd 1
jako 1
.
Krok 5: Registrace modelů
Pomocí MLflow zaregistrujte tyto dva modely:
# Register the model
registered_model_name = f"{EXPERIMENT_NAME}-lightgbm"
raw_model_uri = "runs:/{}/model".format(raw_run.info.run_id)
mlflow.register_model(raw_model_uri, registered_model_name)
smote_model_uri = "runs:/{}/model".format(smote_run.info.run_id)
mlflow.register_model(smote_model_uri, registered_model_name)
Krok 6: Uložení výsledků předpovědi
Microsoft Fabric umožňuje uživatelům zprovoznit modely strojového učení pomocí PREDICT
škálovatelné funkce. Tato funkce podporuje dávkové bodování (nebo dávkové odvozování) v jakémkoli výpočetním modulu.
Dávkové předpovědi můžete generovat přímo z poznámkového bloku Microsoft Fabric nebo ze stránky položek modelu. Další informace o PREDICT
naleznete v tématu Modelování bodování pomocí funkce PREDICT v Microsoft Fabric.
Načtěte výkonnější model (verze 2) pro dávkové vyhodnocování a vygenerujte výsledky předpovědi:
from synapse.ml.predict import MLFlowTransformer spark.conf.set("spark.synapse.ml.predict.enabled", "true") model = MLFlowTransformer( inputCols=feature_cols, outputCol="prediction", modelName=f"{EXPERIMENT_NAME}-lightgbm", modelVersion=2, ) test_spark = spark.createDataFrame(data=test, schema=test.columns.to_list()) batch_predictions = model.transform(test_spark)
Uložte předpovědi do jezera:
# Save the predictions to the lakehouse batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")