Share via

Tutorial: Treine seu primeiro modelo de machine learning (SDK v1, parte 2 de 3)

  • Artigo

APLICA-SE A:azureml do SDK do Python v1

Este tutorial mostra como treinar um modelo de machine learning no Azure Machine Learning. Este tutorial é a segunda parte de uma série com duas partes.

Na Parte 1: Executar "Olá, Mundo!" da série, você aprendeu a usar um script de controle para executar um trabalho na nuvem.

Neste tutorial, você seguirá a próxima etapa enviando um script que treina um modelo de machine learning. Este exemplo ajuda você a entender como o Azure Machine Learning facilita o comportamento consistente entre a depuração local e as execuções remotas.

Neste tutorial, você:

  • Crie um script de treinamento.
  • Usa o Conda para definir um ambiente do Azure Machine Learning.
  • Cria um script de controle.
  • Aprende os conceitos básicos das classes do Azure Machine Learning (Environment, Run, Metrics).
  • Envia e executa seu script de treinamento.
  • Exibe a saída do código na nuvem.
  • Registra em log as métricas para o Azure Machine Learning.
  • Exibe suas métricas na nuvem.

Pré-requisitos

Criar scripts de treinamento

Primeiro, você define a arquitetura de rede neural em um arquivo model.py. Todo o código de treinamento vai para o subdiretório src, incluindo model.py.

O código de treinamento é obtido deste exemplo introdutório do PyTorch. Os conceitos do Azure Machine Learning se aplicam a qualquer código de aprendizado de máquina, não apenas ao PyTorch.

  1. Crie um arquivo model.py na subpasta src. Copie este código para o arquivo:

    import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

  2. Na barra de ferramentas, selecione Salvar para salvar o arquivo. Se desejar, feche a guia.

  3. Em seguida, defina o script de treinamento, também na subpasta src. Esse script baixa o conjunto de dados CIFAR10 usando as APIs torchvision.dataset do PyTorch, configura a rede definida em model.py e a treina por duas épocas usando SGD padrão e perda de entropia cruzada.

    Crie um script train.py na subpasta src:

    import torch
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

from model import Net

# download CIFAR 10 data
trainset = torchvision.datasets.CIFAR10(
    root="../data",
    train=True,
    download=True,
    transform=torchvision.transforms.ToTensor(),
)
trainloader = torch.utils.data.DataLoader(
    trainset, batch_size=4, shuffle=True, num_workers=2
)


if __name__ == "__main__":

    # define convolutional network
    net = Net()

    # set up pytorch loss /  optimizer
    criterion = torch.nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

    # train the network
    for epoch in range(2):

        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # unpack the data
            inputs, labels = data

            # zero the parameter gradients
            optimizer.zero_grad()

            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            # print statistics
            running_loss += loss.item()
            if i % 2000 == 1999:
                loss = running_loss / 2000
                print(f"epoch={epoch + 1}, batch={i + 1:5}: loss {loss:.2f}")
                running_loss = 0.0

    print("Finished Training")

  4. Agora, você tem a seguinte estrutura de pastas:

    A estrutura de diretório mostra train.py no subdiretório src

Testar localmente

Selecione Salvar e executar o script no terminal para executar o script train.py diretamente na instância de computação.

Após a conclusão do script, selecione Atualizar acima das pastas de arquivo. Você verá a nova pasta de dados chamada get-started/data Expandir esta pasta para exibir os dados baixados.

A captura de tela das pastas mostra a nova pasta de dados criada executando o arquivo localmente.

Criar um ambiente de Python

O Azure Machine Learning fornece o conceito de ambiente para representar um ambiente reproduzível com controle de versão do Python para a execução de experimentos. É fácil criar um ambiente de um ambiente Conda ou pip local.

Primeiro, você cria um arquivo com as dependências do pacote.

  1. Crie um arquivo na pasta get-started chamado pytorch-env.yml:

    name: pytorch-env
channels:
    - defaults
    - pytorch
dependencies:
    - python=3.7
    - pytorch
    - torchvision

  2. Na barra de ferramentas, selecione Salvar para salvar o arquivo. Se desejar, feche a guia.

Criar o script de controle

A diferença com relação ao script de controle abaixo e o usado para enviar "Olá, Mundo" é que você adiciona algumas linhas extras para definir o ambiente.

Crie um arquivo Python na pasta get-started chamado run-pytorch.py:

# run-pytorch.py
from azureml.core import Workspace
from azureml.core import Experiment
from azureml.core import Environment
from azureml.core import ScriptRunConfig

if __name__ == "__main__":
    ws = Workspace.from_config()
    experiment = Experiment(workspace=ws, name='day1-experiment-train')
    config = ScriptRunConfig(source_directory='./src',
                             script='train.py',
                             compute_target='cpu-cluster')

    # set up pytorch environment
    env = Environment.from_conda_specification(
        name='pytorch-env',
        file_path='pytorch-env.yml'
    )
    config.run_config.environment = env

    run = experiment.submit(config)

    aml_url = run.get_portal_url()
    print(aml_url)

Dica

Se você usou outro nome quando criou o cluster de cálculo, ajuste o nome no código compute_target='cpu-cluster' também.

Entender as alterações de código

env = ...

Faz referência ao arquivo de dependência que você criou acima.

config.run_config.environment = env

Adiciona o ambiente a ScriptRunConfig.

Enviar a execução para o Azure Machine Learning

  1. Selecione Salvar e executar script no terminal para executar o script run-pytorch.py.

  2. Você verá um link na janela do terminal que é aberta. Selecione o link para exibir o trabalho.

    Observação

    Você pode ver alguns avisos começando com Falha ao carregar azureml_run_type_providers... . Você pode ignorar esses avisos. Use o link da parte inferior desses avisos para exibir a saída.

Exibir a saída

  1. Na página aberta, você verá o status do trabalho. Na primeira vez que você executa esse script, o Azure Machine Learning cria uma nova imagem do Docker a partir do seu ambiente PyTorch. Todo o trabalho pode levar aproximadamente 10 minutos para ser concluído. A imagem será reutilizada em futuros trabalhos para tornar a execução muito mais rápida.
  2. Você pode ver os logs de build do Docker no Estúdio do Azure Machine Learning. para exibir os logs de build:
    1. Selecione a guia Saídas + logs.
    2. Selecione a pasta azureml-logs.
    3. Selecione 20_image_build_log.txt.
  3. Quando o status do trabalho estiver Concluído, selecione Saída + logs.
  4. Selecione user_logs e, em seguida std_log.txt para exibir a saída do trabalho.
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ../data/cifar-10-python.tar.gz
Extracting ../data/cifar-10-python.tar.gz to ../data
epoch=1, batch= 2000: loss 2.19
epoch=1, batch= 4000: loss 1.82
epoch=1, batch= 6000: loss 1.66
...
epoch=2, batch= 8000: loss 1.51
epoch=2, batch=10000: loss 1.49
epoch=2, batch=12000: loss 1.46
Finished Training

Se um erro Your total snapshot size exceeds the limit for exibido, isso indicará que a pasta dados está localizada no valor source_directory usado em ScriptRunConfig.

Selecione ... final da pasta e selecione Mover para mover dados para a pasta get-started.

Métricas de treinamento de log

Agora que você tem um treinamento de modelo no Azure Machine Learning, comece a controlar algumas métricas de desempenho.

O script de treinamento atual imprime as métricas para o terminal. O Azure Machine Learning fornece um mecanismo para registrar métricas em log com mais funcionalidade. Ao adicionar algumas linhas de código, você pode visualizar as métricas no estúdio e compará-las entre vários trabalhos.

Modificar train.py para incluir o registro em log

  1. Modifique o script train.py para incluir mais duas linhas de código:

    import torch
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from model import Net
from azureml.core import Run


# ADDITIONAL CODE: get run from the current context
run = Run.get_context()

# download CIFAR 10 data
trainset = torchvision.datasets.CIFAR10(
    root='./data',
    train=True,
    download=True,
    transform=torchvision.transforms.ToTensor()
)
trainloader = torch.utils.data.DataLoader(
    trainset,
    batch_size=4,
    shuffle=True,
    num_workers=2
)


if __name__ == "__main__":
    # define convolutional network
    net = Net()
    # set up pytorch loss /  optimizer
    criterion = torch.nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
    # train the network
    for epoch in range(2):
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # unpack the data
            inputs, labels = data
            # zero the parameter gradients
            optimizer.zero_grad()
            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            # print statistics
            running_loss += loss.item()
            if i % 2000 == 1999:
                loss = running_loss / 2000
                # ADDITIONAL CODE: log loss metric to AML
                run.log('loss', loss)
                print(f'epoch={epoch + 1}, batch={i + 1:5}: loss {loss:.2f}')
                running_loss = 0.0
    print('Finished Training')

  2. Salve esse arquivo e feche a guia, se desejar.

Entender as duas linhas de código adicionais

Em train.py, você acessa o objeto de execução dentro do próprio script de treinamento usando o método Run.get_context() e o usa para registrar métricas:

# ADDITIONAL CODE: get run from the current context
run = Run.get_context()

...
# ADDITIONAL CODE: log loss metric to AML
run.log('loss', loss)

As métricas no Azure Machine Learning são:

  • Organizadas por experimento e execução, sendo, portanto, fácil controlar e comparar métricas.
  • Equipado com uma interface do usuário para que você possa visualizar o desempenho de treinamento no estúdio.
  • Projetado para ajuste de escala, assim, você aproveita esses benefícios mesmo quando executa centenas de experimentos.

Atualizar o arquivo do ambiente Conda

O script train.py acabou de receber uma nova dependência de azureml.core. Atualize pytorch-env.yml para refletir essa alteração:

name: pytorch-env
channels:
    - defaults
    - pytorch
dependencies:
    - python=3.7
    - pytorch
    - torchvision
    - pip
    - pip:
        - azureml-sdk

Certifique-se de salvar esse arquivo antes de enviar a execução.

Enviar a execução para o Azure Machine Learning

Selecione a guia do script run-pytorch.py e, em seguida, selecione Salvar e executar script no terminal para executar novamente o script run-pytorch.py. Certifique-se de que você salvou suas alterações em pytorch-env.yml primeiro.

Desta vez, quando você visitar o estúdio, acesse a guia Métricas, na qual agora poderá ver atualizações dinâmicas sobre a perda de treinamento do modelo. Podem ser necessário de um a dois minutos para que o treinamento comece.

Grafo de perda de treinamento na guia Métricas.

Limpar os recursos

Se você planeja continuar agora para outro tutorial ou iniciar seus próprios trabalhos de treinamento, pule para recursos relacionados.

Parar a instância de computação

Se não for usá-la agora, pare a instância de computação:

  1. No estúdio, à esquerda, selecione Computação.
  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.

Excluir todos os recursos

Importante

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

Se você não pretende usar nenhum dos recursos criados, exclua-os para não gerar custos:

  1. No portal do Azure, selecione Grupos de recursos no canto esquerdo.

  2. Selecione o grupo de recursos que você criou por meio da lista.

  3. Selecione Excluir grupo de recursos.

    Captura de tela das seleções para excluir um grupo de recursos no portal do Azure.

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

Você também pode manter o grupo de recursos, mas excluir um único workspace. Exiba as propriedades do workspace e, em seguida, selecione Excluir.

Nesta sessão, você atualizou um script básico "Olá, Mundo!" para um script de treinamento mais realista que exigia a execução de um ambiente específico do Python. Você viu como usar os ambientes coletados do Azure Machine Learning. Por fim, em algumas linhas de código, você viu como pode registrar métricas em log para o Azure Machine Learning.

Há outras maneiras de criar ambientes do Azure Machine Learning, incluindo por meio de um arquivo requirements.txt do Pip ou de um ambiente Conda local existente.