Como usar contêineres no AI Platform Training

Neste guia, você verá como criar seu próprio contêiner personalizado para executar jobs no AI Platform Training.

Etapas do uso de contêineres

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

  1. Configure um projeto do Google Cloud e o ambiente local.
  2. Crie um contêiner personalizado:
    1. Grave um Dockerfile que configure o contêiner para trabalhar com o AI Platform Training e inclua as dependências necessárias do 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 Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Ative as APIs AI Platform Training & Prediction, Compute Engine and Container Registry.

    Ative as APIs

  5. Instale e inicialize o SDK do Cloud..
  6. Instale o Docker (em inglês).

    Se você 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 sudo:

    sudo usermod -a -G docker ${USER}

    Talvez seja necessário reiniciar o sistema depois de adicionar você mesmo ao grupo docker.

  7. Abra o Docker. Para garantir que ele esteja funcionando, execute o comando a seguir, que retorna a hora e a data atuais:
    docker run busybox date
  8. Use o gcloud como auxiliar de credencial do Docker:
    gcloud auth configure-docker
  9. Opcional: se você quer executar o contêiner por meio da 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.

Noções básicas sobre o Dockerfile no AI Platform Training

Ao criar um contêiner personalizado, você usa um Dockerfile 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.

Para ser usado com o AI Platform Training, o Dockerfile precisa incluir comandos que processem as tarefas a seguir:

  • Escolher uma imagem de base.
  • Instalar dependências extras.
  • Copiar o código de treinamento para a imagem.
  • Configurar o ponto de entrada do AI Platform Training para invocar o 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 do Dockerfile (ambos os 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 outros pacotes usando pip.

Observação: se sua imagem de base não tiver pip, será preciso 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 opções para 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 utilizado para executar o treinamento no AI Platform Training, não será necessário configurar permissões neste tutorial. Nesse caso, pule para a próxima etapa.

O controle de acesso do Container Registry é baseado em um bucket 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, será necessário permitir que a conta de serviço do AI Platform Training acesse a imagem do outro projeto.

  • Encontre o bucket 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 do AI Platform Training.

Se você quiser enviar a imagem do Docker a um projeto diferente do usado para encaminhar jobs de treinamento do AI Platform Training, conceda o acesso de envio de imagens à conta de serviço que inclui os 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 (em inglês).

Com o comando a seguir, você adiciona a conta de serviço do AI Platform Training 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 a ferramenta gcloud para enviar o job de treinamento ao AI Platform Training. Transmita o URI para a imagem do Docker usando a sinalização --master-image-uri:

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

gcloud 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âmetros com contêineres personalizados

Para realizar o ajuste de hiperparâmetros com contêineres personalizados, é preciso fazer as modificações a seguir:

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.

    Se a configuração de treinamento usar GPUs NVIDIA A100, o contêiner precisará usar o CUDA 11 ou posterior.

  • Instale outras dependências, como wget, curl, pip e outras necessárias ao aplicativo de treinamento.

Veja um exemplo de Dockerfile para treinamento com GPUs.

Como usar TPUs com contêineres personalizados

Ao realizar um treinamento distribuído com o TensorFlow, use TPUs em suas VMs de worker. Para fazer isso, configure seu job de treinamento para usar TPUs e especifique o tpuTfVersion ao enviar o job.

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, use as variáveis de ambiente TF_CONFIG e CLUSTER_SPEC. Essas variáveis descrevem a estrutura geral do cluster, e o AI Platform Training as preenche para você em cada nó do cluster de treinamento. Saiba mais sobre CLUSTER_SPEC.

É possível especificar as imagens no objeto TrainingInput ao enviar um job ou por meio das sinalizações correspondentes em gcloud 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 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

Credencial padrão em contêineres personalizados

Quando você executa um job de treinamento com contêineres personalizados, o aplicativo é executado por padrão como a identidade do Agente de serviço do Cloud ML. Encontre o ID da conta de serviço do Agente de serviço do Cloud ML do projeto na página do IAM no Console do Cloud. Esse ID tem o seguinte formato:

service-PROJECT_NUMBER@cloud-ml.google.com.iam.gserviceaccount.com

Substitua PROJECT_NUMBER pelo número do projeto do Google Cloud.

O AI Platform Training usa automaticamente as credenciais do Agente de serviço do Cloud ML para configurar a autenticação e a autorização se você usar o tfds do Tensorflow, as bibliotecas de cliente do Google Cloud ou outras ferramentas que utilizam a estratégia de Application Default Credentials.

No entanto, se você quiser que o job de contêiner personalizado acesse o Google Cloud de outras maneiras, talvez seja necessário realizar uma configuração adicional. Por exemplo, se você usar gsutil para copiar dados do Cloud Storage e usar a biblioteca boto para carregar credenciais de um arquivo de configuração, adicione um comando ao Dockerfile, que garante que o gsutil use as credenciais padrão do Agente de serviço do Cloud ML:

RUN echo '[GoogleCompute]\nservice_account = default' > /etc/boto.cfg

A seguir