Compartir vía

Puntuación de modelos de Machine Learning con PREDICT en Microsoft Fabric

  • Artículo

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 de Machine Learning determinado.

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

Requisitos previos

Limitaciones

  • La función PREDICT se admite actualmente para un conjunto limitado de tipos de modelos de Machine Learning, entre los que se incluyen:
    • PyTorch
    • Sklearn
    • Spark
    • TensorFlow
    • ONNX
    • XGBoost
    • LightGBM
    • CatBoost
    • Statsmodels
    • Prophet
    • Keras
  • PREDICT requiere que los modelos se guarden en el formato MLflow con sus firmas rellenadas.
  • PREDICT no admite modelos de Machine Learning 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 hay un modelo de Machine Learning entrenado y registrado en el área de trabajo, puede ir directamente al paso 2. 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.

  1. Entrene un modelo de Machine Learning 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. Consulte cómo entrenar modelos de Machine Learning 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"
    )

  2. Cargue datos de prueba como un DataFrame de Spark. Para generar predicciones por lotes mediante el modelo de Machine Learning entrenado en el paso anterior, necesita datos de prueba en forma de un DataFrame de Spark. Puede sustituir el valor de la variable test 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))

  3. Cree un objeto MLFlowTransformer para cargar el modelo de Machine Learning para la inferencia. Para crear un objeto MLFlowTransformer para generar predicciones por lotes, debe realizar las siguientes acciones:

    • Especifique qué columnas del DataFrame test necesita como entradas del modelo (en este caso, todas ellas).
    • Elija un nombre para la nueva columna de salida (en este caso, predictions).
    • Proporcione el nombre y la versión correctos 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 de Machine Learning 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
)

  4. Genere predicciones mediante la función PREDICT. Para invocar la función PREDICT, puede usar la API Transformer, la API Spark SQL 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 de Machine Learning definidos en los pasos anteriores mediante los distintos métodos para invocar PREDICT.

PREDICT con la API Transformer

El código siguiente invoca la función PREDICT con la API Transformer. Si ha usado su propio modelo de Machine Learning, 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 Spark SQL

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

Nota:

El uso de la API SQL Spark para generar predicciones requiere que cree un objeto MLFlowTransformer (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 de Machine Learning, 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 de Machine Learning

En la página de elementos de cualquier modelo de Machine Learning, 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
  • 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 la interfaz de usuario guiada le guía por los pasos para:

  • Seleccionar los datos de origen para la puntuación
  • Asignar los datos correctamente a las entradas del modelo de Machine Learning
  • Especificar el destino de las salidas del modelo
  • Crear un cuaderno que use PREDICT para generar y almacenar resultados de predicción

Para usar la experiencia guiada,

  1. Vaya a la página de elementos de la versión de un modelo de Machine Learning determinado.

  2. Seleccione Aplicar este modelo en el asistente en la lista desplegable Aplicar esta versión.

    Screenshot of the prompt to apply an ML model from its item page.

    La selección abre la ventana "Aplicar predicciones del modelo de Machine Learning" en el paso "Seleccionar tabla de entrada".

  3. Seleccione una tabla de entrada de una de las instancias de Lakehouse del área de trabajo actual.

    Screenshot of the step to select an input table for ML model predictions.

  4. Seleccione Siguiente para ir al paso "Asignar columnas de entrada".

  5. Asigne nombres de columna de la tabla de origen a los campos de entrada del modelo de Machine Learning, que se extraen 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 de Machine Learning.

    Screenshot of the step to map input columns for ML model predictions.

  6. Seleccione Siguiente para ir al paso "Crear tabla de salida".

  7. Proporcione un nombre para una nueva tabla dentro de la instancia de Lakehouse seleccionada del área de trabajo actual. Esta tabla de salida almacena los valores de entrada del modelo de Machine Learning con los valores de predicción anexados. De manera predeterminada, la tabla de salida se crea en la misma instancia de Lakehouse que la tabla de entrada, pero la opción para cambiar la instancia de Lakehouse de destino también está disponible.

    Screenshot of the step to create an output table for ML model predictions.

  8. Seleccione Siguiente para ir al paso "Asignar columnas de salida".

  9. Use los campos de texto proporcionados para asignar un nombre a las columnas de la tabla de salida que almacenan las predicciones del modelo de Machine Learning.

    Screenshot of the step to map output columns for ML model predictions.

  10. Seleccione Siguiente para ir al paso "Configurar cuaderno".

  11. Proporcione un nombre para un nuevo cuaderno que ejecutará 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.

    Screenshot of the step to configure a notebook for ML model predictions.

  12. Seleccione Siguiente para ir al paso "Revisar y finalizar".

  13. 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 llevará directamente a ese cuaderno, donde puede ejecutar el código para generar y almacenar predicciones.

    Screenshot of the review-and-finish step for ML model predictions.

Uso de una plantilla de código personalizable

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

  1. Vaya a la página de elementos de la versión de un modelo de Machine Learning determinado.
  2. Seleccione Copiar código para aplicar en la lista desplegable Aplicar esta versión. La selección 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 de Machine Learning. 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 proporciona entradas al modelo de Machine Learning
  • <INPUT_COLS>: matriz de nombres de columna de la tabla de entrada que va a alimentar al modelo de Machine Learning
  • <OUTPUT_COLS>: nombre de una nueva columna en la tabla de salida que almacena las predicciones
  • <MODEL_NAME>: el nombre del modelo de Machine Learning que se va a usar para generar predicciones
  • <MODEL_VERSION>: la versión del modelo de Machine Learning que se va a usar para generar predicciones
  • <OUTPUT_TABLE>: ruta de acceso del archivo de la tabla que almacena las predicciones

Screenshot of the copy-code template for ML model predictions. 

import mlflow 
from synapse.ml.predict import MLFlowTransformer 
 
df = spark.read.format("delta").load( 
    <INPUT_TABLE> # Your input table filepath here
) 
 
model = MLFlowTransformer( 
    inputCols=<INPUT_COLS>, # Your input columns here
    outputCol=<OUTPUT_COLS>, # Your new column name here
    modelName=<MODEL_NAME>, # Your ML model name here
    modelVersion=<MODEL_VERSION> # Your ML model version here
) 
df = model.transform(df) 
 
df.write.format('delta').mode("overwrite").save( 
    <OUTPUT_TABLE> # Your output table filepath here
)

Contenido relacionado