Pontuação de modelos de Machine Learning com PREDICT no Microsoft Fabric

O Microsoft Fabric permite-lhe operacionalizar modelos de machine learning utilizando a função escalável PREDICT. Esta função suporta pontuação em lote em qualquer mecanismo de computação. Pode gerar previsões em lote diretamente a partir de um notebook Microsoft Fabric ou da página de item de um dado modelo de ML.

Neste artigo, você aprenderá a aplicar o PREDICT escrevendo código você mesmo ou usando uma experiência de interface do usuário guiada que lida com a pontuação em lote para você.

Pré-requisitos

• Faça uma subscrição Microsoft Fabric. Ou, inscreva-se para um teste gratuito Microsoft Fabric.

• Iniciar sessão em Microsoft Fabric.

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

  

Limitações

• A função PREDICT suporta atualmente apenas os seguintes modelos de ML:
  • CatBoost
  • Keras
  • LightGBM
  • ONNX
  • Profeta
  • PyTorch
  • Sklearn
  • Spark
  • Modelos de estatísticas
  • TensorFlow
  • XGBoost
• O PREDICT exige que guarde modelos de ML no formato MLflow, com as suas assinaturas preenchidas.
• O PREDICT não suporta modelos ML com entradas ou saídas multi-tensoriais.

Chamar PREDICT a partir de um bloco de notas

O PREDICT suporta modelos empacotados em MLflow no registo Microsoft Fabric. Se existir um modelo de ML já treinado e registrado em seu espaço de trabalho, você poderá pular para a etapa 2. Caso contrário, a etapa 1 fornece código de exemplo para guiá-lo através do treinamento de um modelo de regressão logística de exemplo. Use este modelo para gerar previsões em lote no final do procedimento.

1. Treine um modelo de ML e registre-o no MLflow. O próximo exemplo de código utiliza a API MLflow para criar uma experiência de machine learning, e depois inicia uma execução MLflow para um modelo de regressão logística scikit-learn. A versão do modelo é então armazenada e registada no registo Microsoft Fabric. Para mais informações sobre treino de modelos e acompanhamento dos seus próprios experimentos, veja como treinar modelos de ML com o scikit-learn.

   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. Carregue os dados de teste como um DataFrame do Spark. Para gerar previsões em lote com o modelo de ML treinado na etapa anterior, você precisa de dados de teste na forma de um Spark DataFrame. No código a seguir, substitua o valor da test variável por seus próprios dados.

   # You can substitute "test" below with your own data
   test = spark.createDataFrame(data.frame.drop(['target'], axis=1))
   

3. Crie um MLFlowTransformer objeto para carregar o modelo de ML para inferência. Para criar um MLFlowTransformer objeto que gere previsões em lote, execute estas ações:

   • Especifique as test colunas DataFrame que precisa como entradas de modelo (neste caso, todas).
   • Escolha um nome para a nova coluna de saída (neste caso, predictions).
   • Forneça o nome e a versão corretos do modelo para a geração dessas previsões.

   Se você usar seu próprio modelo de ML, substitua os valores pelas colunas de entrada, nome da coluna de saída, nome do modelo e versão do 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. Gere previsões usando a função PREDICT. Para invocar a função PREDICT, use a API do Transformer, a API SQL do Spark ou uma função definida pelo usuário (UDF) do PySpark. As seções a seguir mostram como gerar previsões em lote com os dados de teste e o modelo de ML definidos nas etapas anteriores, usando os diferentes métodos para invocar a função PREDICT.

PREDICT com a API do Transformer

Este código invoca a função PREDICT com a API do Transformer. Se você usar seu próprio modelo de ML, substitua os valores para o modelo e os dados de teste.

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

Realizar predições com a Spark SQL API

Este código chama a função PREDICT usando a API SQL do Spark. Se usar o seu próprio modelo de ML, substitua os valores de model_name, model_version, e features pelos nomes do modelo, versão do modelo e colunas de funcionalidades.

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 com uma função definida pelo utilizador

Este código chama a função PREDICT usando um PySpark UDF. Se usares o teu próprio modelo de ML, substitui os valores do modelo e das funcionalidades.

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()

Gerar código PREDICT a partir da página de item de um modelo de ML

A partir da página do item de qualquer modelo de ML, pode escolher uma destas opções para iniciar a geração de previsões em lote para uma versão específica do modelo, usando a função PREDICT:

• Copia um modelo de código para um caderno e personaliza os parâmetros tu mesmo.
• Use uma experiência de interface guiada para gerar código PREDICT.

Experimentar uma interface de utilizador guiada

A experiência guiada da interface do usuário orienta você por estas etapas:

1. Selecione os dados de origem para pontuação.
2. Mapeie os dados corretamente para as entradas do seu modelo de ML.
3. Especifique o destino para as saídas do seu modelo.
4. Crie um caderno que use o PREDICT para gerar e armazenar resultados de previsão.

Para usar a experiência guiada,

1. Navegue até a página do item para uma determinada versão do modelo de ML.

2. No menu suspenso Aplicar esta versão, selecione Aplicar este modelo no assistente.

   

   Na etapa "Selecionar tabela de entrada", a janela "Aplicar previsões de modelo de ML" é aberta.

3. Selecione uma tabela de entrada de uma casa de lago em seu espaço de trabalho atual.

   

4. Selecione Avançar para ir para a etapa "Mapear colunas de entrada".

5. Mapeie nomes de colunas da tabela de origem para os campos de entrada do modelo de ML, que são extraídos da assinatura do modelo. Você deve fornecer uma coluna de entrada para todos os campos obrigatórios do modelo. Além disso, os tipos de dados da coluna de origem devem corresponder aos tipos de dados esperados do modelo.

   Gorjeta

   O assistente preenche previamente esse mapeamento se os nomes das colunas da tabela de entrada corresponderem aos nomes de coluna registrados na assinatura do modelo de ML.

   

6. Selecione Avançar para ir para a etapa "Criar tabela de saída".

7. Forneça um nome para uma nova tabela dentro da casa do lago selecionada do seu espaço de trabalho atual. Esta tabela de saída armazena os valores de entrada do modelo de ML e acrescenta os valores de previsão a essa tabela. Por defeito, a tabela de saída é criada no mesmo lakehouse que a tabela de entrada. Você pode alterar o lakehouse de destino.

   

8. Selecione Avançar para ir para a etapa "Mapear colunas de saída".

9. Use os campos de texto fornecidos para nomear as colunas da tabela de saída que armazena as previsões do modelo de ML.

   

10. Selecione Avançar para ir para a etapa "Configurar bloco de anotações".

11. Forneça um nome para um novo bloco de anotações que execute o código PREDICT gerado. O assistente exibe uma visualização do código gerado neste passo. Se desejar, você pode copiar o código para a área de transferência e colá-lo em um bloco de anotações existente.

    

12. Selecione Avançar para ir para a etapa "Revisar e concluir".

13. Revise os detalhes na página de resumo e selecione Criar bloco de anotações para adicionar o novo bloco de anotações com o código gerado ao seu espaço de trabalho. Você é levado diretamente para esse bloco de anotações, onde pode executar o código para gerar e armazenar previsões.

    

Usar um modelo de código personalizável

Para usar um modelo de código para gerar previsões em lote:

1. Vá para a página do item de uma determinada versão do modelo de ML.
2. Selecione Copiar código a ser aplicado na lista suspensa Aplicar esta versão . A seleção copia um modelo de código personalizável.

Você pode colar esse modelo de código em um bloco de anotações para gerar previsões em lote com seu modelo de ML. Para executar com sucesso o modelo de código, substitua manualmente os seguintes valores:

• <INPUT_TABLE>: O caminho do ficheiro para a tabela que fornece entradas para o modelo de ML.
• <INPUT_COLS>: Um array de nomes de colunas da tabela de entrada para alimentar o modelo ML.
• <OUTPUT_COLS>: Um nome para uma nova coluna na tabela de saída que armazena previsões.
• <MODEL_NAME>: O nome do modelo de ML a usar para gerar previsões.
• <MODEL_VERSION>: A versão do modelo de ML a usar para gerar previsões.
• <OUTPUT_TABLE>: O caminho do ficheiro para a tabela que armazena as previsões.

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
)  

Conteúdos relacionados

• Exemplo de previsão de ponta a ponta usando um modelo de deteção de fraude
• Como treinar modelos de ML com scikit-learn em Microsoft Fabric