Usar contêineres no AI Platform

Neste guia, explicamos como criar seu próprio contêiner personalizado para executar jobs na AI Platform.

Etapas do uso de contêineres

As etapas a seguir são o processo básico de treinamento com contêineres personalizados:

  1. Configurar um projeto do Google Cloud Platform e o ambiente local.
  2. Criar um contêiner personalizado:
    1. Grave um Dockerfile que configure o contêiner para trabalhar com a AI Platform e inclua as dependências necessárias para o aplicativo de treinamento.
    2. Crie e teste o contêiner do Docker no local.
  3. Enviar o contêiner para o Container Registry.
  4. Enviar um job de treinamento que seja executado no contêiner personalizado.

O uso do ajuste de hiperparâmetro ou GPUs requer algumas modificações, mas o processo básico é o mesmo.

Antes de começar

Use o Cloud Shell ou qualquer ambiente com o SDK do Cloud instalado.

Conclua as etapas a seguir para configurar uma conta do GCP, ativar as APIs necessárias e instalar e ativar o SDK do Cloud.

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do GCP, acesse a página Gerenciar recursos e selecione ou crie um projeto.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  4. Ativar AI Platform ("Cloud Machine Learning Engine"), Compute Engine e Container Registry APIs.

    Ativar as APIs

  5. Instale e inicialize o SDK do Cloud.
  6. Instale o gcloud beta:
    gcloud components install beta
  7. Instale o Docker.

    Se estiver usando um sistema operacional baseado em Linux, como Ubuntu ou Debian, adicione seu nome de usuário ao grupo docker para executar o Docker sem usar o sudo:

    sudo usermod -a -G docker ${USER}

    Talvez seja necessário reiniciar o sistema depois de adicionar seu nome de usuário ao grupo docker.

  8. Abra o Docker. Para garantir que ele esteja funcionando, execute o seguinte comando que retorna a hora e a data atuais:
    docker run busybox date
  9. Use o gcloud como auxiliar de credencial do Docker:
    gcloud auth configure-docker
  10. Opcional: se você quer executar o contêiner por meio do GPU no local, instale o nvidia-docker (em inglês).

Criar um contêiner personalizado

A criação de um contêiner personalizado inclui a gravação de um Dockerfile para configurar a imagem do Docker usada no job de treinamento. Depois disso, você cria e testa a imagem no local.

Princípios básicos do Dockerfile para a AI Platform

Ao criar um contêiner personalizado, você usa um Dockerfile (em inglês) para especificar todos os comandos necessários para gerar a imagem.

Nesta seção, mostramos um exemplo genérico de um Dockerfile. Você encontra exemplos específicos em cada tutorial dos contêineres personalizados e nas amostras relacionadas (em inglês).

Para ser usado com a AI Platform, o Dockerfile precisa incluir comandos que tratem das seguintes tarefas:

  • Escolher uma imagem de base.
  • Instalar dependências extras.
  • Copiar o código de treinamento para a imagem.
  • Configurar o ponto de entrada da AI Platform para chamar código de treinamento.

O Dockerfile pode incluir outras lógicas, dependendo das suas necessidades. Saiba mais sobre como gravar Dockerfiles. Para mais informações sobre cada comando específico, consulte a referência (conteúdo dos links em inglês).

Comando do Dockerfile Descrição Exemplos
FROM image:tag Especifica uma imagem de base e a respectiva tag.

Exemplos de imagem de base com tags:

  • pytorch/pytorch:latest
  • tensorflow/tensorflow:nightly
  • python:2.7.15-jessie
  • nvidia/cuda:9.0-cudnn7-runtime
WORKDIR /path/to/directory Especifica o diretório na imagem em que instruções posteriores são executadas. /root
RUN pip install pkg1 pkg2 pkg3 Instala mais pacotes usando o pip.

Observação: se a imagem de base não tem o pip, você precisa incluir um comando para instalá-lo antes de instalar outros pacotes.

Exemplos de pacote:

  • google-cloud-storage
  • cloudml-hypertune
  • pandas
COPY src/foo.py dest/foo.py Copia o código do aplicativo de treinamento para a imagem. Dependendo da estrutura do aplicativo, isso provavelmente inclui vários arquivos.

Exemplos de nomes de arquivos no aplicativo de treinamento:

  • model.py
  • task.py
  • data_utils.py
ENTRYPOINT ["exec", "file"] Configura o ponto de entrada para chamar o código de treinamento a ser executado. ["python", "task.py"]

A lógica no Dockerfile varia de acordo com as necessidades, mas costuma ser mais ou menos assim:

# Specifies base image and tag
FROM image:tag
WORKDIR /root

# Installs additional packages
RUN pip install pkg1 pkg2 pkg3

# Downloads training data
RUN curl https://example-url/path-to-data/data-filename --output /root/data-filename

# Copies the trainer code to the docker image.
COPY your-path-to/model.py /root/model.py
COPY your-path-to/task.py /root/task.py

# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "task.py"]

Criar e testar o contêiner do Docker no local

  1. Crie o URI de imagem correto usando variáveis de ambiente. Em seguida, crie a imagem do Docker. A sinalização -t nomeia e marca a imagem com suas escolhas de IMAGE_REPO_NAME e IMAGE_TAG. É possível escolher um nome e uma tag diferentes para a imagem.

    export PROJECT_ID=$(gcloud config list project --format "value(core.project)")
    export IMAGE_REPO_NAME=example_custom_container_image
    export IMAGE_TAG=example_image_tag
    export IMAGE_URI=gcr.io/$PROJECT_ID/$IMAGE_REPO_NAME:$IMAGE_TAG
    
    docker build -f Dockerfile -t $IMAGE_URI ./
    
  2. Execute a imagem no local para verificá-la. A sinalização --epochs é transmitida para o script do treinador.

    docker run $IMAGE_URI --epochs 1
    

Enviar o contêiner para o Container Registry

Se a execução local funcionar, envie o contêiner para o Container Registry no projeto.

Envie o contêiner para o Container Registry. Primeiro, execute gcloud auth configure-docker se ainda não tiver feito isso.

docker push $IMAGE_URI

Gerenciar permissões do Container Registry

Se você estiver usando uma imagem do Container Registry do mesmo projeto usado para executar o treinamento na AI Platform, não há mais necessidade de configurar permissões para este tutorial, e você pode passar para a próxima etapa.

O controle de acesso do Container Registry é baseado em um intervalo do Cloud Storage que fica em segundo plano. Portanto, a configuração das permissões do Container Registry e do Cloud Storage são muito semelhantes.

Se você quiser extrair uma imagem do Container Registry em um projeto diferente, é necessário permitir que sua conta de serviço da AI Platform acesse a imagem do outro projeto.

  • Encontre o intervalo subjacente do Cloud Storage relacionado às permissões do Container Registry.
  • Conceda um papel, como Visualizador de objetos do Storage, que inclua as permissões storage.objects.get e storage.objects.list na conta de serviço da AI Platform.

Se você quiser enviar a imagem do docker para um projeto diferente daquele que está usando para enviar jobs de treinamento da AI Platform, conceda acesso para solicitar a imagem à conta de serviço da AI Platform no projeto que tem seus repositórios do Container Registry. A conta de serviço está no formato service-$CMLE_PROJ_NUM@cloud-ml.google.com.iam.gserviceaccount.com e pode ser encontrada no Console do IAM.

Com o comando a seguir, você adiciona a conta de serviço da AI Platform ao projeto separado do Container Registry:

export GCR_PROJ_ID=[YOUR-PROJECT-ID-FOR-GCR]
export CMLE_PROJ_NUM=[YOUR-PROJECT-NUMBER-FOR-CMLE-JOB-SUBMISSION]
export \
SVC_ACCT=service-$CMLE_PROJ_NUM@cloud-ml.google.com.iam.gserviceaccount.com

gcloud projects add-iam-policy-binding $GCR_PROJ_ID \
    --member serviceAccount:$SVC_ACCOUNT --role roles/ml.serviceAgent

Veja mais sobre Configurar o controle de acesso do Container Registry.

Enviar o job de treinamento

Use o gcloud beta para enviar o job de treinamento à AI Platform. Transmita o URI para a imagem do Docker utilizando a sinalização --master-image-uri:

export BUCKET_NAME=custom_containers
export MODEL_DIR=example_model_$(date +%Y%m%d_%H%M%S)

gcloud components install beta

gcloud beta ai-platform jobs submit training $JOB_NAME \
  --region $REGION \
  --master-image-uri $IMAGE_URI \
  -- \
  --model-dir=gs://$BUCKET_NAME/$MODEL_DIR \
  --epochs=10

Ajuste de hiperparâmetro com contêineres personalizados

Para realizar o ajuste de hiperparâmetro com contêineres personalizados, você precisa fazer as seguintes modificações:

  • No Dockerfile, instale o cloudml-hypertune.
  • No código de treinamento:
    • use cloudml-hypertune para relatar os resultados de cada avaliação chamando as respectivas funções auxiliares report_hyperparameter_tuning_metric (em inglês);
    • adicione argumentos de linha de comando para cada hiperparâmetro e processe a análise de argumentos com uma ferramenta como argparse (em inglês).
  • Na solicitação do job, inclua um HyperparameterSpec no objeto TrainingInput.

Veja um exemplo de treinamento com contêineres personalizados usando o ajuste de hiperparâmetro.

Como usar GPUs com contêineres personalizados

Para fazer o treinamento com GPUs, o contêiner personalizado precisa atender a alguns requisitos especiais. É necessário criar uma imagem do Docker diferente daquela usada para fazer treinamentos com CPUs.

  • Pré-instale o kit de ferramentas CUDA e cuDNN no contêiner. Usar a imagem nvidia/cuda como a imagem base é a maneira recomendada de lidar com esse processo. Isso acontece porque ela inclui o kit de ferramentas CUDA e cuDNN pré-instalados e ajuda na configuração correta das variáveis de ambiente relacionadas.
  • Instale dependências extras como wget, curl, pip e quaisquer outras necessárias para o aplicativo de treinamento.

Veja um exemplo de Dockerfile para treinamento com GPUs.

Treinamento distribuído com contêineres personalizados

Quando você executa um job de treinamento distribuído com contêineres personalizados, é possível especificar apenas uma imagem para ser usada como servidor de parâmetros, worker e mestre. Também é possível criar e especificar imagens diferentes para essas opções. Nesse caso, as dependências provavelmente serão as mesmas em todas as três imagens, e você executa uma lógica de código diferente em cada uma delas.

No seu código, você pode usar as variáveis de ambiente TF_CONFIG e CLUSTER_SPEC. Essas variáveis descrevem a estrutura geral do cluster e a AI Platform as preenche para você em cada nó do cluster de treinamento. Saiba mais sobre o CLUSTER_SPEC.

É possível especificar as imagens no objeto TrainingInput ao enviar um job ou por meio das sinalizações correspondentes em gcloud beta ai-platform submit training.

Neste exemplo, vamos supor que você já tenha definido três Dockerfiles separados, um para cada tipo de máquina (servidor de parâmetros, worker e mestre). Depois disso, você nomeia, cria, testa e envia as imagens para o Container Registry. Por último, você envia um job de treinamento que especifica as diferentes imagens com a configuração da máquina do cluster.

Primeiro, execute gcloud auth configure-docker se ainda não tiver feito isso.

export PROJECT_ID=$(gcloud config list project --format "value(core.project)")
export BUCKET_NAME=custom_containers
export MASTER_IMAGE_REPO_NAME=master_image_name
export MASTER_IMAGE_TAG=master_tag
export MASTER_IMAGE_URI=gcr.io/$PROJECT_ID/$MASTER_IMAGE_REPO_NAME:$MASTER_IMAGE_TAG
export WORKER_IMAGE_REPO_NAME=worker_image_name
export WORKER_IMAGE_TAG=worker_tag
export WORKER_IMAGE_URI=gcr.io/$PROJECT_ID/$WORKER_IMAGE_REPO_NAME:$WORKER_IMAGE_TAG
export PS_IMAGE_REPO_NAME=ps_image_name
export PS_IMAGE_TAG=ps_tag
export PS_IMAGE_URI=gcr.io/$PROJECT_ID/$PS_IMAGE_REPO_NAME:$PS_IMAGE_TAG
export MODEL_DIR=distributed_example_$(date +%Y%m%d_%H%M%S)
export REGION=us-central1
export JOB_NAME=distributed_container_job_$(date +%Y%m%d_%H%M%S)

docker build -f Dockerfile-master -t $MASTER_IMAGE_URI ./
docker build -f Dockerfile-worker -t $WORKER_IMAGE_URI ./
docker build -f Dockerfile-ps -t $PS_IMAGE_URI ./

docker run $MASTER_IMAGE_URI --epochs 1
docker run $WORKER_IMAGE_URI --epochs 1
docker run $PS_IMAGE_URI --epochs 1

docker push $MASTER_IMAGE_URI
docker push $WORKER_IMAGE_URI
docker push $PS_IMAGE_URI

gcloud components install beta

gcloud beta ai-platform jobs submit training $JOB_NAME \
  --region $REGION \
  --master-machine-type complex_model_m \
  --master-image-uri $MASTER_IMAGE_URI \
  --worker-machine-type complex_model_m \
  --worker-image-uri $WORKER_IMAGE_URI \
  --worker-count 9 \
  --parameter-server-machine-type large_model \
  --parameter-server-image-uri $PS_IMAGE_URI \
  --parameter-server-count 3 \
  -- \
  --model-dir=gs://$BUCKET_NAME/$MODEL_DIR \
  --epochs=10

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…