Självstudie del 4: Utföra batchbedömning och spara förutsägelser till ett lakehouse

Den här självstudien visar hur du importerar den registrerade LightGBMClassifier-modellen som du skapade i del 3. I den handledningen användes Microsoft Fabric MLflow-modellregistret för att träna modellen och sedan utföra batchförutsägelser på en testdatauppsättning som laddades in från ett lakehouse.

Med Microsoft Fabric kan du operationalisera maskininlärningsmodeller med en skalbar funktion som heter PREDICT, som stöder batchbedömning i alla beräkningsmotorer. Du kan generera batchförutsägelser direkt från en Microsoft Fabric-anteckningsbok eller från en viss modells objektsida. Mer information finns i PREDICT.

För att generera batchförutsägelser på testdatauppsättningen använder du version 1 av den tränade LightGBM-modellen som visade bästa prestanda bland alla tränade maskininlärningsmodeller. Du läser in testdatauppsättningen i en spark DataFrame och skapar ett MLFlowTransformer-objekt för att generera batchförutsägelser. Du kan sedan anropa funktionen PREDICT på något av följande tre sätt:

• Transformera API från SynapseML
• Spark SQL API
• Användardefinierad pySpark-funktion (UDF)

Förutsättningar

• Skaffa en Microsoft Fabric-prenumeration. Eller registrera dig för en kostnadsfri Microsoft Fabric-utvärderingsversion.

• Logga in på Microsoft Fabric.

• Växla till Fabric genom att använda upplevelseväxlaren längst ned till vänster på startsidan.

  

Det här är del 4 i en självstudieserie i fem delar. Slutför den här självstudien genom att först slutföra:

• del 1: Mata in data i ett Microsoft Fabric Lakehouse med Apache Spark.
• del 2: Utforska och visualisera data med hjälp av Microsoft Fabric-notebook-filer för att lära dig mer om data.
• del 3: Träna och registrera maskininlärningsmodeller.

%pip install scikit-learn==1.6.1

Följ med i anteckningsboken

4-predict.ipynb är anteckningsboken som medföljer den här handledningen.

• Om du vill öppna den medföljande notebook-filen för denna handledning följer du instruktionerna i Förbered ditt system för handledningar inom datavetenskap för att importera notebook-filen till din arbetsyta.

• Om du hellre kopierar och klistrar in koden från den här sidan kan du skapa en ny notebook-fil.

• Se till att bifoga en lakehouse till notebook- innan du börjar köra kod.

Viktig

Bifoga samma sjöhus som du använde i de andra delarna av den här serien.

Läs in testdata

I följande kodfragment läser du in testdata som du sparade i del 3:

df_test = spark.read.format("delta").load("Tables/df_test")
display(df_test)

FÖRUTSÄGA med transformerings-API:et

Om du vill använda Transformer-API:et från SynapseML måste du först skapa ett MLFlowTransformer-objekt.

Instansiera MLFlowTransformer-objekt

MLFlowTransformer-objektet fungerar som en omslutning runt MLFlow-modellen som du registrerade i del 3. Det gör att du kan generera batchförutsägelser på en viss DataFrame. Om du vill instansiera MLFlowTransformer-objektet måste du ange följande parametrar:

• Testa DataFrame-kolumner som modellen behöver som indata (i det här fallet behöver modellen alla)
• Ett namn på den nya utdatakolumnen (i det här fallet förutsägelser)
• Rätt modellnamn och modellversion för att generera förutsägelserna (i det här fallet lgbm_sm och version 1)

Följande kodfragment hanterar följande steg:

from synapse.ml.predict import MLFlowTransformer

model = MLFlowTransformer(
    inputCols=list(df_test.columns),
    outputCol='predictions',
    modelName='lgbm_sm',
    modelVersion=1
)

Nu när du har MLFlowTransformer-objektet kan du använda det för att generera batchförutsägelser, enligt följande kodfragment:

import pandas

predictions = model.transform(df_test)
display(predictions)

FÖRUTSÄGA med Spark SQL API

Följande kodfragment använder Spark SQL API för att anropa funktionen PREDICT:

from pyspark.ml.feature import SQLTransformer 

# Substitute "model_name", "model_version", and "features" below with values for your own model name, model version, and feature columns
model_name = 'lgbm_sm'
model_version = 1
features = df_test.columns

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

# Substitute "X_test" below with your own test dataset
display(sqlt.transform(df_test))

PREDICT med en användardefinierad funktion (UDF)

Följande kodfragment använder en PySpark UDF för att anropa funktionen PREDICT:

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

# Substitute "model" and "features" below with values for your own model name and feature columns
my_udf = model.to_udf()
features = df_test.columns

display(df_test.withColumn("predictions", my_udf(*[col(f) for f in features])))

Du kan också generera PREDICT-kod från objektsidan i en modell. Mer information om funktionen PREDICT finns i Bedömning av maskininlärningsmodell med PREDICT-resurs .

Skriva modellförutsägelseresultat till lakehouse

När du har genererat batchförutsägelser skriver du modellförutsägelseresultatet tillbaka till lakehouse enligt följande kodfragment:

# Save predictions to lakehouse to be used for generating a Power BI report
table_name = "df_test_with_predictions_v1"
predictions.write.format('delta').mode("overwrite").save(f"Tables/{table_name}")
print(f"Spark DataFrame saved to delta table: {table_name}")

Nästa steg

Fortsätt till:

del 5: Skapa en Power BI-rapport för att visualisera förutsägelser