Bedömning av maskininlärningsmodeller med PREDICT i Microsoft Fabric

Med Microsoft Fabric kan användare operationalisera maskininlärningsmodeller med en skalbar funktion som kallas PREDICT, som stöder batchbedömning i alla beräkningsmotorer. Användare kan generera batchförutsägelser direkt från en Microsoft Fabric-notebook-fil eller från en viss ML-modells objektsida.

I den här artikeln får du lära dig hur du använder PREDICT åt båda hållen, oavsett om du är mer bekväm med att skriva kod själv eller använda en guidad användargränssnittsupplevelse för att hantera batchbedömning åt dig.

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.

  

Begränsningar

• Funktionen PREDICT stöds för närvarande för en begränsad uppsättning ML-modellsmaker, inklusive:
  • PyTorch
  • Sklearn
  • Spark
  • TensorFlow
  • ONNX
  • XGBoost
  • LightGBM
  • CatBoost
  • Statsmodels
  • Profeten
  • Keras
• PREDICT kräver att ML-modeller sparas i MLflow-format med deras signaturer ifyllda.
• PREDICT stöder inte ML-modeller med multi-tensor-indata eller utdata.

Anropa PREDICT från en notebook-fil

PREDICT stöder MLflow-paketerade modeller i Microsoft Fabric-registret. Om det finns en redan tränad och registrerad ML-modell på din arbetsyta kan du gå vidare till steg 2. Om inte, innehåller steg 1 exempelkod som hjälper dig att träna en exempellogistikregressionsmodell. Du kan använda den här modellen för att generera batchförutsägelser i slutet av proceduren.

1. Träna en ML-modell och registrera den med MLflow. Följande exempelkod använder MLflow-API:et för att skapa ett maskininlärningsexperiment och starta en MLflow-körning för en scikit-learn logistic regression-modell. Modellversionen lagras och registreras sedan i Microsoft Fabric-registret. Se hur du tränar ML-modeller med scikit-learn för att lära dig mer om träningsmodeller och egna spårningsexperiment.

   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. Läs in i testdata som en Spark DataFrame. För att generera batchförutsägelser med ml-modellen som tränades i föregående steg behöver du testdata i form av en Spark DataFrame. Du kan ersätta värdet för variabeln test i följande kod med dina egna data.

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

3. Skapa ett MLFlowTransformer objekt för att läsa in ML-modellen för slutsatsdragning. Om du vill skapa ett MLFlowTransformer objekt för att generera batchförutsägelser måste du utföra följande åtgärder:

   • ange vilka kolumner från dataramen test som du behöver som modellindata (i det här fallet alla).
   • välj ett namn för den nya utdatakolumnen (i det här fallet predictions), och
   • ange rätt modellnamn och modellversion för att generera dessa förutsägelser.

   Om du använder din egen ML-modell ersätter du värdena för indatakolumnerna, utdatakolumnens namn, modellnamn och modellversion.

   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. Generera förutsägelser med funktionen PREDICT. Om du vill anropa funktionen PREDICT kan du använda Transformer API, Spark SQL API eller en användardefinierad PySpark-funktion (UDF). Följande avsnitt visar hur du genererar batchförutsägelser med testdata och ML-modellen som definierats i föregående steg, med hjälp av de olika metoderna för att anropa PREDICT.

FÖRUTSÄGA med transformerings-API:et

Följande kod anropar funktionen PREDICT med Transformer-API:et. Om du har använt din egen ML-modell ersätter du värdena för modellen och testar data.

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

FÖRUTSÄGA med Spark SQL API

Följande kod anropar funktionen PREDICT med Spark SQL API. Om du har använt din egen ML-modell ersätter du värdena för model_name, model_versionoch features med modellnamn, modellversion och funktionskolumner.

Kommentar

Om du använder Spark SQL API för att generera förutsägelser måste du fortfarande skapa ett MLFlowTransformer objekt (som i steg 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 med en användardefinierad funktion

Följande kod anropar funktionen PREDICT med en PySpark UDF. Om du har använt din egen ML-modell ersätter du värdena för modellen och funktionerna.

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

Generera PREDICT-kod från en ML-modells objektsida

Från en ML-modells objektsida kan du välja något av följande alternativ för att börja generera batchförutsägelser för en specifik modellversion med PREDICT.

• Använda en guidad användargränssnittsupplevelse för att generera PREDICT-kod
• Kopiera en kodmall till en notebook-fil och anpassa parametrarna själv

Använda en guidad användargränssnittsupplevelse

Den guidade användargränssnittsupplevelsen vägleder dig genom steg för att:

• Välj källdata för bedömning
• Mappa data korrekt till ML-modellens indata
• Ange målet för modellens utdata
• Skapa en notebook-fil som använder PREDICT för att generera och lagra förutsägelseresultat

Om du vill använda den guidade upplevelsen

1. Gå till objektsidan för en viss ML-modellversion.

2. Välj Använd den här modellen i guiden i listrutan Tillämpa den här versionen .

   

   Markeringen öppnar fönstret "Tillämpa ML-modellförutsägelser" i steget "Välj indatatabell".

3. Välj en indatatabell från ett av sjöhusen på din aktuella arbetsyta.

   

4. Välj Nästa för att gå till steget "Mappa indatakolumner".

5. Mappa kolumnnamn från källtabellen till ML-modellens indatafält, som hämtas från modellens signatur. Du måste ange en indatakolumn för alla modellens obligatoriska fält. Dessutom måste datatyperna för källkolumnerna matcha modellens förväntade datatyper.

   Dricks

   Guiden fyller i den här mappningen i förväg om namnen på indatatabellens kolumner matchar kolumnnamnen som loggas i ML-modellsignaturen.

   

6. Välj Nästa för att gå till steget "Skapa utdatatabell".

7. Ange ett namn för en ny tabell i den valda lakehouse för din aktuella arbetsyta. Den här utdatatabellen lagrar ML-modellens indatavärden med de förutsägelsevärden som läggs till. Som standard skapas utdatatabellen i samma lakehouse som indatatabellen, men alternativet att ändra målsjöhuset är också tillgängligt.

   

8. Välj Nästa för att gå till steget "Mappa utdatakolumner".

9. Använd de angivna textfälten för att namnge kolumnerna i utdatatabellen som lagrar ML-modellens förutsägelser.

   

10. Välj Nästa för att gå till steget "Konfigurera anteckningsbok".

11. Ange ett namn för en ny notebook-fil som ska köra den genererade PREDICT-koden. Guiden visar en förhandsversion av den genererade koden i det här steget. Du kan kopiera koden till Urklipp och klistra in den i en befintlig anteckningsbok om du vill.

    

12. Välj Nästa för att gå till steget "Granska och slutför".

13. Granska informationen på sammanfattningssidan och välj Skapa anteckningsbok för att lägga till den nya notebook-filen med dess genererade kod på arbetsytan. Du tas direkt till anteckningsboken, där du kan köra koden för att generera och lagra förutsägelser.

    

Använda en anpassningsbar kodmall

Så här använder du en kodmall för att generera batchförutsägelser:

1. Gå till objektsidan för en viss ML-modellversion.
2. Välj Kopiera kod som ska tillämpas i listrutan Tillämpa den här versionen . Med markeringen kan du kopiera en anpassningsbar kodmall.

Du kan klistra in den här kodmallen i en notebook-fil för att generera batchförutsägelser med ML-modellen. Om du vill köra kodmallen måste du ersätta följande värden manuellt:

• <INPUT_TABLE>: Filsökvägen för tabellen som tillhandahåller indata till ML-modellen
• <INPUT_COLS>: En matris med kolumnnamn från indatatabellen som ska matas till ML-modellen
• <OUTPUT_COLS>: Ett namn på en ny kolumn i utdatatabellen som lagrar förutsägelser
• <MODEL_NAME>: Namnet på ML-modellen som ska användas för att generera förutsägelser
• <MODEL_VERSION>: Den version av ML-modellen som ska användas för att generera förutsägelser
• <OUTPUT_TABLE>: Filsökvägen för tabellen som lagrar förutsägelserna

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
)  

Relaterat innehåll

• Exempel på förutsägelse från slutpunkt till slutpunkt med hjälp av en modell för bedrägeriidentifiering
• Träna ML-modeller med scikit-learn i Microsoft Fabric