Implantar um modelo como um ponto de extremidade online

APLICA-SE A: Python SDK azure-ai-ml v2 (atual)

Aprenda a implantar um modelo em um ponto de extremidade online, usando o SDK do Python do Azure Machine Learning v2.

Neste tutorial, você implanta e usa um modelo que prevê a probabilidade de um cliente ficar inadimplente com um pagamento com cartão de crédito.

Os passos que você toma são:

Este vídeo mostra como começar no estúdio do Azure Machine Learning para que você possa seguir as etapas no tutorial. O vídeo mostra como criar um bloco de anotações, criar uma instância de computação e clonar o bloco de anotações. As etapas também são descritas nas seções a seguir.

Pré-requisitos

1. Para usar o Azure Machine Learning, você precisa de um espaço de trabalho. Se você não tiver um, conclua Criar recursos necessários para começar a criar um espaço de trabalho e saiba mais sobre como usá-lo.

   Importante

   Se seu espaço de trabalho do Azure Machine Learning estiver configurado com uma rede virtual gerenciada, talvez seja necessário adicionar regras de saída para permitir o acesso aos repositórios públicos de pacotes Python. Para obter mais informações, consulte Cenário: acessar pacotes públicos de aprendizado de máquina.

2. Entre no estúdio e selecione seu espaço de trabalho se ele ainda não estiver aberto.

3. Abra ou crie um bloco de notas na sua área de trabalho:

   • Se quiser copiar e colar código em células, crie um novo bloco de anotações.
   • Ou abra tutorials/get-started-notebooks/deploy-model.ipynb na seção Amostras do estúdio. Em seguida, selecione Clonar para adicionar o bloco de anotações aos seus arquivos. Para localizar blocos de notas de exemplo, consulte Aprender com blocos de notas de exemplo.

4. Exiba sua cota de VM e verifique se você tem cota suficiente disponível para criar implantações online. Neste tutorial, você precisa de pelo menos 8 núcleos de STANDARD_DS3_v2 e 12 núcleos de STANDARD_F4s_v2. Para exibir o uso da cota da VM e solicitar aumentos de cota, consulte Gerenciar cotas de recursos.

Defina seu kernel e abra no Visual Studio Code (VS Code)

1. Na barra superior acima do bloco de anotações aberto, crie uma instância de computação se ainda não tiver uma.

   

2. Se a instância de computação for interrompida, selecione Iniciar computação e aguarde até que ela esteja em execução.

   

3. Aguarde até que a instância de computação esteja em execução. Em seguida, certifique-se de que o kernel, encontrado no canto superior direito, é Python 3.10 - SDK v2. Caso contrário, use a lista suspensa para selecionar este kernel.

   

   Se você não vir esse kernel, verifique se sua instância de computação está em execução. Se estiver, selecione o botão Atualizar no canto superior direito do bloco de anotações.

4. Se você vir um banner dizendo que precisa ser autenticado, selecione Autenticar.

5. Você pode executar o bloco de anotações aqui ou abri-lo no VS Code para um ambiente de desenvolvimento integrado (IDE) completo com o poder dos recursos do Azure Machine Learning. Selecione Abrir no VS Code e, em seguida, selecione a opção Web ou desktop. Quando iniciado dessa forma, o VS Code é anexado à sua instância de computação, ao kernel e ao sistema de arquivos do espaço de trabalho.

   

Criar identificador para espaço de trabalho

Antes de mergulhar no código, você precisa de uma maneira de fazer referência ao seu espaço de trabalho. Crie ml_client para um identificador para o espaço de trabalho e use o ml_client para gerenciar recursos e trabalhos.

Na célula seguinte, introduza o ID da Subscrição, o nome do Grupo de Recursos e o nome da Área de Trabalho. Para encontrar estes valores:

1. Na barra de ferramentas do estúdio do Azure Machine Learning no canto superior direito, selecione o nome do seu espaço de trabalho.
2. Copie o valor para espaço de trabalho, grupo de recursos e ID de assinatura para o código.
3. Você precisa copiar um valor, fechar a área e colar, em seguida, voltar para o próximo.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# authenticate
credential = DefaultAzureCredential()

# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id="<SUBSCRIPTION_ID>",
    resource_group_name="<RESOURCE_GROUP>",
    workspace_name="<AML_WORKSPACE_NAME>",
)

Registar o modelo

Se você já concluiu o tutorial de treinamento anterior, Treinar um modelo, registrou um modelo MLflow como parte do script de treinamento e pode pular para a próxima seção.

Se você não concluiu o tutorial de treinamento, você precisa registrar o modelo. Registrar seu modelo antes da implantação é uma prática recomendada recomendada.

O código a seguir especifica o path (de onde carregar arquivos) embutido. Se você clonou a pasta tutoriais, execute o código a seguir como está. Caso contrário, baixe os arquivos e metadados para o modelo da pasta credit_defaults_model. Salve os arquivos baixados em uma versão local da pasta credit_defaults_model no seu computador e atualize o caminho no código a seguir para o local dos arquivos baixados.

O SDK carrega automaticamente os arquivos e registra o modelo.

Para obter mais informações sobre como registrar seu modelo como um ativo, consulte Registrar seu modelo como um ativo no Machine Learning usando o SDK.

# Import the necessary libraries
from azure.ai.ml.entities import Model
from azure.ai.ml.constants import AssetTypes

# Provide the model details, including the
# path to the model files, if you've stored them locally.
mlflow_model = Model(
    path="./deploy/credit_defaults_model/",
    type=AssetTypes.MLFLOW_MODEL,
    name="credit_defaults_model",
    description="MLflow Model created from local files.",
)

# Register the model
ml_client.models.create_or_update(mlflow_model)

Confirmar que o modelo está registado

Você pode verificar a página Modelos no estúdio de Aprendizado de Máquina do Azure para identificar a versão mais recente do modelo registrado.

Como alternativa, o código a seguir recupera o número da versão mais recente para você usar.

registered_model_name = "credit_defaults_model"

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)

print(latest_model_version)

Agora que você tem um modelo registrado, pode criar um ponto de extremidade e uma implantação. A próxima seção aborda brevemente alguns detalhes importantes sobre esses tópicos.

Pontos de extremidade e implantações

Depois de treinar um modelo de aprendizado de máquina, você precisa implantá-lo para que outras pessoas possam usá-lo para inferência. Para esse propósito, o Azure Machine Learning permite que você crie pontos de extremidade e adicione implantações a eles.

Um ponto de extremidade, neste contexto, é um caminho HTTPS que fornece uma interface para os clientes enviarem solicitações (dados de entrada) para um modelo treinado e receberem os resultados de inferência (pontuação) do modelo. Um ponto de extremidade fornece:

• Autenticação usando autenticação baseada em "chave ou token"
• Terminação TLS (SSL)
• Um URI de pontuação estável (endpoint-name.region.inference.ml.azure.com)

Uma implantação é um conjunto de recursos necessários para hospedar o modelo que faz a inferência real.

Um único ponto de extremidade pode conter várias implantações. Pontos de extremidade e implantações são recursos independentes do Azure Resource Manager que aparecem no portal do Azure.

O Azure Machine Learning permite implementar pontos de extremidade online para inferência em tempo real em dados do cliente e pontos de extremidade em lote para inferência em grandes volumes de dados durante um período de tempo.

Neste tutorial, você percorre as etapas de implementação de um ponto de extremidade online gerenciado. Os pontos de extremidade online gerenciados funcionam com poderosas máquinas de CPU e GPU no Azure de uma maneira escalável e totalmente gerenciada que libera você da sobrecarga de configurar e gerenciar a infraestrutura de implantação subjacente.

Criar um ponto de extremidade online

Agora que você tem um modelo registrado, é hora de criar seu endpoint online. O nome do ponto de extremidade precisa ser exclusivo em toda a região do Azure. Para este tutorial, você cria um nome exclusivo usando um identificador UUIDuniversalmente exclusivo . Para obter mais informações sobre as regras de nomenclatura de pontos de extremidade, consulte Limites de pontos de extremidade.

import uuid

# Create a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]

Primeiro, defina o ponto de extremidade, usando a ManagedOnlineEndpoint classe.

from azure.ai.ml.entities import ManagedOnlineEndpoint

# define an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
    },
)

Usando o MLClient criado anteriormente, crie o ponto de extremidade no espaço de trabalho. Este comando inicia a criação do ponto de extremidade e retorna uma resposta de confirmação enquanto a criação do ponto de extremidade continua.

# create the online endpoint
# expect the endpoint to take approximately 2 minutes.

endpoint = ml_client.online_endpoints.begin_create_or_update(endpoint).result()

Depois de criar o ponto de extremidade, você pode recuperá-lo da seguinte maneira:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpoint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Noções básicas sobre implantações on-line

Os principais aspetos de uma implantação incluem:

• name - Nome da implantação.
• endpoint_name - Nome do ponto de extremidade que conterá a implantação.
• model - O modelo a utilizar para a implantação. Esse valor pode ser uma referência a um modelo versionado existente no espaço de trabalho ou uma especificação de modelo embutido.
• environment - O ambiente a utilizar para a implementação (ou para executar o modelo). Esse valor pode ser uma referência a um ambiente versionado existente no espaço de trabalho ou uma especificação de ambiente embutido. O ambiente pode ser uma imagem do Docker com dependências do Conda ou um Dockerfile.
• code_configuration - a configuração do código-fonte e do script de pontuação.
  • path- Caminho para o diretório de código fonte para pontuar o modelo.
  • scoring_script - Caminho relativo para o arquivo de pontuação no diretório de código-fonte. Esse script executa o modelo em uma determinada solicitação de entrada. Para obter um exemplo de um script de pontuação, consulte Compreender o script de pontuação no artigo "Implantar um modelo de ML com um ponto de extremidade online".
• instance_type - O tamanho da VM a ser usado para a implantação. Para obter a lista de tamanhos suportados, consulte Lista de SKU de pontos de extremidade online gerenciados.
• instance_count - O número de instâncias a serem usadas para a implantação.

Implantação usando um modelo MLflow

O Azure Machine Learning dá suporte à implantação sem código de um modelo criado e registrado com MLflow. Isso significa que você não precisa fornecer um script de pontuação ou um ambiente durante a implantação do modelo, pois o script de pontuação e o ambiente são gerados automaticamente ao treinar um modelo MLflow. Se você estivesse usando um modelo personalizado, no entanto, teria que especificar o ambiente e o script de pontuação durante a implantação.

Implantar o modelo no ponto de extremidade

Comece criando uma única implantação que lide com 100% do tráfego de entrada. Escolha um nome de cor arbitrária (azul) para a implantação. Para criar a implantação para o ponto de extremidade, use a ManagedOnlineDeployment classe.

from azure.ai.ml.entities import ManagedOnlineDeployment

# Choose the latest version of the registered model for deployment
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)

# define an online deployment
# if you run into an out of quota error, change the instance_type to a comparable VM that is available.\
# Learn more on https://azure.microsoft.com/en-us/pricing/details/machine-learning/.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

Usando o MLClient criado anteriormente, agora crie a implantação no espaço de trabalho. Este comando inicia a criação da implantação e retorna uma resposta de confirmação enquanto a criação da implantação continua.

# create the online deployment
blue_deployment = ml_client.online_deployments.begin_create_or_update(
    blue_deployment
).result()

# blue deployment takes 100% traffic
# expect the deployment to take approximately 8 to 10 minutes.
endpoint.traffic = {"blue": 100}
ml_client.online_endpoints.begin_create_or_update(endpoint).result()

Verificar o estado do ponto final

Você pode verificar o status do ponto de extremidade para ver se o modelo foi implantado sem erro:

# return an object that contains metadata for the endpoint
endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

# print a selection of the endpoint's metadata
print(
    f"Name: {endpoint.name}\nStatus: {endpoint.provisioning_state}\nDescription: {endpoint.description}"
)

# existing traffic details
print(endpoint.traffic)

# Get the scoring URI
print(endpoint.scoring_uri)

Testar o ponto de extremidade com dados de amostra

Agora que o modelo é implantado no ponto de extremidade, você pode executar a inferência com ele. Comece criando um arquivo de solicitação de exemplo que siga o design esperado no método de execução encontrado no script de pontuação.

import os

# Create a directory to store the sample request file.
deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)

Agora, crie o arquivo no diretório deploy. A célula de código a seguir usa a magia do IPython para gravar o arquivo no diretório que você acabou de criar.

%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
            ]
                }
}

Usando o MLClient criado anteriormente, obtenha um identificador para o ponto de extremidade. Você pode invocar o ponto de extremidade usando o invoke comando com os seguintes parâmetros:

• endpoint_name - Nome do ponto final
• request_file - Arquivo com dados de solicitação
• deployment_name - Nome da implantação específica a ser testada em um endpoint

Teste a implantação azul com os dados de exemplo.

# test the blue deployment with the sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    deployment_name="blue",
    request_file="./deploy/sample-request.json",
)

Obter logs da implantação

Verifique os logs para ver se o ponto de extremidade/implantação foi invocado com êxito. Se você enfrentar erros, consulte Solução de problemas de implantação de pontos de extremidade online.

logs = ml_client.online_deployments.get_logs(
    name="blue", endpoint_name=online_endpoint_name, lines=50
)
print(logs)

Criar uma segunda implantação

Implante o modelo como uma segunda implantação chamada green. Na prática, você pode criar várias implantações e comparar seu desempenho. Essas implantações podem usar uma versão diferente do mesmo modelo, um modelo diferente ou uma instância de computação mais poderosa.

Neste exemplo, você implanta a mesma versão do modelo, usando uma instância de computação mais poderosa que poderia melhorar o desempenho.

# pick the model to deploy. Here you use the latest version of the registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)

# define an online deployment using a more powerful instance type
# if you run into an out of quota error, change the instance_type to a comparable VM that is available.\
# Learn more on https://azure.microsoft.com/en-us/pricing/details/machine-learning/.
green_deployment = ManagedOnlineDeployment(
    name="green",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1,
)

# create the online deployment
# expect the deployment to take approximately 8 to 10 minutes
green_deployment = ml_client.online_deployments.begin_create_or_update(
    green_deployment
).result()

Dimensione a implantação para lidar com mais tráfego

Usando o MLClient criado anteriormente, você pode obter um identificador para a green implantação. Em seguida, você pode dimensioná-lo aumentando ou diminuindo o instance_count.

No código a seguir, você aumenta a instância da VM manualmente. No entanto, também é possível dimensionar automaticamente os endpoints online. O dimensionamento automático executa a quantidade certa de recursos para processar a carga da aplicação. Os pontos de extremidade online gerenciados dão suporte ao dimensionamento automático por meio da integração com o recurso de dimensionamento automático do monitor do Azure. Para configurar o dimensionamento automático, consulte Pontos de extremidade online de dimensionamento automático.

# update definition of the deployment
green_deployment.instance_count = 2

# update the deployment
# expect the deployment to take approximately 8 to 10 minutes
ml_client.online_deployments.begin_create_or_update(green_deployment).result()

Atualizar a alocação de tráfego para implantações

Você pode dividir o tráfego de produção entre implantações. Você pode primeiro querer testar a green implantação com dados de exemplo, assim como fez para a blue implantação. Depois de testar sua implantação verde, aloque uma pequena porcentagem de tráfego para ela.

endpoint.traffic = {"blue": 80, "green": 20}
ml_client.online_endpoints.begin_create_or_update(endpoint).result()

Teste a alocação de tráfego invocando o ponto de extremidade várias vezes:

# You can invoke the endpoint several times
for i in range(30):
    ml_client.online_endpoints.invoke(
        endpoint_name=online_endpoint_name,
        request_file="./deploy/sample-request.json",
    )

Mostrar logs da green implantação para verificar se houve solicitações de entrada e se o modelo foi pontuado com êxito.

logs = ml_client.online_deployments.get_logs(
    name="green", endpoint_name=online_endpoint_name, lines=50
)
print(logs)

Exibir métricas usando o Azure Monitor

Você pode visualizar várias métricas (números de solicitação, latência de solicitação, bytes de rede, utilização de CPU/GPU/disco/memória e muito mais) para um endpoint online e suas implantações seguindo os links da página Detalhes do endpoint no estúdio. Seguir qualquer um desses links leva você à página de métricas exatas no portal do Azure para o ponto de extremidade ou implantação.

Se você abrir as métricas para o ponto de extremidade online, poderá configurar a página para ver métricas como a latência média da solicitação, conforme mostrado na figura a seguir.

Para obter mais informações sobre como exibir métricas de ponto de extremidade online, consulte Monitorar pontos de extremidade online.

Enviar todo o tráfego para a nova implantação

Quando estiver totalmente satisfeito com sua green implantação, alterne todo o tráfego para ela.

endpoint.traffic = {"blue": 0, "green": 100}
ml_client.begin_create_or_update(endpoint).result()

Excluir a implantação antiga

Remova a implantação antiga (azul):

ml_client.online_deployments.begin_delete(
    name="blue", endpoint_name=online_endpoint_name
).result()

Clean up resources (Limpar recursos)

Se você não vai usar o ponto de extremidade e a implantação depois de concluir este tutorial, exclua-os.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name).result()

Excluir tudo

Use estas etapas para excluir seu espaço de trabalho do Azure Machine Learning e todos os recursos de computação.

Se você não planeja usar nenhum dos recursos que criou, exclua-os para não incorrer em cobranças:

1. No portal do Azure, na caixa de pesquisa, insira Grupos de recursos e selecione-o nos resultados.

2. Na lista, selecione o grupo de recursos que você criou.

3. Na página Visão geral, selecione Excluir grupo de recursos.

   

4. Insira o nome do grupo de recursos. Em seguida, selecione Eliminar.

Próximo passo