Treinar um modelo de ML com contêineres personalizados

Treinar um modelo de ML com contêineres personalizados

O AI Platform Training é compatível com treinamento em contêineres personalizados, permitindo que os usuários tragam os próprios contêineres do Docker com qualquer estrutura ou algoritmo de ML pré-instalados para serem executados no AI Platform Training. Neste tutorial, fornecemos uma explicação introdutória que mostra como treinar um modelo PyTorch no AI Platform Training com um contêiner personalizado.

Visão geral

Neste guia de primeiros passos, demonstramos o processo de treinamento com contêineres personalizados no AI Platform Training. Usamos um modelo básico que classifica dígitos por escrito com base no conjunto de dados MNIST (em inglês).

Abordamos as etapas a seguir:

• Configurar o projeto e o ambiente local
• Crie um contêiner personalizado
  • Gravar um Dockerfile
  • Criar e testar sua imagem do Docker localmente
• Enviar a imagem ao Container Registry
• Enviar um job de treinamento do contêiner personalizado.
• Enviar um job de ajuste de hiperparâmetro.
• Usar GPUs com um contêiner personalizado.

Observação: Container Registry é o único registro de contêineres compatível com o treinamento de contêineres personalizados.

Antes de começar

Para este Guia explicativo, use qualquer ambiente em que a Google Cloud CLI esteja instalada.

Observação: ambientes com recursos limitados de computação e memória, como o Cloud Shell, talvez não consigam criar ou executar as imagens do Docker usadas neste tutorial. Se você tiver problemas com o Docker em seu ambiente local, considere executar este tutorial em uma máquina virtual Compute Engine com mais recursos de computação e memória do que sua máquina local. Como alternativa, é possível criar sua imagem do Docker e enviá-la ao Container Registry usando o Cloud Build em vez de executar o Docker em sua máquina local.

Opcional: consulte o conceito do treinamento com contêineres personalizados.

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.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

   Ative as APIs

5. Instale a CLI do Google Cloud.

6. Para inicializar a CLI gcloud, execute o seguinte comando:

   gcloud init

7. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

8. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

   Ative as APIs

10. Instale a CLI do Google Cloud.

11. Para inicializar a CLI gcloud, execute o seguinte comando:

    gcloud init

12. Instale o Docker.

    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}

    Cuidado: o grupo docker equivale ao usuário root. Consulte a documentação do Docker para ver detalhes de como isso afeta a segurança do sistema.

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

13. 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

14. Use o gcloud como auxiliar de credencial do Docker:

    gcloud auth configure-docker

15. Opcional: se você quer executar o contêiner por meio da GPU no local, instale o nvidia-docker (link em inglês).

Configurar o bucket do Cloud Storage

Nesta seção, você aprende a criar um novo bucket. É possível usar um bucket atual, mas ele precisa estar na mesma região em que você planeja executar os jobs do AI Platform. Além disso, se ele não fizer parte do projeto que você está usando para executar o AI Platform Training, conceda acesso explícito às contas de serviço do AI Platform Training.

1. Especifique um nome para o novo bucket. Ele precisa ser único em todos os buckets no Cloud Storage.

   BUCKET_NAME="YOUR_BUCKET_NAME"

   Por exemplo, use o nome do projeto com -aiplatform anexado:

   PROJECT_ID=$(gcloud config list project --format "value(core.project)")
   BUCKET_NAME=${PROJECT_ID}-aiplatform

2. Verifique o nome do bucket que você criou.

   echo $BUCKET_NAME

3. Selecione a região do bucket e defina a variável de ambiente REGION.

   Use a mesma região em que você planeja executar jobs do AI Platform Training. Veja as regiões disponíveis para os serviços do AI Platform Training.

   Por exemplo, o código a seguir cria REGION e a define como us-central1:

   REGION=us-central1

4. Crie o novo bucket:

   gsutil mb -l $REGION gs://$BUCKET_NAME

Fazer o download do código para este tutorial

1. Digite o seguinte comando para fazer o download do arquivo zip de amostra do AI Platform Training:

   wget https://github.com/GoogleCloudPlatform/cloudml-samples/archive/master.zip
   

2. Descompacte o arquivo para extrair o diretório cloudml-samples-master.

   unzip master.zip
   

3. Navegue até o diretório cloudml-samples-master > pytorch > containers > quickstart > mnist. Os comandos neste tutorial precisam ser executados no diretório mnist.

   cd cloudml-samples-master/pytorch/containers/quickstart/mnist
   

Criar um contêiner personalizado

Para criar um contêiner personalizado, a primeira etapa é definir um Dockerfile para instalar as dependências necessárias para o job de treinamento. Em seguida, você cria e testa a imagem do Docker localmente para verificá-la antes de usá-la com o AI Platform Training.

Gravar um Dockerfile

O Dockerfile de amostra neste tutorial realiza as seguintes etapas:

1. Usa uma imagem de base do Python 2.7 com dependências integradas.
2. Instala outras dependências, incluindo PyTorch, CLI gcloud e cloudml-hypertune (em inglês) para fazer ajuste de hiperparâmetro.
3. Copia o código do aplicativo de treinamento para o contêiner.
4. Configura o ponto de entrada do AI Platform Training para executar seu código de treinamento quando o contêiner estiver sendo iniciado.

O Dockerfile pode incluir outras lógicas, dependendo das suas necessidades. Saiba mais sobre Como gravar Dockerfiles.

# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the \"License\");
# you may not use this file except in compliance with the License.\n",
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an \"AS IS\" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Dockerfile
FROM python:2.7.16-jessie
WORKDIR /root

# Installs pytorch and torchvision.
RUN pip install torch==1.0.0 torchvision==0.2.1

# Installs cloudml-hypertune for hyperparameter tuning.
# It’s not needed if you don’t want to do hyperparameter tuning.
RUN pip install cloudml-hypertune

# Installs google cloud sdk, this is mostly for using gsutil to export model.
RUN wget -nv \
    https://dl.google.com/dl/cloudsdk/release/google-cloud-sdk.tar.gz && \
    mkdir /root/tools && \
    tar xvzf google-cloud-sdk.tar.gz -C /root/tools && \
    rm google-cloud-sdk.tar.gz && \
    /root/tools/google-cloud-sdk/install.sh --usage-reporting=false \
        --path-update=false --bash-completion=false \
        --disable-installation-options && \
    rm -rf /root/.config/* && \
    ln -s /root/.config /config && \
    # Remove the backup directory that gcloud creates
    rm -rf /root/tools/google-cloud-sdk/.install/.backup

# Path configuration
ENV PATH $PATH:/root/tools/google-cloud-sdk/bin
# Make sure gsutil will use the default service account
RUN echo '[GoogleCompute]\nservice_account = default' > /etc/boto.cfg

# Copies the trainer code
RUN mkdir /root/trainer
COPY trainer/mnist.py /root/trainer/mnist.py

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

Criar e testar sua imagem do Docker localmente

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=mnist_pytorch_custom_container
   export IMAGE_TAG=mnist_pytorch_cpu
   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 em um novo contêiner. A sinalização --epochs é transmitida para o script do treinador.

   docker run $IMAGE_URI --epochs 1
   

Enviar a imagem ao Container Registry

Se a execução local funcionar, envie a imagem do Docker para o Container Registry no projeto.

Observação: se as imagens do Container Registry e os jobs do AI Platform Training estiverem em diferentes projetos do Google Cloud, configure permissões para que seu projeto do AI Platform Training acesse seu projeto do Container Registry. Consulte Como gerenciar as permissões do Container Registry para mais informações.

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

docker push $IMAGE_URI

Enviar e monitorar o job

1. Defina variáveis de ambiente para a solicitação do job.

   • MODEL_DIR nomeia um novo diretório com carimbo de data/hora dentro do bucket do Cloud Storage em que o arquivo de modelo salvo é armazenado depois do treinamento.
   • REGION especifica uma região válida para o treinamento do AI Platform Training.

   export MODEL_DIR=pytorch_model_$(date +%Y%m%d_%H%M%S)
   export REGION=us-central1
   export JOB_NAME=custom_container_job_$(date +%Y%m%d_%H%M%S)
   

2. 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:

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

3. Depois de enviar o job, monitore o status dele e os registros de stream:

   gcloud ai-platform jobs describe $JOB_NAME
   gcloud ai-platform jobs stream-logs $JOB_NAME
   

Observação: também é possível especificar imagens diferentes para usá-las em workers e servidores de parâmetros no treinamento distribuído. Basta utilizar as sinalizações gcloud, --worker-image-uri e --parameter-server-image-uri. Saiba mais sobre o treinamento distribuído com contêineres personalizados.

Enviar um job de ajuste de hiperparâmetro

Você precisa fazer algumas modificações em um job de ajuste de hiperparâmetro. Observe essas áreas no código de amostra:

• A amostra do Dockerfile inclui o pacote cloudml-hypertune (em inglês) para instalá-lo no contêiner personalizado.
• Exemplo de código (mnist.py):
  • Usa cloudml-hypertune para relatar os resultados de cada avaliação chamando a função auxiliar report_hyperparameter_tuning_metric. Isso não acontecerá se o job não for enviado como um job de ajuste de hiperparâmetro;
  • Inclui argumentos de linha de comando para cada hiperparâmetro e processa a análise dos argumentos com argparse (em inglês).
• A solicitação de job inclui HyperparameterSpec no objeto TrainingInput. Nesse caso, ajustamos --lr e --momentum para minimizar a perda do modelo.

1. Crie um arquivo config.yaml para definir a especificação do hiperparâmetro. Redefina MODEL_DIR e JOB_NAME. Defina REGION caso ainda não tenha feito isso:

   export MODEL_DIR=pytorch_hptuning_model_$(date +%Y%m%d_%H%M%S)
   export REGION=us-central1
   export JOB_NAME=custom_container_job_hptuning_$(date +%Y%m%d_%H%M%S)
   
   # Creates a YAML file with job request.
   cat > config.yaml <<EOF
   trainingInput:
     hyperparameters:
       goal: MINIMIZE
       hyperparameterMetricTag: "my_loss"
       maxTrials: 20
       maxParallelTrials: 5
       enableTrialEarlyStopping: True
       params:
       - parameterName: lr
         type: DOUBLE
         minValue: 0.0001
         maxValue: 0.1
       - parameterName: momentum
         type: DOUBLE
         minValue: 0.2
         maxValue: 0.8
   EOF
   

2. Envie o job de ajuste de hiperparâmetros para o AI Platform Training:

   gcloud ai-platform jobs submit training $JOB_NAME \
     --scale-tier BASIC \
     --region $REGION \
     --master-image-uri $IMAGE_URI \
     --config config.yaml \
     -- \
     --epochs=5 \
     --model-dir="gs://$BUCKET_NAME/$MODEL_DIR"
   

Como usar GPUs com contêineres personalizados

Para enviar um job de contêiner personalizado usando GPUs, você precisa criar uma imagem do Docker diferente daquela usada anteriormente. Fornecemos um exemplo de Dockerfile para usar com GPUs que atende aos seguintes requisitos:

• 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 outras dependências, como wget, curl, pip e outras necessárias ao aplicativo de treinamento.

# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the \"License\");
# you may not use this file except in compliance with the License.\n",
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an \"AS IS\" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Dockerfile-gpu
FROM nvidia/cuda:9.0-cudnn7-runtime

# Installs necessary dependencies.
RUN apt-get update && apt-get install -y --no-install-recommends \
         wget \
         curl \
         python-dev && \
     rm -rf /var/lib/apt/lists/*

# Installs pip.
RUN curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \
    python get-pip.py && \
    pip install setuptools && \
    rm get-pip.py

WORKDIR /root

# Installs pytorch and torchvision.
RUN pip install torch==1.0.0 torchvision==0.2.1

# Installs cloudml-hypertune for hyperparameter tuning.
# It’s not needed if you don’t want to do hyperparameter tuning.
RUN pip install cloudml-hypertune

# Installs google cloud sdk, this is mostly for using gsutil to export model.
RUN wget -nv \
    https://dl.google.com/dl/cloudsdk/release/google-cloud-sdk.tar.gz && \
    mkdir /root/tools && \
    tar xvzf google-cloud-sdk.tar.gz -C /root/tools && \
    rm google-cloud-sdk.tar.gz && \
    /root/tools/google-cloud-sdk/install.sh --usage-reporting=false \
        --path-update=false --bash-completion=false \
        --disable-installation-options && \
    rm -rf /root/.config/* && \
    ln -s /root/.config /config && \
    # Remove the backup directory that gcloud creates
    rm -rf /root/tools/google-cloud-sdk/.install/.backup

# Path configuration
ENV PATH $PATH:/root/tools/google-cloud-sdk/bin
# Make sure gsutil will use the default service account
RUN echo '[GoogleCompute]\nservice_account = default' > /etc/boto.cfg

# Copies the trainer code
RUN mkdir /root/trainer
COPY trainer/mnist.py /root/trainer/mnist.py

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

Crie e teste a imagem do Docker da GPU no local

1. Crie uma nova imagem do job de treinamento de GPU usando o Dockerfile da GPU. Para evitar a modificação da imagem da CPU, você precisa redefinir IMAGE_REPO_NAME e IMAGE_TAG com nomes diferentes dos usados anteriormente no tutorial.

   export PROJECT_ID=$(gcloud config list project --format "value(core.project)")
   export IMAGE_REPO_NAME=mnist_pytorch_gpu_container
   export IMAGE_TAG=mnist_pytorch_gpu
   export IMAGE_URI=gcr.io/$PROJECT_ID/$IMAGE_REPO_NAME:$IMAGE_TAG
   
   docker build -f Dockerfile-gpu -t $IMAGE_URI ./
   

2. Se você tiver GPUs disponíveis na máquina e instalou o nvidia-docker (em inglês), execute a imagem localmente para verificá-la:

   docker run --runtime=nvidia $IMAGE_URI --epochs 1
   

3. Envie a imagem do Docker para o Container Registry. Primeiro, execute gcloud auth configure-docker, se ainda não tiver feito isso.

   docker push $IMAGE_URI
   

Enviar o job

Este exemplo usa o nível de escalonamento básico da GPU para enviar a solicitação do job de treinamento. Consulte outras opções de máquinas para treinamento com GPUs.

1. Redefina MODEL_DIR e JOB_NAME. Defina REGION se ainda não tiver feito isso:

   export MODEL_DIR=pytorch_model_gpu_$(date +%Y%m%d_%H%M%S)
   export REGION=us-central1
   export JOB_NAME=custom_container_job_gpu_$(date +%Y%m%d_%H%M%S)
   

2. 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

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

A seguir

• Saiba mais sobre os conceitos envolvidos no uso de contêineres.
• Saiba mais sobre o treinamento distribuído com contêineres personalizados.