Tutorial: Treine seu primeiro modelo de machine learning (SDK v1, parte 2 de 3)
APLICA-SE A: SDK do Python azureml 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
- Conclusão da parte 1 da série.
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.
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
Na barra de ferramentas, selecione Salvar para salvar o arquivo. Se desejar, feche a guia.
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")
Agora, você tem a seguinte estrutura de pastas:
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.
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.
Crie um arquivo na pasta get-started chamado
pytorch-env.yml
:name: pytorch-env channels: - defaults - pytorch dependencies: - python=3.7 - pytorch - torchvision
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
Selecione Salvar e executar script no terminal para executar o script run-pytorch.py.
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
- 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.
- Você pode ver os logs de build do Docker no Estúdio do Azure Machine Learning. para exibir os logs de build:
- Selecione a guia Saídas + logs.
- Selecione a pasta azureml-logs.
- Selecione 20_image_build_log.txt.
- Quando o status do trabalho estiver Concluído, selecione Saída + logs.
- 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
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')
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.
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:
- No estúdio, à esquerda, selecione Computação.
- 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.
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:
No portal do Azure, selecione Grupos de recursos no canto esquerdo.
Selecione o grupo de recursos que você criou por meio da lista.
Selecione Excluir grupo de recursos.
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.
Recursos relacionados
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.