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

Questa esercitazione presenta un esempio end-to-end di un flusso di lavoro di data science synapse 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 di Microsoft Fabric. In alternativa, iscriversi per ottenere una versione di valutazione di Microsoft Fabric gratuita.

• Accedere a Microsoft Fabric.

• Usare l’opzione esperienza sul lato sinistro della home page per passare all'esperienza Science di Synapse.

  

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

Seguire la procedura in un notebook

È possibile scegliere una di queste opzioni per seguire la procedura in un notebook:

• Aprire ed eseguire il notebook predefinito nell'esperienza Data Science
• Caricare il notebook da GitHub nell'esperienza Data Science

Aprire il notebook predefinito

Il notebook di rilevamento delle frodi di esempio accompagna questa esercitazione.

Per aprire il notebook di esempio predefinito dell'esercitazione nell'esperienza Synapse Data Science:

1. Passare alla home page di Synapse Data Science.

2. Selezionare Usa un esempio.

3. Selezionare l’esempio corrispondente:

   • Dalla scheda predefinita Flussi di lavoro end-to-end (Python), se l'esempio è relativo a un'esercitazione su Python.
   • Dalla scheda Flussi di lavoro end-to-end (R), se l'esempio è relativo a un'esercitazione su R.
   • Dalla scheda Esercitazioni rapide, se l'esempio è relativo a un'esercitazione rapida.

4. Collegare un 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 si preferisce copiare e incollare il codice da questa pagina, è possibile creare un nuovo notebook.

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

Passaggio 1: Installare librerie personalizzate

Per lo sviluppo di modelli di apprendimento automatico o l'analisi dei dati ad hoc, 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 diventano quindi disponibili per l'uso in qualsiasi notebook e definizione del processo Spark nell'area di lavoro. Per altre informazioni sugli ambienti, vedere creare, configurare e usare un ambiente in Microsoft Fabric.

Per questa esercitazione, usare %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 da titolari di carte europei 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 funzionalità ad eccezione di Time e Amount. Per proteggere la riservatezza, non è possibile fornire le funzionalità originali o altre informazioni di base sul set di dati.

Questi dettagli descrivono il set di dati:

• Le funzionalità V1, V2, V3, ..., V28 sono i componenti principali ottenuti con PCA
• La funzionalità Time contiene i secondi trascorsi tra una transazione e la prima transazione nel set di dati
• La funzionalità Amount è l'importo della transazione. È possibile usare questa funzionalità per l'apprendimento sensibile ai costi dipendente dall'esempio
• La colonna Class è la variabile di risposta (destinazione). 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 da poter 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.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.")

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, è consigliabile arrestare l'esperimento e provarne uno nuovo.

L'esperienza di data science di Synapse in Microsoft Fabric include una funzionalità di assegnazione automatica dei tag. 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 funzionalità di assegnazione automatica di MLflow. Offre un'integrazione approfondita nell'esperienza di data science.

Con l'assegnazione automatica, è possibile tenere traccia e confrontare facilmente le prestazioni di diversi modelli e esperimenti, senza la necessità di tenere traccia manuale. Per altre informazioni, vedere Autologging in Microsoft Fabric.

Per disabilitare l'autologging 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 le statistiche di alto livello con il comando display. Per altre informazioni sulla visualizzazione dei dati, vedere Visualizzazione 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. Eseguire 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 set di dati: 99,83% No Frauds e 0,17% Frauds. 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 i dati altamente sbilanciati, i tracciati box potrebbero non mostrare approfondimenti accurati. Tuttavia, è possibile risolvere prima il problema di Class di squilibrio e quindi creare gli stessi tracciati per approfondimenti più accurati.

Passaggio 4: eseguire il training e valutare i modelli

In questo caso si esegue il training di un modello LightGBM per classificare le transazioni di frode. 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 del training, suddividere i dati nei set di dati di training e 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 training

La libreria imblearn usa l'approccio SMOTE (Synthetic Minority Oversampling Technique) per risolvere il problema della classificazione sbilanciata. La classificazione sbilanciata si verifica quando sono disponibili troppi esempi della classe di minoranza, per consentire a un modello di apprendere efficacemente il limite 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.

Eseguire il training di modelli di apprendimento automatico ed eseguire gli esperimenti

Apache Spark, in Microsoft Fabric, consente l'apprendimento automatico con Big Data. Con Apache Spark è possibile ottenere informazioni dettagliate preziose da grandi quantità di dati strutturati, non strutturati e veloci.

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

Un esperimento di Machine Learning funge da unità primaria di organizzazione e controllo per tutte le esecuzioni di Machine Learning correlate. Un'esecuzione corrisponde a una singola esecuzione del codice dei modelli. Il rilevamento degli esperimenti di Machine Learning 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 altre informazioni, 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 dell'assegnazione automatica di tag MLflow:

   mlflow.autolog(exclusive=False)
   

2. Eseguire il training di 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 della funzionalità per il training

1. Determinare l'importanza di funzionalità per il modello sottoposto a training nel 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. Determinare l'importanza della funzionalità per il modello sottoposto a training 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")
   

Per eseguire il training di un modello con il set di dati sbilanciato, le caratteristiche importanti presentano 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 sottoposto a training su dati non elaborati e sbilanciati
• smote_model sottoposto a training su dati bilanciati

Metriche del modello di calcolo

1. Definire una funzione prediction_to_spark che esegue stime e converte i risultati della stima in un dataframe Spark. È quindi possibile calcolare le statistiche del modello sui risultati della stima con 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 funzione prediction_to_spark 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 stime 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. Tracciare la matrice di confusione per le stime di model (sottoposto a training su dati non elaborati 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 Area Sotto la curva di richiamo della precisione (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 sottoposto a training sui 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 successiva, qualsiasi esperimento viene registrato con il rispettivo nome. È possibile tenere traccia dei parametri dell'esperimento e delle metriche delle prestazioni nell'area di lavoro.

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

È possibile selezionare la versione 1 per visualizzare le metriche per il modello sottoposto a training nel set di dati sbilanciato. Quando si confrontano le metriche, l'AUROC è superiore per il modello sottoposto a training con il set di dati bilanciato. Questi risultati indicano che questo modello è migliore per stimare correttamente le classi 0 come 0, e stimare 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 consente agli utenti di rendere operativi i modelli di Machine Learning con la funzione scalabile PREDICT. Questa funzione supporta l'assegnazione dei punteggi batch (o l'inferenza batch) in qualsiasi motore di calcolo.

È possibile generare stime batch direttamente dal notebook di Microsoft Fabric o dalla pagina dell'elemento di un modello. Per altre informazioni su PREDICT, vedere Assegnazione dei punteggi ai modelli di Machine Learning 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 stime 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 i notebook di Microsoft Fabric
• Modello di apprendimento automatico in Microsoft Fabric
• Eseguire il training di modelli di Machine Learning
• Esperimenti di apprendimento automatico in Microsoft Fabric