Valutazione del modello di machine learning con PREDICT in Microsoft Fabric

Microsoft Fabric consente di rendere operativi i modelli machine learning usando la funzione PREDICT scalabile. Questa funzione supporta l'assegnazione dei punteggi batch in qualsiasi motore di calcolo. È possibile generare stime batch direttamente da un notebook Microsoft Fabric o dalla pagina degli elementi di un determinato modello di Machine Learning.

In questo articolo si apprenderà come applicare PREDICT scrivendo codice manualmente o usando un'esperienza guidata dell'interfaccia utente che gestisce automaticamente l'assegnazione dei punteggi batch.

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.

  

Limiti

• La funzione PREDICT supporta attualmente solo le versioni del modello di Machine Learning seguenti:
  • CatBoost
  • Keras
  • LightGBM
  • ONNX
  • Prophet
  • PyTorch
  • Sklearn
  • Spark
  • Statsmodels
  • TensorFlow
  • XGBoost
• PREDICT richiede di salvare i modelli di Machine Learning nel formato MLflow, con le relative firme popolate.
• PREDICT non supporta i modelli di apprendimento automatico con ingressi o uscite multitensore.

Chiamare PREDICT da un notebook

PREDICT supporta i modelli in pacchetto MLflow nel registro di Microsoft Fabric. Se nell'area di lavoro esiste 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. 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. L'esempio di codice successivo usa l'API MLflow per creare un esperimento di machine learning e quindi avvia un'esecuzione MLflow per un modello di regressione logistica scikit-learn. La versione del modello viene quindi archiviata e registrata nel Registro di sistema Microsoft Fabric. Per altre informazioni sui modelli di training e sul rilevamento di esperimenti personalizzati, vedere come eseguire il training di modelli di Machine Learning con scikit-learn.

   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 con il modello di Machine Learning sottoposto a training nel passaggio precedente, sono necessari dati di test sotto forma di dataframe Spark. Nel codice seguente sostituire il valore della test variabile 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 MLFlowTransformer oggetto per generare stime batch, eseguire queste azioni:

   • Specificare le test colonne del dataframe necessarie come input del modello (in questo caso, tutte).
   • Scegliere un nome per la nuova colonna di output (in questo caso, predictions).
   • 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, 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 la funzione PREDICT.

PREDICT con l'API Transformer

Questo codice 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

Questo codice chiama la funzione PREDICT usando l'API SPARK SQL. Se si usa un modello di Machine Learning personalizzato, sostituire i valori per model_name, model_versione features con il nome del modello, la versione del modello e le colonne delle funzionalità.

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

Questo codice chiama la funzione PREDICT utilizzando una UDF PySpark. Se si usa un modello di Machine Learning personalizzato, 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 dell'elemento di qualsiasi modello di Machine Learning è possibile scegliere una di queste opzioni per avviare la generazione di stime batch per una versione specifica del modello, usando la funzione PREDICT:

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

Usare un'esperienza di interfaccia utente guidata

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

1. Selezionare i dati di origine per l'assegnazione dei punteggi.
2. Eseguire il mapping dei dati correttamente agli input del modello di Machine Learning.
3. Specificare la destinazione per gli output del modello.
4. 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. Nell'elenco Applica questa versione selezionare Applica questo modello nella procedura guidata.

   

   Nel passaggio "Select input table" (Seleziona tabella di input) viene visualizzata la finestra "Apply ML model predictions" (Applica stime del modello di Machine Learning).

3. Seleziona una tabella di input da una lakehouse nel tuo spazio di lavoro corrente.

   

4. Selezionare Avanti per passare alla fase "Mappatura colonne di input".

5. Mappare i nomi delle colonne dalla tabella di origine ai campi di input del modello di Machine Learning, che vengono estratti dalla signature del modello. È necessario specificare una colonna di input per tutti i campi obbligatori del modello. Inoltre, i tipi di dati della colonna di origine devono corrispondere ai tipi di dati previsti del modello.

   Suggerimento

   L'assistente prepopola questo mapping se i nomi delle colonne della tabella di input corrispondono ai nomi di colonna registrati nella firma del modello di apprendimento automatico.

   

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

7. Specifica il nome di una nuova tabella nel lakehouse selezionato nell'area di lavoro corrente. Questa tabella di output archivia i valori di input del modello di Machine Learning e aggiunge i valori di stima a tale tabella. Per impostazione predefinita, la tabella di output viene creata nella stessa lakehouse della tabella di input. È possibile modificare il lakehouse di destinazione.

   

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

9. Usare i campi di testo forniti per denominare le colonne della 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 esegue il codice PREDICT generato. La procedura guidata visualizza un'anteprima del codice generato in questo passaggio. Se si vuole, è possibile copiare il codice negli Appunti e incollarlo in un notebook esistente.

    

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 copia 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, 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