Puntuación de modelos con PREDICT en Microsoft Fabric

Artículo
05/23/2023

Microsoft Fabric permite a los usuarios 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. Los usuarios pueden generar predicciones por lotes directamente desde un cuaderno de Microsoft Fabric o desde la página de elementos de un modelo determinado.

Importante

Microsoft Fabric está actualmente en versión preliminar. Esta información está relacionada con un producto en versión preliminar que puede modificarse considerablemente antes de su lanzamiento. Microsoft no ofrece ninguna garantía, expresa o implícita, con respecto a la información que se ofrece aquí.

En este artículo, aprenderá a aplicar PREDICT de ambas maneras, tanto si es más cómodo escribir código usted mismo como usar una experiencia de interfaz de usuario guiada para controlar la puntuación por lotes automáticamente.

Requisitos previos

Una suscripción Power BI Premium. Si no tiene una, consulte Cómo comprar Power BI Premium.
Un área de trabajo de Power BI con capacidad Premium asignada. Si no tiene un área de trabajo, siga los pasos descritos en Creación de un área de trabajo para crear una y asignarla a una capacidad Premium.
Inicie sesión en Microsoft Fabric.

Limitaciones

La función PREDICT se admite actualmente para un conjunto limitado de tipos de modelo, incluidos PyTorch, Sklearn, Spark, TensorFlow, ONNX, XGBoost, LightGBM, CatBoost y Statsmodels.
PREDICT requiere que los modelos se guarden en el formato MLflow con sus firmas rellenadas.
PREDICT no admite modelos con entradas o salidas de varios tensores.

Llamada a PREDICT desde un cuaderno

PREDICT admite modelos empaquetados de MLflow en el registro de Microsoft Fabric. Si ya ha entrenado y registrado un modelo en el área de trabajo, puede ir directamente al paso 2 siguiente. Si no es así, el paso 1 proporciona código de ejemplo para guiarle a través del entrenamiento de un modelo de regresión logística de ejemplo. Puede usar este modelo para generar predicciones por lotes al final del procedimiento.

Entrene un modelo y regístrelo con MLflow. En el código de ejemplo siguiente se usa la API de MLflow para crear un experimento de aprendizaje automático e iniciar una ejecución de MLflow para un modelo de regresión logística scikit-learn. A continuación, la versión del modelo se almacena y registra en el registro de Microsoft Fabric. Vea cómo entrenar modelos con scikit-learn para obtener más información sobre los modelos de entrenamiento y los experimentos de seguimiento propios.

import mlflow
import numpy as np 
from sklearn.linear_model import LogisticRegression 
from sklearn.datasets import load_diabetes
from mlflow.models.signature import infer_signature 

mlflow.set_experiment("diabetes-demo")
with mlflow.start_run() as run:
    lr = LogisticRegression()
    data = load_diabetes(as_frame=True)
    lr.fit(data.data, data.target) 
    signature = infer_signature(data.data, data.target) 

    mlflow.sklearn.log_model(
        lr,
        "diabetes-model",
        signature=signature,
        registered_model_name="diabetes-model"
    )

Cargar en datos de prueba como dataFrame de Spark. Para generar predicciones por lotes mediante el modelo entrenado en el paso anterior, necesita datos de prueba en forma de dataFrame de Spark. Puede sustituir el valor de la test variable en el código siguiente por sus propios datos.
```
# You can substitute "test" below with your own data
test = spark.createDataFrame(data.frame.drop(['target'], axis=1))
```
Cree un MLFlowTransformer objeto para cargar el modelo para la inferencia. Para crear un MLFlowTransformer objeto para generar predicciones por lotes, debe hacer lo siguiente:
- especifique qué columnas del test DataFrame necesita como entradas de modelo (en este caso, todas ellas),
- elija un nombre para la nueva columna de salida (en este caso, predictions) y
- proporcione el nombre correcto del modelo y la versión del modelo para generar esas predicciones.
Si usa su propio modelo, sustituya los valores de las columnas de entrada, el nombre de la columna de salida, el nombre del modelo y la versión del modelo.
```
from synapse.ml.predict import MLFlowTransformer

# You can substitute values below for your own input columns,
# output column name, model name, and model version
model = MLFlowTransformer(
    inputCols=test.columns,
    outputCol='predictions',
    modelName='diabetes-model',
    modelVersion=1
)
```
Genere predicciones mediante la función PREDICT. Para invocar la función PREDICT, puede usar transformer API, spark SQL API o una función definida por el usuario (UDF) de PySpark. En las secciones siguientes se muestra cómo generar predicciones por lotes con los datos de prueba y el modelo definidos en los pasos anteriores, mediante los distintos métodos para invocar PREDICT.

PREDICT con Transformer API

El código siguiente invoca la función PREDICT con Transformer API. Si ha usado su propio modelo, sustituya los valores del modelo y los datos de prueba.

# You can substitute "model" and "test" below with values  
# for your own model and test data 
model.transform(test).show()

PREDICT con la API de SPARK SQL

El código siguiente invoca la función PREDICT con la API de Spark SQL. Si ha usado su propio modelo, sustituya los valores de model_name, model_versiony features por el nombre del modelo, la versión del modelo y las columnas de características.

Nota:

El uso de la API de SQL de Spark para generar predicciones requiere que cree un MLFlowTransformer objeto (como en el paso 3).

from pyspark.ml.feature import SQLTransformer 

# You can substitute "model_name," "model_version," and "features" 
# with values for your own model name, model version, and feature columns
model_name = 'diabetes-model'
model_version = 1
features = test.columns

sqlt = SQLTransformer().setStatement( 
    f"SELECT PREDICT('{model_name}/{model_version}', {','.join(features)}) as predictions FROM __THIS__")

# You can substitute "test" below with your own test data
sqlt.transform(test).show()

PREDICT con una función definida por el usuario

El código siguiente invoca la función PREDICT con una UDF de PySpark. Si ha usado su propio modelo, sustituya los valores del modelo y las características.

from pyspark.sql.functions import col, pandas_udf, udf, lit

# You can substitute "model" and "features" below with your own values
my_udf = model.to_udf()
features = test.columns

test.withColumn("PREDICT", my_udf(*[col(f) for f in features])).show()

Generación de código PREDICT desde la página de elementos de un modelo

En la página de elementos de cualquier modelo, puede elegir cualquiera de las siguientes opciones para empezar a generar predicciones por lotes para una versión de modelo específica con PREDICT.

Uso de una experiencia de interfaz de usuario guiada para generar código PREDICT automáticamente
Copia de una plantilla de código en un cuaderno y personalización de los parámetros usted mismo

Uso de una experiencia de interfaz de usuario guiada

La experiencia de interfaz de usuario guiada le guía por los pasos necesarios para seleccionar los datos de origen para la puntuación, asignar los datos correctamente a las entradas del modelo, especificar el destino de las salidas del modelo y crear un cuaderno que use PREDICT para generar y almacenar los resultados de la predicción.

Para usar la experiencia guiada,

Vaya a la página de elementos de una versión de modelo determinada.
Seleccione Aplicar este modelo en el asistente en la lista desplegable Aplicar modelo .

La selección abre la ventana "Aplicar predicciones del modelo" en el paso "Seleccionar tabla de entrada".
Seleccione una tabla de entrada de uno de los Lakehouses del área de trabajo actual.
Seleccione Siguiente para ir al paso "Asignar columnas de entrada".
Asigne nombres de columna de la tabla de origen a los campos de entrada del modelo, que se han extraído de la firma del modelo. Debe proporcionar una columna de entrada para todos los campos obligatorios del modelo. Además, los tipos de datos de las columnas de origen deben coincidir con los tipos de datos esperados del modelo.

Sugerencia

El asistente rellenará previamente esta asignación si los nombres de las columnas de la tabla de entrada coinciden con los nombres de columna registrados en la firma del modelo.
Seleccione Siguiente para ir al paso "Crear tabla de salida".
Proporcione un nombre para una nueva tabla dentro de la instancia de Lakehouse seleccionada del área de trabajo actual. Esta tabla de salida almacenará los valores de entrada del modelo con los valores de predicción anexados. De forma predeterminada, la tabla de salida se creará en la misma instancia de Lakehouse que la tabla de entrada, pero la opción para cambiar el lakehouse de destino también está disponible.
Seleccione Siguiente para ir al paso "Asignar columnas de salida".
Use los campos de texto proporcionados para asignar un nombre a las columnas de la tabla de salida que almacenarán las predicciones del modelo.
Seleccione Siguiente para ir al paso "Configurar cuaderno".
Proporcione un nombre para un nuevo cuaderno que ejecute el código PREDICT generado. El asistente muestra una vista previa del código generado en este paso. Puede copiar el código en el Portapapeles y pegarlo en un cuaderno existente si lo prefiere.
Seleccione Siguiente para ir al paso "Revisar y finalizar".
Revise los detalles de la página de resumen y seleccione Crear cuaderno para agregar el nuevo cuaderno con su código generado al área de trabajo. Se le dirigirá directamente a ese cuaderno, donde puede ejecutar el código para generar y almacenar predicciones.

Uso de una plantilla de código personalizable

Para usar una plantilla de código para generar predicciones por lotes:

Vaya a la página de elementos de una versión de modelo determinada.
Seleccione Copiar código para aplicar en la lista desplegable Aplicar modelo . La selección le permite copiar una plantilla de código personalizable.

Puede pegar esta plantilla de código en un cuaderno para generar predicciones por lotes con el modelo. Para ejecutar correctamente la plantilla de código, debe reemplazar manualmente los valores siguientes:

<INPUT_TABLE>: ruta de acceso del archivo de la tabla que proporcionará entradas al modelo.
<INPUT_COLS>: matriz de nombres de columna de la tabla de entrada que se va a alimentar al modelo.
<OUTPUT_COLS>: nombre de una nueva columna en la tabla de salida que almacenará predicciones.
<MODEL_NAME>: el nombre del modelo que se va a usar para generar predicciones.
<MODEL_VERSION>: la versión del modelo que se va a usar para generar predicciones.
<OUTPUT_TABLE>: ruta de acceso del archivo de la tabla que almacenará las predicciones.

import mlflow 
from synapse.ml.predict import MLFlowTransformer 
 
df = spark.read.format("delta").load( 
    <INPUT_TABLE> 
) 
 
model = MLFlowTransformer( 
    inputCols=<INPUT_COLS>, 
    outputCol=<OUTPUT_COLS>, 
    modelName=<MODEL_NAME>, 
    modelVersion=<MODEL_VERSION> 
) 
df = model.transform(df) 
 
df.write.format('delta').mode("overwrite").save( 
    <OUTPUT_TABLE> 
)