Compartilhar via

Treine os modelos PyTorch em escala com o SDK (v1) do Azure Machine Learning

  • Artigo

APLICA-SE A: SDK do Python azureml v1

Neste artigo, aprenda como executar scripts de treinamento PyTorch em escala empresarial usando o Azure Machine Learning.

Os scripts de exemplo deste artigo são usados para classificar imagens de galinhas e perus a fim de criar uma DNN (rede neural de aprendizado profundo) com base no tutorial de transferência de aprendizado 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 transferência de aprendizado, consulte o artigo aprendizado profundo vs aprendizado de máquina.

Se você está treinando em um modelo PyTorch de aprendizado profundo do zero ou está usando um modelo existente na nuvem, você pode usar o Azure Machine Learning para escalar horizontalmente execuções de treinamento de open-source usando recursos de computação em nuvem elásticos. Você pode criar, implantar, versionar e monitorar modelos de nível de produção com o Azure Machine Learning.

Pré-requisitos

Execute este código em qualquer um destes ambientes:

Antes de executar o código neste artigo para criar um cluster de GPU, você precisará solicitar um aumento de cota para seu workspace.

Configurar o experimento

Esta seção configura o teste de treinamento, o carregamento dos pacotes necessários do Python, a inicialização de um workspace, a criação do destino da computação e a definição do ambiente de treinamento.

Importar pacotes

Primeiro, importe as bibliotecas necessárias do Python.

import os
import shutil

from azureml.core.workspace import Workspace
from azureml.core import Experiment
from azureml.core import Environment

from azureml.core.compute import ComputeTarget, AmlCompute
from azureml.core.compute_target import ComputeTargetException

Inicializar um workspace

O workspace do Azure Machine Learning é o recurso de nível superior para o serviço. Ele fornece um local centralizado para trabalhar com todos os artefatos que você criar. No SDK do Python você pode acessar os artefatos do workspace criando um objeto workspace.

Crie um objeto de espaço de trabalho a partir do config.jsonarquivo criado na config.json.

ws = Workspace.from_config()

Obter os dados

O conjunto de dados consiste em cerca de 120 imagens de treinamento para perus e galinhas, com 100 imagens de validação para cada classe. Vamos baixar e extrair o conjunto de dados como parte do nosso script de treinamento pytorch_train.py. As imagens são um subconjunto do Conjunto de dados do Open images V5. Para obter mais etapas sobre como criar um JSONL para treinar com seus próprios dados, consulte este Jupyter Notebook.

Preparar o script do treinamento

Neste tutorial, o script de treinamento, pytorch_train.py, já foi fornecido. Na prática, você pode usar qualquer script de treinamento personalizado, como está, e executá-lo com o Azure Machine Learning.

Crie uma pasta para seus scripts de treinamento.

project_folder = './pytorch-birds'
os.makedirs(project_folder, exist_ok=True)
shutil.copy('pytorch_train.py', project_folder)

Criar um destino de computação

Crie um destino de computação para a execução da sua execução do PyTorch. Neste exemplo, crie um cluster de computação Azure Machine Learning habilitado para GPU.

Importante

Antes de criar um cluster de GPU, você precisará solicitar um aumento de cota para seu workspace.


# Choose a name for your CPU cluster
cluster_name = "gpu-cluster"

# Verify that cluster does not exist already
try:
    compute_target = ComputeTarget(workspace=ws, name=cluster_name)
    print('Found existing compute target')
except ComputeTargetException:
    print('Creating a new compute target...')
    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_NC6', 
                                                           max_nodes=4)

    # Create the cluster with the specified name and configuration
    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    # Wait for the cluster to complete, show the output log
    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

Se, em vez disso, você quiser criar um cluster de CPU, forneça um tamanho de VM diferente para o parâmetro vm_size, como STANDARD_D2_V2.

Para obter mais informações sobre destinos de computação, consulte o artigo o que é um destino de computação.

Definir seu ambiente

Para definir o Ambiente do Azure Machine Learning que encapsula as dependências do script de treinamento, você pode definir um ambiente personalizado ou usar um ambiente coletado do Azure Machine Learning.

Usar o ambiente coletado

O Azure Machine Learning fornece ambientes coletados predefinidos caso você não deseje definir seu ambiente. Há vários ambientes de CPU e GPU coletados para PyTorchs correspondentes a diferentes versões do PyTorch.

Se quiser usar um ambiente coletado, você pode executar o seguinte comando:

curated_env_name = 'AzureML-PyTorch-1.6-GPU'
pytorch_env = Environment.get(workspace=ws, name=curated_env_name)

Para ver os pacotes incluídos no ambiente coletado, você pode gravar as dependências do Conda em disco:

pytorch_env.save_to_directory(path=curated_env_name)

Verifique se o ambiente coletado inclui todas as dependências exigidas pelo seu script de treinamento. Caso contrário, você precisará modificar o ambiente para incluir as dependências ausentes. Se o ambiente for modificado, você precisará dar um novo nome a ele, pois o prefixo 'AzureML' é reservado para ambientes coletados. Se você modificar o arquivo YAML de dependências do Conda, crie um ambiente com base nele com um novo nome, por exemplo:

pytorch_env = Environment.from_conda_specification(name='pytorch-1.6-gpu', file_path='./conda_dependencies.yml')

Se, em vez disso, você modificou diretamente o objeto do ambiente coletado, pode clonar esse ambiente com um novo nome:

pytorch_env = pytorch_env.clone(new_name='pytorch-1.6-gpu')

Criar um ambiente personalizado

Crie também seu ambiente do Azure Machine Learning que encapsula as dependências do script de treinamento.

Primeiro, defina suas dependências do Conda em um arquivo YAML. Neste exemplo, o arquivo é nomeado conda_dependencies.yml.

channels:
- conda-forge
dependencies:
- python=3.7
- pip=21.3.1
- pip:
  - azureml-defaults
  - torch==1.6.0
  - torchvision==0.7.0
  - future==0.17.1
  - pillow

Crie um ambiente do Azure Machine Learning com base nesta especificação de ambiente do Conda. O ambiente será empacotado em um contêiner do Docker em tempo de execução.

Por padrão, se nenhuma imagem base for especificada, o Azure Machine Learning usará uma imagem de CPU azureml.core.environment.DEFAULT_CPU_IMAGE como a imagem base. Como este exemplo executa o treinamento em um cluster de GPU, você precisará especificar uma imagem base de GPU que tenha os drivers de GPU e as dependências necessárias. O Azure Machine Learning mantém um conjunto de imagens base publicadas no MCR (Microsoft Container Registry) que podem ser usadas. Para saber mais, confira Repositório AzureML-Containers do GitHub.

pytorch_env = Environment.from_conda_specification(name='pytorch-1.6-gpu', file_path='./conda_dependencies.yml')

# Specify a GPU base image
pytorch_env.docker.enabled = True
pytorch_env.docker.base_image = 'mcr.microsoft.com/azureml/openmpi3.1.2-cuda10.1-cudnn7-ubuntu18.04'

Dica

Com alternativa, você pode capturar todas as suas dependências diretamente em uma imagem personalizada do Docker ou Dockerfile e criar seu ambiente a partir dela. Para obter mais informações, consulte Treinar com imagem personalizada.

Para obter mais informações sobre como criar e usar ambientes, consulte Criar e usar ambientes de software no Azure Machine Learning.

Configurar e enviar execuções de treinamento

Criar um ScriptRunConfig

Crie um objeto ScriptRunConfig para especificar os detalhes da configuração de seu trabalho de treinamento, incluindo o script de treinamento, o ambiente a ser usado e o destino de computação para a execução. Todos os argumentos para seu script de treinamento serão passados por meio da linha de comando, se for especificado no parâmetro arguments. O código a seguir configurará um trabalho de PyTorch de nó único.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory=project_folder,
                      script='pytorch_train.py',
                      arguments=['--num_epochs', 30, '--output_dir', './outputs'],
                      compute_target=compute_target,
                      environment=pytorch_env)

Aviso

O Azure Machine Learning executa scripts de treinamento copiando o diretório de origem inteiro. Se você tiver dados confidenciais que não deseja carregar, use um arquivo .ignore ou não o inclua no diretório de origem. Em vez disso, acesse seus dados usando um conjunto de dados do Azure Machine Learning.

Para obter mais informações sobre como configurar execuções com ScriptRunConfig, confira Configurar e enviar execuções de treinamento.

Aviso

Se anteriormente você estava usando o avaliador do PyTorch para configurar suas execuções de treinamento do PyTorch, observe que os Avaliadores foram preteridos a partir da versão1.19.0 do SDK. Com o SDK >= 1.15.0 do Azure Machine Learning, o ScriptRunConfig é a maneira recomendada para configurar trabalhos de treinamento, incluindo aqueles que usam estruturas de aprendizado profundo. Para dúvidas comuns sobre migração, consulte o Guia de migração do Avaliador para ScriptRunConfig.

Enviar a execução

O objeto Executar fornece a interface para o histórico das execuções em andamento e concluídas.

run = Experiment(ws, name='Tutorial-pytorch-birds').submit(src)
run.wait_for_completion(show_output=True)

O que acontece durante a execução

A execução dos trabalhos passam pelos seguintes estágios:

  • Preparação: uma imagem Docker é criada de acordo com o ambiente definido. A imagem é carregada no registro de contêiner do workspace e armazenada em cache para execuções posteriores. Os logs também são transmitidos para o histórico de execuções e podem ser visualizados para monitorar o andamento. Mas se um ambiente coletado for especificado, a imagem armazenada em cache desse ambiente coletado é usada.

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

  • Execução: todos os scripts na pasta de scripts são carregados para o destino de computação, os armazenamentos de dados são montados ou copiados e o script é executado. As saídas de stdout e a pasta ./logs são transmitidas para o histórico de execuções e podem ser usadas para o monitoramento.

  • Pós-processamento: a pasta ./outputs da execução é copiada para o histórico de execuções.

Registrar ou baixar um modelo

Depois de treinar o modelo, você pode registrá-lo em seu workspace. O registro de modelo permite que você armazene e versione os modelos no workspace para simplificar o gerenciamento e a implantação de modelos.

model = run.register_model(model_name='pytorch-birds', model_path='outputs/model.pt')

Dica

A implantação "como" contém uma seção sobre como registrar modelos, mas você pode pular diretamente para criar um destino de computação para implantação, uma vez você já tem um modelo registrado.

Você também pode baixar uma cópia local do modelo usando o objeto Executar. No script de treinamento pytorch_train.py, o objeto “salvar PyTorch” grava o modelo em uma pasta local (local para o destino de computação). Você pode usar o objeto Executar para baixar uma cópia.

# Create a model folder in the current directory
os.makedirs('./model', exist_ok=True)

# Download the model from run history
run.download_file(name='outputs/model.pt', output_file_path='./model/model.pt'),

Treinamento distribuído

O Azure Machine Learning também suporta trabalhos PyTorch distribuídos a vários nós para que você possa dimensionar suas cargas de trabalho de treinamento. É muito fácil executar trabalhos do PyTorch distribuído, e o Azure Machine Learning gerenciará a orquestração para você.

O Azure Machine Learning dá suporte à execução de trabalhos do PyTorch distribuído com o módulo DistributedDataParallel interno do Horovod e do PyTorch.

Para obter mais informações sobre o treinamento distribuído, consulte o Guia de treinamento distribuído da GPU.

Exportar para ONNX

Para otimizar a inferência com o ONNX Runtime, converta seu modelo PyTorch treinado para o formato ONNX. A inferência ou a pontuação do modelo é a fase em que o modelo implantado é usado para previsão, mais comumente em dados de produção. Para ver um exemplo, confira o tutorial Como exportar o modelo do PyTorch para o ONNX.

Próximas etapas

Neste artigo, você treinou e registrou uma rede neural de aprendizado profundo usando PyTorch no Azure Machine Learning. Para saber como implantar um modelo, continue no nosso artigo sobre implantação de modelo.