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

Artigo
02/06/2024

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 que você operacionalize 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 lote diretamente em um notebook do Microsoft Fabric ou na página de item de 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ê poderá invocar a função PREDICT usando uma das três seguintes maneiras:

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

Pré-requisitos

Obtenha uma assinatura do Microsoft Fabric. Ou, inscreva-se para uma avaliação gratuita do Microsoft Fabric.
Entre no Microsoft Fabric.
Use o alternador de experiência no lado esquerdo da sua página inicial para mudar para a experiência de Ciência de Dados Synapse.

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

Parte 1: ingerir dados em um lakehouse do Microsoft Fabric usando o Apache Spark.
Parte 2: Explorar e visualizar dados usando os notebooks do Microsoft Fabric para saber mais sobre os dados.
Parte 3: Treinar e registrar modelos de machine learning.

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 preferir copiar e colar o código a partir dessa página, você poderá criar um novo 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)

PREDICT com a API do Transformador

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

Criar uma instância do objeto MLFlowTransformer

O objeto MLFlowTransformer é um wrapper em torno do modelo do MLFlow que você registrou na Parte 3. Ele permite que você gere previsões em lote em um DataFrame especificado. Para criar uma instância do 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ê precisará 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, use-o para gerar previsões em lote.

import pandas

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

PREDICT com a API do SPARK SQL

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 uma 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 o código PREDICT por meio da 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 em:

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

Compartilhar via