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:

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ů.

1. 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.

2. 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.

# 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á hodnotu 1 pro podvod a 0 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:

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.

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

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

2. 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

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

2. 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ě

1. 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í.

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

3. 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.

1. Pokud chcete sledovat další metriky, parametry a soubory, nastavte exclusive=False pro aktualizaci konfigurace automatického protokolování MLflow:

   mlflow.autolog(exclusive=False)
   

2. 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í

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

2. 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

1. 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
   

2. Pomocí funkce prediction_to_spark můžete provádět předpovědi se 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()
   

3. 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.

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

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

3. 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:

1. 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    
   

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

3. 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 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 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 PREDICTnaleznete v tématu Modelování bodování pomocí funkce PREDICT v Microsoft Fabric.

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

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

Související obsah

• Jak používat poznámkové bloky Microsoft Fabric
• model strojového učení v Microsoft Fabric
• Trénování modelů strojového učení
• experimenty strojového učení v Microsoft Fabric