Entrena un modelo de AA con contenedores personalizados

AI Platform Training admite el entrenamiento en contenedores personalizados, lo que permite a los usuarios proporcionar sus propios contenedores de Docker con cualquier algoritmo o framework de AA preinstalado para ejecutarse en AI Platform Training. En este instructivo, se proporciona una explicación introductoria sobre cómo entrenar un modelo de PyTorch en AI Platform Training con un contenedor personalizado.

Descripción general

En esta guía de introducción, se demuestra el proceso de entrenamiento con contenedores personalizados en AI Platform Training mediante un modelo básico que clasifica los dígitos escritos a mano según el conjunto de datos MNIST.

En esta guía, se incluyen los siguientes pasos:

  • Configurar el proyecto y el entorno local
  • Crea un contenedor personalizado
    • Escribe un Dockerfile
    • Compila y prueba la imagen de Docker de forma local
  • Envía la imagen a Container Registry
  • Envía un trabajo de entrenamiento de contenedor personalizado
  • Envía un trabajo de ajuste de hiperparámetros
  • Uso de GPU con un contenedor personalizado

Antes de comenzar

Para esta guía de introducción, usa cualquier entorno en el que esté instalada Google Cloud CLI.

Opcional: Revisa la información conceptual sobre el entrenamiento con contenedores personalizados.

Completa los siguientes pasos para configurar una cuenta de GCP, habilitar las API necesarias, e instalar y activar el SDK de Cloud.

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  4. Enable the AI Platform Training & Prediction, Compute Engine and Container Registry APIs.

    Enable the APIs

  5. Install the Google Cloud CLI.

  6. To initialize the gcloud CLI, run the following command: 

    gcloud init

  7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  8. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  9. Enable the AI Platform Training & Prediction, Compute Engine and Container Registry APIs.

    Enable the APIs

  10. Install the Google Cloud CLI.

  11. To initialize the gcloud CLI, run the following command: 

    gcloud init
  12. Instala Docker.

    Si usas un sistema operativo basado en Linux, como Ubuntu o Debian, agrega tu nombre de usuario al grupo docker para que puedas ejecutar Docker sin usar sudo:

    sudo usermod -a -G docker ${USER}

    Es posible que debas reiniciar tu sistema después de agregarte al grupo docker.

  13. Abre Docker. Para garantizar que Docker esté en funcionamiento, ejecuta el siguiente comando de Docker, que muestra la hora y la fecha actuales: 
    docker run busybox date
  14. Usa gcloud como auxiliar de credenciales para Docker:
    gcloud auth configure-docker
  15. Opcional: Si deseas ejecutar el contenedor con GPU de forma local, instala nvidia-docker.

Configura tu bucket de Cloud Storage

En esta sección se muestra cómo crear un bucket nuevo. Puedes usar un bucket existente, pero debe estar en la misma región en la que planeas ejecutar los trabajos de AI Platform. Además, si no es parte del proyecto que usas para ejecutar AI Platform Training, debes otorgar acceso a las cuentas de servicio de AI Platform Training de forma explícita.

  1. Especifica un nombre para el bucket nuevo. El nombre debe ser único en todos los depósitos en Cloud Storage.

    BUCKET_NAME="YOUR_BUCKET_NAME"

    Por ejemplo, usa el nombre de tu proyecto con -aiplatform agregado:

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

  2. Comprueba el nombre del bucket que creaste.

    echo $BUCKET_NAME

  3. Selecciona una región para tu depósito y establece una variable de entorno REGION.

    Usa la misma región en la que planeas ejecutar los trabajos de AI Platform Training. Consulta las regiones disponibles para los servicios de AI Platform Training.

    Por ejemplo, con el código siguiente, se crea una REGION y se la configura como us-central1:

    REGION=us-central1

  4. Crea el bucket nuevo:

    gcloud storage buckets create gs://$BUCKET_NAME --location=$REGION

Descarga el código para este instructivo

  1. Ingresa el siguiente comando para descargar el archivo ZIP de muestra de AI Platform Training:

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

  2. Descomprime el archivo para extraer el directorio cloudml-samples-master.

    unzip master.zip

  3. Navega al directorio cloudml-samples-master > pytorch > containers > quickstart > mnist. Los comandos que aparecen en esta guía deben ejecutarse desde el directorio mnist.

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

Crea un contenedor personalizado

A fin de crear un contenedor personalizado, el primer paso es definir un Dockerfile para instalar las dependencias necesarias para el trabajo de entrenamiento. Luego, compila y prueba la imagen de Docker de forma local para verificarla antes de usarla con AI Platform Training.

Escribe un Dockerfile

El Dockerfile de muestra que se proporciona en este instructivo cumple los siguientes pasos:

  1. Usa una imagen base de Python 2.7 que tiene dependencias de Python integradas.
  2. Instala dependencias adicionales, incluidos PyTorch, la CLI de gcloud y cloudml-hypertune para ajustar los hiperparámetros.
  3. Copia el código para tu aplicación de entrenamiento en el contenedor.
  4. Configura el punto de entrada para que AI Platform Training ejecute el código de entrenamiento cuando se inicia el contenedor.

Tu Dockerfile podría incluir lógica adicional, según tus necesidades. Obtén más información sobre cómo escribir los Dockerfile.

# 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"]

Compila y prueba la imagen de Docker de forma local

  1. Crea el URI de imagen correcto; para ello, usa las variables de entorno y compila la imagen de Docker. La marca -t nombra y etiqueta la imagen con tus opciones para IMAGE_REPO_NAME y IMAGE_TAG. Puedes elegir un nombre y una etiqueta diferentes para tu imagen.

    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. Si quieres verificar la imagen, ejecútala de forma local en un contenedor nuevo. Ten en cuenta que la marca --epochs se pasa a la secuencia de comandos del entrenador.

    docker run $IMAGE_URI --epochs 1

Envía la imagen a Container Registry

Si la ejecución local funciona, puedes enviar la imagen de Docker a Container Registry en tu proyecto.

Primero, ejecuta gcloud auth configure-docker si aún no lo has hecho.

docker push $IMAGE_URI

Envía y supervisa el trabajo

  1. Define las variables de entorno para la solicitud de trabajo.

    • MODEL_DIR nombra un nuevo directorio con marca de tiempo dentro de tu depósito de Cloud Storage donde se almacena el archivo del modelo guardado una vez que se completa el entrenamiento.
    • REGION especifica una región válida para el entrenamiento de 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. Envía el trabajo de entrenamiento a AI Platform Training con la CLI de gcloud. Pasa el URI a tu imagen de Docker mediante la marca --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. Después de enviar tu trabajo, puedes supervisar el estado del trabajo y transmitir los registros:

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

Envía un trabajo de ajuste de hiperparámetros

Debes hacer algunos ajustes antes de enviar un trabajo de ajuste de hiperparámetros. Toma nota de estas áreas en el código de muestra:

  • El Dockerfile de muestra incluye el paquete cloudml-hypertune para instalarlo en el contenedor personalizado.
  • El código de muestra (mnist.py):
    • Usa cloudml-hypertune para informar los resultados de cada prueba, mediante llamadas a su función auxiliar, report_hyperparameter_tuning_metric. El código de muestra informa sobre los resultados del ajuste de hiperparámetros después de la evaluación, a menos que el trabajo no se envíe como un trabajo de ajuste de hiperparámetros.
    • Agrega argumentos de línea de comandos para cada hiperparámetro y controla el análisis de los argumentos con argparse.
  • La solicitud de trabajo incluye HyperparameterSpec en el objeto TrainingInput. En este caso, ajustamos --lr y --momentum para minimizar la pérdida del modelo.

  1. Crea un archivo config.yaml para definir la especificación de hiperparámetros. Vuelve a definir MODEL_DIR y JOB_NAME. Define REGION si aún no lo hiciste:

    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. Envía el trabajo de ajuste de hiperparámetros a 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"

Usa GPU con contenedores personalizados

Para enviar un trabajo de contenedor personalizado mediante GPU, debes compilar una imagen de Docker diferente a la que utilizaste anteriormente. Te proporcionamos un Dockerfile de ejemplo para su uso con GPU que cumple los siguientes requisitos:

  • Instala previamente el kit de herramientas CUDA y cuDNN en tu contenedor. El uso de la imagen nvidia/cuda como tu imagen base es la forma recomendada de manejar esto, ya que tiene el kit de herramientas CUDA y cuDNN preinstalados, y te ayuda a configurar las variables de entorno relacionadas de manera correcta.
  • Instala dependencias adicionales, como wget, curl, pip, y cualquier otra que necesite tu aplicación de entrenamiento.
# 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"]

Compila y prueba la imagen de Docker de GPU de manera local

  1. Compila una imagen nueva para el trabajo de entrenamiento de GPU con el Dockerfile de GPU. Para evitar anular la imagen de la CPU, debes volver a definir IMAGE_REPO_NAME y, además, IMAGE_TAG con nombres diferentes a los que utilizaste anteriormente en el instructivo.

    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. Si tienes GPU disponibles en tu máquina y ya instalaste nvidia-docker, puedes verificar la imagen mediante su ejecución local:

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

  3. Envía la imagen de Docker a Container Registry. Primero, ejecuta gcloud auth configure-docker si aún no lo hiciste.

    docker push $IMAGE_URI

Envía el trabajo

En este ejemplo, se usa el nivel de escala básico de GPU para enviar la solicitud de trabajo de entrenamiento. Consulta otras opciones de máquinas para realizar el entrenamiento con GPU.

  1. Vuelve a definir MODEL_DIR y JOB_NAME. Define REGION si aún no lo has hecho:

    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. Envía el trabajo de entrenamiento a AI Platform Training con la CLI de gcloud. Pasa el URI a tu imagen de Docker mediante la marca --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

¿Qué sigue?