Implantar modelos MLflow em endpoints online

Artigo
10/16/2024

APLICA-SE A: Azure CLI ml extension v2 (atual)

Neste artigo, saiba como implantar seu modelo MLflow em um ponto de extremidade online para inferência em tempo real. Quando você implanta seu modelo MLflow em um ponto de extremidade online, não precisa especificar um script de pontuação ou um ambiente — essa funcionalidade é conhecida como implantação sem código.

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

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

Gorjeta

Espaços de trabalho sem acesso à rede pública: antes de implantar modelos MLflow em pontos de extremidade online sem conectividade de saída, você precisa empacotar os modelos (visualização). Usando o empacotamento de modelo, você pode evitar a necessidade de uma conexão com a Internet, que o Aprendizado de Máquina do Azure exigiria para instalar dinamicamente os pacotes Python necessários para os modelos MLflow.

Sobre o exemplo

O exemplo mostra como você pode implantar um modelo MLflow em um ponto de extremidade online para executar previsões. O exemplo usa um modelo MLflow baseado no conjunto de dados Diabetes. Este conjunto de dados contém 10 variáveis basais: idade, sexo, índice de massa corporal, pressão arterial média e seis medições séricas obtidas de 442 pacientes com diabetes. Contém também a resposta de interesse, uma medida quantitativa da progressão da doença um ano após o início do estudo.

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

As informações neste artigo são baseadas em exemplos de código contidos no repositório azureml-examples . Para executar os comandos localmente sem ter que copiar/colar YAML e outros arquivos, clone o repositório e 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

Acompanhe no Jupyter Notebook

Você pode seguir as etapas para usar o SDK Python do Azure Machine Learning abrindo o modelo Implantar MLflow no bloco de anotações de 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 subscrição do Azure. Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar. Experimente a versão gratuita ou paga do Azure Machine Learning.
Os controlos de acesso baseado em funções (RBAC do Azure) são utilizados para conceder acesso às 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 espaço de trabalho do Azure Machine Learning ou uma função personalizada que permita Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*. Para obter mais informações sobre funções, consulte Gerenciar o acesso a um espaço de trabalho do Azure Machine Learning.
Você deve ter um modelo MLflow registrado em seu espaço de trabalho. Este artigo registra um modelo treinado para o conjunto de dados Diabetes no espaço de trabalho.
Além disso, você precisa:
- Instale a CLI do Azure e a ml extensão para a CLI do Azure. Para obter mais informações sobre como instalar a CLI, consulte Instalar e configurar a CLI (v2).
- Instale o SDK do Azure Machine Learning para Python.
```
pip install azure-ai-ml azure-identity
```
- Instale o pacote mlflow MLflow SDK e o plug-in do Azure Machine Learning para MLflow azureml-mlflow.
```
pip install mlflow azureml-mlflow
```
- Se você não estiver executando código na computação do Aprendizado de Máquina do Azure, configure o URI de rastreamento do MLflow ou o URI do registro do MLflow para apontar para o espaço de trabalho do Aprendizado de Máquina do Azure no qual você está trabalhando. Para obter mais informações sobre como conectar o MLflow ao espaço de trabalho, consulte Configurar o MLflow para o Azure Machine Learning.
Não há pré-requisitos adicionais ao trabalhar no estúdio do Azure Machine Learning.

Ligar à sua área de trabalho

Primeiro, conecte-se ao espaço de trabalho do Azure Machine Learning onde você trabalhará.

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

A área de trabalho é o recurso de nível superior do Azure Machine Learning que proporciona um local centralizado para trabalhar com todos os artefactos que cria quando utiliza o Azure Machine Learning. Nesta seção, conecte-se ao espaço de trabalho 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 espaço de trabalho e obtenha um identificador para o espaço de trabalho:

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

Registar o modelo

Você pode implantar apenas modelos registrados em endpoints online. Nesse caso, você já tem uma cópia local do modelo no repositório, portanto, só precisa publicar o modelo no registro no espaço de trabalho. Você pode pular esta 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 tiver sido registado dentro de uma corrida?

Se o seu modelo foi registrado dentro de uma corrida, você pode registrá-lo diretamente.

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

Se você estiver usando o log_model método 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 onde o modelo está armazenado será chamado classifier.

Use a CLI do Azure Machine Learning v2 para criar um modelo a partir 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 ID $RUN_ID. O caminho onde o modelo é armazenado é $MODEL_PATH.

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

Nota

O caminho $MODEL_PATH é o local onde 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
    )
)

Nota

O caminho MODEL_PATH é o local onde 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

Nota

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

Implantar um modelo MLflow em um ponto de extremidade online

Configure o ponto de extremidade onde 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>"

Configure 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 para ser "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"
    }
}

Escreva esta configuração em um JSON arquivo:

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

Crie 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},
)

Configure a implantação. Uma implantação é um conjunto de recursos necessários para hospedar o modelo que faz 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 ponto de extremidade não tiver conectividade de saída, use o empacotamento do modelo (visualização) 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 de sua implantação, crie um arquivo JSON com a configuração desejada:

deploy_config = {
    "instance_type": "Standard_F4s_v2",
    "instance_count": 1,
}

Nota

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

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

Nota

Autogeração do e environment são suportados apenas para pyfunc o scoring_script sabor do modelo. Para usar um modelo diferente, consulte Personalizando implantações de modelo MLflow.

Crie 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 seu ponto de extremidade não tiver conectividade de saída, use o empacotamento do modelo (visualização) 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 MLflow que você registrou anteriormente e, em seguida, selecione o botão Selecionar .
  
  Nota
  
  A página de configuração inclui uma nota para informá-lo de que o script de pontuação e o ambiente são gerados automaticamente para o modelo 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 de seu tráfego é atribuído a ele.
Esta etapa não é necessária na CLI do Azure, pois você usou o sinalizador durante a --all-traffic criação. Se você precisar alterar o tráfego, você pode usar o comando az ml online-endpoint update --traffic. Para obter mais informações sobre como atualizar o tráfego, consulte Atualizar progressivamente o tráfego.
```
endpoint.traffic = {"blue": 100}
```
```
traffic_config = {"traffic": {blue_deployment_name: 100}}
```
Escreva 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))
```
Este passo não é obrigatório no estúdio.
Atualize a configuração do ponto final:
Esta etapa não é necessária na CLI do Azure, pois você usou o sinalizador durante a --all-traffic criação. Se você precisar alterar o tráfego, você pode usar o comando az ml online-endpoint update --traffic. Para obter mais informações sobre como atualizar o tráfego, consulte 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},
)
```
Este passo não é obrigatório no estúdio.

Invoque o ponto de extremidade

Quando a implantação estiver pronta, você poderá usá-la para atender à solicitação. Uma maneira de testar a implantação é usando o recurso de invocação interno 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]
  }}

Nota

input_data é usado neste exemplo, em vez de inputs que é usado no serviço MLflow. Isso ocorre porque o Aprendizado de Máquina do Azure requer um formato de entrada diferente para poder gerar automaticamente os contratos swagger para os pontos de extremidade. Para obter mais informações sobre os formatos de entrada esperados, consulte Diferenças entre modelos implantados no Azure Machine Learning e no servidor interno 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 no-code-deployment, o teste por meio de endpoints locais não é suportado no momento.

Personalizar implantações de modelo MLflow

Não é necessário especificar um script de pontuação na definição de implantação de um modelo 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 sabor PyFunc .
Você precisa personalizar a maneira como o modelo é executado, por exemplo, para usar um sabor específico para carregar o modelo, usando mlflow.<flavor>.load_model().
Você precisa fazer pré/pós processamento na sua rotina de pontuação quando não é 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 MLflow, também terá que especificar o ambiente onde a implantação será executada.

Passos

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

Identifique a pasta onde seu modelo 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 você está tentando implantar e vá para a guia Artefatos .

d. Anote a pasta que é exibida. Esta pasta foi especificada quando o modelo foi registrado.

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

Gorjeta

O script de pontuação a seguir é fornecido como um exemplo sobre como executar inferência com um modelo 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

Aviso do MLflow 2.0: O script de pontuação fornecido funcionará com o MLflow 1.X e o MLflow 2.X. No entanto, esteja ciente de 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ó é suportado no Python 3.8+.

Crie um ambiente onde o script de pontuação possa ser executado. Como o modelo é um modelo MLflow, os requisitos de conda também são especificados no pacote do modelo. Para obter mais detalhes sobre os arquivos incluídos em um modelo MLflow, consulte O formato MLmodel. Em seguida, você criará o ambiente usando as dependências 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 de 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
```
Nota

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

Você usará este arquivo de dependências conda para criar o ambiente:
O ambiente será criado em linha 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",
)
```
Esta operação não é suportada no MLflow SDK
1. Vá para a guia Ambientes no menu lateral.
2. Selecione a guia Ambientes>personalizados Criar.
3. Digite o nome do ambiente, neste caso sklearn-mlflow-online-py37.
4. Para Selecionar origem do ambiente, escolha Usar imagem docker existente com arquivo conda opcional.
5. Em Caminho da imagem do Registro de contêiner, digite mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04.
6. Selecione Avançar para ir para a seção Personalizar .
7. Copie o sklearn-diabetes/environment/conda.yml conteúdo do arquivo 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 Revisão, selecione Criar. O ambiente está pronto para uso.
Crie a implantação:
Crie 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
```
Crie 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,
)
```
Esta operação não é suportada no MLflow SDK
1. Na página Pontos de extremidade, selecione +Criar.
2. Selecione o modelo MLflow que você registrou anteriormente.
3. Selecione Mais opções no assistente de criação de pontos finais para abrir opções avançadas.
4. Forneça um nome e um tipo de autenticação para o ponto de extremidade e selecione Avançar para ver se o modelo selecionado está sendo usado para 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ê deseja especificar um nesta seção
7. Selecione o controle deslizante ao lado de Personalizar ambiente e 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.
Quando a implantação for concluída, ela estará pronta para atender às solicitações. Uma maneira de testar a implantação é usando um arquivo de solicitação de exemplo junto com o invoke método.

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",
)
```
Esta operação não é suportada no MLflow SDK
1. Vá para a guia Pontos de extremidade e selecione o novo ponto de extremidade criado.
2. Vá para a guia Teste.
3. Cole o sample-request-sklearn.json conteúdo do arquivo na caixa Dados de entrada para testar o ponto de extremidade .
4. Selecione Teste.
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 predictions chave estará ausente.

Clean up resources (Limpar recursos)

Quando terminar de usar o ponto de extremidade, exclua os 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)

Partilhar via

Implantar modelos MLflow em endpoints online

Sobre o exemplo

Acompanhe no Jupyter Notebook

Pré-requisitos

Ligar à sua área de trabalho

Registar o modelo

E se o seu modelo tiver sido registado dentro de uma corrida?

Implantar um modelo MLflow em um ponto de extremidade online

Invoque o ponto de extremidade

Personalizar implantações de modelo MLflow

Passos

Clean up resources (Limpar recursos)

Comentários

Recursos adicionais

Partilhar via

Implantar modelos MLflow em endpoints online

Sobre o exemplo

Acompanhe no Jupyter Notebook

Pré-requisitos

Ligar à sua área de trabalho

Registar o modelo

E se o seu modelo tiver sido registado dentro de uma corrida?

Implantar um modelo MLflow em um ponto de extremidade online

Invoque o ponto de extremidade

Personalizar implantações de modelo MLflow

Passos

Clean up resources (Limpar recursos)

Conteúdos relacionados

Comentários

Recursos adicionais