Tutorial – Parte 4: Executar a pontuação em lote e salvar as previsões em um lakehouse

Artigo
02/05/2025

Neste tutorial, você aprenderá a importar um modelo LightGBMClassifier que foi treinado na parte 3 usando o registro de modelo do MLflow do Microsoft Fabric e a executar previsões em lote em um conjunto de dados de teste carregado de um lakehouse.

O Microsoft Fabric permite operacionalizar modelos de machine learning com uma função escalonável chamada PREDICT, que dá suporte à pontuação em lote em qualquer mecanismo de computação. Você pode gerar previsões em lotes diretamente de um bloco de anotações do Microsoft Fabric ou da página de itens de um determinado modelo. Saiba mais sobre PREDICT.

Para gerar previsões em lote no conjunto de dados de teste, você usará a versão 1 do modelo LightGBM treinado que demonstrou o melhor desempenho entre todos os modelos de machine learning treinados. Você carregará o conjunto de dados de teste em um DataFrame do Spark e criará um objeto MLFlowTransformer para gerar previsões em lote. Em seguida, você pode invocar a função PREDICT usando uma das três seguintes maneiras:

API do Transformador do SynapseML
Spark SQL API
UDF (função definida pelo usuário) do PySpark

Pré-requisitos

Obtenha uma assinatura do Microsoft Fabric . Inscreva-se para uma avaliação gratuita do Microsoft Fabric .
Entre no Microsoft Fabric.
Utilize o alternador de experiências no canto inferior esquerdo da sua página inicial para alternar para o Fabric.

Esta é a parte 4 de 5 na série de tutoriais. Para concluir este tutorial, primeiro conclua:

Acompanhar no notebook

4-predict.ipynb é o notebook que acompanha este tutorial.

Para abrir o notebook que acompanha este tutorial, siga as instruções em Preparar seu sistema para tutoriais de ciência de dados para importar os notebooks para seu workspace.
Se você prefere copiar e colar o código desta página, pode criar um notebook.
Certifique-se de anexar um lakehouse ao notebook antes de começar a executar o código.

Importante

Anexe o mesmo lakehouse que você usou nas outras partes desta série.

Carregar os dados de teste

Carregue os dados de teste que você salvou na Parte 3.

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

PREVER com a API do Transformador

Para usar a API transformer do SynapseML, primeiro você precisará criar um objeto MLFlowTransformer.

Instanciar objeto MLFlowTransformer

O objeto MLFlowTransformer é um wrapper em torno do modelo MLFlow que você registrou na Parte 3. Ele permite que você gere previsões em lote em um determinado DataFrame. Para instanciar o objeto MLFlowTransformer, você precisará fornecer os seguintes parâmetros:

As colunas do DataFrame de teste que você precisa como entrada para o modelo (nesse caso, você precisaria de todas elas).
Um nome para a nova coluna de saída (nesse caso, previsões).
O nome do modelo correto e a versão do modelo para gerar as previsões (nesse caso, lgbm_sm e versão 1).

from synapse.ml.predict import MLFlowTransformer

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

Agora que você tem o objeto MLFlowTransformer, pode usá-lo para gerar previsões em lote.

import pandas

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

PREDICT com a API de SQL do Spark

O código a seguir invoca a função PREDICT com a API do SPARK SQL.

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 com uma UDF (função definida pelo usuário)

O código a seguir invoca a função PREDICT com um UDF do PySpark.

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

Observe que você também pode gerar código PREDICT na página de item de um modelo. Saiba mais sobre PREDICT.

Gravar os resultados da previsão do modelo no lakehouse

Depois de gerar previsões em lote, grave os resultados da previsão do modelo de volta no lakehouse.

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

Próxima etapa

Continue para:

Parte 5: criar um relatório do Power BI para visualizar previsões

Compartilhar via