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

Este tutorial mostra como importar o modelo LightGBMClassifier registrado que você criou na parte 3. Esse tutorial usou o registro de modelo MLflow do Microsoft Fabric para treinar o modelo e, em seguida, executar previsões em lotes em um conjunto de dados de teste carregado de um lakehouse.

Com o Microsoft Fabric, você pode operacionalizar modelos de machine learning com a função PREDICT escalonável. Essa função 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 item de um determinado modelo. Para obter mais informações sobre a função PREDICT, visite este recurso.

Para gerar previsões em lote no conjunto de dados de teste, use a versão 1 do modelo lightGBM treinado. Essa versão mostrou o melhor desempenho entre todos os modelos de machine learning treinados. Carregue o conjunto de dados de teste em um DataFrame do Spark e crie um objeto MLFlowTransformer para gerar previsões em lotes. Em seguida, você pode invocar a função PREDICT usando uma destas técnicas:

Pré-requisitos

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

• Entre no Microsoft Fabric.

• Alterne para o Fabric usando o alternador de experiências no canto inferior esquerdo da página inicial.

  

Essa é a parte 4 de uma série de tutoriais de cinco partes. Para concluir este tutorial, primeiro conclua:

• Parte 1: ingerir dados em um lakehouse 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 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 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.

Carregar os dados de teste

No snippet de código a seguir, 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ê deve criar um objeto MLFlowTransformer.

Instanciar objeto MLFlowTransformer

O objeto MLFlowTransformer serve como 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ê deve fornecer os seguintes parâmetros:

• As colunas DataFrame de teste que o modelo precisa como entrada (nesse caso, o modelo precisa 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 (neste caso, lgbm_sm e a versão 1)

O snippet de código a seguir manipula estas etapas:

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, você pode usá-lo para gerar previsões em lote, conforme mostrado no seguinte snippet de código:

import pandas

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

PREDICT com a API de SQL do Spark

O snippet de código a seguir usa 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 UDF (função definida pelo usuário)

O snippet de código a seguir usa um UDF do PySpark 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])))

Você também pode gerar código PREDICT na página de item de um modelo. Para obter mais informações sobre a função PREDICT, visite este recurso.

Gravar os resultados da previsão do modelo no lakehouse

Depois de gerar previsões em lotes, escreva os resultados da previsão do modelo de volta para o sistema de armazenamento de dados, conforme mostrado no seguinte trecho 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óxima etapa

Continue para: