Implantar modelos de MLflow em pontos de extremidade online

Artigo
09/03/2024

APLICA-SE A: Extensão de ML da CLI do Azurev2 (atual)

Neste artigo, aprenda a implantar o modelo de MLflow e um ponto de extremidade online para inferência em tempo real. Ao implantar o modelo do MLflow em um ponto de extremidade online, não é necessário especificar um script de pontuação ou um ambiente; essa funcionalidade é conhecida como implantação sem código.

Para a implantação sem código, o Azure Machine Learning:

Instala dinamicamente os pacotes do Python fornecidos no arquivo conda.yaml. Portanto, as dependências são instaladas durante o runtime do contêiner.
Fornece uma imagem base/ambiente coletado do MLflow que contém os seguintes itens:
- azureml-inference-server-http
- mlflow-skinny
- Um script de pontuação para inferência.

Dica

Workspaces sem acesso à rede pública: antes de implantar modelos do MLflow em pontos de extremidade online sem conectividade de saída, você precisa empacotar os modelos (versão prévia). Usando o empacotamento de modelo, você pode evitar a necessidade de uma conexão com a Internet, o que, de outro modo, o Azure Machine Learning exigirá para instalar dinamicamente os pacotes do Python necessários para os modelos do MLflow.

Sobre o exemplo

O exemplo mostra como você pode implantar um modelo do MLflow em um ponto de extremidade online para executar previsões. O exemplo usa um modelo do MLflow baseado no conjunto de dados Diabetes. Esse conjunto de dados contém dez variáveis de linha de base: idade, sexo, índice de massa corporal, pressão arterial média e seis medidas de soro sanguíneo obtidas de 442 pacientes com diabetes. Também contém a resposta de interesse, uma medida quantitativa da progressão da doença um ano após a linha de base.

O modelo foi treinado usando um regressor scikit-learn, e todo o pré-processamento necessário foi empacotado como um pipeline, tornando esse modelo um pipeline de ponta a ponta que vai de dados brutos a previsões.

As informações deste artigo se baseiam em exemplos de código contidos no repositório azureml-examples. Para executar os comandos localmente sem precisar copiar/colar YAML e outros arquivos, clone o repositório e, em seguida, altere os diretórios para cli, se estiver usando a CLI do Azure. Se você estiver usando o SDK do Azure Machine Learning para Python, altere os diretórios para sdk/python/endpoints/online/mlflow.

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Acompanhar no Jupyter Notebook

Siga as etapas para usar o SDK do Python do Azure Machine Learning abrindo o notebook Implantar modelo do MLflow em pontos de extremidade online no repositório clonado.

Pré-requisitos

Antes de seguir as etapas neste artigo, verifique se você tem os seguintes pré-requisitos:

Uma assinatura do Azure. Caso não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning.
O RBAC do Azure (controle de acesso baseado em função) do Azure é usado para permitir acesso a operações no Azure Machine Learning. Para executar as etapas neste artigo, sua conta de usuário deve receber a função de proprietário ou colaborador para o workspace do Azure Machine Learning ou uma função personalizada que permita Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*. Para obter mais informações, confira Gerenciar acesso a um workspace do Azure Machine Learning.
Você deve ter um modelo do MLflow registrado em seu workspace. Este artigo registra um modelo treinado para o conjunto de dados Diabetes no workspace.
Além disso, você precisa:
- Instale a CLI do Azure e a extensão ml na CLI do Azure. Para obter mais informações sobre como instalar a CLI, confira Instalar e configurar a CLI (v2).
- Instalar o SDK do Azure Machine Learning para Python.
```
pip install azure-ai-ml azure-identity
```
- Instale o pacote mlflow do SDK do MLflow e o plug-in do Azure Machine Learning para MLflow azureml-mlflow.
```
pip install mlflow azureml-mlflow
```
- Se você não estiver executando um código no computador do Azure Machine Learning, configure o URI de acompanhamento do MLflow ou o URI de registro do MLflow para apontar para o workspace do Azure Machine Learning em que você está trabalhando. Para obter mais informações sobre como conectar o MLflow ao workspace, confira Configurar o MLflow para o Azure Machine Learning.
Não há pré-requisitos adicionais ao trabalhar no Estúdio do Azure Machine Learning.

Conectar-se ao workspace

Primeiro, conecte-se ao workspace do Azure Machine Learning no qual você trabalhará.

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

O workspace é o recurso de nível superior para o Azure Machine Learning. Ele fornece um local centralizado para trabalhar com todos os artefatos que você cria ao usar o Azure Machine Learning. Nesta seção, conecte-se ao workspace no qual você executará tarefas de implantação.

Importe as bibliotecas necessárias:

from azure.ai.ml import MLClient, Input
from azure.ai.ml.entities import (
ManagedOnlineEndpoint,
ManagedOnlineDeployment,
Model,
Environment,
CodeConfiguration,
)
from azure.identity import DefaultAzureCredential
from azure.ai.ml.constants import AssetTypes

Configure os detalhes do workspace e obtenha um identificador para o workspace:

subscription_id = "<subscription>"
resource_group = "<resource-group>"
workspace = "<workspace>"

ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

Importar as bibliotecas necessárias

import json
import mlflow
import requests
import pandas as pd
from mlflow.deployments import get_deploy_client
from mlflow.tracking import MlflowClient

Inicializar o cliente MLflow
```
mlflow_client = MlflowClient()
```

Configurar o cliente de implantação

deployment_client = get_deploy_client(mlflow.get_tracking_uri())

Registre o modelo

Você pode implantar apenas modelos registrados em pontos de extremidade online. Nesse caso, você já tem uma cópia local do modelo no repositório, portanto, só precisa publicar o modelo no registro do workspace. Você poderá pular essa etapa se o modelo que está tentando implantar já estiver registrado.

MODEL_NAME='sklearn-diabetes'
az ml model create --name $MODEL_NAME --type "mlflow_model" --path "endpoints/online/ncd/sklearn-diabetes/model"

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"
model = ml_client.models.create_or_update(
        Model(name=model_name, path=model_local_path, type=AssetTypes.MLFLOW_MODEL)
)

model_name = 'sklearn-diabetes'
model_local_path = "sklearn-diabetes/model"

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"file://{model_local_path}"
)
version = registered_model.version

E se o seu modelo foi registrado dentro de uma execução?

Se o seu modelo foi registrado dentro de uma execução, você poderá registrá-lo diretamente.

Para registrar o modelo, você precisa saber o local onde ele está armazenado. Se você estiver usando o recurso autolog do MLflow, o caminho para o modelo dependerá do tipo de modelo e da estrutura. Você deve verificar a saída dos trabalhos para identificar o nome da pasta do modelo. A pasta contém um arquivo chamado MLModel.

Se você estiver usando o método log_model para registrar manualmente seus modelos, passe o caminho para o modelo como o argumento para o método. Por exemplo, se você registrar o modelo usando mlflow.sklearn.log_model(my_model, "classifier"), o caminho em que o modelo está armazenado será chamado de classifier.

Use a CLI do Azure Machine Learning v2 para criar um modelo de uma saída de trabalho de treinamento. No exemplo a seguir, um modelo nomeado $MODEL_NAME é registrado usando os artefatos de um trabalho com a ID $RUN_ID. O caminho em que o modelo é armazenado é $MODEL_PATH.

az ml model create --name $MODEL_NAME --path azureml://jobs/$RUN_ID/outputs/artifacts/$MODEL_PATH

Observação

O caminho $MODEL_PATH é o local em que o modelo foi armazenado na execução.

model_name = 'sklearn-diabetes'

ml_client.models.create_or_update(
    Model(
        path=f"azureml://jobs/{RUN_ID}/outputs/artifacts/{MODEL_PATH}"
        name=model_name,
        type=AssetTypes.MLFLOW_MODEL
    )
)

Observação

O caminho MODEL_PATH é o local em que o modelo foi armazenado na execução.

model_name = 'sklearn-diabetes'

registered_model = mlflow_client.create_model_version(
    name=model_name, source=f"runs://{RUN_ID}/{MODEL_PATH}"
)
version = registered_model.version

Observação

O caminho MODEL_PATH é o local em que o modelo foi armazenado na execução.

Implantar um modelo do MLflow em um ponto de extremidade online

Configure o ponto de extremidade em que o modelo será implantado. O exemplo a seguir configura o nome e o modo de autenticação do ponto de extremidade:

Defina um nome de ponto de extremidade executando o seguinte comando (substitua YOUR_ENDPOINT_NAME por um nome exclusivo):

export ENDPOINT_NAME="<YOUR_ENDPOINT_NAME>"

Configurar o ponto de extremidade:

create-endpoint.yaml

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineEndpoint.schema.json
name: my-endpoint
auth_mode: key

# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

endpoint = ManagedOnlineEndpoint(
    name=endpoint_name,
    description="An online endpoint to generate predictions for the diabetes dataset",
    auth_mode="key",
    tags={"foo": "bar"},
)

Você pode configurar as propriedades desse ponto de extremidade usando um arquivo de configuração. Nesse caso, você está configurando o modo de autenticação do ponto de extremidade como "chave".


# Creating a unique endpoint name with current datetime to avoid conflicts
import datetime

endpoint_name = "sklearn-diabetes-" + datetime.datetime.now().strftime("%m%d%H%M%f")

endpoint_config = {
    "auth_mode": "key",
    "identity": {
        "type": "system_assigned"
    }
}

Grave essa configuração em um arquivo JSON:

endpoint_config_path = "endpoint_config.json"
with open(endpoint_config_path, "w") as outfile:
    outfile.write(json.dumps(endpoint_config))

Criar o ponto de extremidade:

az ml online-endpoint create --name $ENDPOINT_NAME -f endpoints/online/ncd/create-endpoint.yaml

ml_client.begin_create_or_update(endpoint)

endpoint = deployment_client.create_endpoint(
    name=endpoint_name,
    config={"endpoint-config-file": endpoint_config_path},
)

Configurar a implantação. Uma implantação é um conjunto de recursos necessários para hospedar o modelo que executa a inferência real.
sklearn-deployment.yaml
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-deployment
endpoint_name: my-endpoint
model:
  name: mir-sample-sklearn-ncd-model
  version: 2
  path: sklearn-diabetes/model
  type: mlflow_model
instance_type: Standard_DS3_v2
instance_count: 1
```
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1
)
```
Como alternativa, se o seu ponto de extremidade não tiver conectividade de saída, use o empacotamento de modelo (versão prévia) incluindo o argumento with_package=True:
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1,
    with_package=True,
)
```
```
blue_deployment_name = "blue"
```
Para configurar os requisitos de hardware da implantação, crie um arquivo JSON com a configuração desejada:
```
deploy_config = {
    "instance_type": "Standard_F4s_v2",
    "instance_count": 1,
}
```
Observação

Para obter detalhes sobre a especificação completa dessa configuração, confira Esquema de implantação online gerenciado (v2).

Gravar a configuração em um arquivo:
```
deployment_config_path = "deployment_config.json"
with open(deployment_config_path, "w") as outfile:
    outfile.write(json.dumps(deploy_config))
```
Você executará essa etapa no estágio de implantação.
Observação

A geração automática de scoring_script e environment só tem suporte para a variante do modelo pyfunc. Para usar uma variante diferente, confira Personalização das implantações de modelo do MLflow.
Criar a implantação:
```
az ml online-deployment create --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
Se o ponto de extremidade não tiver conectividade de saída, use o empacotamento de modelo (versão prévia) incluindo o sinalizador --with-package:
```
az ml online-deployment create --with-package --name sklearn-deployment --endpoint $ENDPOINT_NAME -f endpoints/online/ncd/sklearn-deployment.yaml --all-traffic
```
```
ml_client.online_deployments.begin_create_or_update(blue_deployment)
```
```
blue_deployment = deployment_client.create_deployment(
    name=blue_deployment_name,
    endpoint=endpoint_name,
    model_uri=f"models:/{model_name}/{version}",
    config={"deploy-config-file": deployment_config_path},
)    
```
1. Na página Pontos de Extremidade, selecione Criar na guia Pontos de extremidade em tempo real.
2. Escolha o modelo do MLflow que você registrou anteriormente e, em seguida, selecione o botão Selecionar.
  
  Observação
  
  A página de configuração inclui uma observação para informar que o script de pontuação e o ambiente são gerados automaticamente para o modelo do MLflow selecionado.
3. Selecione Novo para implantar em um novo ponto de extremidade.
4. Forneça um nome para o ponto de extremidade e a implantação ou mantenha os nomes padrão.
5. Selecione Implantar para implantar o modelo no ponto de extremidade.
Atribua todo o tráfego à implantação. Até agora, o ponto de extremidade tem uma implantação, mas nenhum tráfego é atribuído a ele.
Essa etapa não é necessária na CLI do Azure, pois você usou o sinalizador --all-traffic durante a criação. Se você precisar alterar o tráfego, poderá usar o comando az ml online-endpoint update --traffic. Para obter mais informações sobre como atualizar o tráfego, confira Atualizar progressivamente o tráfego.
```
endpoint.traffic = {"blue": 100}
```
```
traffic_config = {"traffic": {blue_deployment_name: 100}}
```
Gravar a configuração em um arquivo:
```
traffic_config_path = "traffic_config.json"
with open(traffic_config_path, "w") as outfile:
    outfile.write(json.dumps(traffic_config))
```
Essa etapa não é necessária no estúdio.
Atualizar a configuração do ponto de extremidade:
Essa etapa não é necessária na CLI do Azure, pois você usou o sinalizador --all-traffic durante a criação. Se você precisar alterar o tráfego, poderá usar o comando az ml online-endpoint update --traffic. Para obter mais informações sobre como atualizar o tráfego, confira Atualizar progressivamente o tráfego.
```
ml_client.begin_create_or_update(endpoint).result()
```
```
deployment_client.update_endpoint(
    endpoint=endpoint_name,
    config={"endpoint-config-file": traffic_config_path},
)
```
Essa etapa não é necessária no estúdio.

Invocar o ponto de extremidade

Depois que a implantação estiver pronta, você poderá usá-la para atender à solicitação. Uma maneira de testar a implantação é usar o recurso de invocação integrado no cliente de implantação que você está usando. O JSON a seguir é uma solicitação de exemplo para a implantação.

sample-request-sklearn.json

{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}

Observação

input_data é usado nesse exemplo, em vez do inputs usado no serviço do MLflow. Isso ocorre porque o Azure Machine Learning exige um formato de entrada diferente para poder gerar automaticamente os contratos do Swagger para os pontos de extremidade. Para obter mais informações sobre os formatos de entrada esperados, confira Diferenças entre os modelos implantados no Azure Machine Learning e no servidor interno do MLflow.

Envie uma solicitação para o ponto de extremidade da seguinte maneira:

az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json

ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    request_file="sample-request-sklearn.json",
)

# Read the sample request that's in the json file to construct a pandas data frame
with open("sample-request-sklearn.json", "r") as f:
    sample_request = json.loads(f.read())
    samples = pd.DataFrame(**sample_request["input_data"])

deployment_client.predict(endpoint=endpoint_name, df=samples)

A resposta será semelhante ao seguinte texto:

[ 
  11633.100167144921,
  8522.117402884991
]

Importante

Para MLflow sem código-implantação, não há suporte para o teste por meio de pontos de extremidade locais .

Personalizar implantações de modelo do MLflow

Você não precisa especificar um script de pontuação na definição de implantação de um modelo do MLflow para um ponto de extremidade online. No entanto, você pode optar por fazer isso e personalizar como a inferência é executada.

Normalmente, você desejará personalizar a implantação do modelo MLflow quando:

O modelo não tem um sabor PyFunc.
Você precisa personalizar a forma como o modelo é executado, por exemplo, para usar uma variante específica para carregar o modelo, usando mlflow.<flavor>.load_model().
Você precisa fazer o pré/pós-processamento em sua rotina de pontuação quando isso não for feito pelo próprio modelo.
A saída do modelo não pode ser bem representada em dados tabulares. Por exemplo, é um tensor que representa uma imagem.

Importante

Se você optar por especificar um script de pontuação para uma implantação de modelo do MLflow, também precisará especificar o ambiente em que a implantação será executada.

Etapas

Para implantar um modelo do MLflow com um script de pontuação personalizado:

Identifique a pasta em que seu modelo do MLflow está localizado.

a. Vá para o estúdio do Azure Machine Learning.

b. Vá para a seção Modelos.

c. Selecione o modelo que está tentando implantar e vá para a guia Artefatos.

d. Anote a pasta exibida. Essa pasta foi especificada quando o modelo foi registrado.

Crie um script de pontuação. Observe como o nome da pasta model que você identificou anteriormente está incluído na função init().

Dica

O script de pontuação a seguir é fornecido como um exemplo de como executar a inferência com um modelo do MLflow. Você pode adaptar esse script às suas necessidades ou alterar qualquer uma de suas partes para refletir seu cenário.

score.py

import logging
import os
import json
import mlflow
from io import StringIO
from mlflow.pyfunc.scoring_server import infer_and_parse_json_input, predictions_to_json


def init():
    global model
    global input_schema
    # "model" is the path of the mlflow artifacts when the model was registered. For automl
    # models, this is generally "mlflow-model".
    model_path = os.path.join(os.getenv("AZUREML_MODEL_DIR"), "model")
    model = mlflow.pyfunc.load_model(model_path)
    input_schema = model.metadata.get_input_schema()


def run(raw_data):
    json_data = json.loads(raw_data)
    if "input_data" not in json_data.keys():
        raise Exception("Request must contain a top level key named 'input_data'")

    serving_input = json.dumps(json_data["input_data"])
    data = infer_and_parse_json_input(serving_input, input_schema)
    predictions = model.predict(data)

    result = StringIO()
    predictions_to_json(predictions, result)
    return result.getvalue()

Aviso

Consultoria do MLflow 2.0: o script de pontuação fornecido funcionará com o MLflow 1.X e o MLflow 2.X. No entanto, saiba que os formatos de entrada/saída esperados nessas versões podem variar. Verifique a definição de ambiente usada para garantir que você esteja usando a versão esperada do MLflow. Observe que o MLflow 2.0 só tem suporte no Python 3.8+.

Crie um ambiente em que o script de pontuação possa ser executado. Como o modelo é um modelo do MLflow, os requisitos do conda também são especificados no pacote do modelo. Para obter mais detalhes sobre os arquivos incluídos em um modelo do MLflow, confira O formato do MLmodel. Em seguida, você criará o ambiente usando as dependências do conda do arquivo. No entanto, você também precisa incluir o pacote azureml-inference-server-http, que é necessário para implantações online no Azure Machine Learning.

O arquivo de definição do conda é o seguinte:

conda.yml
```
channels:
- conda-forge
dependencies:
- python=3.9
- pip
- pip:
  - mlflow
  - scikit-learn==1.2.2
  - cloudpickle==2.2.1
  - psutil==5.9.4
  - pandas==2.0.0
  - azureml-inference-server-http
name: mlflow-env
```
Observação

O pacote azureml-inference-server-http foi adicionado ao arquivo original de dependências do conda.

Você usará esse arquivo de dependências do conda para criar o ambiente:
O ambiente será criado embutido na configuração de implantação.
```
environment = Environment(
    conda_file="sklearn-diabetes/environment/conda.yml",
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04:latest",
)
```
Não há suporte para essa operação no SDK do MLflow
1. Vá para a guia Ambientes no menu lateral.
2. Selecione a guia Ambientes personalizados>Criar.
3. Insira o nome do ambiente, neste caso, sklearn-mlflow-online-py37.
4. Para Selecionar origem do ambiente, escolha Usar imagem do docker existente com arquivo conda opcional.
5. Para Caminho da imagem de registro do contêiner, insira mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04.
6. Selecione Avançar para ir para a seção Personalizar.
7. Copie o conteúdo do arquivo sklearn-diabetes/environment/conda.yml e cole-o na caixa de texto.
8. Selecione Avançar para ir para a página Marcas e, em seguida, Avançar novamente.
9. Na página Examinar, selecione Criar. O ambiente está pronto para uso.
Criar a implantação:
Criar um arquivo de configuração de implantação deployment.yml:
```
$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: sklearn-diabetes-custom
endpoint_name: my-endpoint
model: azureml:sklearn-diabetes@latest
environment: 
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04
  conda_file: sklearn-diabetes/environment/conda.yml
code_configuration:
  code: sklearn-diabetes/src
  scoring_script: score.py
instance_type: Standard_F2s_v2
instance_count: 1
```
Criar a implantação:
```
az ml online-deployment create -f deployment.yml
```
```
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=endpoint_name,
    model=model,
    environment=environment,
    code_configuration=CodeConfiguration(
        code="sklearn-diabetes/src",
        scoring_script="score.py"
    ),
    instance_type="Standard_F4s_v2",
    instance_count=1,
)
```
Não há suporte para essa operação no SDK do MLflow
1. Na página Pontos de extremidade, selecione +Criar.
2. Selecione o modelo do MLflow que você registrou anteriormente.
3. Selecione Mais opções no assistente de criação do ponto de extremidade para abrir as opções avançadas.
4. Forneça um nome e um tipo de autenticação para o ponto de extremidade e, em seguida, selecione Avançar para verificar se o modelo selecionado está sendo usado em sua implantação.
5. Selecione Avançar para continuar na página _Implantação.
6. Selecione Avançar para ir para a página Código + ambiente. Ao selecionar um modelo registrado no formato MLflow, não é necessário especificar um script de pontuação ou um ambiente nesta página. No entanto, você quer especificar um nesta seção
7. Selecione o controle deslizante ao lado de Personalizar o ambiente e o script de pontuação.
8. Navegue para selecionar o script de pontuação que você criou anteriormente.
9. Selecione Ambientes personalizados para o tipo de ambiente.
10. Selecione o ambiente personalizado criado anteriormente e selecione Avançar.
11. Conclua o assistente para implantar o modelo no ponto de extremidade.
Após a conclusão da implantação, ela estará pronta para atender às solicitações. Uma maneira de testar a implantação é usar um arquivo de solicitação de amostra junto com o método invoke.

sample-request-sklearn.json
```
{"input_data": {
    "columns": [
      "age",
      "sex",
      "bmi",
      "bp",
      "s1",
      "s2",
      "s3",
      "s4",
      "s5",
      "s6"
    ],
    "data": [
      [ 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0 ],
      [ 10.0,2.0,9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0]
    ],
    "index": [0,1]
  }}
```
Envie uma solicitação para o ponto de extremidade da seguinte maneira:
```
az ml online-endpoint invoke --name $ENDPOINT_NAME --request-file endpoints/online/ncd/sample-request-sklearn.json
```
```
ml_client.online_endpoints.invoke(
    endpoint_name=endpoint_name,
    deployment_name=deployment.name,
    request_file="sample-request-sklearn.json",
)
```
Não há suporte para essa operação no SDK do MLflow
1. Acesse a guia Pontos de extremidade e selecione o novo ponto de extremidade criado.
2. Acesse a guia Testar.
3. Cole o conteúdo do arquivo sample-request-sklearn.json na caixa Dados de entrada para testar o ponto de extremidade.
4. Selecione Testar.
5. As previsões aparecerão em "Resultados do teste" no lado direito da caixa.
A resposta será semelhante ao seguinte texto:
```
{
  "predictions": [ 
    11633.100167144921,
    8522.117402884991
  ]
}
```
Aviso

Aviso do MLflow 2.0: no MLflow 1.X, a chave predictions estará ausente.

Limpar os recursos

Depois de terminar de usar o ponto de extremidade, exclua seus recursos associados:

az ml online-endpoint delete --name $ENDPOINT_NAME --yes

ml_client.online_endpoints.begin_delete(endpoint_name)

deployment_client.delete_endpoint(endpoint_name)

Compartilhar via

Implantar modelos de MLflow em pontos de extremidade online

Sobre o exemplo

Acompanhar no Jupyter Notebook

Pré-requisitos

Conectar-se ao workspace

Registre o modelo

E se o seu modelo foi registrado dentro de uma execução?

Implantar um modelo do MLflow em um ponto de extremidade online

Invocar o ponto de extremidade

Personalizar implantações de modelo do MLflow

Etapas

Limpar os recursos

Comentários

Recursos adicionais

Compartilhar via

Implantar modelos de MLflow em pontos de extremidade online

Sobre o exemplo

Acompanhar no Jupyter Notebook

Pré-requisitos

Conectar-se ao workspace

Registre o modelo

E se o seu modelo foi registrado dentro de uma execução?

Implantar um modelo do MLflow em um ponto de extremidade online

Invocar o ponto de extremidade

Personalizar implantações de modelo do MLflow

Etapas

Limpar os recursos

Conteúdo relacionado

Comentários

Recursos adicionais