Pontuação de modelo de aprendizado de máquina com PREDICT no Microsoft Fabric

O Microsoft Fabric permite que os usuários operacionalizem modelos de aprendizado de máquina com uma função escalável chamada PREDICT, que suporta pontuação em lote em qualquer mecanismo de computação. Os usuários podem gerar previsões em lote diretamente de um bloco de anotações do Microsoft Fabric ou da página de item de um determinado modelo de ML.

Neste artigo, você aprenderá a aplicar o PREDICT nos dois sentidos, quer se sinta mais confortável em escrever código sozinho ou usando uma experiência de interface do usuário guiada para lidar com a pontuação em lote para você.

Pré-requisitos

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

• Entre no Microsoft Fabric.

• Use o seletor de experiência no lado esquerdo da sua página inicial para alternar para a experiência Synapse Data Science.

  

Limitações

• A função PREDICT é atualmente suportada para um conjunto limitado de sabores de modelo de ML, incluindo:
  • PyTorch
  • Sklearn
  • Spark
  • TensorFlow
  • ONNX
  • XGBoost
  • LightGBM
  • CatBoost
  • Modelos de estatísticas
  • Profeta
  • Keras
• PREDICT requer que os modelos de ML sejam salvos no formato MLflow com suas assinaturas preenchidas.
• PREDICT não suporta modelos de ML com entradas ou saídas multitensores.

Chamar PREDICT a partir de um bloco de notas

O PREDICT oferece suporte a modelos empacotados em MLflow no registro do Microsoft Fabric. Se houver um modelo de ML já treinado e registrado em seu espaço de trabalho, você pode 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. Você pode usar esse modelo para gerar previsões em lote no final do procedimento.

1. Treine um modelo de ML e registre-o no MLflow. O código de exemplo a seguir usa a API MLflow para criar um experimento de aprendizado de máquina e iniciar uma execução MLflow para um modelo de regressão logística scikit-learn. A versão do modelo é então armazenada e registrada no registro do Microsoft Fabric. Veja como treinar modelos de ML com scikit-learn para saber mais sobre modelos de treinamento e experimentos de rastreamento próprios.

   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 nos dados de teste como um DataFrame do Spark. Para gerar previsões em lote usando o modelo de ML treinado na etapa anterior, você precisa de dados de teste na forma de um Spark DataFrame. Você pode substituir o valor da test variável no código a seguir 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 para gerar previsões em lote, você deve executar as seguintes ações:

   • especificar quais colunas do test DataFrame você precisa como entradas de modelo (neste caso, todas elas),
   • escolha um nome para a nova coluna de saída (neste caso, predictions) e
   • Forneça o nome do modelo correto e a versão do modelo para gerar essas previsões.

   Se você estiver usando 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, você pode usar 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 PREDICT.

PREDICT com a API do Transformer

O código a seguir invoca a função PREDICT com a API do Transformer. Se você estiver usando seu próprio modelo de ML, substitua os valores pelo modelo e pelos dados de teste.

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

PREVER com a API SQL do Spark

O código a seguir invoca a função PREDICT com a API SQL do Spark. Se você estiver usando seu próprio modelo de ML, substitua os valores por model_name, model_versione pelo nome do modelo, versão do modelo e features colunas de recursos.

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

O código a seguir invoca a função PREDICT com um UDF PySpark. Se você estiver usando seu próprio modelo de ML, substitua os valores para o modelo e os recursos.

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

Na página de item de qualquer modelo de ML, você pode escolher uma das seguintes opções para começar a gerar previsões em lote para uma versão específica do modelo com PREDICT.

• Usar uma experiência de interface do usuário guiada para gerar código PREDICT
• Copie um modelo de código para um bloco de anotações e personalize os parâmetros você mesmo

Usar uma experiência de interface do usuário guiada

A experiência guiada da interface do usuário orienta você pelas etapas para:

• Selecionar dados de origem para pontuação
• Mapeie os dados corretamente para as entradas do seu modelo de ML
• Especifique o destino das saídas do seu modelo
• Criar um bloco de notas que utilize PREDICT para gerar e armazenar resultados de previsão

Para usar a experiência guiada,

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

2. Selecione Aplicar este modelo no assistente na lista suspensa Aplicar esta versão .

   

   A seleção abre a janela "Aplicar previsões de modelo de ML" na etapa "Selecionar tabela de entrada".

3. Selecione uma tabela de entrada de uma das casas do 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 para as colunas de origem devem corresponder aos tipos de dados esperados do modelo.

   Gorjeta

   O assistente preencherá 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 seu modelo de ML com os valores de previsão acrescentados. Por padrão, a tabela de saída é criada na mesma lakehouse que a tabela de entrada, mas a opção de alterar a lakehouse de destino também está disponível.

   

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 na 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 executará o código PREDICT gerado. O assistente exibe uma visualização do código gerado nesta etapa. Você pode copiar o código para a área de transferência e colá-lo em um bloco de anotações existente, se preferir.

    

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

13. Reveja os detalhes na página de resumo e selecione Criar bloco de notas para adicionar o novo bloco de notas com o respetivo código gerado à sua área 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 permite copiar 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 êxito o modelo de código, você precisa substituir manualmente os seguintes valores:

• <INPUT_TABLE>: O caminho do arquivo para a tabela que fornece entradas para o modelo de ML
• <INPUT_COLS>: Uma matriz de nomes de colunas da tabela de entrada para alimentar o modelo de 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 ser usado para gerar previsões
• <MODEL_VERSION>: A versão do modelo de ML a ser usada para gerar previsões
• <OUTPUT_TABLE>: O caminho do arquivo 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 no Microsoft Fabric