Parte 4: Realizar la puntuación por lotes y guardar predicciones en una instancia de lago de datos

Artículo
02/04/2025

En este tutorial, aprenderás a importar el modelo LightGBMClassifier registrado que se entrenó en la parte 3 mediante el registro de modelos MLflow de Microsoft Fabric, y realizarás predicciones por lotes en un conjunto de datos de prueba cargado desde un lakehouse.

Microsoft Fabric permite poner en marcha modelos de aprendizaje automático con una función escalable denominada PREDICT, que admite la puntuación por lotes en cualquier motor de proceso. Puede generar predicciones por lotes directamente desde un cuaderno de Microsoft Fabric o desde la página de elementos de un modelo determinado. Obtenga información sobre PREDICT.

Para generar predicciones por lotes en el conjunto de datos de prueba, usará la versión 1 del modelo LightGBM entrenado que mostró el mejor rendimiento entre todos los modelos de aprendizaje automático entrenados. Cargará el conjunto de datos de prueba en un dataframe de Spark y creará un objeto MLFlowTransformer para generar predicciones por lotes. A continuación, puede invocar la función PREDICT mediante una de las tres maneras siguientes:

Transformer API de SynapseML
Spark SQL API
Función definida por el usuario (UDF) de PySpark

Prerrequisitos

Obtenga una suscripción a Microsoft Fabric . También puede registrarse para obtener una evaluación gratuita de Microsoft Fabric.
Inicie sesión en Microsoft Fabric.
Use el conmutador de experiencia en la parte inferior izquierda de la página principal para cambiar a Fabric.

Esta parte 4 de 5 de la serie de tutoriales. Para completar este tutorial, primero complete:

parte 1: Ingesta de datos en un lago de Microsoft Fabric mediante Apache Spark.
parte 2: Explorar y visualizar datos mediante cuadernos de Microsoft Fabric para obtener más información sobre los datos.
parte 3: Entrenamiento y registro de modelos de aprendizaje automático.

Seguir en el cuaderno

4-predict.ipynb es el cuaderno que acompaña a este tutorial.

Para abrir el cuaderno complementario para este tutorial, siga las instrucciones en Preparar el sistema para los tutoriales de ciencia de datos para importar el cuaderno a su área de trabajo.
Si prefiere copiar y pegar el código de esta página, puede crear un cuaderno nuevo.
Asegúrese de adjuntar un almacén de lago de datos al cuaderno antes de empezar a ejecutar código.

Importante

Conecte el mismo almacén de lago de datos que usó en las otras partes de esta serie.

Carga de los datos de prueba

Cargue los datos de prueba que guardó en la parte 3.

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

PREDICT con Transformer API

Para usar transformer API desde SynapseML, primero deberá crear un objeto MLFlowTransformer.

Creación de instancias del objeto MLFlowTransformer

El objeto MLFlowTransformer es un contenedor alrededor del modelo de MLFlow que registró en la Parte 3. Permite generar predicciones por lotes en un dataframe determinado. Para crear una instancia del objeto MLFlowTransformer, deberá proporcionar los parámetros siguientes:

Las columnas de la trama de datos de prueba que necesita como entrada para el modelo (en este caso, necesitará todas ellas).
Nombre de la nueva columna de salida (en este caso, predicciones).
El nombre de modelo y la versión del modelo correctos para generar las predicciones (en este caso, lgbm_sm y versión 1).

from synapse.ml.predict import MLFlowTransformer

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

Ahora que tiene el objeto MLFlowTransformer, puede usarlo para generar predicciones por lotes.

import pandas

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

PREDICT con la API de SPARK SQL

El código siguiente invoca la función PREDICT con la API de SQL de 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 con una función definida por el usuario (UDF)

El código siguiente invoca la función PREDICT con una UDF de 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])))

Tenga en cuenta que también puede generar código PREDICT desde la página de elementos de un modelo. Obtenga información sobre PREDICT.

Escritura de los resultados de predicción del modelo en el almacén de lago de datos

Una vez que haya generado predicciones por lotes, vuelva a escribir los resultados de predicción del modelo en 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}")

Paso siguiente

Continúe con:

parte 5: Creación de un informe de Power BI para visualizar predicciones

Compartir vía