Tutorial Parte 4: Executar pontuação em lote e salvar previsões em uma casa de lago

Artigo
01/23/2024

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

O Microsoft Fabric permite operacionalizar modelos de aprendizado de máquina com uma função escalável chamada PREDICT, que oferece suporte à pontuação em lote em qualquer mecanismo de computação. Você pode gerar previsões em lote diretamente de um bloco de anotações do Microsoft Fabric ou da página de item de um determinado modelo. Saiba mais sobre o 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 aprendizado de máquina treinados. Você carregará o conjunto de dados de teste em um spark DataFrame 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 maneiras a seguir:

API do transformador do SynapseML
Spark SQL API
Função definida pelo usuário (UDF) 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 seletor de experiência no lado esquerdo da sua página inicial para alternar para a experiência Synapse Data Science.

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

Parte 1: Ingerir dados em um lago do Microsoft Fabric usando o Apache Spark.
Parte 2: Explore e visualize dados usando blocos de anotações do Microsoft Fabric para saber mais sobre os dados.
Parte 3: Treinar e registrar modelos de aprendizado de máquina.

Acompanhe no caderno

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

Para abrir o bloco de anotações que acompanha este tutorial, siga as instruções em Preparar seu sistema para tutoriais de ciência de dados, para importar o bloco de anotações para seu espaço de trabalho.

Se preferir copiar e colar o código desta página, pode criar um novo bloco de notas.

Certifique-se de anexar um lakehouse ao bloco de anotações antes de começar a executar o código.

Importante

Anexe a mesma casa do lago que você usou nas outras partes desta série.

Carregue 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 Transformer

Para usar a API do Transformer do SynapseML, você precisará primeiro 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 (neste caso, você precisaria de todas elas).
Um nome para a nova coluna de saída (neste caso, previsões).
O nome do modelo correto e a versão do modelo para gerar as previsões (neste caso, lgbm_sm e a 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)

PREVER com a API SQL do Spark

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

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

O código a seguir invoca a função PREDICT com um UDF 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 a partir da página de item de um modelo. Saiba mais sobre o PREDICT.

Escreva os resultados da previsão do modelo para a casa do lago

Depois de gerar previsões em lote, escreva os resultados da previsão do modelo de volta para a casa do lago.

# 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óximo passo

Continue para:

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

Partilhar via