Treinar modelos do TensorFlow em escala com o SDK do Azure Machine Learning (v1)

Artigo
09/01/2024

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

Este exemplo treina e registra um modelo TensorFlow para classificar dígitos manuscritos usando uma rede neural profunda (DNN).

Quer esteja a desenvolver um modelo TensorFlow a partir do zero 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 para criar, implementar, disponibilizar versões e monitorizar modelos de nível de produção.

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 > tensorflow > train-hyperparameter-tune-deploy-with-tensorflow folder.
Seu próprio servidor Jupyter Notebook
- Instale o SDK do Azure Machine Learning (>= 1.15.0).
- Crie um arquivo de configuração do espaço de trabalho.
- Baixe os arquivos tf_mnist.py de script de exemplo e utils.py
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 urllib
import shutil
import azureml

from azureml.core import Experiment
from azureml.core import Workspace, Run
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()

Criar um conjunto de dados de arquivo

Um FileDataset objeto faz referência a um ou vários arquivos em seu espaço de trabalho, armazenamento de dados ou urls públicas. Os arquivos podem ser de qualquer formato, e a classe fornece a capacidade de baixar ou montar os arquivos para sua computação. Ao criar um FileDataset, você cria uma referência ao local da fonte de dados. Se você aplicou quaisquer transformações ao conjunto de dados, elas também serão armazenadas no conjunto de dados. Os dados permanecem em sua localização existente, portanto, nenhum custo de armazenamento extra é incorrido. Para obter mais informações sobre o Dataset pacote, consulte o artigo Como criar conjuntos de dados de registro.

from azureml.core.dataset import Dataset

web_paths = [
            'http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz',
            'http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz'
            ]
dataset = Dataset.File.from_files(path = web_paths)

Use o register() método para registrar o conjunto de dados em seu espaço de trabalho para que eles possam ser compartilhados com outras pessoas, reutilizados em vários experimentos e referidos pelo nome em seu script de treinamento.

dataset = dataset.register(workspace=ws,
                           name='mnist-dataset',
                           description='training and test dataset',
                           create_new_version=True)

# list the files referenced by dataset
dataset.to_path()

Criar um destino de computação

Crie um destino de computação para o trabalho do TensorFlow 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.

cluster_name = "gpu-cluster"

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)

    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    compute_target.wait_for_completion(show_output=True, min_node_count=None, timeout_in_minutes=20)

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. O Azure Machine Learning tem vários ambientes curados por CPU e GPU para o TensorFlow correspondentes a diferentes versões do TensorFlow. Você pode usar a versão mais recente deste ambiente usando a @latest diretiva. Para obter mais informações, consulte Ambientes com curadoria do Azure Machine Learning.

Se você quiser usar um ambiente com curadoria, o código será semelhante ao exemplo a seguir:

curated_env_name = 'AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu'
tf_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:


tf_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:


tf_env = Environment.from_conda_specification(name='AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-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:


tf_env = tf_env.clone(new_name='my-AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-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:
  - azureml-defaults
  - tensorflow-gpu==2.2.0

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, consulte o repositório GitHub Azure/AzureML-Containers para obter mais informações.

tf_env = Environment.from_conda_specification(name='AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu', file_path='./conda_dependencies.yml')

# Specify a GPU base image
tf_env.docker.enabled = True
tf_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.

from azureml.core import ScriptRunConfig

args = ['--data-folder', dataset.as_mount(),
        '--batch-size', 64,
        '--first-layer-neurons', 256,
        '--second-layer-neurons', 128,
        '--learning-rate', 0.01]

src = ScriptRunConfig(source_directory=script_folder,
                      script='tf_mnist.py',
                      arguments=args,
                      compute_target=compute_target,
                      environment=tf_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 TensorFlow para configurar seus trabalhos de treinamento do TensorFlow, 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.

Enviar uma execução

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(workspace=ws, name='Tutorial-TF-Mnist').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.

Opcional: especificando os parâmetros model_framework, model_framework_versione , a resource_configurationimplantação do modelo sem código fica disponível. Isso permite que você implante diretamente seu modelo como um serviço Web a partir do modelo registrado, e o ResourceConfiguration objeto define o recurso de computação para o serviço Web.

from azureml.core import Model
from azureml.core.resource_configuration import ResourceConfiguration

model = run.register_model(model_name='tf-mnist', 
                           model_path='outputs/model',
                           model_framework=Model.Framework.TENSORFLOW,
                           model_framework_version='2.0',
                           resource_configuration=ResourceConfiguration(cpu=1, memory_in_gb=0.5))

Você também pode baixar uma cópia local do modelo usando o objeto Executar. No script tf_mnist.pyde treinamento, um objeto de economia do TensorFlow 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)
run.download_files(prefix='outputs/model', output_directory='./model', append_prefix=False)

Preparação distribuída

O Aprendizado de Máquina do Azure também dá suporte a trabalhos TensorFlow 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 TensorFlow e o Azure Machine Learning gerenciará a orquestração para você.

O Azure Machine Learning dá suporte à execução de trabalhos distribuídos do TensorFlow com a API de treinamento distribuída integrada do Horovod e do TensorFlow.

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

Implantar um modelo do TensorFlow

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.

(Pré-visualização) Implantação de modelo sem código

Importante

Esta funcionalidade está atualmente em pré-visualização pública. Esta versão de pré-visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas.

Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

Em vez da rota de implantação tradicional, você também pode usar o recurso de implantação sem código (visualização) para o TensorFlow. Ao registrar seu modelo como mostrado acima com os model_frameworkparâmetros , model_framework_versione resource_configuration , você pode usar a deploy() função estática para implantar seu modelo.

service = Model.deploy(ws, "tensorflow-web-service", [model])

O tutorial completo aborda a implantação no Azure Machine Learning com mais profundidade.

Próximos passos

Neste artigo, você treinou e registrou um modelo do TensorFlow e aprendeu sobre as opções de implantação. Consulte estes outros artigos para saber mais sobre o Azure Machine Learning.

Partilhar via