Kurz: Vytvoření, vyhodnocení a hodnocení modelu detekce podvodů

Tento kurz představuje kompletní příklad pracovního postupu synapse pro datové vědy v Microsoft Fabric. Scénář vytváří model detekce podvodů s algoritmy machine learning natrénovanými na historická data. 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žijte knihovnu scikit-learn k trénování modelu strojového učení a sledování experimentů pomocí funkcí MLflow a Fabric automatického logování.
Uložení a registrace modelu machine learning s nejvyšším výkonem
Načtení modelu machine learning pro bodování a provedení 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.
Přepněte na Fabric pomocí přepínače prostředí na levé dolní straně domovské stránky.

V případě potřeby vytvořte Microsoft Fabric jezero, jak je popsáno v tématu Vytvoření jezera v Microsoft Fabric.

Sledujte v poznámkovém bloku

Pokud chcete sledovat postup v poznámkovém bloku, zvolte jednu z těchto možností:

Otevřete a spusťte integrovaný poznámkový blok.
Nahrajte poznámkový blok z GitHub.

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 GitHub

Tento kurz doprovází poznámkový blok AIsample - Fraud Detection.ipynb.

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 potřebovat rychle nainstalovat svoji vlastní knihovnu pro relaci Apache Spark. 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 Fabric prostředí, nainstalovat knihovny z veřejných zdrojů nebo do něj nahrát vlastní knihovny a správce pracovního prostoru pak může prostředí připojit jako výchozí pro pracovní prostor. Všechny knihovny v prostředí jsou k dispozici pro použití v libovolném poznámkovém bloku 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 platební karty od září 2013, které v průběhu dvou dnů provedli evropští držitelé karet. 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 nejsou původní funkce nebo více informací o datové sadě k dispozici.

Tyto podrobnosti popisují datovou sadu:

Funkce V1, , V2V3, ... 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 příkladově závislé, na náklady citlivé učení.
Sloupec Class je proměnná odpovědi (cíl). Má hodnotu 1 pro podvod a 0 v ostatních případech.

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 Fabric lakehouse.

Důležitý

Před spuštěním poznámkového bloku přidejte jezero. 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.z13.web.core.windows.net/data/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ůžete získat lepší výsledky při spuštění konkrétního experimentu. V takových případech experiment zastavte a zkuste nový.

Prostředí pro datové vědy Synapse v Microsoft Fabric zahrnuje funkci automatickéhologování. Tato funkce snižuje množství kódu potřebného k automatickému protokolování parametrů, metrik a položek modelu machine learning 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.

Pomocí automatického 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 najdete v tématu Autologging v Microsoft Fabric.

Pokud chcete zakázat automatické protokolování Microsoft Fabric v relaci poznámkového bloku, 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 pomocí příkazu zobrazte statistiky display vysoké úrovně. 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řefitování.

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ů

V tomto kroku 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)

Trénování modelů machine learning a spouštění experimentů

Apache Spark v Microsoft Fabric umožňuje strojové učení s velkými objemy dat. Pomocí 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. Machine learning experiment tracking 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 machine learning experimentu. 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 Učovací experimenty ve 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 nevyváženou datovou sadou zobrazují 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

prediction_to_spark Definujte funkci, která vytváří předpovědi a převádí výsledky předpovědi na datový rámec Sparku. Pak můžete pomocí SynapseML vypočítat statistiky modelu s výsledky předpovědi.

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

Použijte funkci prediction_to_spark k vytváření předpovědí s dvěma modely, model a smote_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ů machine learning 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 je vidět na následujícím obrázku, systém zaznamená každý experiment s příslušným názvem. V pracovním prostoru můžete sledovat parametry experimentu a metriky výkonu.

Následující obrázek ukazuje metriky výkonu pro model natrénovaný na vyvážené datové sadě (ve verzi 2):

Výběrem verze 1 zobrazíte metriky modelu natrénovaného na nevyrovnané datové sadě. Při porovnávání metrik vidíte, že AUROC je 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 0a 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 uživatelé mohou zprovoznit modely strojového učení pomocí škálovatelné funkce PREDICT. 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žky modelu. Další informace o PREDICT naleznete v tématu Model 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")

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-11