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:
- Configure um projeto do Google Cloud e o ambiente local.
- Crie um contêiner personalizado:
- 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.
- Crie e teste o contêiner do Docker no local.
- Enviar o contêiner para o Container Registry.
- 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 em que a CLI gcloud esteja instalada.
Conclua as etapas a seguir para configurar uma conta do GCP, ativar as APIs necessárias e instalar e ativar o SDK do Cloud.
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
-
Enable the AI Platform Training & Prediction, Compute Engine and Container Registry APIs.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
-
Enable the AI Platform Training & Prediction, Compute Engine and Container Registry APIs.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
- 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 usarsudo
:sudo usermod -a -G docker ${USER}
Talvez seja necessário reiniciar o sistema depois de adicionar você mesmo ao grupo
docker
. - 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
- Use o
gcloud
como auxiliar de credencial do Docker:gcloud auth configure-docker
- 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:
|
WORKDIR /path/to/directory |
Especifica o diretório na imagem em que instruções posteriores são executadas. | /root |
|
Instala outros pacotes usando pip .Observação: se sua imagem de base não tiver |
Exemplos de pacote:
|
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:
|
|
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
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 paraIMAGE_REPO_NAME
eIMAGE_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 ./
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 Leitor de objetos do Storage, que inclua
as permissões
storage.objects.get
estorage.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 CLI 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:
- No Dockerfile, instale
cloudml-hypertune
(em inglês). - No código de treinamento:
- Use
cloudml-hypertune
para informar os resultados de cada tentativa ao chamar as respectivas funções auxiliaresreport_hyperparameter_tuning_metric
(em inglês). - Adicione argumentos de linha de comando a cada hiperparâmetro e processe a análise deles com
uma ferramenta como
argparse
(em inglês).
- Use
- Na solicitação do job, inclua
HyperparameterSpec
no objetoTrainingInput
.
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 Google 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.
A seguir
- Saiba mais sobre os conceitos envolvidos no uso de contêineres.
- Treine um modelo PyTorch usando contêineres personalizados.
- Saiba mais sobre o treinamento distribuído com contêineres personalizados.