Tutorial parte 4: Executar pontuação em lote e salvar previsões num lakehouse

Este tutorial mostra como importar o modelo registado do LightGBMClassifier que construiu na parte 3. Esse tutorial utilizou o registo de modelos Microsoft Fabric MLflow para treinar o modelo e, em seguida, realizar previsões em lote num conjunto de dados de teste carregado a partir de um lakehouse.

Com o Microsoft Fabric, pode operacionalizar modelos de aprendizagem automática com a função escalável PREDICT . Essa função suporta a pontuação em lote em qualquer motor de computação. Pode gerar previsões em lote diretamente a partir de um caderno Microsoft Fabric ou da página do item de um determinado modelo. Para mais informações sobre a função PREDICT, visite este recurso.

Para gerar previsões em lote no conjunto de dados de teste, utilize a versão 1 do modelo treinado LightGBM. Essa versão mostrou o melhor desempenho entre todos os modelos treinados de aprendizagem automática. Carregas o conjunto de dados de teste num DataFrame Spark e crias um objeto MLFlowTransformer para gerar previsões em lote. Pode então invocar a função PREDICT usando uma destas técnicas:

• API Transformer do SynapseML
• Spark SQL API
• Função definida pelo usuário (UDF) do PySpark

Pré-requisitos

• Obtenha uma assinatura Microsoft Fabric. Ou inscreva-se para obter uma avaliação gratuita do Microsoft Fabric.

• Inicie sessão no Microsoft Fabric.

• Altera para o Fabric usando o alternador de experiência no canto inferior esquerdo da sua página inicial.

  

Esta é a parte 4 de uma série de tutoriais de cinco partes. 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 notebooks do Microsoft Fabric para aprender 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 caderno que acompanha este tutorial, siga as instruções em Prepare o seu sistema para tutoriais de ciência de dados para importar o caderno para o 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 a um bloco de notas antes de começar a executar código.

Importante

Anexe a mesma casa junto ao lago que usou nas outras partes desta série.

Carregue os dados de teste

No seguinte excerto de código, carregue os dados de teste que guardou 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 Transformer do SynapseML, deve primeiro criar um objeto MLFlowTransformer.

Instanciar objeto MLFlowTransformer

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

• Das colunas do DataFrame de teste que o modelo precisa como entrada (neste caso, o modelo precisa de todas)
• Um nome para a nova coluna de saída (neste caso, previsões)
• O nome e a versão corretos do modelo para gerar as previsões (neste caso, lgbm_sm e a versão 1)

O seguinte excerto de código trata destes passos:

from synapse.ml.predict import MLFlowTransformer

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

Agora que tem o objeto MLFlowTransformer, pode usá-lo para gerar previsões em lote, como mostrado no seguinte excerto de código:

import pandas

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

PREVER com a API SQL do Spark

O seguinte excerto de código utiliza a API SQL do Spark para invocar a função 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 com uma função definida pelo usuário (UDF)

O seguinte excerto de código utiliza um PySpark UDF para invocar a função 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])))

Também pode gerar código PREDICT a partir da página de detalhes de um modelo. Para mais informações sobre a função PREDICT, visite este recurso.

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

Depois de gerar previsões em lote, escreva os resultados das previsões do modelo de volta no lakehouse, conforme mostrado no seguinte excerto de código:

# 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