Tutorial: Treinar um modelo no Azure Machine Learning

Artigo
11/15/2023

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

Saiba como um cientista de dados usa o Aprendizado de Máquina do Azure para treinar um modelo. Neste exemplo, usamos o conjunto de dados de cartão de crédito associado para mostrar como você pode usar o Azure Machine Learning para um problema de classificação. O objetivo é prever se um cliente tem uma alta probabilidade de inadimplência em um pagamento com cartão de crédito.

O script de treinamento lida com a preparação de dados e, em seguida, treina e registra um modelo. Este tutorial leva você pelas etapas para enviar um trabalho de treinamento baseado em nuvem (trabalho de comando). Se quiser saber mais sobre como carregar os seus dados no Azure, consulte Tutorial: Carregar, aceder e explorar os seus dados no Azure Machine Learning. Os passos são:

Obter um identificador para o seu espaço de trabalho do Azure Machine Learning
Crie seu recurso de computação e ambiente de trabalho
Crie seu script de treinamento
Crie e execute seu trabalho de comando para executar o script de treinamento no recurso de computação, configurado com o ambiente de trabalho apropriado e a fonte de dados
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

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

Pré-requisitos

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.
Entre no estúdio e selecione seu espaço de trabalho se ele ainda não estiver aberto.
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/train-model.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

Na barra superior acima do bloco de anotações aberto, crie uma instância de computação se ainda não tiver uma.
Se a instância de computação for interrompida, selecione Iniciar computação e aguarde até que ela esteja em execução.
Certifique-se de que o kernel, encontrado no canto superior direito, é Python 3.10 - SDK v2. Caso contrário, use a lista suspensa para selecionar este kernel.
Se você 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.

Usar um trabalho de comando para treinar um modelo no Azure Machine Learning

Para treinar um modelo, você precisa enviar um trabalho. O tipo de trabalho que você enviará neste tutorial é um trabalho de comando. O Azure Machine Learning oferece vários tipos diferentes de trabalhos para treinar modelos. Os usuários podem selecionar seu método de treinamento com base na complexidade do modelo, tamanho dos dados e requisitos de velocidade de treinamento. Neste tutorial, você aprenderá como enviar um trabalho de comando para executar um script de treinamento.

Um trabalho de comando é uma função que permite enviar um script de treinamento personalizado para treinar seu modelo. Isso também pode ser definido como um trabalho de treinamento personalizado. Um trabalho de comando no Azure Machine Learning é um tipo de trabalho que executa um script ou comando em um ambiente especificado. Você pode usar trabalhos de comando para treinar modelos, processar dados ou qualquer outro código personalizado que queira executar na nuvem.

Neste tutorial, vamos nos concentrar em usar um trabalho de comando para criar um trabalho de treinamento personalizado que usaremos para treinar um modelo. Para qualquer trabalho de treinamento personalizado, os itens abaixo são necessários:

ambiente
dados
trabalho de comando
guião de formação

Neste tutorial, forneceremos todos esses itens para o nosso exemplo: criar um classificador para prever clientes que têm uma alta probabilidade de inadimplência em pagamentos com cartão de crédito.

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

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

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 um ambiente de trabalho

Para executar seu trabalho do Azure Machine Learning em seu recurso de computação, você precisa de um ambiente. Um ambiente lista o tempo de execução do software e as bibliotecas que você deseja instalar na computação onde você treinará. É semelhante ao seu ambiente python na sua máquina local.

O Azure Machine Learning fornece muitos ambientes selecionados ou prontos, que são úteis para cenários comuns de treinamento e inferência.

Neste exemplo, você criará um ambiente conda personalizado para seus trabalhos, usando um arquivo conda yaml.

Primeiro, crie um diretório para armazenar o arquivo.

import os

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

A célula abaixo usa a magia do IPython para gravar o arquivo conda no diretório que você acabou de criar.

%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=1.0.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - mlflow==2.8.0
    - mlflow-skinny==2.8.0
    - azureml-mlflow==1.51.0
    - psutil>=5.8,<5.9
    - tqdm>=4.59,<4.60
    - ipykernel~=6.0
    - matplotlib

A especificação contém alguns pacotes usuais, que você usará em seu trabalho (numpy, pip).

Faça referência a este arquivo yaml para criar e registrar esse ambiente personalizado em seu espaço de trabalho:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

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

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

Configurar um trabalho de treinamento usando a função de comando

Você cria um trabalho de comando do Azure Machine Learning para treinar um modelo para previsão de padrão de crédito. O trabalho de comando executa um script de treinamento em um ambiente especificado em um recurso de computação especificado. Você já criou o ambiente e o cluster de computação. Em seguida, você criará o script de treinamento. Em nosso caso específico, estamos treinando nosso conjunto de dados para produzir um classificador usando o GradientBoostingClassifier modelo.

O script de treinamento lida com a preparação de dados, treinamento e registro do modelo treinado. O método train_test_split lida com a divisão do conjunto de dados em dados de teste e treinamento. Neste tutorial, você criará um script de treinamento em Python.

Os trabalhos de comando podem ser executados a partir da CLI, Python SDK ou interface de estúdio. Neste tutorial, você usará o SDK do Python do Azure Machine Learning v2 para criar e executar o trabalho de comando.

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 é usado para registrar os parâmetros e métricas durante o nosso trabalho. O pacote MLFlow permite que você acompanhe as métricas e os resultados de cada modelo de trem do Azure. Usaremos o MLFlow para primeiro obter o melhor modelo para nossos dados e, em seguida, exibiremos as métricas do modelo no estúdio do Azure.

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

    #Split train and test datasets
    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()

Neste script, uma vez que o modelo é treinado, o arquivo de modelo é salvo e registrado no espaço de trabalho. Registrar seu modelo permite que você armazene e faça a versão de seus modelos na nuvem do Azure, em seu espaço de trabalho. Depois de registrar um modelo, você pode encontrar todos os outros modelos registrados em um só lugar no Azure Studio chamado registro de modelo. O registro de modelos ajuda você a organizar e acompanhar seus modelos treinados.

Configurar o comando

Agora que você tem um script que pode executar a tarefa de classificação, use o comando de propósito geral que pode executar ações de linha de comando. Essa ação de linha de comando pode ser chamada diretamente de comandos do sistema ou executando um script.

Aqui, crie 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 o ambiente criado anteriormente - você pode usar a @latest notação para indicar a versão mais recente do ambiente quando o comando for executado.
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.
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="aml-scikit-learn@latest",
    display_name="credit_default_prediction",
)

Submeter o trabalho

Agora é hora de enviar o trabalho para ser executado no estúdio do Azure Machine Learning. Desta vez, você usará create_or_update em ml_client. ml_client é uma classe de cliente que permite que você se conecte à sua assinatura do Azure usando Python e interaja com os serviços do Azure Machine Learning. ml_client permite que você envie seus trabalhos usando Python.

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.

Quando você executa a célula, a saída do bloco de anotações mostra um link para a página de detalhes do trabalho no Azure Studio. Como alternativa, você também pode selecionar Trabalhos no menu de navegação à esquerda. Um trabalho é um agrupamento de muitas execuções a partir de um script ou pedaço de código especificado. As informações para a execução são armazenadas sob esse trabalho. A página de detalhes fornece uma visão geral do trabalho, o tempo que levou para ser executado, quando foi criado, etc. A página também tem guias para outras informações sobre o trabalho, como métricas, saídas + logs e código. Abaixo estão listadas as guias disponíveis na página de detalhes da vaga:

Visão geral: A seção de visão geral fornece informações básicas sobre o trabalho, incluindo seu status, horários de início e término e o tipo de trabalho que foi executado
Entradas: A seção de entrada lista os dados e o código que foram usados como entradas para o trabalho. Esta seção pode incluir conjuntos de dados, scripts, configurações de ambiente e outros recursos que foram usados durante o treinamento.
Saídas + logs: A guia Saídas + logs contém logs gerados durante a execução do trabalho. Esta guia ajuda na solução de problemas se algo der errado com seu script de treinamento ou criação de modelo.
Métricas: a guia métricas mostra as principais métricas de desempenho do seu modelo, como pontuação de treinamento, pontuação de f1 e pontuação de precisão.

Clean up resources (Limpar recursos)

Se você planeja continuar agora para outros tutoriais, pule para Próximas etapas.

Parar instância de computação

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

No estúdio, na área de navegação esquerda, selecione Computar.
Nas guias superiores, selecione Instâncias de computação
Selecione a instância de computação na lista.
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:

No portal do Azure, selecione Grupos de recursos na extremidade esquerda.
Na lista, selecione o grupo de recursos que você criou.
Selecione Eliminar grupo de recursos.
Insira o nome do grupo de recursos. Em seguida, selecione Eliminar.

Passos Seguintes

Saiba mais sobre como implantar um modelo

Implante um modelo.

Este tutorial usou um arquivo de dados online. Para saber mais sobre outras formas de aceder a dados, consulte Tutorial: Carregar, aceder e explorar os seus dados no Azure Machine Learning.

Se você quiser saber mais sobre diferentes maneiras de treinar modelos no Azure Machine Learning, consulte O que é o aprendizado de máquina automatizado (AutoML)?. O ML automatizado é uma ferramenta suplementar para reduzir a quantidade de tempo que um cientista de dados gasta encontrando um modelo que funcione melhor com seus dados.

Se você quiser mais exemplos semelhantes a este tutorial, consulte a seção Exemplos do estúdio. Esses mesmos exemplos estão disponíveis em nossa página de exemplos do GitHub. Os exemplos incluem Blocos de Anotações Python completos que você pode executar código e aprender a treinar um modelo. Você pode modificar e executar scripts existentes a partir dos exemplos, contendo cenários incluindo classificação, processamento de linguagem natural e deteção de anomalias.

Tutorial: Treinar um modelo no Azure Machine Learning

Pré-requisitos

Defina o seu kernel

Usar um trabalho de comando para treinar um modelo no Azure Machine Learning

Criar identificador para espaço de trabalho

Criar um ambiente de trabalho

Configurar um trabalho de treinamento usando a função de comando

Criar script de treinamento

Configurar o comando

Submeter o trabalho

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

Clean up resources (Limpar recursos)

Parar instância de computação

Eliminar todos os recursos

Passos Seguintes

Recursos adicionais