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

  • Artigo

APLICA-SE ASDK do Python azureml v1

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

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

Se você estiver desenvolvendo um modelo de TensorFlow do zero ou estiver trazendo um modelo existente para a nuvem, poderá usar o Azure Machine Learning para escalar horizontalmente os trabalhos de treinamento de software open-source para criar, implantar, criar uma versão e monitorar modelos de nível de produção.

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 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 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()

Criar um conjunto de dados de um arquivo

Um objeto FileDataset referencia um ou vários arquivos no armazenamento de dados do workspace ou em URLs públicas. Os arquivos podem ser de qualquer formato e a classe fornece a capacidade de baixar ou montar os arquivos no computador. Ao criar um FileDataset, você cria uma referência à localização da fonte de dados. Se você tiver aplicado transformações ao conjunto de dados, elas também serão armazenadas no conjunto de dados. Os dados permanecem na localização existente, portanto, nenhum custo de armazenamento extra é gerado. Para obter mais informações sobre pacote Dataset, confira o artigo Como criar e registrar conjuntos de dados.

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 método register() para registrar o conjunto de dados no workspace, de modo que ele possa ser compartilhado com outras pessoas, reutilizado em vários experimentos e referenciado pelo nome no 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 a execução do seu trabalho do TensorFlow. 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.

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.

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

Se você quiser usar um ambiente coletado, o código será semelhante ao seguinte exemplo:

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 coletado, você pode gravar as dependências do Conda em disco:


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


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ê modificou diretamente o objeto do ambiente coletado, pode 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

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:
  - azureml-defaults
  - tensorflow-gpu==2.2.0

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 você pode usar. Confira o repositório GitHub Azure/AzureML-Contêineres 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'

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.

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 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 você estava usando o avaliador do TensorFlow anteriormente para configurar seus trabalhos de treinamento do TensorFlow, observe que os Avaliadores foram preteridos a partir da versão do SDK do 1.19.0. 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 uma execução

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

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

Opcional: especificando os parâmetros model_framework, model_framework_version e resource_configuration, a implantação do modelo sem código fica disponível. Isso permite que você implante diretamente seu modelo como um serviço Web do modelo registrado, e o objeto ResourceConfiguration 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 de treinamento tf_mnist.py, o objeto do agente de gravação do TensorFlow mantém 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)
run.download_files(prefix='outputs/model', output_directory='./model', append_prefix=False)

Treinamento distribuído

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

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

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

Implantar um modelo do TensorFlow

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.

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

Importante

Esse recurso está atualmente em visualização pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos.

Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

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

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

As instruções completas abrange a implantação do Azure Machine Learning mais detalhadamente.

Próximas etapas

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 Azure Machine Learning.