Tutorial: Criar pipelines de ML de produção com o SDK Python v2 num bloco de notas do Jupyter

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

Nota

Para obter um tutorial que utiliza o SDK v1 para criar um pipeline, veja Tutorial: Criar um pipeline do Azure Machine Learning para classificação de imagens

Neste tutorial, irá utilizar o Azure Machine Learning para criar um projeto de machine learning pronto para produção (ML), com o SDK Python v2 do Azure Machine Learning.

Irá aprender a utilizar o SDK Python v2 do Azure Machine Learning para:

• Ligar à área de trabalho do Azure Machine Learning
• Criar recursos de dados do Azure Machine Learning
• Criar componentes reutilizáveis do Azure Machine Learning
• Criar, validar e executar pipelines do Azure Machine Learning
• Implementar o modelo recém-preparado como um ponto final
• Chamar o ponto final do Azure Machine Learning para inferência

Pré-requisitos

• Conclua o Início Rápido: Introdução ao Azure Machine Learning para:
  • Crie uma área de trabalho.
  • Crie uma instância de computação baseada na cloud para utilizar no seu ambiente de desenvolvimento.
  • Crie um cluster de computação baseado na cloud para utilizar para preparar o seu modelo.
• Conclua o Início Rápido: Executar blocos de notas do Jupyter no studio para clonar a pasta SDK v2/tutorials .

Abrir o bloco de notas

1. Abra a pasta de tutoriais que foi clonada na secção Ficheiros a partir do Início Rápido: Executar blocos de notas do Jupyter no studio.

2. Selecione o ficheiro e2e-ml-workflow.ipynb na pasta tutorials/azureml-examples/tutorials/e2e-ds-experience/ .

   

3. Na barra superior, selecione a instância de computação que criou durante o Início Rápido: Introdução ao Azure Machine Learning para utilizar para executar o bloco de notas.

Importante

O resto deste artigo contém o mesmo conteúdo que vê no bloco de notas.

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 prima Shift+Enter. Em alternativa, execute o bloco de notas inteiro ao selecionar Executar tudo na barra de ferramentas superior

Introdução

Neste tutorial, vai criar um pipeline do Azure Machine Learning para preparar um modelo para predição predefinida de crédito. O pipeline processa a preparação, preparação e registo de dados do modelo preparado. Em seguida, irá executar o pipeline, implementar o modelo e utilizá-lo.

A imagem abaixo mostra o pipeline como o verá no portal do Azure Machine Learning uma vez submetido. É um pipeline bastante simples que iremos utilizar para guiá-lo através do SDK do Azure Machine Learning v2.

Os dois passos são primeiro a preparação de dados e a segunda preparação.

Configurar os recursos do pipeline

A arquitetura do Azure Machine Learning pode ser utilizada a partir da CLI, do SDK Python ou da interface de estúdio. Neste exemplo, irá utilizar o SDK Python v2 do Azure Machine Learning para criar um pipeline.

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

• O recurso de dados para preparação
• O ambiente de software para executar o pipeline
• Um recurso de computação para onde a tarefa será executada

Ligar à área de trabalho

Antes de analisarmos o código, terá de se ligar à sua área de trabalho do Azure Machine Learning. 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, introduza o ID da Subscrição, o nome do Grupo de Recursos e o nome da Área de Trabalho. Para localizar o ID da Subscrição:

1. No canto superior direito estúdio do Azure Machine Learning barra de ferramentas, selecione o nome da área de trabalho.
2. Verá os valores necessários para <SUBSCRIPTION_ID>, <RESOURCE_GROUP> e <AML_WORKSPACE_NAME>.
3. Copie um valor e, em seguida, feche a janela e cole-o no seu código. Abra a ferramenta novamente para obter o valor seguinte.

# 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 processador da área de trabalho que irá utilizar para gerir outros recursos e tarefas.

Importante

A criação do MLClient não se ligará à área de trabalho. A inicialização do cliente é lenta, aguardará pela primeira vez que precisar de fazer uma chamada (no bloco de notas abaixo, isso acontecerá durante o registo do conjunto de dados).

Registar dados a partir de um URL externo

Normalmente, os dados utilizados para a preparação encontram-se numa das localizações abaixo:

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

O Azure Machine Learning utiliza um Data objeto para registar uma definição reutilizável de dados e consumir dados num pipeline. Na secção abaixo, irá consumir alguns dados do URL da Web como exemplo. Também podem ser criados dados de outras origens. Data também podem ser criados recursos de outras origens.

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 acabou de criar um Data recurso, pronto para ser consumido como uma entrada pelo pipeline que irá definir nas secções seguintes. Além disso, pode registar os dados na área de trabalho para que se tornem reutilizáveis em pipelines.

Registar o recurso de dados irá permitir-lhe:

• Reutilizar e partilhar o recurso de dados em pipelines futuros
• Utilizar versões para controlar a modificação do recurso de dados
• Utilizar o recurso de dados do estruturador do Azure Machine Learning, que é a GUI do Azure Machine Learning para a criação de pipelines

Uma vez que esta é a primeira vez que faz uma chamada para a área de trabalho, poderá ser-lhe pedido para se autenticar. Assim que a autenticação estiver concluída, 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 da área de trabalho com credit_dataset = ml_client.data.get("<DATA ASSET NAME>", version='<VERSION>').

Criar um recurso de computação para executar o pipeline

Cada passo de um pipeline do Azure Machine Learning pode utilizar um recurso de computação diferente para executar a tarefa específica desse passo. Podem ser máquinas individuais ou com vários nós com Linux ou SO Windows ou recursos de infraestrutura de computação específicos, como o Spark.

Nesta secção, irá aprovisionar um cluster de cálculo do Linux. Veja a lista completa sobre os tamanhos e preços das VMs .

Neste tutorial, só precisa de um cluster básico, pelo que vamos utilizar um modelo de Standard_DS3_v2 com 2 núcleos vCPU, 7 GB de RAM e criar uma Computação do Azure Machine Learning.

Dica

Se já tiver um cluster de cálculo, substitua "cpu-cluster" no código abaixo pelo nome do cluster. Isto irá impedi-lo 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 os passos do pipeline

Até agora, criou um ambiente de desenvolvimento na instância de computação, o seu computador de desenvolvimento. Também precisará de um ambiente para utilizar para cada passo do pipeline. Cada passo pode ter o seu próprio ambiente ou pode utilizar alguns ambientes comuns para vários passos.

Neste exemplo, irá criar um ambiente conda para as suas tarefas com um ficheiro yaml conda. Primeiro, crie um diretório no qual armazenar 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 irá utilizar no pipeline (numpy, pip), juntamente com alguns pacotes específicos do Azure Machine Learning (azureml-defaults, azureml-mlflow).

Os pacotes do Azure Machine Learning não são obrigatórios para executar tarefas do Azure Machine Learning. No entanto, adicionar estes pacotes irá permitir-lhe interagir com o Azure Machine Learning para registar métricas e registar modelos, tudo dentro da tarefa do Azure Machine Learning. Irá utilizá-los no script de preparação mais adiante neste tutorial.

Utilize o ficheiro yaml para criar e registar este ambiente personalizado na área 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}"
)

Criar o pipeline de preparação

Agora que tem todos os recursos necessários para executar o pipeline, está na altura de criar o próprio pipeline com o SDK Python v2 do Azure Machine Learning.

Os pipelines do Azure Machine Learning são fluxos de trabalho de ML reutilizáveis que normalmente consistem em vários componentes. A vida normal de um componente é:

• Escreva a especificação yaml do componente ou crie-a programaticamente com ComponentMethod.
• Opcionalmente, registe o componente com um nome e uma versão na área de trabalho para o tornar reutilizável e partilhável.
• Carregue esse componente a partir do código do pipeline.
• Implementar o pipeline com as entradas, saídas e parâmetros do componente
• Submeta o pipeline.

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

Vamos começar por criar o primeiro componente. Este componente processa o pré-processamento dos dados. A tarefa de pré-processamento é realizada no ficheiro Python data_prep.py .

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 preparação e teste. Por conseguinte, o Azure Machine Learning monta conjuntos de dados como pastas para os cálculos, pelo que 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 as métricas durante a nossa execução do pipeline.

%%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 pretendida, crie um Componente do Azure Machine Learning a partir do mesmo.

Irá utilizar o CommandComponent para fins gerais que pode executar ações da linha de comandos. Esta ação de linha de comandos pode chamar diretamente comandos do sistema ou executar um script. As entradas/saídas são especificadas na linha de comandos 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 na área de trabalho para reutilização futura.

Criar componente 2: preparação (com a definição yaml)

O segundo componente que irá criar consumirá os dados de preparação e teste, preparará um modelo baseado em árvore e devolverá o modelo de saída. Irá utilizar as capacidades de registo do Azure Machine Learning para registar e visualizar o progresso da aprendizagem.

Utilizou a CommandComponent classe para criar o seu primeiro componente. Desta vez, irá utilizar a definição yaml para definir o segundo componente. Cada método tem as suas próprias vantagens. Uma definição yaml pode, na verdade, ser dada entrada ao longo do código e fornecer um controlo do histórico legível. A utilização CommandComponent do método programático pode ser mais fácil com a documentação de classe incorporada e a 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)

Crie o script de preparação no diretório:

%%writefile {train_src_dir}/train.py
import argparse
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
import os
import pandas as pd
import mlflow


def select_first_file(path):
    """Selects first file in folder, use under assumption there is only one file in folder
    Args:
        path (str): path to directory or file to choose
    Returns:
        str: full path of selected file
    """
    files = os.listdir(path)
    return os.path.join(path, files[0])


# Start Logging
mlflow.start_run()

# enable autologging
mlflow.sklearn.autolog()

os.makedirs("./outputs", exist_ok=True)


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

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    parser.add_argument("--model", type=str, help="path to model file")
    args = parser.parse_args()

    # paths are mounted as folder, therefore, we are selecting the file from folder
    train_df = pd.read_csv(select_first_file(args.train_data))

    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # paths are mounted as folder, therefore, we are selecting the file from folder
    test_df = pd.read_csv(select_first_file(args.test_data))

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))

    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.model, "trained_model"),
    )

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Como pode ver neste script de preparação, assim que o modelo for preparado, o ficheiro de modelo é guardado e registado na área de trabalho. Agora, pode utilizar o modelo registado na inferência de pontos finais.

Para o ambiente deste passo, irá utilizar um dos ambientes incorporados (organizados) do Azure Machine Learning. A etiqueta azureml, indica ao sistema para utilizar para procurar o nome em ambientes organizados.

Em primeiro lugar, crie o ficheiro yaml que descreve 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 pipeline a partir de componentes

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

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

As funções python devolvidas pelo load_component() trabalho como qualquer função regular do Python que iremos utilizar num pipeline para chamar cada passo.

Para codificar o pipeline, utilize um decorador específico @dsl.pipeline que identifique os pipelines do Azure Machine Learning. No decorador, podemos especificar a descrição do pipeline e os recursos predefinidos, como computação e armazenamento. Tal como uma função do Python, os pipelines podem ter entradas. Em seguida, pode criar várias instâncias de um único pipeline com entradas diferentes.

Aqui, utilizámos dados de entrada, taxa de divisão e nome do modelo registado como variáveis de entrada. Em seguida, chamamos os componentes e ligamo-los através dos respetivos 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, utilize a definição do pipeline para instanciar um pipeline com o conjunto de dados, a taxa de divisão de escolha 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 altura de submeter a tarefa a ser executada no Azure Machine Learning. Desta vez, irá utilizar create_or_update em ml_client.jobs.

Aqui, também irá transmitir um nome de experimentação. Uma experimentação é um contentor para todas as iterações que se faz num determinado projeto. Todas as tarefas submetidas com o mesmo nome de experimentação seriam listadas entre si no estúdio do Azure Machine Learning.

Depois de concluído, o pipeline registará um modelo na área de trabalho como resultado da preparação.

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)

É esperada uma saída de "Falso" a partir da célula acima. Pode controlar o progresso do pipeline com a ligação gerada na célula acima.

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

• Outputs+logs>user_logs>std_log.txt Esta secção mostra o script run sdtout.

  

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

  

Implementar o modelo como um ponto final online

Agora, implemente o modelo de machine learning como um serviço Web na cloud do Azure, um online endpoint. Para implementar um serviço de machine learning, normalmente precisa de:

• Os recursos do modelo (arquivados, metadados) que pretende implementar. Já registou estes recursos no componente de preparação.
• Algum código para ser executado como um serviço. O código executa o modelo num determinado pedido de entrada. Este script de entrada recebe dados submetidos para um serviço Web implementado e transmite-os ao modelo e, em seguida, devolve a resposta do modelo ao cliente. O script é específico do seu modelo. O script de entrada tem de compreender os dados esperados e devolvidos pelo modelo. Ao utilizar um modelo do MLFlow, como neste tutorial, este script é criado automaticamente para si

Criar um novo ponto final online

Agora que tem um modelo registado e um script de inferência, está na altura de criar o ponto final online. O nome do ponto final tem de ser exclusivo em toda a região do Azure. Neste tutorial, irá criar um nome exclusivo com 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}"
)

Depois de criar um ponto final, pode obtê-lo da seguinte forma:

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

Assim que o ponto final for criado, implemente o modelo com o script de entrada. Cada ponto final pode ter várias implementações e o tráfego direto para estas implementações pode ser especificado através de regras. Aqui, irá criar uma única implementação que processa 100% do tráfego de entrada. Escolhemos um nome de cor para a implementação, por exemplo, implementações azuis, verdes, vermelhas , que são arbitrárias.

Pode consultar a página Modelos no estúdio do Azure Machine Learning para identificar a versão mais recente do modelo registado. Em alternativa, o código abaixo irá obter o número da 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

Esta implementação deverá demorar 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}"
)

Testar com uma consulta de exemplo

Agora que o modelo está implementado no ponto final, pode executar a inferência com o mesmo.

Crie um ficheiro de pedido de exemplo seguindo a estrutura esperada no método de execução no script de classificaçã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 pretender utilizar o ponto final, elimine-o para parar de utilizar o recurso. Certifique-se de que nenhuma outra implementação está a utilizar um ponto final antes de o eliminar.

Nota

Espere que este passo dedfeque aproximadamente 6 a 8 minutos.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Passos seguintes

Saiba mais sobre o registo do Azure Machine Learning.