Esercitazione: Creare, valutare e assegnare un punteggio a un modello di rilevamento delle frodi

Questa esercitazione presenta un esempio completo di un flusso di lavoro di Synapse Data Science, in Microsoft Fabric. Lo scenario crea un modello di rilevamento delle frodi con algoritmi di machine learning sottoposti a training sui dati cronologici. Usa quindi il modello per rilevare le transazioni fraudolente future.

Questa esercitazione comprende i seguenti passaggi:

Prerequisiti

• Ottenere una sottoscrizione Microsoft Fabric. In alternativa, iscriversi per ottenere una versione di valutazione gratuita Microsoft Fabric.

• Accedere a Microsoft Fabric.

• Passare a Fabric usando il commutatore dell'esperienza in basso a sinistra della tua home page.

  

• Se necessario, crea un lakehouse di Microsoft Fabric come descritto in Creare un lakehouse in Microsoft Fabric.

Segui con un blocco per appunti

Per seguire la procedura in un notebook, scegliere una di queste opzioni:

• Aprire ed eseguire il notebook predefinito.
• Caricare il notebook da GitHub.

Aprire il notebook predefinito

Il notebook di esempio Rilevamento Frodi accompagna questa esercitazione.

1. Per aprire il notebook di esempio per questa esercitazione, seguire le istruzioni riportate in Preparare il sistema per le esercitazioni sull'analisi scientifica dei dati.

2. Assicurarsi di collegare una lakehouse al notebook prima di iniziare a eseguire il codice.

Importare il notebook da GitHub

Il notebook AIsample - Fraud Detection.ipynb accompagna questa esercitazione.

• Per aprire il notebook di accompagnamento per questa esercitazione, seguire le istruzioni riportate in Preparare il sistema per le esercitazioni di data science per importare il notebook nell'area di lavoro.

• Se preferisci copiare e incollare il codice in questa pagina, puoi creare un nuovo notebook.

• Assicurati di collegare un lakehouse al notebook prima di iniziare a eseguire il codice.

Passaggio 1: Installare librerie personalizzate

Per lo sviluppo di modelli di machine learning o l'analisi dei dati su richiesta, potrebbe essere necessario installare rapidamente una libreria personalizzata per la sessione di Apache Spark. Sono disponibili due opzioni per installare le librerie.

• Usare le funzionalità di installazione inline (%pip o %conda) del notebook per installare una libreria solo nel notebook corrente.
• In alternativa, è possibile creare un ambiente Fabric, installare librerie da origini pubbliche o caricarvi librerie personalizzate e quindi l'amministratore dell'area di lavoro può collegare l'ambiente come predefinito per l'area di lavoro. Tutte le librerie nell'ambiente sono disponibili per l'uso nei notebook e nelle definizioni di job Spark nell'area di lavoro. Per altre informazioni sugli ambienti, vedere creare, configurare e usare un ambiente in Microsoft Fabric.

Per questa esercitazione, utilizzare %pip install per installare la libreria imblearn nel notebook.

# Use pip to install imblearn
%pip install imblearn

Passaggio 2: caricare i dati

Il set di dati di rilevamento delle frodi contiene le transazioni con carta di credito di settembre 2013 effettuate dai titolari di carte europee nel corso di due giorni. Il set di dati contiene solo funzionalità numeriche a causa di una trasformazione di Analisi delle Componenti Principali (PCA) applicata alle funzionalità originali. PCA ha trasformato tutte le caratteristiche ad eccezione di Time e Amount. Per proteggere la riservatezza, le funzionalità originali o altre informazioni generali sul set di dati non sono disponibili.

Questi dettagli descrivono il set di dati:

• Le V1, V2, V3, ..., V28 sono i componenti principali ottenuti con il PCA.
• La Time funzionalità contiene i secondi trascorsi tra una transazione e la prima transazione nel set di dati.
• La funzionalità Amount è l'importo della transazione. È possibile utilizzare questa funzionalità per l'apprendimento dipendente da esempi e sensibile ai costi.
• La colonna Class è la variabile di risposta (target). Ha il valore 1 per le frodi e 0 in caso contrario.

Solo 492 transazioni, su un totale di 284.807 transazioni, sono fraudolente. Il set di dati è altamente sbilanciato, perché la classe di minoranza (fraudolenta) rappresenta solo circa lo 0,172% dei dati.

Questa tabella mostra un'anteprima dei dati creditcard.csv:

Scaricare il set di dati e caricarlo nel lakehouse

Definire questi parametri in modo che sia possibile usare questo notebook con set di dati diversi:

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

Questo codice scarica una versione disponibile pubblicamente del set di dati e quindi la archivia in un lakehouse di Fabric.

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

Configurare il rilevamento dell'esperimento MLflow

Il processo di rilevamento dell'esperimento salva tutte le informazioni pertinenti relative all'esperimento per ogni esperimento eseguito. In alcuni casi, non è possibile ottenere risultati migliori quando si esegue un esperimento specifico. In questi casi, arrestare l'esperimento e provarne uno nuovo.

L'esperienza di data science di Synapse in Microsoft Fabric include una funzionalità di registrazione automatica. Questa funzionalità riduce la quantità di codice necessaria per registrare automaticamente i parametri, le metriche e gli elementi di un modello di machine learning durante il training. La funzionalità estende le capacità di autologging di MLflow. Offre un'integrazione approfondita nell'esperienza di data science.

Usando il tracciamento automatico, è possibile monitorare e confrontare facilmente le prestazioni di modelli e esperimenti diversi, senza la necessità di registrazione manuale. Per altre informazioni, vedere Autologging in Microsoft Fabric.

Per disabilitare il login automatico di Microsoft Fabric in una sessione del notebook, chiamare mlflow.autolog() e impostare disable=True:

# Set up MLflow for experiment tracking
import mlflow

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

Leggere i dati non elaborati dal lakehouse

Questo codice legge i dati non elaborati dal lakehouse:

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

Passaggio 3: eseguire l'analisi esplorativa dei dati

In questa sezione vengono innanzitutto esaminati i dati non elaborati e le statistiche di alto livello. Quindi, per trasformare i dati, eseguire il cast delle colonne nei tipi corretti e convertirli dal dataframe Spark in un dataframe pandas per semplificare la visualizzazione. Infine, si esplorano e si visualizzano le distribuzioni di classi nei dati.

Visualizzare i dati non elaborati

1. Esplorare i dati non elaborati e visualizzare statistiche di alto livello usando il display comando . Per ulteriori informazioni sulla visualizzazione dei dati, consultare la visualizzazione dei Notebook in Microsoft Fabric.

   display(df)
   

2. Stampare alcune informazioni di base sul set di dati:

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

Trasformazione dei dati

1. Effettuare il cast delle colonne del set di dati nei tipi corretti:

   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. Convertire il dataframe Spark in un dataframe pandas per semplificare la visualizzazione e l'elaborazione:

   df_pd = df.toPandas()
   

Esplorare la distribuzione delle classi nel set di dati

1. Visualizzare la distribuzione della classe nel set di dati:

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

   Il codice restituisce questa distribuzione della classe del dataset: No Frauds 99,83% e Frauds 0,17%. Questa distribuzione di classi mostra che la maggior parte delle transazioni non è fraudolenta. Pertanto, la pre-elaborazione dei dati è necessaria prima del training del modello per evitare l'overfitting.

2. Usare un tracciato per visualizzare lo squilibrio della classe nel set di dati visualizzando la distribuzione delle transazioni fraudolente e nonfradulente:

   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. Mostra il riepilogo a cinque numeri (punteggio minimo, primo quartile, mediano, terzo quartile e punteggio massimo) per l'importo della transazione, con tracciati box:

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

   Per dati altamente sbilanciati, i diagrammi a scatola potrebbero non mostrare approfondimenti accurati. Tuttavia, è possibile risolvere prima il problema di squilibrio Class e quindi creare gli stessi tracciati per ottenere approfondimenti più accurati.

Passaggio 4: eseguire il training e valutare i modelli

In questo passaggio si esegue il training di un modello LightGBM per classificare le transazioni illecite. Si esegue il training di un modello LightGBM sia nel set di dati sbilanciato che nel set di dati bilanciato. Quindi, confrontare le prestazioni di entrambi i modelli.

Preparare i set di dati di training e di test

Prima dell'addestramento, suddividere i dati nei set di dati di addestramento e di test.

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

Applicare SMOTE al set di dati di addestramento

La libreria imblearn utilizza l'approccio SMOTE (Synthetic Minority Oversampling Technique) per risolvere il problema della classificazione sbilanciata. La classificazione sbilanciata si verifica quando sono disponibili troppo pochi esempi della classe di minoranza, affinché un modello possa apprendere efficacemente il confine decisionale. SMOTE è l'approccio più diffuso per sintetizzare nuovi campioni per la classe di minoranza.

Applicare SMOTE solo al set di dati di training anziché al set di dati di test. Quando si assegna un punteggio al modello con i dati di test, è necessaria un'approssimazione delle prestazioni del modello sui dati non visualizzati nell'ambiente di produzione. Per un'approssimazione valida, i dati di test si basano sulla distribuzione originale sbilanciata per rappresentare i dati di produzione il più possibile.

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

Per altre informazioni su SMOTE, vedere la pagina di riferimento scikit-learn per il metodo SMOTE e la guida dell'utente scikit-learn sulle risorse di sovracampionamento.

Addestrare modelli di apprendimento automatico e condurre esperimenti

Apache Spark, in Microsoft Fabric, abilita machine learning con Big Data. Usando Apache Spark, è possibile ottenere informazioni dettagliate preziose da grandi quantità di dati strutturati, non strutturati e in rapida evoluzione.

Sono disponibili diverse opzioni per eseguire il training di modelli machine learning con Apache Spark in Microsoft Fabric: Apache Spark MLlib, SynapseML e altre librerie open source. Per ulteriori informazioni, vedere Addestrare modelli di machine learning in Microsoft Fabric.

Un esperimento machine learning funge da unità primaria di organizzazione e controllo per tutte le esecuzioni di machine learning correlate. Un run corrisponde a una singola esecuzione del codice del modello. Machine learning tracciamento degli esperimenti implica la gestione di tutti gli esperimenti e dei relativi componenti, ad esempio parametri, metriche, modelli e altri artefatti.

Per il rilevamento dell'esperimento, è possibile organizzare tutti i componenti necessari di un esperimento di machine learning specifico. Inoltre, è possibile riprodurre facilmente i risultati precedenti con esperimenti salvati. Per ulteriori informazioni sugli esperimenti di apprendimento automatico, vedere Esperimenti di apprendimento automatico in Microsoft Fabric.

1. Per tenere traccia di altre metriche, parametri e file, impostare exclusive=False per aggiornare la configurazione di autologging di MLflow.

   mlflow.autolog(exclusive=False)
   

2. Allenare due modelli con LightGBM. Un modello gestisce il set di dati sbilanciato e l'altro modello gestisce il set di dati bilanciato (tramite SMOTE). Confrontare quindi le prestazioni dei due modelli.

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

Determinare l'importanza delle caratteristiche per l'addestramento

1. Determinare l'importanza delle caratteristiche per il modello che hai allenato sul set di dati sbilanciato.

   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. Determina l'importanza della caratteristica per il modello che hai addestrato su dati bilanciati. SMOTE ha generato i dati bilanciati:

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

Quando si esegue il training di un modello con il set di dati sbilanciato, le caratteristiche importanti mostrano differenze significative rispetto a un modello sottoposto a training con il set di dati bilanciato.

Valutare i modelli

In questo caso, si valutano i due modelli sottoposti a training:

• model addestrato su dati grezzi e sbilanciati
• smote_model addestrato su dati bilanciati

Metriche del modello di calcolo

1. Definire una prediction_to_spark funzione che esegue stime e converte i risultati della stima in un dataframe Spark. È quindi possibile calcolare le statistiche del modello sui risultati della stima usando 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. Usare la prediction_to_spark funzione per eseguire stime con i due modelli model e smote_model:

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

3. Metriche di calcolo per i due modelli:

   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)
   

Valutare le prestazioni del modello con una matrice di confusione

Una matrice di confusione visualizza il numero di

• veri positivi (TP)
• veri negativi (TN)
• falsi positivi (FP)
• falsi negativi (FN)

che un modello produce quando viene ottenuto un punteggio con i dati di test. Per la classificazione binaria, il modello restituisce una matrice di confusione 2x2. Per la classificazione multiclasse, il modello restituisce una matrice di confusione nxn, dove n è il numero di classi.

1. Usare una matrice di confusione per riepilogare le prestazioni dei modelli di machine learning sottoposti a training sui dati di test:

   # 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. Tracciare la matrice di confusione per le previsioni di smote_model (sottoposto a training su dati bilanciati):

   # 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. Traccia la matrice di confusione per le predizioni di model (addestrato su dati grezzi e sbilanciati):

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

Valutare le prestazioni del modello con misure AUC-ROC e AUPRC

La misura Area sotto la curva Caratteristica di funzionamento del ricevitore (AUC-ROC) valuta le prestazioni dei classificatori binari. Il grafico AUC-ROC visualizza il compromesso tra il tasso positivo reale (TPR) e il tasso falso positivo (FPR).

In alcuni casi, è più appropriato valutare il classificatore in base alla misura dell'Area sotto la curva Precisione-Richiamo (AUPRC). La curva AUPRC combina queste frequenze:

• Precisione o valore predittivo positivo (PPV)
• Richiamo o TPR

Per valutare le prestazioni con le misure AUC-ROC e AUPRC:

1. Definire una funzione che restituisce le misure AUC-ROC e 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. Registrare le metriche AUC-ROC e AUPRC per il modello addestrato su dati sbilanciati.

   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. Registrare le metriche AUC-ROC e AUPRC per il modello sottoposto a training sui dati bilanciati:

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

Il modello sottoposto a training sui dati bilanciati restituisce valori AUC-ROC e AUPRC superiori rispetto al modello sottoposto a training sui dati sbilanciati. In base a queste misure, SMOTE sembra una tecnica efficace per migliorare le prestazioni del modello quando si lavora con dati altamente sbilanciati.

Come illustrato nell'immagine seguente, il sistema registra ogni esperimento con il rispettivo nome. È possibile tenere traccia dei parametri dell'esperimento e delle metriche delle prestazioni nell'area di lavoro.

Screenshot dell'esperimento rilevato.

L'immagine seguente mostra le metriche delle prestazioni per il modello sottoposto a training nel set di dati bilanciato (nella versione 2):

Schermata delle metriche delle prestazioni registrate del modello e dei parametri del modello.

Selezionare Versione 1 per visualizzare le metriche per il modello sottoposto a training nel set di dati sbilanciato. Quando si confrontano le metriche, si noterà che l'AUROC è superiore per il modello sottoposto a training con il set di dati bilanciato. Questi risultati indicano che questo modello è migliore nel prevedere correttamente le classi 0 come 0, e prevedere le classi 1 come 1.

Passaggio 5: Registrazione dei modelli

Usare MLflow per registrare i due modelli:

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

Passaggio 6: Salvare i risultati della stima

Microsoft Fabric gli utenti possono rendere operativi i modelli di machine learning usando la funzione scalabile PREDICT. Questa funzione supporta la valutazione in batch (o inferenza in batch) in qualsiasi motore di calcolo.

È possibile generare stime batch direttamente dal notebook Microsoft Fabric o dalla pagina dell'elemento di un modello. Per ulteriori informazioni su PREDICT, consultare Valutazione del modello con PREDICT in Microsoft Fabric.

1. Caricare il modello con prestazioni migliori (versione 2) per l'assegnazione dei punteggi batch e generare i risultati della stima:

   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. Salvare le previsioni nel Lakehouse

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

Contenuto correlato

• Come usare Microsoft Fabric notebook
• Modello di machine learning in Microsoft Fabric
• Allena modelli di apprendimento automatico
• Esperimenti di machine learning in Microsoft Fabric