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 o 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 secções seguintes também descrevem os passos.

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.

  Importante

  Se o seu espaço de trabalho do Azure Machine Learning estiver configurado com uma rede virtual gerenciada, talvez seja necessário adicionar regras de saída para permitir o acesso aos repositórios públicos de pacotes Python. Para obter mais informações, consulte Cenário: acessar pacotes públicos de aprendizado de máquina.

• 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. Pode selecionar o seu método de treino com base na complexidade do modelo, tamanho dos dados e requisitos de velocidade de treino. Neste tutorial, você aprenderá a enviar um trabalho de comando para executar um script de treinamento.

Um trabalho de comando é uma função que usas para submeter um script de treino personalizado para treinar o teu modelo. Também podes definir este trabalho como uma formação personalizada. Um trabalho de comando no Azure Machine Learning é um tipo de trabalho que executa um script ou comando em um ambiente especificado. Podes usar jobs de comando para treinar modelos, processar dados ou executar qualquer outro código personalizado que queiras executar na cloud.

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. Crie ml_client como 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 queres instalar no computador onde ocorre o treino. É semelhante ao ambiente Python na tua máquina local. Para mais informações, consulte O que são os ambientes 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.

Podes executar trabalhos de comandos a partir de CLI, SDK Python 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 abas para ver vários detalhes, como métricas, resultados e muito mais. Assim que o trabalho termina, regista um modelo no seu espaço de trabalho como resultado da formaçã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 estúdio de Aprendizado de Máquina. Alternativamente, também podes selecionar Jobs no painel esquerdo.

Um trabalho é um agrupamento de muitas execuções a partir de um script ou pedaço de código especificado. A execução armazena informação sob essa tarefa. 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 abas 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ção básica sobre o trabalho, incluindo o seu estado, horários de início e fim, e o tipo de trabalho que foi realizado
• Entradas: Os dados e o código que usou como entradas para o trabalho. Esta secção pode incluir conjuntos de dados, scripts, configurações de ambiente e outros recursos que utilizaste durante o treino.
• Saídas + logs: Logs gerados enquanto o trabalho estava em execução. Esta guia ajuda a solucionar problemas se algo der errado com seu script de treinamento ou criação de modelo.
• Métricas: Métricas-chave de desempenho do seu modelo, como pontuação de treino, pontuação F1 e pontuação de precisão.

Clean up resources (Limpar recursos)

Se planeias continuar com outros tutoriais, salta para Conteúdo Relacionado.

Parar instância de computação

Se não vais usar a instância de computação, para com isso:

1. No estúdio, no painel esquerdo, 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 utiliza um ficheiro 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 que reduz o tempo que um cientista de dados passa a encontrar um modelo que funcione melhor com os seus dados. Para obter mais informações, consulte O que é aprendizado de máquina automatizado.

Se quiseres mais exemplos semelhantes a este tutorial, vê Aprende a partir de cadernos 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.