Tutorial: Azure Machine Learning num dia

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

Saiba como um cientista de dados utiliza o Azure Machine Learning (Azure ML) para preparar um modelo e, em seguida, utilize o modelo para predição. Este tutorial irá ajudá-lo a familiarizar-se com os conceitos principais do Azure ML e a utilização mais comum.

Irá aprender a submeter uma tarefa de comando para executar o script de preparação num recurso de computação especificado, configurado com o ambiente de trabalho necessário para executar o script.

O script de preparação processa a preparação de dados e, em seguida, prepara e regista um modelo. Assim que tiver o modelo, irá implementá-lo como um ponto final e, em seguida, chamar o ponto final para inferência.

Os passos que irá seguir são:

  • Ligar à área de trabalho do Azure ML
  • Criar o seu recurso de computação e ambiente de trabalho
  • Criar o script de preparação
  • Criar e executar a tarefa de comando para executar o script de preparação no recurso de computação, configurado com o ambiente de trabalho adequado
  • Ver o resultado do script de preparação
  • Implementar o modelo recém-preparado como um ponto final
  • Chamar o ponto final do Azure ML para inferência

Pré-requisitos

Executar o seu bloco de notas

  1. 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.

  2. Certifique-se de que o kernel, encontrado no canto superior direito, é Python 3.10 - SDK v2. Caso contrário, utilize a lista pendente para selecionar este kernel.

Captura de ecrã: defina o kernel.

Importante

O resto deste tutorial contém células do bloco de notas do tutorial. Copie/cole-os no seu novo bloco de notas ou mude para o bloco de notas agora, se o clonou.

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 todo o bloco de notas ao selecionar Executar tudo na barra de ferramentas superior.

Ligar à área de trabalho

Antes de analisar o código, terá de se ligar à área de trabalho do 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.

Estamos a utilizar DefaultAzureCredential para obter acesso à área de trabalho. DefaultAzureCredential é utilizado para lidar com a maioria dos cenários de autenticação do SDK do Azure.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

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 estes valores:

  1. No canto superior direito estúdio do Azure Machine Learning barra de ferramentas, selecione o nome da área de trabalho.
  2. Copie o valor para a área de trabalho, o grupo de recursos e o ID da subscrição para o código.
  3. Terá de copiar um valor, fechar a área e colar e, em seguida, voltar para o próximo.

Captura de ecrã: localize as credenciais do seu código no canto superior direito da barra de ferramentas.

# 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 é preguiçosa, aguardará pela primeira vez que precisar de fazer uma chamada (no bloco de notas abaixo, isso acontecerá durante a criação da computação).

Criar um recurso de computação para executar a sua tarefa

Precisará de um recurso de computação para executar uma tarefa. Pode ser máquinas de nó único ou múltiplos com Linux ou SO Windows, ou um recurso de infraestrutura de computação específico, como o Spark.

Irá aprovisionar um cluster de computação do Linux. Veja a lista completa sobre os tamanhos e preços das VMs .

Neste exemplo, só precisa de um cluster básico, pelo que irá utilizar um modelo de Standard_DS3_v2 com dois núcleos vCPU, 7 GB de RAM e criar uma Computação ML do Azure.

from azure.ai.ml.entities import AmlCompute

# Name assigned to the compute cluster
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=cpu_compute_target,
        # 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",
    )
    print(
         f"AMLCompute with name {cpu_cluster.name} will be created, with compute size {cpu_cluster.size}"
          )
    # Now, we pass the object to MLClient's create_or_update method
    cpu_cluster = ml_client.compute.begin_create_or_update(cpu_cluster)

Criar um ambiente de trabalho

Para executar a tarefa do AzureML no recurso de computação, precisará de um ambiente. Um ambiente lista o runtime de software e as bibliotecas que pretende instalar na computação onde irá preparar. É semelhante ao seu ambiente Python no seu computador local.

O AzureML fornece muitos ambientes organizados ou preparados, que são úteis para cenários comuns de preparação e inferência. Também pode criar os seus próprios ambientes personalizados com uma imagem do docker ou uma configuração conda.

Neste exemplo, irá criar um ambiente conda personalizado para as suas tarefas com um ficheiro yaml conda.

Primeiro, crie um diretório para 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. A célula abaixo utiliza a magia IPython para escrever o ficheiro no diretório que acabou de criar.

%%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
    - psutil>=5.8,<5.9
    - tqdm>=4.59,<4.60
    - ipykernel~=6.0
    - matplotlib

A especificação contém alguns pacotes habituais que irá utilizar na sua tarefa (numpy, pip).

Faça referência a este 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/openmpi3.1.2-ubuntu18.04:latest",
)
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}"
)

O que é uma tarefa de comando?

Irá criar uma tarefa de comando do Azure ML para preparar um modelo para predição predefinida de crédito. A tarefa de comando é utilizada para executar um script de preparação num ambiente especificado num recurso de computação especificado. Já criou o ambiente e o recurso de computação. Em seguida, irá criar o script de preparação.

O script de preparação processa a preparação, preparação e registo de dados do modelo preparado. Neste tutorial, irá criar um script de preparação do Python.

As tarefas de comando podem ser executadas a partir da CLI, do SDK python ou da interface de estúdio. Neste tutorial, irá utilizar o SDK Python v2 do Azure ML para criar e executar a tarefa de comando.

Depois de executar a tarefa de preparação, irá implementar o modelo e, em seguida, utilizá-lo para produzir uma predição.

Criar script de preparação

Vamos começar por criar o script de preparação - o ficheiro python main.py .

Primeiro, crie uma pasta de origem para o script:

import os

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

Este script processa o pré-processamento dos dados, dividindo-os em dados de teste e preparação. Em seguida, consome estes dados para preparar um modelo baseado em árvore e devolver o modelo de saída.

O MLFlow será utilizado para registar os parâmetros e as métricas durante a nossa execução do pipeline.

A célula abaixo utiliza a magia IPython para escrever o script de preparação no diretório que acabou de criar.

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

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("--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")
    args = parser.parse_args()
   
    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    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)

    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

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

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

    # 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))
    ###################
    #</train the model>
    ###################

    ##########################
    #<save and register model>
    ##########################
    # 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.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    
    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Como pode ver neste script, assim que o modelo for preparado, o ficheiro de modelo é guardado e registado na área de trabalho. Agora, pode utilizar o modelo registado para inferir pontos finais.

Configurar o comando

Agora que tem um script que pode executar as tarefas pretendidas, irá utilizar o comando para fins gerais que pode executar ações de linha de comandos. Esta ação da linha de comandos pode chamar diretamente os comandos do sistema ou executar um script.

Aqui, irá criar variáveis de entrada para especificar os dados de entrada, a taxa de divisão, a taxa de aprendizagem e o nome do modelo registado. O script de comandos:

  • Utilize a computação criada anteriormente para executar este comando.
  • Utilize o ambiente criado anteriormente – pode utilizar a @latest notação para indicar a versão mais recente do ambiente quando o comando é executado.
  • Configure alguns metadados, como o nome a apresentar, o nome da experimentação, etc. Uma experimentação é um contentor para todas as iterações que faz num determinado projeto. Todas as tarefas submetidas com o mesmo nome de experimentação seriam listadas entre si no Azure ML Studio.
  • Configure a ação da linha de comandos em si , python main.py neste caso. As entradas/saídas são acessíveis no comando através da ${{ ... }} notação.
from azure.ai.ml import command
from azure.ai.ml import Input

registered_model_name = "credit_defaults_model"

job = command(
    inputs=dict(
        data=Input(
            type="uri_file",
            path="https://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls",
        ),
        test_train_ratio=0.2,
        learning_rate=0.25,
        registered_model_name=registered_model_name,
    ),
    code="./src/",  # location of source code
    command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
    environment="aml-scikit-learn@latest",
    compute="cpu-cluster",
    experiment_name="train_model_credit_default_prediction",
    display_name="credit_default_prediction",
)

Submeter o trabalho

Chegou a altura de submeter a tarefa a ser executada no AzureML. Desta vez, irá utilizar create_or_update em ml_client.jobs.

ml_client.create_or_update(job)

Ver o resultado da tarefa e aguardar a conclusão da tarefa

Veja a tarefa no estúdio do AzureML ao selecionar a ligação na saída da célula anterior.

O resultado desta tarefa terá este aspeto no estúdio do AzureML. Explore os separadores para obter vários detalhes, como métricas, saídas, etc. Depois de concluída, a tarefa registará um modelo na área de trabalho como resultado da preparação.

Captura de ecrã que mostra a descrição geral da tarefa

Importante

Aguarde até que o estado da tarefa esteja concluído antes de regressar a este bloco de notas para continuar. A execução da tarefa demorará 2 a 3 minutos. Pode demorar mais (até 10 minutos) se o cluster de cálculo tiver sido reduzido verticalmente para zero nós e o ambiente personalizado ainda estiver a ser criado.

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 (ficheiro, metadados) que pretende implementar. Já registou estes recursos na sua tarefa 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. Com um modelo do MLFlow, como neste tutorial, este script é criado automaticamente para si. Pode encontrar exemplos de scripts de classificação aqui.

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]

Nota

Espere que a criação do ponto final demorou aproximadamente 6 a 8 minutos.

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 = ml_client.online_endpoints.begin_create_or_update(endpoint).result()

print(f"Endpoint {endpoint.name} provisioning state: {endpoint.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'Endpoint "{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. 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 ML 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_DS3_v2",
    instance_count=1,
)

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

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

Espera-se que este passo demorou aproximadamente 6 a 8 minutos.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Eliminar tudo

Utilize estes passos para eliminar a área de trabalho do Azure Machine Learning e todos os recursos de computação.

Importante

Os recursos que criou podem ser utilizados como pré-requisitos para outros tutoriais e artigos de procedimentos do Azure Machine Learning.

Se não planear utilizar nenhum dos recursos que criou, elimine-os para não incorrer em custos:

  1. No portal do Azure, selecione Grupos de recursos na extremidade esquerda.

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

  3. Selecione Eliminar grupo de recursos.

    Captura de ecrã a mostrar as seleções para eliminar um grupo de recursos no portal do Azure.

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

Passos seguintes