Primeiros passos: treinamento 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
  • Criar 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.

Antes de começar

Para este guia de primeiros passos, use qualquer ambiente em que o SDK do Cloud SDK esteja instalado.

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.

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

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 seu 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, SDK do Cloud 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.15-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 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:

    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 ferramenta gcloud para enviar o job de treinamento ao AI Platform Training. Passe 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