Partilhar via

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

  • Artigo

APLICA-SE A: Python SDK azureml v1

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

Os scripts de exemplo neste artigo são usados para classificar imagens de frango e peru para construir uma rede neural de aprendizado profundo (DNN) com base no tutorial de aprendizagem de transferência do PyTorch. A aprendizagem por transferência é uma técnica que aplica o conhecimento adquirido na resolução de um problema a um problema diferente, mas relacionado. A aprendizagem de transferência encurta o processo de treinamento, exigindo menos dados, tempo e recursos de computação do que o treinamento do zero. Para saber mais sobre o aprendizado de transferência, consulte o artigo deep learning vs machine learning .

Quer esteja a treinar um modelo PyTorch de aprendizagem profunda desde o início ou a trazer um modelo existente para a nuvem, pode utilizar o Azure Machine Learning para expandir trabalhos de formação de código aberto utilizando 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

Execute este código em qualquer um destes ambientes:

  • Instância de computação do Azure Machine Learning - sem necessidade de downloads ou instalação

    • Conclua o Guia de início rápido: introdução ao Aprendizado de Máquina do Azure para criar um servidor de bloco de anotações dedicado pré-carregado com o SDK e o repositório de exemplo.
    • Na pasta de aprendizado profundo de exemplos no servidor de notebook, localize um bloco de anotações concluído e expandido navegando até este diretório: how-to-use-azureml > ml-frameworks > pytorch > train-hyperparameter-tune-deploy-with-pytorch folder.

  • Seu próprio servidor Jupyter Notebook

    Você também pode encontrar uma versão completa do Jupyter Notebook deste guia na página de exemplos do GitHub. O notebook inclui seções expandidas que abrangem ajuste inteligente de hiperparâmetros, implantação de modelos e widgets de notebook.

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

Configurar a experiência

Esta seção configura o experimento de treinamento carregando os pacotes Python necessários, inicializando um espaço de trabalho, criando o destino de computação e definindo o ambiente de treinamento.

Importar pacotes

Primeiro, importe as bibliotecas Python necessárias.

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 espaço de trabalho

O espaço de trabalho 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ê cria. No SDK do Python, você pode acessar os artefatos do espaço de trabalho criando um workspace objeto.

Crie um objeto de espaço de trabalho a partir do config.json arquivo criado na seção de pré-requisitos.

ws = Workspace.from_config()

Obter os dados

O conjunto de dados consiste em cerca de 120 imagens de treinamento cada 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 pytorch_train.pyde treinamento. As imagens são um subconjunto do conjunto de dados Open Images v5. Para obter mais etapas sobre como criar um JSONL para treinar com seus próprios dados, consulte este bloco de anotações Jupyter.

Preparar script de treinamento

Neste tutorial, o script de treinamento, pytorch_train.py, já é 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 o(s) seu(s) script(s) 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 o seu trabalho PyTorch ser executado. Neste exemplo, crie um cluster de computação do Azure Machine Learning habilitado para GPU.

Importante

Antes de criar um cluster de GPU, você precisará solicitar um aumento de cota para seu espaço de trabalho.


# 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.

Defina 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 com curadoria do Azure Machine Learning.

Use um ambiente com curadoria

O Azure Machine Learning fornece ambientes pré-criados e selecionados se você não quiser definir seu próprio ambiente. Existem vários ambientes com curadoria de CPU e GPU para o PyTorch correspondentes a diferentes versões do PyTorch.

Se você quiser usar um ambiente com curadoria, 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 curado, você pode escrever as dependências do conda no disco:

pytorch_env.save_to_directory(path=curated_env_name)

Certifique-se de que o ambiente selecionado inclua todas as dependências exigidas pelo seu script de treinamento. Caso contrário, você terá que modificar o ambiente para incluir as dependências ausentes. Se o ambiente for modificado, você terá que dar a ele um novo nome, pois o prefixo 'AzureML' é reservado para ambientes com curadoria. Se você modificou o arquivo YAML de dependências conda, poderá criar um novo ambiente a partir dele 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ê tiver modificado o objeto de ambiente curado diretamente, poderá clonar esse ambiente com um novo nome:

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

Criar um ambiente personalizado

Você também pode criar seu próprio ambiente do Azure Machine Learning que encapsula as dependências do script de treinamento.

Primeiro, defina suas dependências de conda em um arquivo YAML; Neste exemplo, o arquivo é chamado 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 a partir desta especificação de ambiente 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 Aprendizado de Máquina do Azure usará uma imagem azureml.core.environment.DEFAULT_CPU_IMAGE da CPU como imagem base. Como este exemplo executa treinamento em um cluster de GPU, você precisará especificar uma imagem base de GPU que tenha os drivers e dependências de GPU necessários. O Azure Machine Learning mantém um conjunto de imagens base publicadas no Microsoft Container Registry (MCR) que você pode usar. Para obter mais informações, consulte AzureML-Containers GitHub repo.

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'

Gorjeta

Opcionalmente, você pode capturar todas as suas dependências diretamente em uma imagem personalizada do Docker ou Dockerfile e criar seu ambiente a partir disso. 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 sua execução de treinamento

Criar um ScriptRunConfig

Crie um objeto ScriptRunConfig para especificar os detalhes de configuração do seu trabalho de treinamento, incluindo o script de treinamento, o ambiente a ser usado e o destino de computação a ser executado. Quaisquer argumentos para o seu script de treinamento serão passados através da arguments linha de comando, se especificado no parâmetro. O código a seguir configurará um trabalho 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 todo o diretório de origem. 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 trabalhos com ScriptRunConfig, consulte Configurar e enviar execuções de treinamento.

Aviso

Se você estava usando anteriormente o estimador PyTorch para configurar seus trabalhos de treinamento do PyTorch, observe que os estimadores foram preteridos a partir da versão 1.19.0 do SDK. Com o SDK >do Azure Machine Learning = 1.15.0, ScriptRunConfig é a maneira recomendada de configurar trabalhos de treinamento, incluindo aqueles que usam estruturas de aprendizado profundo. Para perguntas comuns sobre migração, consulte o guia de migração Estimador para ScriptRunConfig.

Envie a sua corrida

O objeto Run fornece a interface para o histórico de execução enquanto o trabalho está em execução e depois de concluído.

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

O que acontece durante a execução da execução

À medida que a execução é executada, ela passa pelas seguintes etapas:

  • Preparação: Uma imagem docker é criada de acordo com o ambiente definido. A imagem é carregada no registro de contêiner do espaço de trabalho e armazenada em cache para execuções posteriores. Os logs também são transmitidos para o histórico de execução e podem ser visualizados para monitorar o progresso. Se, em vez disso, um ambiente com curadoria for especificado, a imagem armazenada em cache que faz o backup desse ambiente curado será usada.

  • Dimensionamento: o cluster tenta aumentar a escala se o cluster de IA em lote exigir mais nós para executar a execução do que os atualmente disponíveis.

  • Em execução: Todos os scripts na pasta de script 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 do stdout e da pasta ./logs são transmitidas para o histórico de execução e podem ser usadas para monitorar a execução.

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

Registar ou descarregar um modelo

Depois de treinar o modelo, você pode registrá-lo em seu espaço de trabalho. O registro de modelo permite armazenar e fazer a versão de seus modelos em seu espaço de trabalho para simplificar o gerenciamento e a implantação de modelos.

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

Gorjeta

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

Você também pode baixar uma cópia local do modelo usando o objeto Executar. No script pytorch_train.pyde treinamento, um objeto de salvamento PyTorch persiste o modelo em uma pasta local (local para o destino de computação). Você pode usar o objeto Run 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'),

Preparação distribuída

O Azure Machine Learning também dá suporte a trabalhos PyTorch distribuídos de vários nós para que você possa dimensionar suas cargas de trabalho de treinamento. Você pode executar facilmente trabalhos distribuídos do PyTorch e o Azure Machine Learning gerenciará a orquestração para você.

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

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

Exportar para ONNX

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

Próximos passos

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