Entrena un modelo de AA con contenedores personalizados

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

Nota: Container Registry es el único registro de contenedores compatible para el entrenamiento de contenedores personalizados.

Antes de comenzar

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

Nota: Puede que los entornos con recursos de procesamiento y memoria limitados, como Cloud Shell, no sean capaces de compilar o ejecutar las imágenes de Docker que se usan en este instructivo. Si tienes problemas con Docker en tu entorno local, considera ejecutar este instructivo en una máquina virtual de Compute Engine con más recursos de procesamiento y memoria que tu máquina local. Como alternativa, puedes compilar tu imagen de Docker y enviarla a Container Registry mediante Cloud Build en lugar de ejecutar Docker en tu máquina local.

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

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

8. Make sure that billing is enabled for your Google Cloud project.

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}

    Precaución: El grupo docker es equivalente al usuario root. Consulta la documentación de Docker para obtener información sobre cómo esto afecta la seguridad de tu sistema.

    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.

Nota: Si las imágenes de Container Registry y los trabajos de AI Platform Training se encuentran en proyectos diferentes de Google Cloud, debes configurar los permisos para que tu proyecto de AI Platform Training pueda acceder al proyecto de Container Registry. Consulta cómo administrar los permisos de Container Registry para obtener más información.

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
   

Nota: También puedes especificar diferentes imágenes para usar con trabajadores y servidores de parámetros en el marco del entrenamiento distribuido mediante las marcas gcloud, --worker-image-uri y --parameter-server-image-uri. Obtén más información sobre el entrenamiento distribuido con contenedores personalizados.

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?

• Obtén más información sobre los conceptos involucrados en el uso de los contenedores.
• Aprende acerca del entrenamiento distribuido con contenedores personalizados.