Tutorial: Criar gasodutos ML de produção com Python SDK v2 num caderno Jupyter

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

Nota

Para um tutorial que usa SDK v1 para construir um oleoduto, consulte Tutorial: Construa um pipeline de Aprendizagem automática Azure para classificação de imagem

Neste tutorial, você usará Azure Machine Learning (Azure ML) para criar um projeto de aprendizagem automática pronta para produção (ML), utilizando AzureML Python SDK v2.

Você vai aprender a usar o AzureML Python SDK v2 para:

  • Ligue-se ao seu espaço de trabalho Azure ML
  • Criar ativos de dados Azure ML
  • Criar componentes Azure ML reutilizáveis
  • Criar, validar e executar gasodutos Azure ML
  • Implementar o modelo recém-treinado como ponto final
  • Ligue para o ponto final do Azure ML para inferenização

Pré-requisitos

Abra o caderno

  1. Abra a pasta de tutoriais que foi clonada na secção De Ficheiros a partir do Quickstart: Executar cadernos Jupyter em estúdio.

  2. Selecione o ficheiro e2e-ml-workflow.ipynb a partir dos seus tutoriais/azureml-exemplos/tutoriais/e2e-ds-experience/ pasta.

    A screenshot mostra a pasta de tutoriais abertos.

  3. Na barra superior, selecione a instância de cálculo que criou durante o Quickstart: Começa com o Azure Machine Learning para usar para executar o caderno.

Importante

O resto deste artigo contém o mesmo conteúdo que se vê no caderno.

Mude para o Jupyter Notebook agora se quiser executar o código enquanto lê. Para executar uma única célula de código num bloco de notas, clique na célula de código e clique no Shift+Enter. Ou, executar todo o caderno escolhendo Executar tudo a partir da barra de ferramentas superior

Introdução

Neste tutorial, você vai criar um oleoduto Azure ML para treinar um modelo para previsão de incumprimento de crédito. O gasoduto trata da preparação de dados, da formação e registo do modelo treinado. Em seguida, irá executar o oleoduto, implementar o modelo e usá-lo.

A imagem abaixo mostra o gasoduto tal como o verá no portal AzureML uma vez submetido. É um oleoduto bastante simples que usaremos para te acompanhar através do AzureML SDK v2.

Os dois passos são a primeira preparação de dados e o segundo treino.

O diagrama mostra uma visão geral do oleoduto.

Criar os recursos do gasoduto

A estrutura Azure ML pode ser usada a partir de CLI, Python SDK ou interface de estúdio. Neste exemplo, você usará o AzureML Python SDK v2 para criar um oleoduto.

Antes de criar o oleoduto, irá configurar os recursos que o gasoduto irá utilizar:

  • O ativo de dados para a formação
  • O ambiente de software para executar o oleoduto
  • Um recurso de computação para onde o trabalho vai funcionar

Ligar-se ao espaço de trabalho

Antes de mergulharmos no código, terá de se ligar ao seu espaço de trabalho Azure ML. 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.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

Na célula seguinte, insira o seu ID de subscrição, nome do Grupo de Recursos e nome do espaço de trabalho. Para encontrar o seu ID de subscrição:

  1. Na barra de ferramentas estúdio do Azure Machine Learning superior direita, selecione o nome do seu espaço de trabalho.
  2. Verá os valores de que precisa para <SUBSCRIPTION_ID>, <RESOURCE_GROUP> e <AML_WORKSPACE_NAME>.
  3. Copie um valor, feche a janela e cole-a no seu código. Abra novamente a ferramenta para obter o próximo valor.

A screenshot mostra como encontrar valores necessários para o seu código.

# 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>",
)

O resultado é um manipulador para o espaço de trabalho que você vai usar para gerir outros recursos e empregos.

Importante

A criação de MLClient não se ligará ao espaço de trabalho. A inicialização do cliente é preguiçosa, vai esperar pela primeira vez que precisa de fazer uma chamada (no caderno abaixo, que vai acontecer durante o registo do conjunto de dados).

Registar dados de um url externo

Os dados que utiliza para a formação estão geralmente num dos locais abaixo:

  • Computador local
  • Web
  • Serviços de Armazenamento de Big Data (por exemplo, Azure Blob, Azure Data Lake Storage, SQL)

AZure ML usa um Data objeto para registar uma definição reutilizável de dados e consumir dados dentro de um pipeline. Na secção abaixo, irá consumir alguns dados da web url como um exemplo. Os dados de outras fontes também podem ser criados. Data os ativos de outras fontes também podem ser criados.

from azure.ai.ml.entities import Data
from azure.ai.ml.constants import AssetTypes

web_path = "https://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls"

credit_data = Data(
    name="creditcard_defaults",
    path=web_path,
    type=AssetTypes.URI_FILE,
    description="Dataset for credit card defaults",
    tags={"source_type": "web", "source": "UCI ML Repo"},
    version="1.0.0",
)

Este código acaba de criar um Data ativo, pronto a ser consumido como uma entrada pelo pipeline que definirá nas próximas secções. Além disso, pode registar os dados no seu espaço de trabalho para que se torne reutilizável através de oleodutos.

Registar o ativo de dados permitir-lhe-á:

  • Reutilizar e partilhar o ativo de dados em futuros oleodutos
  • Utilize versões para acompanhar a modificação do ativo de dados
  • Utilize o ativo de dados do designer Azure ML, que é o GUI da Azure ML para autoria de gasodutos

Uma vez que é a primeira vez que faz uma chamada para o espaço de trabalho, pode ser-lhe pedido que autente para autenticar. Uma vez concluída a autenticação, verá a mensagem de conclusão do registo do conjunto de dados.

credit_data = ml_client.data.create_or_update(credit_data)
print(
    f"Dataset with name {credit_data.name} was registered to workspace, the dataset version is {credit_data.version}"
)

No futuro, pode obter o mesmo conjunto de dados do espaço de trabalho utilizando credit_dataset = ml_client.data.get("<DATA ASSET NAME>", version='<VERSION>').

Crie um recurso computacional para executar o seu pipeline

Cada passo de um gasoduto Azure ML pode usar um recurso computacional diferente para executar o trabalho específico desse passo. Pode ser máquinas individuais ou multi-nós com Linux ou Windows OS, ou um tecido computacional específico como o Spark.

Nesta secção, você vai providenciar um cluster de cálculo Linux. Consulte a lista completa dos tamanhos e preços dos VM .

Para este tutorial você só precisa de um cluster básico, por isso vamos usar um modelo Standard_DS3_v2 com 2 núcleos vCPU, 7 GB RAM e criar um Azure ML Compute.

Dica

Se já tiver um cluster de cálculo, substitua o "cpu-cluster" no código abaixo pelo nome do seu cluster. Isto vai impedir-te de criar outro.

from azure.ai.ml.entities import AmlCompute

cpu_compute_target = "cpu-cluster"

try:
    # let's see if the compute target already exists
    cpu_cluster = ml_client.compute.get(cpu_compute_target)
    print(
        f"You already have a cluster named {cpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new cpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    cpu_cluster = AmlCompute(
        # Name assigned to the compute cluster
        name="cpu-cluster",
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_DS3_V2",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )

    # Now, we pass the object to MLClient's create_or_update method
    cpu_cluster = ml_client.begin_create_or_update(cpu_cluster)

print(
    f"AMLCompute with name {cpu_cluster.name} is created, the compute size is {cpu_cluster.size}"
)

Criar um ambiente de trabalho para passos de pipeline

Até agora, criaste um ambiente de desenvolvimento sobre a putação, a tua máquina de desenvolvimento. Você também vai precisar de um ambiente para usar para cada passo do oleoduto. Cada passo pode ter o seu próprio ambiente, ou pode usar alguns ambientes comuns para vários passos.

Neste exemplo, você vai criar um ambiente conda para o seu trabalho, usando um arquivo conda yaml. Primeiro, crie um diretório para guardar o ficheiro.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Agora, crie o ficheiro no diretório de dependências.

%%writefile {dependencies_dir}/conda.yml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - xlrd==2.0.1
    - mlflow== 1.26.1
    - azureml-mlflow==1.42.0

A especificação contém alguns pacotes habituais, que você usará no seu pipeline (numpy, pip), juntamente com alguns pacotes específicos Azure ML (azureml-defaults, azureml-mlflow).

Os pacotes Azure ML não são obrigatórios para gerir empregos da Azure ML. No entanto, a adição destes pacotes permitirá interagir com a Azure ML para registar métricas e modelos de registo, tudo dentro do trabalho Azure ML. Vais usá-los no guião de treino mais tarde neste tutorial.

Utilize o ficheiro yaml para criar e registar este ambiente personalizado no seu espaço de trabalho:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

pipeline_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults pipeline",
    tags={"scikit-learn": "0.24.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
    version="0.1.0",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)

print(
    f"Environment with name {pipeline_job_env.name} is registered to workspace, the environment version is {pipeline_job_env.version}"
)

Construir o gasoduto de treino

Agora que tem todos os ativos necessários para executar o seu oleoduto, é hora de construir o oleoduto em si, usando o Azure ML Python SDK v2.

Os gasodutos Azure ML são fluxos de trabalho ML reutilizáveis que normalmente consistem em vários componentes. A vida típica de um componente é:

  • Escreva a especificação yaml do componente ou crie-o programáticamente utilizando ComponentMethod.
  • Opcionalmente, registe o componente com um nome e versão no seu espaço de trabalho, para torná-lo reutilizável e partilhável.
  • Carregue o componente do código do gasoduto.
  • Implementar o gasoduto utilizando as entradas, saídas e parâmetros do componente
  • Envie o oleoduto.

Criar componente 1: preparação de dados (utilizando definição programática)

Vamos começar por criar o primeiro componente. Este componente trata do pré-processamento dos dados. A tarefa de pré-processamento é executada no ficheiro data_prep.py python.

Primeiro, crie uma pasta de origem para o componente data_prep:

import os

data_prep_src_dir = "./components/data_prep"
os.makedirs(data_prep_src_dir, exist_ok=True)

Este script executa a tarefa simples de dividir os dados em conjuntos de dados de comboio e teste. O Azure ML monta conjuntos de dados como pastas para os cálculos, por isso, criámos uma função auxiliar select_first_file para aceder ao ficheiro de dados dentro da pasta de entrada montada.

O MLFlow será utilizado para registar os parâmetros e métricas durante o nosso percurso de gasoduto.

%%writefile {data_prep_src_dir}/data_prep.py
import os
import argparse
import pandas as pd
from sklearn.model_selection import train_test_split
import logging
import mlflow


def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    args = parser.parse_args()

    # Start Logging
    mlflow.start_run()

    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)

    credit_df = pd.read_excel(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    credit_train_df, credit_test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )

    # output paths are mounted as folder, therefore, we are adding a filename to the path
    credit_train_df.to_csv(os.path.join(args.train_data, "data.csv"), index=False)

    credit_test_df.to_csv(os.path.join(args.test_data, "data.csv"), index=False)

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Agora que tem um script que pode executar a tarefa desejada, crie um Componente Azure ML a partir dele.

Você usará o propósito geral CommandComponent que pode executar ações de linha de comando. Esta ação de linha de comando pode ligar diretamente os comandos do sistema ou executar um script. As entradas/saídas são especificadas na linha de comando através da ${{ ... }} notação.

from azure.ai.ml import command
from azure.ai.ml import Input, Output

data_prep_component = command(
    name="data_prep_credit_defaults",
    display_name="Data preparation for training",
    description="reads a .xl input, split the input to train and test",
    inputs={
        "data": Input(type="uri_folder"),
        "test_train_ratio": Input(type="number"),
    },
    outputs=dict(
        train_data=Output(type="uri_folder", mode="rw_mount"),
        test_data=Output(type="uri_folder", mode="rw_mount"),
    ),
    # The source folder of the component
    code=data_prep_src_dir,
    command="""python data_prep.py \
            --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} \
            --train_data ${{outputs.train_data}} --test_data ${{outputs.test_data}} \
            """,
    environment=f"{pipeline_job_env.name}:{pipeline_job_env.version}",
)

Opcionalmente, registe o componente no espaço de trabalho para futura reutilização.

Criar componente 2: formação (usando a definição yaml)

O segundo componente que vai criar irá consumir os dados de treino e teste, treinar um modelo à base de árvores e devolver o modelo de saída. Você usará as capacidades de registo Azure ML para gravar e visualizar o progresso da aprendizagem.

Usaste a CommandComponent aula para criar o teu primeiro componente. Desta vez, usará a definição de yaml para definir o segundo componente. Cada método tem as suas próprias vantagens. Uma definição de yaml pode realmente ser verificada ao longo do código, e forneceria um rastreio de histórico legível. O método programático de utilização CommandComponent pode ser mais fácil com documentação de classe incorporada e conclusão de código.

Crie o diretório para este componente:

import os

train_src_dir = "./components/train"
os.makedirs(train_src_dir, exist_ok=True)

Como pode ver neste script de treino, uma vez que o modelo é treinado, o ficheiro modelo é guardado e registado no espaço de trabalho. Agora pode utilizar o modelo registado em pontos finais de inferenculação.

Para o ambiente deste passo, você usará um dos ambientes Azure ML embutidos (com curadoria). A etiqueta azureml, diz ao sistema para usar o nome em ambientes com curadoria.

Primeiro, crie o ficheiro yaml descrevendo o componente:

%%writefile {train_src_dir}/train.yml
# <component>
name: train_credit_defaults_model
display_name: Train Credit Defaults Model
# version: 1 # Not specifying a version will automatically update the version
type: command
inputs:
  train_data: 
    type: uri_folder
  test_data: 
    type: uri_folder
  learning_rate:
    type: number     
  registered_model_name:
    type: string
outputs:
  model:
    type: uri_folder
code: .
environment:
  # for this step, we'll use an AzureML curate environment
  azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu:1
command: >-
  python train.py 
  --train_data ${{inputs.train_data}} 
  --test_data ${{inputs.test_data}} 
  --learning_rate ${{inputs.learning_rate}}
  --registered_model_name ${{inputs.registered_model_name}} 
  --model ${{outputs.model}}
# </component>

Agora crie e registe o componente:

# importing the Component Package
from azure.ai.ml import load_component

# Loading the component from the yml file
train_component = load_component(source=os.path.join(train_src_dir, "train.yml"))
# Now we register the component to the workspace
train_component = ml_client.create_or_update(train_component)

# Create (register) the component in your workspace
print(
    f"Component {train_component.name} with Version {train_component.version} is registered"
)

Criar o gasoduto a partir de componentes

Agora que ambos os seus componentes estão definidos e registados, pode começar a implementar o pipeline.

Aqui, utilizará dados de entrada, rácio de divisão e nome de modelo registado como variáveis de entrada. Em seguida, ligue para os componentes e conecte-os através dos seus identificadores de entradas/saídas. As saídas de cada passo podem ser acedidas através da .outputs propriedade.

As funções de python retornadas pelo load_component() trabalho como qualquer função pitão regular que usaremos dentro de um oleoduto para chamar cada passo.

Para codificar o gasoduto, utilize um decorador específico @dsl.pipeline que identifique os gasodutos Azure ML. No decorador, podemos especificar a descrição do pipeline e recursos predefinidos como computação e armazenamento. Como uma função de pitão, os oleodutos podem ter entradas. Em seguida, pode criar múltiplas instâncias de um único oleoduto com entradas diferentes.

Aqui, usamos dados de entrada, rácio de divisão e nome de modelo registado como variáveis de entrada. Em seguida, chamamos os componentes e os conectamos através dos seus identificadores de entradas/saídas. As saídas de cada passo podem ser acedidas através da .outputs propriedade.

# the dsl decorator tells the sdk that we are defining an Azure ML pipeline
from azure.ai.ml import dsl, Input, Output


@dsl.pipeline(
    compute=cpu_compute_target,
    description="E2E data_perp-train pipeline",
)
def credit_defaults_pipeline(
    pipeline_job_data_input,
    pipeline_job_test_train_ratio,
    pipeline_job_learning_rate,
    pipeline_job_registered_model_name,
):
    # using data_prep_function like a python call with its own inputs
    data_prep_job = data_prep_component(
        data=pipeline_job_data_input,
        test_train_ratio=pipeline_job_test_train_ratio,
    )

    # using train_func like a python call with its own inputs
    train_job = train_component(
        train_data=data_prep_job.outputs.train_data,  # note: using outputs from previous step
        test_data=data_prep_job.outputs.test_data,  # note: using outputs from previous step
        learning_rate=pipeline_job_learning_rate,  # note: using a pipeline input as parameter
        registered_model_name=pipeline_job_registered_model_name,
    )

    # a pipeline returns a dictionary of outputs
    # keys will code for the pipeline output identifier
    return {
        "pipeline_job_train_data": data_prep_job.outputs.train_data,
        "pipeline_job_test_data": data_prep_job.outputs.test_data,
    }

Agora use a definição de pipeline para instantaneaizar um pipeline com o seu conjunto de dados, taxa de escolha dividida e o nome que escolheu para o seu modelo.

registered_model_name = "credit_defaults_model"

# Let's instantiate the pipeline with the parameters of our choice
pipeline = credit_defaults_pipeline(
    pipeline_job_data_input=Input(type="uri_file", path=credit_data.path),
    pipeline_job_test_train_ratio=0.25,
    pipeline_job_learning_rate=0.05,
    pipeline_job_registered_model_name=registered_model_name,
)

Submeter o trabalho

Está na hora de submeter o trabalho a correr na Azure ML. Desta vez vai usarcreate_or_update.ml_client.jobs

Aqui também passará um nome de experiência. Uma experiência é um recipiente para todas as iterações que se faz num determinado projeto. Todos os trabalhos submetidos com o mesmo nome de experiência seriam listados ao lado um do outro no estúdio da Azure ML.

Uma vez concluído, o pipeline registará um modelo no seu espaço de trabalho como resultado do treino.

import webbrowser

# submit the pipeline job
pipeline_job = ml_client.jobs.create_or_update(
    pipeline,
    # Project's name
    experiment_name="e2e_registered_components",
)
# open the pipeline in web browser
webbrowser.open(pipeline_job.studio_url)

Espera-se uma saída de "Falso" da célula acima. Pode acompanhar o progresso do seu oleoduto, utilizando a ligação gerada na célula acima.

Quando selecionar em cada componente, verá mais informações sobre os resultados desse componente. Há duas partes importantes a procurar nesta fase:

  • Outputs+logs>user_logs>std_log.txt Esta secção mostra que o script é executado.

    Imagem de std_log.txt.

  • Outputs+logs>Metric Esta secção mostra diferentes métricas registadas. Neste exemplo. mlflow autologging, registou automaticamente as métricas de treino.

    Os programas de screenshot metrics.txt registados.

Implemente o modelo como um ponto final online

Agora implemente o seu modelo de aprendizagem automática como um serviço web na nuvem Azure, um online endpoint. Para implementar um serviço de aprendizagem automática, normalmente precisa:

  • Os ativos do modelo (arquivados, metadados) que pretende implementar. Já registou estes ativos na sua componente de treino.
  • Algum código para funcionar como um serviço. O código executa o modelo num dado pedido de entrada. Este script de entrada recebe dados submetidos a um serviço web implantado e passa-os para o modelo, devolvendo depois a resposta do modelo ao cliente. O script é específico do seu modelo. O script de entrada deve compreender os dados que o modelo espera e devolve. Ao utilizar um modelo MLFlow, como neste tutorial, este script é automaticamente criado para si

Criar um novo ponto final online

Agora que tem um modelo registado e um script de inferência, está na hora de criar o seu ponto final online. O nome final tem de ser único em toda a região de Azure. Para este tutorial, você vai criar um nome único usando UUID.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

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

print(
    f"Endpint {endpoint_result.name} provisioning state: {endpoint_result.provisioning_state}"
)

Uma vez criado um ponto final, pode recuperá-lo como abaixo:

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

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

Implementar o modelo no ponto final

Uma vez criado o ponto final, insate o modelo com o script de entrada. Cada ponto final pode ter múltiplas implementações e o tráfego direto para estas implementações pode ser especificado usando regras. Aqui irá criar uma única implantação que lida com 100% do tráfego de entrada. Escolhemos um nome a cores para a implantação, por exemplo, implantações azuis, verdes e vermelhas , que é arbitrária.

Pode consultar a página Modelos no estúdio Azure ML, para identificar a versão mais recente do seu modelo registado. Em alternativa, o código abaixo irá recuperar o número de versão mais recente para utilizar.

# 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)]
)

Implemente a versão mais recente do modelo.

Nota

Espere que esta colocação leve aproximadamente 6 a 8 minutos.

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


# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_F4s_v2",
    instance_count=1,
)

blue_deployment_results = ml_client.online_deployments.begin_create_or_update(
    blue_deployment
).result()

print(
    f"Deployment {blue_deployment_results.name} provisioning state: {blue_deployment_results.provisioning_state}"
)

Teste com uma consulta de amostra

Agora que o modelo está implantado no ponto final, pode inferência com ele.

Crie um ficheiro de pedido de amostra seguindo o design esperado no método de execução no script de pontuação.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)
%%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]
        ]
  }
}
# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Limpar os recursos

Se não utilizar o ponto final, elimine-o para parar de usar o recurso. Certifique-se de que não existem outras implementações antes de o eliminar.

Nota

Espere que este passo leve aproximadamente 6 a 8 minutos.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Passos seguintes