Treinar um modelo de ML com contêineres personalizados

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.

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
   

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.
• Código de amostra (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

Neste exemplo, usamos o nível de escalonamento básico da GPU para enviar a solicitação do job de treinamento. Consulte outras opções de máquina para ver o treinamento com GPUs.

1. Redefina MODEL_DIR e JOB_NAME. Configure 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