Självstudie: Skapa, utvärdera och poängsätta en modell för bedrägeriidentifiering

I den här självstudien visas ett exempel från slutpunkt till slutpunkt på ett Synapse-Datavetenskap arbetsflöde i Microsoft Fabric. Scenariot bygger en modell för identifiering av bedrägerier med maskininlärningsalgoritmer som tränats på historiska data. Den använder sedan modellen för att identifiera framtida bedrägliga transaktioner.

Den här självstudien beskriver följande steg:

Förutsättningar

• Skaffa en Microsoft Fabric-prenumeration. Eller registrera dig för en kostnadsfri utvärderingsversion av Microsoft Fabric.

• Logga in på Microsoft Fabric.

• Använd upplevelseväxlaren till vänster på startsidan för att växla till Synapse Datavetenskap upplevelse.

  

• Om det behövs skapar du ett Microsoft Fabric Lakehouse enligt beskrivningen i Skapa ett sjöhus i Microsoft Fabric.

Följ med i en notebook-fil

Du kan välja något av följande alternativ för att följa med i en notebook-fil:

• Öppna och kör den inbyggda notebook-filen i Datavetenskap-upplevelsen
• Ladda upp din notebook-fil från GitHub till Datavetenskap upplevelse

Öppna den inbyggda notebook-filen

Exempelanteckningsboken bedrägeriidentifiering medföljer den här självstudien.

Så här öppnar du självstudiekursens inbyggda exempelanteckningsbok i Synapse Datavetenskap upplevelse:

1. Gå till startsidan för Synapse Datavetenskap.

2. Välj Använd ett exempel.

3. Välj motsvarande exempel:

   • Från standardfliken för arbetsflöden från slutpunkt till slutpunkt (Python) om exemplet är för en Python-självstudie.
   • Från fliken Arbetsflöden från slutpunkt till slutpunkt (R) om exemplet är för en R-självstudie.
   • Om exemplet är för en snabb självstudie på fliken Snabbsjälvstudier.

4. Koppla ett lakehouse till notebook-filen innan du börjar köra kod.

Importera anteckningsboken från GitHub

Notebook-filen AIsample – Fraud Detection.ipynb medföljer den här självstudien.

Om du vill öppna den medföljande notebook-filen för den här självstudien följer du anvisningarna i Förbereda systemet för självstudier för datavetenskap för att importera anteckningsboken till din arbetsyta.

Om du hellre vill kopiera och klistra in koden från den här sidan kan du skapa en ny notebook-fil.

Se till att bifoga ett lakehouse i notebook-filen innan du börjar köra kod.

Steg 1: Installera anpassade bibliotek

För utveckling av maskininlärningsmodeller eller ad hoc-dataanalys kan du snabbt behöva installera ett anpassat bibliotek för Apache Spark-sessionen. Du har två alternativ för att installera bibliotek.

• Använd de infogade installationsfunktionerna (%pip eller %conda) i notebook-filen för att installera ett bibliotek, endast i den aktuella notebook-filen.
• Du kan också skapa en Infrastrukturmiljö, installera bibliotek från offentliga källor eller ladda upp anpassade bibliotek till den och sedan kan din arbetsyteadministratör koppla miljön som standard för arbetsytan. Alla bibliotek i miljön blir sedan tillgängliga för användning i alla notebook-filer och Spark-jobbdefinitioner på arbetsytan. Mer information om miljöer finns i skapa, konfigurera och använda en miljö i Microsoft Fabric.

I den här självstudien använder du %pip install för att installera imblearn biblioteket i notebook-filen.

# Use pip to install imblearn
%pip install imblearn

Steg 2: Läs in data

Datamängden för bedrägeriidentifiering innehåller kreditkortstransaktioner från september 2013 som europeiska kortinnehavare gjort under loppet av två dagar. Datamängden innehåller endast numeriska funktioner på grund av en PCA-transformering (Principal Component Analysis) som tillämpas på de ursprungliga funktionerna. PCA omvandlade alla funktioner förutom Time och Amount. För att skydda konfidentialiteten kan vi inte tillhandahålla de ursprungliga funktionerna eller mer bakgrundsinformation om datauppsättningen.

Den här informationen beskriver datamängden:

• Funktionerna V1, V2, V3, ..., V28 är huvudkomponenterna som erhålls med PCA
• Funktionen Time innehåller de förflutna sekunderna mellan en transaktion och den första transaktionen i datamängden
• Funktionen Amount är transaktionsbeloppet. Du kan använda den här funktionen för till exempel beroende, kostnadskänslig inlärning
• Kolumnen Class är variabeln svar (mål). Det har värdet 1 för bedrägeri, och 0 i övrigt

Endast 492 transaktioner, av totalt 284 807 transaktioner, är bedrägliga. Datamängden är mycket obalanserad eftersom minoritetsklassen (bedräglig) endast står för cirka 0,172 % av data.

Den här tabellen visar en förhandsgranskning av creditcard.csv data:

Ladda ned datauppsättningen och ladda upp till lakehouse

Definiera dessa parametrar så att du kan använda den här notebook-filen med olika datauppsättningar:

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

Den här koden laddar ned en offentligt tillgänglig version av datamängden och lagrar den sedan i en Infrastruktursjöhus.

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

Konfigurera MLflow-experimentspårning

Experimentspårningsprocessen sparar all relevant experimentrelaterad information för varje experiment som du kör. Ibland kan du inte få bättre resultat när du kör ett specifikt experiment. I dessa fall bör du stoppa experimentet och prova ett nytt.

Synapse-Datavetenskap i Microsoft Fabric innehåller en funktion för automatisk loggning. Den här funktionen minskar mängden kod som behövs för att automatiskt logga parametrar, mått och objekt i en maskininlärningsmodell under träningen. Funktionen utökar funktionerna för automatisk MLflow-loggning. Den har djup integrering i Datavetenskap erfarenhet.

Med automatisk loggning kan du enkelt spåra och jämföra prestanda för olika modeller och experiment, utan att behöva manuell spårning. Mer information finns i Automatisk loggning i Microsoft Fabric.

Om du vill inaktivera automatisk loggning av Microsoft Fabric i en notebook-session anropar mlflow.autolog() du och anger disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Läsa rådata från lakehouse

Den här koden läser rådata från lakehouse:

df = (
    spark.read.format("csv")
    .option("header", "true")
    .option("inferSchema", True)
    .load(f"{DATA_FOLDER}/raw/{DATA_FILE}")
    .cache()
)

Steg 3: Utföra undersökande dataanalys

I det här avsnittet utforskar du först rådata och statistik på hög nivå. Om du sedan vill omvandla data omvandlar du kolumnerna till rätt typer och konverterar dem från Spark DataFrame till en Pandas DataFrame för enklare visualisering. Slutligen utforskar och visualiserar du klassdistributionerna i data.

Visa rådata

1. Utforska rådata och visa statistik på hög nivå med display kommandot . Mer information om datavisualisering finns i Notebook-visualisering i Microsoft Fabric.

   display(df)
   

2. Skriv ut grundläggande information om datauppsättningen:

   # Print dataset basic information
   print("records read: " + str(df.count()))
   print("Schema: ")
   df.printSchema()
   

Omvandla data

1. Omvandla datauppsättningskolumnerna till rätt typer:

   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. Konvertera Spark DataFrame till en Pandas DataFrame för enklare visualisering och bearbetning:

   df_pd = df.toPandas()
   

Utforska klassdistributionen i datauppsättningen

1. Visa klassfördelningen i datauppsättningen:

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

   Koden returnerar den här datamängdsklassfördelningen: 99,83 % No Frauds och 0,17 % Frauds. Den här klassfördelningen visar att de flesta transaktionerna är icke-infrastrukturfria. Därför krävs förbearbetning av data före modellträning för att undvika överanpassning.

2. Använd ett diagram för att visa klassobalansen i datamängden genom att visa fördelningen av bedrägliga kontra icke-bedrägliga transaktioner:

   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. Visa femtalssammanfattningen (minsta poäng, första kvartilen, median, tredje kvartilen och högsta poäng) för transaktionsbeloppet, med rutor:

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

   För data med hög obalans kan det hända att lådritningar inte visar korrekta insikter. Du kan dock åtgärda obalanssproblemet Class först och sedan skapa samma diagram för mer exakta insikter.

Steg 4: Träna och utvärdera modellerna

Här tränar du en LightGBM-modell för att klassificera bedrägeritransaktionerna. Du tränar en LightGBM-modell på både den obalanserade datamängden och den balanserade datamängden. Sedan jämför du prestandan för båda modellerna.

Förbereda tränings- och testdatauppsättningar

Innan träningen delar du upp data i tränings- och testdatauppsättningarna:

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

Tillämpa SMOTE på träningsdatauppsättningen

Biblioteket imblearn använder smote-metoden (Synthetic Minority Oversampling Technique) för att lösa problemet med obalanserad klassificering. Obalanserad klassificering inträffar när för få exempel på minoritetsklassen är tillgängliga, för att en modell effektivt ska kunna lära sig beslutsgränsen. SMOTE är den mest använda metoden för att syntetisera nya exempel för minoritetsklassen.

Använd endast SMOTE på träningsdatauppsättningen i stället för testdatauppsättningen. När du bedömer modellen med testdata behöver du en uppskattning av modellens prestanda för osedda data i produktionen. För en giltig uppskattning förlitar sig testdata på den ursprungliga obalanserade fördelningen för att representera produktionsdata så nära som möjligt.

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

Mer information om SMOTE finns på referenssidan för scikit-learn för SMOTE-metoden och användarhandboken för scikit-learn om översampling av resurser.

Träna maskininlärningsmodeller och köra experiment

Apache Spark i Microsoft Fabric möjliggör maskininlärning med stordata. Med Apache Spark kan du få värdefulla insikter från stora mängder strukturerade, ostrukturerade och snabba data.

Du har flera tillgängliga alternativ för att träna maskininlärningsmodeller med Apache Spark i Microsoft Fabric: Apache Spark MLlib, SynapseML och andra bibliotek med öppen källkod. Mer information finns i Träna maskininlärningsmodeller i Microsoft Fabric.

Ett maskininlärningsexperiment fungerar som den primära enheten för organisation och kontroll för alla relaterade maskininlärningskörningar. En körning motsvarar en enda körning av modellkod. Spårning av maskininlärningsexperiment omfattar hantering av alla experiment och deras komponenter, till exempel parametrar, mått, modeller och andra artefakter.

För experimentspårning kan du organisera alla nödvändiga komponenter i ett specifikt maskininlärningsexperiment. Dessutom kan du enkelt återskapa tidigare resultat med sparade experiment. Mer information om maskininlärningsexperiment finns i Maskininlärningsexperiment i Microsoft Fabric.

1. Om du vill spåra fler mått, parametrar och filer anger du exclusive=False för att uppdatera konfigurationen för automatisk MLflow-loggning:

   mlflow.autolog(exclusive=False)
   

2. Träna två modeller med LightGBM. Den ena modellen hanterar den obalanserade datamängden och den andra modellen hanterar den balanserade datamängden (via SMOTE). Jämför sedan prestandan för de två modellerna.

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

Fastställa funktionsvikt för träning

1. Fastställa funktionsvikt för den modell som du har tränat på den obalanserade datamängden:

   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. Fastställa funktionsvikt för den modell som du har tränat på balanserade data. SMOTE genererade balanserade 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")
   

För att träna en modell med den obalanserade datamängden har de viktiga funktionerna betydande skillnader jämfört med en modell som tränats med den balanserade datamängden.

Utvärdera modellerna

Här utvärderar du de två tränade modellerna:

• model tränas på rådata, obalanserade data
• smote_model tränas på balanserade data

Beräkningsmodellmått

1. Definiera en prediction_to_spark funktion som utför förutsägelser och konverterar förutsägelseresultatet till en Spark DataFrame. Du kan sedan beräkna modellstatistik för förutsägelseresultatet med SynapseML.

   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. prediction_to_spark Använd funktionen för att utföra förutsägelser med de två modellerna model och smote_model:

   predictions = prediction_to_spark(model, test)
   smote_predictions = prediction_to_spark(smote_model, test)
   predictions.limit(10).toPandas()
   

3. Beräkningsmått för de två modellerna:

   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)
   

Utvärdera modellprestanda med en förvirringsmatris

En förvirringsmatris visar antalet

• sanna positiva identifieringar (TP)
• true negatives (TN)
• falska positiva identifieringar (FP)
• falska negativa (FN)

som en modell producerar när den poängsätts med testdata. För binär klassificering returnerar modellen en 2x2 förvirringsmatris. För multiklassklassificering returnerar modellen en nxn förvirringsmatris, där n är antalet klasser.

1. Använd en förvirringsmatris för att sammanfatta prestanda för de tränade maskininlärningsmodellerna på testdata:

   # 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. Rita sammanblandningsmatrisen för förutsägelserna för smote_model (tränas på balanserade data):

   # 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. Rita sammanblandningsmatrisen för förutsägelserna för model (tränad på rådata, obalanserade data):

   with mlflow.start_run(run_id=raw_run.info.run_id):
       ax = plot(cm)
       mlflow.log_figure(ax.figure, "ConfusionMatrix.png")
   

Utvärdera modellprestanda med AUC-ROC- och AUPRC-mått

Area under måttet Curve Receiver Operating Characteristic (AUC-ROC) utvärderar prestanda för binära klassificerare. AUC-ROC-diagrammet visualiserar kompromissen mellan den sanna positiva kursen (TPR) och den falska positiva kursen (FPR).

I vissa fall är det lämpligare att utvärdera klassificeraren baserat på måttet Område under AUPRC-måttet (Precision-Recall Curve). AUPRC-kurvan kombinerar dessa priser:

• Precisionen eller det positiva prediktiva värdet (PPV)
• Återkallandet, eller TPR

Så här utvärderar du prestanda med måtten AUC-ROC och AUPRC:

1. Definiera en funktion som returnerar måtten AUC-ROC och 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. Logga måtten AUC-ROC och AUPRC för den modell som du har tränat på obalanserade data:

   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. Logga måtten AUC-ROC och AUPRC för den modell som du har tränat på balanserade data:

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

Modellen som tränas på balanserade data returnerar högre AUC-ROC- och AUPRC-värden jämfört med modellen som tränas på obalanserade data. Baserat på dessa mått verkar SMOTE vara en effektiv teknik för att förbättra modellprestanda när du arbetar med mycket obalanserade data.

Som nästa bild visar loggas alla experiment med respektive namn. Du kan spåra experimentparametrar och prestandamått på din arbetsyta.

Den här bilden visar prestandamåtten för modellen som tränats på den balanserade datamängden (i version 2):

Du kan välja Version 1 för att se måtten för modellen som tränats på den obalanserade datamängden. När du jämför måtten är AUROC högre för modellen som tränats med den balanserade datamängden. Dessa resultat indikerar att den här modellen är bättre på att 0 korrekt förutsäga klasser som 0och förutsäga 1 klasser som 1.

Steg 5: Registrera modellerna

Använd MLflow för att registrera de två modellerna:

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

Steg 6: Spara förutsägelseresultatet

Med Microsoft Fabric kan användare operationalisera maskininlärningsmodeller med den PREDICT skalbara funktionen. Den här funktionen stöder batchbedömning (eller batch-slutsatsdragning) i en beräkningsmotor.

Du kan generera batchförutsägelser direkt från Microsoft Fabric-anteckningsboken eller från en modells objektsida. Mer information om PREDICTfinns i Modellbedömning med PREDICT i Microsoft Fabric.

1. Läs in modellen med bättre prestanda (version 2) för batchbedömning och generera förutsägelseresultatet:

   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. Spara förutsägelser till lakehouse:

   # Save the predictions to the lakehouse
   batch_predictions.write.format("delta").mode("overwrite").save(f"{DATA_FOLDER}/predictions/batch_predictions")
   

Relaterat innehåll

• Så här använder du Microsoft Fabric-notebook-filer
• Maskininlärningsmodell i Microsoft Fabric
• Träna maskininlärningsmodeller
• Maskininlärningsexperiment i Microsoft Fabric