Guia de início rápido: introdução ao Azure Machine Learning

  • Artigo

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

Este tutorial é uma introdução a alguns dos recursos mais usados do serviço Azure Machine Learning. Nele, você criará, registrará e implantará um modelo. Este tutorial irá ajudá-lo a familiarizar-se com os principais conceitos do Azure Machine Learning e a sua utilização mais comum.

Você aprenderá como executar um trabalho de treinamento em um recurso de computação escalável, implantá-lo e, finalmente, testar a implantação.

Você criará um script de treinamento para lidar com a preparação de dados, treinar e registrar um modelo. Depois de treinar o modelo, você o implantará como um ponto de extremidade e, em seguida, chamará o ponto de extremidade para inferência.

As etapas que você tomará são:

  • Configurar um identificador para seu espaço de trabalho do Azure Machine Learning
  • Crie seu script de treinamento
  • Criar um recurso de computação escalável, um cluster de computação
  • Criar e executar um trabalho de comando que executará o script de treinamento no cluster de computação, configurado com o ambiente de trabalho apropriado
  • Exibir a saída do seu script de treinamento
  • Implantar o modelo recém-treinado como um ponto de extremidade
  • Chamar o ponto de extremidade do Azure Machine Learning para inferência

Assista a este vídeo para obter uma visão geral das etapas deste início rápido.

Pré-requisitos

  1. Para usar o Aprendizado de Máquina do Azure, primeiro você precisará 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.

  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:

    • Crie um novo bloco de notas, se pretender copiar/colar código nas células.
    • Ou abra tutoriais/get-started-notebooks/quickstart.ipynb na seção Amostras do estúdio. Em seguida, selecione Clonar para adicionar o bloco de anotações aos seus arquivos. (Veja onde encontrar amostras.)

Defina o seu kernel

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

    Screenshot shows how to create a compute instance.

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

    Screenshot shows how to start compute if it is stopped.

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

    Screenshot shows how to set the kernel.

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

Importante

O restante deste tutorial contém células do bloco de anotações do tutorial. Copie/cole-os no seu novo bloco de notas ou mude para o bloco de notas agora se o tiver clonado.

Criar identificador para espaço de trabalho

Antes de mergulharmos no código, você precisa de uma maneira de referenciar seu espaço de trabalho. 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.

Você criará ml_client um identificador para o espaço de trabalho. Em seguida, você usará 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 do espaço de trabalho, do grupo de recursos e da ID da assinatura para o código.
  3. Você precisará copiar um valor, fechar a área e colar, depois voltar para o próximo.

Screenshot: find the credentials for your code in the upper right of the toolbar. 

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

# authenticate
credential = DefaultAzureCredential()

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

Nota

A criação do MLClient não se conectará ao espaço de trabalho. A inicialização do cliente é preguiçosa, ele vai esperar pela primeira vez que precisa fazer uma chamada (isso acontecerá na próxima célula de código).

# Verify that the handle works correctly.  
# If you ge an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location,":", ws.resource_group)

Criar script de treinamento

Vamos começar criando o script de treinamento - o arquivo 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 lida com o pré-processamento dos dados, dividindo-os em dados de teste e treinamento. Em seguida, ele consome esses dados para treinar um modelo baseado em árvore e retornar o modelo de saída.

MLFlow será usado para registrar os parâmetros e métricas durante nossa execução de pipeline.

A célula abaixo usa a magia do IPython para escrever o script de treinamento no diretório que você 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_csv(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 você pode ver neste script, uma vez que o modelo é treinado, o arquivo de modelo é salvo e registrado no espaço de trabalho. Agora você pode usar o modelo registrado na inferência de pontos de extremidade.

Talvez seja necessário selecionar Atualizar para ver a nova pasta e o novo script em seus arquivos.

Screenshot shows the refresh icon.

Configurar o comando

Agora que você tem um script que pode executar as tarefas desejadas e um cluster de computação para executar o script, você usará um comando de propósito geral que pode executar ações de linha de comando. Esta ação de linha de comando pode chamar diretamente comandos do sistema ou executar um script.

Aqui, você criará variáveis de entrada para especificar os dados de entrada, a taxa de divisão, a taxa de aprendizado e o nome do modelo registrado. O script de comando irá:

  • Use um ambiente que defina o software e as bibliotecas de tempo de execução necessárias para o script de treinamento. O Azure Machine Learning fornece muitos ambientes selecionados ou prontos, que são úteis para cenários comuns de treinamento e inferência. Você usará um desses ambientes aqui. Em Tutorial: Treinar um modelo no Azure Machine Learning, você aprenderá a criar um ambiente personalizado.
  • Configure a própria ação da linha de comando - python main.py neste caso. As entradas/saídas são acessíveis no comando através da ${{ ... }} notação.
  • Neste exemplo, acessamos os dados de um arquivo na internet.
  • Como um recurso de computação não foi especificado, o script será executado em um cluster de computação sem servidor que é criado automaticamente.
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://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
        ),
        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="AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    display_name="credit_default_prediction",
)

Submeter o trabalho

Agora é hora de enviar o trabalho para ser executado no Azure Machine Learning. Desta vez, você usará create_or_update em ml_client.

ml_client.create_or_update(job)

Visualize a saída do trabalho e aguarde a conclusão do trabalho

Exiba o trabalho no estúdio do Azure Machine Learning selecionando o link na saída da célula anterior.

A saída deste trabalho terá esta aparência no estúdio do Azure Machine Learning. Explore as guias para vários detalhes, como métricas, saídas, etc. Uma vez concluído, o trabalho registrará um modelo em seu espaço de trabalho como resultado do treinamento.

Screenshot shows the overview page for the job.

Importante

Aguarde até que o status do trabalho esteja concluído antes de retornar a este bloco de anotações para continuar. O trabalho levará de 2 a 3 minutos para ser executado. Pode levar mais tempo (até 10 minutos) se o cluster de computação tiver sido reduzido para zero nós e o ambiente personalizado ainda estiver em construção.

Implantar o modelo como um ponto de extremidade online

Agora, implante seu modelo de aprendizado de máquina como um serviço Web na nuvem do Azure, um online endpointarquivo .

Para implantar um serviço de aprendizado de máquina, você usará o modelo registrado.

Criar um novo 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ê criará um nome exclusivo usando UUIDo .

import uuid

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

Crie o ponto de extremidade:

# Expect the endpoint creation to take a few minutes
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}")

Nota

Espere que a criação do ponto de extremidade demore alguns minutos.

Uma vez que o ponto de extremidade tenha sido criado, você pode recuperá-lo como abaixo:

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

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

Implantar o modelo no ponto de extremidade

Depois que o ponto de extremidade for criado, implante o modelo com o script de entrada. Cada ponto de extremidade pode ter várias implantações. O tráfego direto para essas implantações pode ser especificado usando regras. Aqui você criará uma única implantação que lida com 100% do tráfego de entrada. Escolhemos um nome de cor para a implantação, por exemplo, implantações azuis, verdes e vermelhas , o que é arbitrário.

Você pode verificar a página Modelos no estúdio do Azure Machine Learning para identificar a versão mais recente do seu modelo registrado. Como alternativa, o código abaixo recuperará o número da versão mais recente para você usar.

# 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(f'Latest model is version "{latest_model_version}" ')

Implante a versão mais recente do modelo.

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

# Expect this deployment to take approximately 6 to 8 minutes.
# create 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/pricing/details/machine-learning/.
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()

Nota

Espere que essa implantação demore aproximadamente 6 a 8 minutos.

Quando a implantação estiver concluída, você estará pronto para testá-la.

Teste com uma consulta de exemplo

Depois que o modelo é implantado no ponto de extremidade, você pode executar a inferência com ele.

Crie um arquivo de solicitação de exemplo seguindo o design esperado no método run no script score.

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

Clean up resources (Limpar recursos)

Se você não vai usar o ponto de extremidade, exclua-o para parar de usar o recurso. Certifique-se de que nenhuma outra implantação esteja usando um ponto de extremidade antes de excluí-lo.

Nota

Espere que a exclusão completa demore aproximadamente 20 minutos.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Parar instância de computação

Se você não vai usá-lo agora, pare a instância de computação:

  1. No estúdio, na área de navegação esquerda, selecione Computar.
  2. Nas guias superiores, selecione Instâncias de computação
  3. Selecione a instância de computação na lista.
  4. Na barra de ferramentas superior, selecione Parar.

Eliminar todos os recursos

Importante

Os recursos que você criou podem ser usados como pré-requisitos para outros tutoriais e artigos de instruções do Azure Machine Learning.

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, selecione Grupos de recursos na extremidade esquerda.

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

  3. Selecione Eliminar grupo de recursos.

    Screenshot of the selections to delete a resource group in the Azure portal.

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

Próximos passos

Agora que você já tem uma ideia do que está envolvido no treinamento e na implantação de um modelo, saiba mais sobre o processo nestes tutoriais:

Tutorial Description
Carregue, aceda e explore os seus dados no Azure Machine Learning Armazene dados grandes na nuvem e recupere-os de blocos de anotações e scripts
Desenvolvimento de modelos em uma estação de trabalho na nuvem Comece a prototipar e desenvolver modelos de aprendizado de máquina
Treinar um modelo no Azure Machine Learning Mergulhe nos detalhes do treinamento de um modelo
Implantar um modelo como um ponto de extremidade online Aprofunde-se nos detalhes da implantação de um modelo
Criar pipelines de aprendizado de máquina de produção Divida uma tarefa completa de aprendizado de máquina em um fluxo de trabalho de várias etapas.