Treine os modelos PyTorch em escala com o Azure Machine Learning

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

Neste artigo, você aprenderá a treinar, ajustar hiperparâmetro e implantar um modelo PyTorch usando o SDK do Python do Azure Machine Learning v2.

Você usa scripts de exemplo para classificar imagens de frango e peru para criar uma rede neural de aprendizado profundo (DNN) com base no Tutorial de aprendizado de transferência do PyTorch. O aprendizado de transferência é uma técnica que aplica o conhecimento obtido na resolução de um problema para um problema diferente, mas relacionado. A transferência de aprendizado reduz o processo de treinamento, exigindo menos dados, tempo e recursos computacionais do que o treinamento começando do zero. Para saber mais sobre aprendizado por transferência, consulte Aprendizado profundo vs aprendizado de máquina.

Se você estiver treinando um modelo PyTorch de aprendizado profundo desde o início ou se estiver trazendo um modelo existente para a nuvem, use o Azure Machine Learning para expandir os trabalhos de treinamento de software livre usando recursos de computação em nuvem elástica. Você pode criar, implantar, versionar e monitorar modelos de nível de produção com o Azure Machine Learning.

Pré-requisitos

• Uma assinatura do Azure. Se você ainda não tem, crie uma conta gratuita.
• Python 3.10 ou posterior.
• Execute o código neste artigo usando uma instância de computação do Azure Machine Learning ou seu próprio jupyter notebook.
  • Instância de computação do Azure Machine Learning – não há necessidade de fazer download nem instalação:
    • Conclua o Início Rápido: introdução ao Azure Machine Learning para criar um servidor de notebook dedicado pré-carregado com o SDK e o repositório de exemplo.
    • Na guia Amostras, na seção Notebooks do seu workspace, encontre um notebook amplo e completo navegando para este diretório: SDK v2/sdk/python/jobs/single-step/pytorch/train-hyperparameter-tune-deploy-with-pytorch
  • Seu servidor do Jupyter Notebook:
    • Instale o SDK do Azure Machine Learning (v2).
    • Baixe o arquivo de script de treinamento pytorch_train.py.

Você também pode encontrar uma versão completa do notebook Jupyter deste guia na página de exemplos do GitHub.

Configurar a tarefa

Esta seção configura o trabalho para treinamento carregando os pacotes necessários do Python, conectando-se a um workspace, criando um recurso de computação para executar um trabalho de comando e criando um ambiente para executar o trabalho.

Conectar-se ao espaço de trabalho

Primeiro, conecte-se ao workspace do Azure Machine Learning. O workspace é o recurso de nível superior para o serviço. Ele fornece um local centralizado para trabalhar com todos os artefatos criados quando você usa o Azure Machine Learning.

Use DefaultAzureCredential para acessar o espaço de trabalho. Essa credencial lida com a maioria dos cenários de autenticação do SDK do Azure.

Se DefaultAzureCredential não funcionar para você, consulte o pacote azure.identity ou Configurar autenticação para obter mais credenciais disponíveis.

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

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

from azure.identity import InteractiveBrowserCredential
credential = InteractiveBrowserCredential()

Em seguida, obtenha acesso ao workspace. Para isso, forneça sua ID de assinatura, o nome do grupo de recursos e o nome do workspace. Para localizar esses parâmetros:

1. Procure o nome da área de trabalho no canto superior direito da barra de ferramentas do Azure Machine Learning Studio.
2. Selecione o nome do workspace para exibir o grupo de recursos e a ID da assinatura.
3. Copie os valores do grupo de recursos e da ID de assinatura no código.

# 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 da execução desse script é um identificador do workspace que você pode usar para gerenciar outros recursos e trabalhos.

Criar um recurso de computação para executar o trabalho

O Azure Machine Learning precisa de um recurso de computação para executar um trabalho. Esse recurso pode ser computadores únicos ou multinodos com Linux ou sistema operacional Windows ou uma malha de computação específica como o Spark.

No script de exemplo a seguir, você provisiona um cluster de computação do Linux. Para obter a lista completa de tamanhos e preços da VM, consulte a página de preços do Azure Machine Learning . Como você precisa de um cluster de GPU para este exemplo, selecione um Standard_NC4as_T4_v3 modelo e crie uma computação do Azure Machine Learning.

from azure.ai.ml.entities import AmlCompute

gpu_compute_target = "gpu-cluster"

try:
    # let's see if the compute target already exists
    gpu_cluster = ml_client.compute.get(gpu_compute_target)
    print(
        f"You already have a cluster named {gpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new gpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    gpu_cluster = AmlCompute(
        # Name assigned to the compute cluster
        name="gpu-cluster",
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_NC4AS_T4_V3",
        # 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",
    )

    # Now, we pass the object to MLClient's create_or_update method
    gpu_cluster = ml_client.begin_create_or_update(gpu_cluster).result()

print(
    f"AMLCompute with name {gpu_cluster.name} is created, the compute size is {gpu_cluster.size}"
)

Criar um ambiente de trabalho

Você precisa ter um ambiente para executar um trabalho do Azure Machine Learning. Um ambiente do Azure Machine Learning encapsula as dependências, como runtime de software e bibliotecas, necessárias para executar seu script de treinamento de machine learning em seu recurso de computação. Esse ambiente é semelhante a um ambiente do Python no computador local.

O Azure Machine Learning permite que você use um ambiente curado (ou pronto) ou crie um ambiente personalizado usando uma imagem Docker ou uma configuração Conda. Neste artigo, você reutiliza o ambiente curado do Azure Machine Learning AzureML-acpt-pytorch-2.8-cuda12.6. Use a versão mais recente desse ambiente usando a @latest diretiva.

curated_env_name = "AzureML-acpt-pytorch-2.8-cuda12.6@latest"

Configurar e enviar seu trabalho de treinamento

Nesta seção, você apresentará os dados para treinamento. Em seguida, você aborda como executar um trabalho de treinamento usando um script de treinamento fornecido. Você aprende a criar o trabalho de treinamento configurando o comando para executar o script de treinamento. Em seguida, você envia o trabalho de treinamento para execução no Azure Machine Learning.

Obter os dados de treinamento

Este conjunto de dados consiste em cerca de 120 imagens de treinamento cada para duas classes (perus e galinhas), com 100 imagens de validação para cada classe. As imagens são um subconjunto do Conjunto de dados do Open images V5. O script de treinamento pytorch_train.py baixa e extrai o conjunto de dados.

Preparar o script de treinamento

Na seção de pré-requisitos, você forneceu o script de treinamento pytorch_train.py. Na prática, você deve conseguir usar qualquer script de treinamento personalizado no estado em que se encontra e executá-lo com o Azure Machine Learning sem precisar modificar o código.

O script de treinamento fornecido baixa os dados, treina um modelo e registra o modelo.

Compilar o trabalho de treinamento

Agora que você tem todos os ativos necessários para executar seu trabalho, compile-o usando o SDK do Python do Azure Machine Learning v2. Para este exemplo, crie um command.

Um recurso do Azure Machine Learning especifica todos os detalhes necessários para executar o seu código de treinamento na nuvem. Esses detalhes incluem as entradas e saídas, o tipo de hardware a ser usado, o software a ser instalado e como executar o código. command contém informações para executar um único comando.

Configurar o comando

Use a finalidade command geral para executar o script de treinamento e executar as tarefas desejadas. Crie um objeto command para especificar os detalhes de configuração do trabalho de treinamento.

from azure.ai.ml import command
from azure.ai.ml import Input

job = command(
    inputs=dict(
        num_epochs=30, learning_rate=0.001, momentum=0.9, output_dir="./outputs"
    ),
    compute=gpu_compute_target,
    environment=curated_env_name,
    code="./src/",  # location of source code
    command="python pytorch_train.py --num_epochs ${{inputs.num_epochs}} --output_dir ${{inputs.output_dir}}",
    experiment_name="pytorch-birds",
    display_name="pytorch-birds-image",
)

• As entradas desse comando incluem o número de épocas, a taxa de aprendizado, o momento e o diretório de saída.
• Para os valores dos parâmetros:
  1. Forneça o cluster de computação gpu_compute_target = "gpu-cluster" que você criou para executar este comando.
  2. Forneça o ambiente curado que você inicializou anteriormente.
  3. Se você não estiver usando o notebook concluído na pasta Amostras, especifique o local do arquivo pytorch_train.py.
  4. Configure a ação de linha de comando em si. Nesse caso, o comando é python pytorch_train.py. É possível acessar as entradas e saídas no comando por meio da notação ${{ ... }}.
  5. Configure metadados, como o nome de exibição e o nome do experimento. Um experimento é um contêiner para todas as iterações que você faz em um determinado projeto. Todos os trabalhos que você envia com o mesmo nome de experimento aparecem um ao lado do outro no estúdio do Azure Machine Learning.

Submeter o trabalho

Agora, envie o trabalho para ser executado no Azure Machine Learning. Desta vez, use create_or_update em ml_client.jobs.

ml_client.jobs.create_or_update(job)

Quando a tarefa é concluída, ela registra um modelo em seu espaço de trabalho como resultado do treinamento. Ele também gera um link para exibir o trabalho no Estúdio do Azure Machine Learning.

O que acontece durante o trabalho

À medida que o trabalho é executado, ele passa pelos seguintes estágios:

• Preparação: o processo cria uma imagem do Docker de acordo com o ambiente que você definiu. Ele carrega a imagem no registro de contêiner do workspace e a armazena em cache para execuções posteriores. O processo também transmite logs para o histórico de trabalhos, para que você possa exibi-los para monitorar o progresso. Se você especificar um ambiente coletado, o processo usará a imagem armazenada em cache que faz backup desse ambiente coletado.

• Dimensionamento: o cluster tenta escalar verticalmente se exigir mais nós para a execução, além do que está disponível no momento.

• Em execução: o processo carrega todos os scripts na pasta de script src para o destino de computação. Ele monta ou copia armazenamentos de dados. Ele executa o script. O processo transmite saídas do stdout e da pasta ./logs para o histórico de trabalhos. Você pode usar essas saídas para monitorar o trabalho.

Ajustar hiperparâmetros do modelo

Você treinou o modelo com um conjunto de parâmetros. Agora, veja se você pode melhorar ainda mais a precisão do modelo. Ajuste e otimize os hiperparâmetros do modelo usando os recursos do sweep Azure Machine Learning.

Para ajustar os hiperparâmetros do modelo, defina o espaço de parâmetro a ser pesquisado durante o treinamento. Substituir alguns dos parâmetros passados ​​para o trabalho de treinamento por entradas especiais do pacote azure.ml.sweep.

Como o script de treinamento usa um esquema de taxa de aprendizado para reduzir a taxa de aprendizado a cada algumas épocas, você pode ajustar a taxa de aprendizado inicial e os parâmetros de momentum.

from azure.ai.ml.sweep import Uniform

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
job_for_sweep = job(
    learning_rate=Uniform(min_value=0.0005, max_value=0.005),
    momentum=Uniform(min_value=0.9, max_value=0.99),
)

Em seguida, configure a varredura no trabalho de comando usando alguns parâmetros específicos, como a métrica primária a ser observada e o algoritmo de amostragem a ser usado.

No código a seguir, a amostragem aleatória tenta diferentes conjuntos de configuração de hiperparâmetros na tentativa de maximizar a métrica primária. best_val_acc

Você também define uma política de término antecipado, o BanditPolicy, para encerrar execuções com baixo desempenho antecipadamente. O BanditPolicy encerra qualquer execução que não está dentro da margem de folga da métrica de avaliação principal. Você aplica essa política a cada época (já que a métrica best_val_acc é relatada a cada época e evaluation_interval=1). A primeira avaliação de política é adiada até depois das primeiras 10 épocas (delay_evaluation=10).

from azure.ai.ml.sweep import BanditPolicy

sweep_job = job_for_sweep.sweep(
    compute="gpu-cluster",
    sampling_algorithm="random",
    primary_metric="best_val_acc",
    goal="Maximize",
    max_total_trials=8,
    max_concurrent_trials=4,
    early_termination_policy=BanditPolicy(
        slack_factor=0.15, evaluation_interval=1, delay_evaluation=10
    ),
)

Agora, envie este trabalho como antes. Desta vez, você está executando um trabalho de varredura que limpa seu trabalho de treinamento.

returned_sweep_job = ml_client.create_or_update(sweep_job)

# stream the output and wait until the job is finished
ml_client.jobs.stream(returned_sweep_job.name)

# refresh the latest status of the job after streaming
returned_sweep_job = ml_client.jobs.get(name=returned_sweep_job.name)

Você pode monitorar o trabalho usando o link da interface de usuário do estúdio, que é disponibilizado durante a execução do trabalho.

Localizar o melhor modelo

Quando todas as execuções terminarem, encontre a execução que produziu o modelo com a maior precisão.

from azure.ai.ml.entities import Model

if returned_sweep_job.status == "Completed":

    # First let us get the run which gave us the best result
    best_run = returned_sweep_job.properties["best_child_run_id"]

    # lets get the model from this run
    model = Model(
        # the script stores the model as "outputs"
        path="azureml://jobs/{}/outputs/artifacts/paths/outputs/".format(best_run),
        name="run-model-example",
        description="Model created from run.",
        type="custom_model",
    )

else:
    print(
        "Sweep job status: {}. Please wait until it completes".format(
            returned_sweep_job.status
        )
    )

Implantar o modelo como um endpoint online

Agora você pode implantar seu modelo como um ponto de extremidade online, ou seja, como um serviço Web na nuvem do Azure.

Para implantar um serviço de aprendizado de máquina, geralmente você precisa:

• Os ativos do modelo que você deseja implantar. Esses ativos incluem o arquivo e os metadados do modelo que você já registrou em seu trabalho de treinamento.
• Alguns códigos a serem executados como um serviço. O código executa o modelo em uma determinada solicitação de entrada (um script de entrada). Esse script recebe dados enviados para um serviço Web implantado e os passa para o modelo. Depois que o modelo processa os dados, o script retorna a resposta do modelo ao cliente. O script é específico para seu modelo e deve compreender os dados que o modelo espera e retorna. Quando você usa um modelo do MLFlow, o Azure Machine Learning cria esse script automaticamente para você.

Para obter mais informações sobre a implantação, confira Implante e pontue um modelo de machine learning com um ponto de extremidade online gerenciado usando o SDK do Python v2.

Criar um ponto de extremidade online

Como primeira etapa para implantar seu modelo, crie seu endpoint online. O nome do ponto de extremidade deve ser exclusivo em toda a região do Azure. Para este artigo, crie um nome exclusivo usando um UUID (identificador universal exclusivo).

import uuid

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

from azure.ai.ml.entities import ManagedOnlineEndpoint

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="Classify turkey/chickens using transfer learning with PyTorch",
    auth_mode="key",
    tags={"data": "birds", "method": "transfer learning", "framework": "pytorch"},
)

endpoint = ml_client.begin_create_or_update(endpoint).result()

print(f"Endpoint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Depois de criar o ponto de extremidade, recupere-o da seguinte maneira:

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

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

Implantar o modelo ao ponto de extremidade

Implante o modelo usando o script de entrada. Um ponto de extremidade pode ter várias implantações. Usando regras, o endpoint pode direcionar o tráfego de rede para essas implantações.

No código a seguir, você cria uma única implantação que manipula 100% do tráfego de entrada. O código usa um nome de cor arbitrário azul para a implantação. Você também pode usar qualquer outro nome, como verde ou vermelho para a implantação.

O código para implantar o modelo no endpoint:

• Implanta a melhor versão do modelo que você registrou anteriormente.
• Avaliando o modelo usando o arquivo score.py.
• Usa o ambiente configurado (que você especificou anteriormente) para realizar a inferência.

from azure.ai.ml.entities import (
    ManagedOnlineDeployment,
    Model,
    Environment,
    CodeConfiguration,
)

online_deployment_name = "aci-blue"

# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name=online_deployment_name,
    endpoint_name=online_endpoint_name,
    model=model,
    environment=curated_env_name,
    code_configuration=CodeConfiguration(code="./score/", scoring_script="score.py"),
    instance_type="STANDARD_NC4AS_T4_V3",
    instance_count=1,
)

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

Testar o modelo implantado

Depois de implantar o modelo no ponto de extremidade, use o invoke método no ponto de extremidade para prever a saída do modelo implantado.

Para testar o ponto de extremidade, use uma imagem de exemplo para previsão. Primeiro, exiba a imagem.

# install pillow if PIL cannot imported
%pip install pillow
import json
from PIL import Image
import matplotlib.pyplot as plt

%matplotlib inline
plt.imshow(Image.open("test_img.jpg"))

Crie uma função para formatar e redimensionar a imagem.

# install torch and torchvision if needed
%pip install torch
%pip install torchvision

import torch
from torchvision import transforms


def preprocess(image_file):
    """Preprocess the input image."""
    data_transforms = transforms.Compose(
        [
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
        ]
    )

    image = Image.open(image_file)
    image = data_transforms(image).float()
    image = torch.tensor(image)
    image = image.unsqueeze(0)
    return image.numpy()

Formate a imagem e converta-a em um arquivo JSON.

image_data = preprocess("test_img.jpg")
input_data = json.dumps({"data": image_data.tolist()})
with open("request.json", "w") as outfile:
    outfile.write(input_data)

Invoque o ponto de extremidade com este JSON e imprima o resultado.

# test the blue deployment
result = ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="request.json",
    deployment_name=online_deployment_name,
)

print(result)

Limpar os recursos

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

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Conteúdo relacionado

Neste artigo, você treinou e registrou uma rede neural de aprendizado profundo usando PyTorch no Azure Machine Learning. Você também implantou o modelo em um endpoint online. Para saber mais sobre o Azure Machine Learning, confira os seguintes artigos:

• Executar as métricas de execução durante o treinamento
• Ajustar hiperparâmetros
• Arquitetura de referência para treinamento de aprendizado profundo distribuído no Azure