Treinar um modelo usando uma imagem personalizada do Docker

Artigo
09/03/2024

APLICA-SE A: SDK do Python azureml v1

Neste artigo, aprenda a usar uma imagem personalizada do Docker quando você estiver treinando modelos com Azure Machine Learning. Você usará os scripts de exemplo deste artigo para classificar imagens de animais de estimação criando uma rede neural de convolucional.

O Azure Machine Learning fornece uma imagem base padrão do Docker. Você também pode usar ambientes de Azure Machine Learning para especificar uma imagem de base diferente, como uma das imagens de base do Azure Machine Learning mantidas ou sua própria imagem personalizada. As imagens de base personalizadas permitem que você gerencie de perto suas dependências e mantenha um controle mais rígido sobre as versões de componentes ao executar trabalhos de treinamento.

Pré-requisitos

Execute o código em qualquer um destes ambientes:

Instância de computação do Azure Machine Learning (não há necessidade de fazer download nem instalação):
- Complete o tutorial Criar recursos para começar para criar um servidor de notebook dedicado pré-carregado com o SDK e o repositório de exemplo.
Seu próprio servidor Jupyter Notebook:
- Crie um arquivo de configuração de workspace.
- Instale o SDK do Azure Machine Learning.
- Crie um Registro de contêiner do Azure ou outro registro do Docker que esteja disponível na Internet.

Configurar um teste de treinamento

Nesta seção, você configura o teste de treinamento inicializando o espaço de trabalho, definindo seu ambiente e configurando um destino de computação.

Inicializar um workspace

O workspace do Azure Machine Learning é o recurso de nível superior para o serviço. Ele oferece 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 Workspace do arquivo config.jsno que você criou como um pré-requisito.

from azureml.core import Workspace

ws = Workspace.from_config()

Definir seu ambiente

Crie um objeto Environment.

from azureml.core import Environment

fastai_env = Environment("fastai2")

A imagem base especificada no código a seguir dá suporte à biblioteca fast.ai, que permite a transmissão de recursos de aprendizado profundo. Para saber mais, veja o repositório do Docker Hub fast.ai.

Quando você estiver usando sua imagem personalizada do Docker, você já pode ter configurado corretamente seu ambiente do Python. Nesse caso, defina o user_managed_dependencies sinalizador para True para usar o ambiente interno do Python da sua imagem personalizada. Por padrão, o Azure Machine Learning cria um ambiente Conda com as dependências que você especificou. O serviço executa o script nesse ambiente em vez de usar as bibliotecas do Python que você instalou na imagem de base.

fastai_env.docker.base_image = "fastdotai/fastai2:latest"
fastai_env.python.user_managed_dependencies = True

Usar um registro de contêiner privado (opcional)

Para usar uma imagem de um registro de contêiner privado que não está em seu espaço de trabalho, use docker.base_image_registry para especificar o endereço do repositório e um nome de usuário e senha:

# Set the container registry information.
fastai_env.docker.base_image_registry.address = "myregistry.azurecr.io"
fastai_env.docker.base_image_registry.username = "username"
fastai_env.docker.base_image_registry.password = "password"

Usar um Dockerfile personalizado (opcional)

Também é possível usar um Dockerfile personalizado. Use essa abordagem se precisar instalar pacotes que não sejam Python como dependências. Lembre-se de definir a imagem base como None.

# Specify Docker steps as a string. 
dockerfile = r"""
FROM mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:20210615.v1
RUN echo "Hello from custom container!"
"""

# Set the base image to None, because the image is defined by Dockerfile.
fastai_env.docker.base_image = None
fastai_env.docker.base_dockerfile = dockerfile

# Alternatively, load the string from a file.
fastai_env.docker.base_image = None
fastai_env.docker.base_dockerfile = "./Dockerfile"

Importante

O Azure Machine Learning somente é compatível com imagens do Docker que fornecem o seguinte software:

Ubuntu 18.04 ou versão superior.
Conda 4.7.# ou versão superior.
Python 3.7 e superior.
Um shell compatível com POSIX disponível em /bin/sh é necessário em qualquer imagem de contêiner usada para treinamento.

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

Criar ou anexar um destino de computação

Você precisa criar um destino de computação para treinar seu modelo. Neste tutorial, você cria AmlCompute como seu recurso de computação de treinamento.

A criação de AmlCompute leva alguns minutos. Se o recurso AmlCompute já estiver no seu workspace, este código ignorará o processo de criação.

Como acontece com outros serviços do Azure, há limites em determinados recursos (por exemplo, AmlCompute) associados ao Serviço do Azure Machine Learning. Para saber mais, veja Limites padrão e como solicitar uma cota mais alta.

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

# Choose a name for your cluster.
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)

    # Create the cluster.
    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

    compute_target.wait_for_completion(show_output=True)

# Use get_status() to get a detailed status for the current AmlCompute.
print(compute_target.get_status().serialize())

Importante

Use SKUs de CPU para qualquer compilação de imagem em computação.

Configure seu trabalho de treinamento

Para este tutorial, use o script de treinamento train.py no GitHub. Na prática, você pode usar qualquer script de treinamento personalizado e executá-lo, como está, com o Azure Machine Learning.

Crie um recurso ScriptRunConfig para configurar seu trabalho para ser executado no destino de computaçãodesejado.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory='fastai-example',
                      script='train.py',
                      compute_target=compute_target,
                      environment=fastai_env)

Enviar o trabalho de treinamento

Quando você envia uma execução de treinamento usando um objeto ScriptRunConfig, o método submit retorna um objeto do tipo ScriptRun. O objeto ScriptRun devolvido fornece acesso programático a informações sobre a execução do treinamento.

from azureml.core import Experiment

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

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 por meio de um datastore.

Próximas etapas

Neste artigo, você treinou um modelo usando uma imagem personalizada do Docker. Veja estes outros artigos para saber mais sobre Azure Machine Learning:

Executar as métricas de execução durante o treinamento.
Implemente um modelo usando uma imagem personalizada do Docker.

Compartilhar via