Tutorial: Treinar um modelo no Azure Machine Learning

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, você usa um conjunto de dados de cartão de crédito para entender como usar o Aprendizado de Máquina do Azure 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. Em seguida, o script 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.

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 Azure Machine Learning, você precisa 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:

  • Se quiser copiar e colar código em células, crie um novo bloco de anotações.
  • 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. Para localizar blocos de notas de exemplo, consulte Aprender com blocos de notas de exemplo.

Defina seu kernel e abra no Visual Studio Code (VS Code)

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

   

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

   

3. Aguarde até que a instância de computação esteja em execução. Em seguida, 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ê não vir esse kernel, verifique se sua instância de computação está em execução. Se estiver, selecione o botão Atualizar no canto superior direito do bloco de anotações.

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

5. Você pode executar o bloco de anotações aqui ou abri-lo no VS Code para um ambiente de desenvolvimento integrado (IDE) completo com o poder dos recursos do Azure Machine Learning. Selecione Abrir no VS Code e, em seguida, selecione a opção Web ou desktop. Quando iniciado dessa forma, o VS Code é anexado à sua instância de computação, ao kernel e ao sistema de arquivos do espaço de trabalho.

   

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

Para treinar um modelo, você precisa enviar um trabalho. 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á a 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. Este trabalho 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.

Este tutorial se concentra no uso de um trabalho de comando para criar um trabalho de treinamento personalizado que você usa para treinar um modelo. Qualquer trabalho de treinamento personalizado requer os seguintes itens:

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

Este tutorial fornece estes itens para o 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 mergulhar no código, você precisa de uma maneira de fazer referência ao seu espaço de trabalho. Criar ml_client para um identificador para o espaço de trabalho. Em seguida, use 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 para espaço de trabalho, grupo de recursos e ID de assinatura para o código. Você precisa copiar um valor, fechar a área e colar, em seguida, 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,
)

# 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 fazer o treinamento. É semelhante ao ambiente python em sua máquina local. Para obter mais informações, consulte O que são ambientes do Azure Machine Learning?

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ê cria 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 próxima célula usa a magia do IPython para gravar o arquivo conda no diretório que você criou.

%%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ê usa em seu trabalho, como numpy e 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, crie o script de treinamento. Nesse caso, você está treinando o 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 divide o conjunto de dados em dados de teste e treinamento. Neste tutorial, você cria um script de treinamento do Python.

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

Criar script de treinamento

Comece criando o script de treinamento: o arquivo main.py python. 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 pré-processa os dados, dividindo-os em dados de teste e treino. Em seguida, ele consome os 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 este trabalho. O pacote MLFlow permite acompanhar métricas e resultados para cada modelo de trens do Azure. Use MLFlow para obter o melhor modelo para seus dados. Em seguida, exiba as métricas do modelo no estúdio do Azure. Para obter mais informações, consulte MLflow e Azure Machine Learning.

%%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, depois 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.

Crie variáveis de entrada para especificar os dados de entrada, a taxa de divisão, a taxa de aprendizagem e o nome do modelo registrado. O script de comando:

• Usa o ambiente criado anteriormente. Use a @latest notação para indicar a versão mais recente do ambiente quando o comando for executado.
• Configura a própria ação da linha de comando, python main.py nesse caso. Você pode acessar as entradas e saídas no comando usando ${{ ... }} notação.
• Como um recurso de computação não foi especificado, o script é 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

Envie o trabalho para ser executado no estúdio do Azure Machine Learning. Desta vez, use 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

Para exibir o trabalho no estúdio do Azure Machine Learning, selecione o link na saída da célula anterior. A saída deste trabalho tem esta aparência no estúdio do Azure Machine Learning. Explore as guias para vários detalhes, como métricas, saídas, etc. Depois que o trabalho termina, ele registra um modelo em seu espaço de trabalho como resultado do treinamento.

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 estúdio de Aprendizado de Máquina. 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 e outras informações. A página também tem guias para outras informações sobre o trabalho, como métricas, saídas + logs e código. Aqui estão as guias disponíveis na página de detalhes da vaga:

• Visão geral: 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: 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: logs gerados durante a execução do trabalho. Esta guia ajuda a solucionar problemas se algo der errado com seu script de treinamento ou criação de modelo.
• Métricas: 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 Conteúdo relacionado.

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

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, na caixa de pesquisa, insira Grupos de recursos e selecione-o nos resultados.

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

3. Na página Visão geral, selecione Excluir grupo de recursos.

   

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

Conteúdos relacionados

Saiba mais sobre como implantar 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.

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. Para obter mais informações, consulte O que é aprendizado de máquina automatizado.

Se quiser mais exemplos semelhantes a este tutorial, consulte Aprender com blocos de anotações de exemplo. Esses exemplos estão disponíveis na 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.