Assegnazione dei punteggi ai modelli di apprendimento automatico con PREDICT in Microsoft Fabric

Microsoft Fabric consente agli utenti di rendere operativi i modelli di Machine Learning con una funzione scalabile denominata PREDICT, che supporta l'assegnazione dei punteggi batch in qualsiasi motore di calcolo. Gli utenti possono generare stime batch direttamente da un notebook di Microsoft Fabric o dalla pagina dell'elemento di un determinato modello di Machine Learning.

In questo articolo si apprenderà come applicare PREDICT in entrambi i modi, sia che si tratti di scrivere codice manualmente o di usare un'esperienza di interfaccia utente guidata per gestire automaticamente l'assegnazione dei punteggi batch.

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.

  

Limiti

• La funzione PREDICT è attualmente supportata per un set limitato di versioni del modello di Machine Learning, tra cui:
  • PyTorch
  • Sklearn
  • Spark
  • TensorFlow
  • ONNX
  • XGBoost
  • LightGBM
  • CatBoost
  • Statsmodels
  • Prophet
  • Keras
• PREDICT richiede che i modelli ML vengano salvati nel formato MLflow con le relative firme popolate.
• PREDICT non supporta i modelli di Machine Learning con input o output multi-tensor.

Chiamare PREDICT da un notebook

PREDICT supporta i modelli in pacchetto MLflow nel Registro di sistema di Microsoft Fabric. Se nell'area di lavoro è già presente un modello di Machine Learning già sottoposto a training e registrato, è possibile passare al passaggio 2. In caso contrario, il passaggio 1 fornisce codice di esempio che consente di eseguire il training di un modello di regressione logistica di esempio. È possibile usare questo modello per generare stime batch alla fine della procedura.

1. Eseguire il training di un modello di Machine Learning e registrarlo con MLflow. Il codice di esempio seguente usa l'API MLflow per creare un esperimento di Machine Learning e avviare un'esecuzione MLflow per un modello di regressione logistica scikit-learn. La versione del modello viene quindi archiviata e registrata nel Registro di sistema di Microsoft Fabric. Vedere come eseguire il training di modelli di Machine Learning con scikit-learn per altre informazioni sui modelli di training e sul rilevamento di esperimenti personalizzati.

   import mlflow
   import numpy as np 
   from sklearn.linear_model import LogisticRegression 
   from sklearn.datasets import load_diabetes
   from mlflow.models.signature import infer_signature 
   
   mlflow.set_experiment("diabetes-demo")
   with mlflow.start_run() as run:
       lr = LogisticRegression()
       data = load_diabetes(as_frame=True)
       lr.fit(data.data, data.target) 
       signature = infer_signature(data.data, data.target) 
   
       mlflow.sklearn.log_model(
           lr,
           "diabetes-model",
           signature=signature,
           registered_model_name="diabetes-model"
       ) 
   

2. Caricare i dati di test in un dataframe Spark. Per generare stime batch usando il modello di Machine Learning sottoposto a training nel passaggio precedente, sono necessari dati di test sotto forma di dataframe Spark. È possibile sostituire il valore per la variabile test nel codice seguente con i propri dati.

   # You can substitute "test" below with your own data
   test = spark.createDataFrame(data.frame.drop(['target'], axis=1))
   

3. Creare un oggetto MLFlowTransformer per caricare il modello di Machine Learning per l'inferenza. Per creare un oggetto MLFlowTransformer per la generazione di stime batch, è necessario eseguire le azioni seguenti:

   • specificare quali colonne del test DataFrame sono necessarie come input del modello (in questo caso, tutte),
   • scegliere un nome per la nuova colonna di output (in questo caso , predictions) e
   • specificare il nome del modello e la versione del modello corretti per la generazione di tali stime.

   Se si usa un modello di Machine Learning personalizzato, sostituire i valori per le colonne di input, il nome della colonna di output, il nome del modello e la versione del modello.

   from synapse.ml.predict import MLFlowTransformer
   
   # You can substitute values below for your own input columns,
   # output column name, model name, and model version
   model = MLFlowTransformer(
       inputCols=test.columns,
       outputCol='predictions',
       modelName='diabetes-model',
       modelVersion=1
   )
   

4. Generare stime usando la funzione PREDICT. Per richiamare la funzione PREDICT, è possibile usare l'API Transformer, l'API SQL Spark o una funzione definita dall'utente pySpark. Le sezioni seguenti illustrano come generare stime batch con i dati di test e il modello di Machine Learning definiti nei passaggi precedenti, usando i diversi metodi per richiamare PREDICT.

PREDICT con l'API Transformer

Il codice seguente richiama la funzione PREDICT con l'API Transformer. Se si usa un modello di Machine Learning personalizzato, sostituire i valori per il modello e i dati di test.

# You can substitute "model" and "test" below with values  
# for your own model and test data 
model.transform(test).show()

PREDICT con l'API SPARK SQL

Il codice seguente richiama la funzione PREDICT con l'API SQL Spark. Se si usa il proprio modello di Machine Learning, sostituire i valori per model_name, model_version e features con il nome del modello, la versione del modello e le colonne delle funzionalità.

Nota

L'uso dell'API SQL Spark per generare stime richiede comunque la creazione di un oggetto MLFlowTransformer (come nel passaggio 3).

from pyspark.ml.feature import SQLTransformer 

# You can substitute "model_name," "model_version," and "features" 
# with values for your own model name, model version, and feature columns
model_name = 'diabetes-model'
model_version = 1
features = test.columns

sqlt = SQLTransformer().setStatement( 
    f"SELECT PREDICT('{model_name}/{model_version}', {','.join(features)}) as predictions FROM __THIS__")

# You can substitute "test" below with your own test data
sqlt.transform(test).show()

PREDICT con una funzione definita dall'utente

Il codice seguente richiama la funzione PREDICT con una UDF PySpark. Se si usa il proprio modello di Machine Learning, sostituire i valori per il modello e le funzionalità.

from pyspark.sql.functions import col, pandas_udf, udf, lit

# You can substitute "model" and "features" below with your own values
my_udf = model.to_udf()
features = test.columns

test.withColumn("PREDICT", my_udf(*[col(f) for f in features])).show()

Generare il codice PREDICT dalla pagina dell'elemento di un modello di Machine Learning

Dalla pagina degli elementi di qualsiasi modello di Machine Learning è possibile scegliere una delle opzioni seguenti per iniziare a generare stime batch per una versione specifica del modello con PREDICT.

• Usare un'esperienza di interfaccia utente guidata per generare codice PREDICT
• Copiare un modello di codice in un notebook e personalizzare manualmente i parametri

Usare un'esperienza di interfaccia utente guidata

L'esperienza dell'interfaccia utente guidata illustra i passaggi per:

• Selezionare i dati di origine per l'assegnazione dei punteggi
• Eseguire il mapping corretto dei dati agli input del modello di Machine Learning
• Specificare la destinazione per gli output del modello
• Creare un notebook che usa PREDICT per generare e archiviare i risultati della stima

Per usare l'esperienza guidata,

1. Passare alla pagina dell'elemento per una determinata versione del modello di Machine Learning.

2. Selezionare Applica questo modello nella procedura guidata nell'elenco a discesa Applica questa versione.

   

   La selezione apre la finestra "Applica stime del modello di Machine Learning" nel passaggio "Seleziona tabella di input".

3. Selezionare una tabella di input da uno dei lakehouse nell'area di lavoro corrente.

   

4. Selezionare Avanti per passare al passaggio "Mappa colonne di input".

5. Eseguire il mapping dei nomi delle colonne dalla tabella di origine ai campi di input del modello di Machine Learning, estratti dalla firma del modello. È necessario specificare una colonna di input per tutti i campi obbligatori del modello. Inoltre, i tipi di dati per le colonne di origine devono corrispondere ai tipi di dati previsti del modello.

   Suggerimento

   La procedura guidata prepopola questo mapping se i nomi delle colonne della tabella di input corrispondono ai nomi di colonna registrati nella firma del modello di Machine Learning.

   

6. Selezionare Avanti per passare al passaggio "Crea tabella di output".

7. Specificare un nome per una nuova tabella all'interno del lakehouse selezionato dell'area di lavoro corrente. Questa tabella di output archivia i valori di input del modello di Machine Learning con i valori di stima aggiunti. Per impostazione predefinita, la tabella di output viene creata nello stesso lakehouse della tabella di input, ma è disponibile anche l'opzione per modificare il lakehouse di destinazione.

   

8. Selezionare Avanti per passare al passaggio "Mappa colonne di output".

9. Usare i campi di testo forniti per denominare le colonne nella tabella di output in cui sono archiviate le stime del modello di Machine Learning.

   

10. Selezionare Avanti per passare al passaggio "Configura notebook".

11. Specificare un nome per un nuovo notebook che eseguirà il codice PREDICT generato. La procedura guidata visualizza un'anteprima del codice generato in questo passaggio. È possibile copiare il codice negli Appunti e incollarlo in un notebook esistente, se si preferisce.

    

12. Selezionare Avanti per passare al passaggio "Rivedi e termina".

13. Esaminare i dettagli nella pagina di riepilogo e selezionare Crea notebook per aggiungere il nuovo notebook con il codice generato all'area di lavoro. Si passa direttamente a quel notebook, in cui è possibile eseguire il codice per generare e archiviare stime.

    

Usare un modello di codice personalizzabile

Per usare un modello di codice per la generazione di stime batch:

1. Passare alla pagina dell'elemento per una determinata versione del modello di Machine Learning.
2. Selezionare Copia codice da applicare nell'elenco a discesa Applica questa versione. La selezione consente di copiare un modello di codice personalizzabile.

È possibile incollare questo modello di codice in un notebook per generare stime batch con il modello di Machine Learning. Per eseguire correttamente il modello di codice, è necessario sostituire manualmente i valori seguenti:

• <INPUT_TABLE>: percorso del file per la tabella che fornisce input al modello di Machine Learning
• <INPUT_COLS>: matrice di nomi di colonna dalla tabella di input da inserire nel modello di Machine Learning
• <OUTPUT_COLS>: nome di una nuova colonna nella tabella di output in cui sono archiviate le stime
• <MODEL_NAME>: nome del modello di Machine Learning da usare per la generazione di stime
• <MODEL_VERSION>: versione del modello di Machine Learning da usare per la generazione di stime
• <OUTPUT_TABLE>: percorso del file per la tabella in cui sono archiviate le stime

import mlflow 
from synapse.ml.predict import MLFlowTransformer 
 
df = spark.read.format("delta").load( 
    <INPUT_TABLE> # Your input table filepath here
) 
 
model = MLFlowTransformer( 
    inputCols=<INPUT_COLS>, # Your input columns here
    outputCol=<OUTPUT_COLS>, # Your new column name here
    modelName=<MODEL_NAME>, # Your ML model name here
    modelVersion=<MODEL_VERSION> # Your ML model version here
) 
df = model.transform(df) 
 
df.write.format('delta').mode("overwrite").save( 
    <OUTPUT_TABLE> # Your output table filepath here
)  

Contenuto correlato

• Esempio di stima end-to-end usando un modello di rilevamento delle frodi
• Come eseguire il training di modelli di Machine Learning con scikit-learn in Microsoft Fabric