Usa contenedores en AI Platform Training

En esta guía, se explica cómo compilar tu propio contenedor personalizado para ejecutar trabajos en AI Platform Training.

Pasos para el uso de contenedores

En los siguientes pasos, se muestra el proceso básico para el entrenamiento con contenedores personalizados:

  1. Configura un proyecto de Google Cloud y tu entorno local.
  2. Crea un contenedor personalizado:
    1. Escribe un Dockerfile que configure tu contenedor de modo que funcione con AI Platform Training y, además, incluya las dependencias necesarias para la aplicación de entrenamiento.
    2. Compila y prueba el contenedor de Docker de forma local.
  3. Envía el contenedor a Container Registry.
  4. Envía un trabajo de entrenamiento que se ejecute en tu contenedor personalizado.

El uso de ajustes de hiperparámetros o GPU requiere algunos cambios, pero el proceso básico es el mismo.

Antes de comenzar

Usa Cloud Shell o cualquier entorno en el que esté instalada la CLI de gcloud.

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.

    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.

    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}

    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.

Crea un contenedor personalizado

Crear un contenedor personalizado implica escribir un Dockerfile a fin de configurar la imagen de Docker que utilizarás para tu trabajo de entrenamiento. A continuación, compila y prueba la imagen de forma local.

Conceptos básicos de Dockerfile para AI Platform Training

Cuando creas un contenedor personalizado, usa un Dockerfile a fin de especificar todos los comandos necesarios para compilar tu imagen.

En esta sección, se brinda un ejemplo genérico de un Dockerfile. Puedes encontrar ejemplos específicos en cada instructivo de contenedores personalizados y en las muestras relacionadas.

A fin de que AI Platform Training se pueda usar, tu Dockerfile debe incluir comandos que cubran las siguientes tareas:

  • Elegir una imagen base
  • Instalar dependencias adicionales
  • Copiar tu código de entrenamiento en la imagen
  • Configurar el punto de entrada para que AI Platform Training invoque tu código de entrenamiento

Tu Dockerfile podría incluir lógica adicional, según tus necesidades. Obtén más información sobre cómo escribir los Dockerfile y, para obtener más información sobre cada comando específico, consulta la referencia de Dockerfile.

Comando Dockerfile Descripción Ejemplos
FROM image:tag Especifica una imagen básica y su etiqueta.

Imágenes base de ejemplo con etiquetas:

  • pytorch/pytorch:latest
  • tensorflow/tensorflow:nightly
  • python:2.7.15-jessie
  • nvidia/cuda:9.0-cudnn7-runtime
WORKDIR /path/to/directory Especifica el directorio en la imagen en la que se ejecutan las instrucciones posteriores. /root
RUN pip install pkg1 pkg2 pkg3 Instala paquetes adicionales con pip.

Nota: Si tu imagen base no tiene pip, debes incluir un comando para instalarla antes de instalar otros paquetes.

Paquetes de ejemplo:

  • google-cloud-storage
  • cloudml-hypertune
  • pandas
COPY src/foo.py dest/foo.py Copia el código para tu aplicación de entrenamiento en la imagen. Según cómo esté estructurada tu aplicación de entrenamiento, es probable que esto incluya varios archivos.

Ejemplos de nombres de archivos en tu aplicación de entrenamiento:

  • model.py
  • task.py
  • data_utils.py
ENTRYPOINT ["exec", "file"] Configura el punto de entrada para invocar el código de entrenamiento que se debe ejecutar. ["python", "task.py"]

La lógica en tu Dockerfile puede variar según tus necesidades, pero en general se parece al siguiente ejemplo:

# Specifies base image and tag
FROM image:tag
WORKDIR /root

# Installs additional packages
RUN pip install pkg1 pkg2 pkg3

# Downloads training data
RUN curl https://example-url/path-to-data/data-filename --output /root/data-filename

# Copies the trainer code to the docker image.
COPY your-path-to/model.py /root/model.py
COPY your-path-to/task.py /root/task.py

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

Compila y prueba tu contenedor de Docker de forma local

  1. Crea el URI de imagen correcto con las variables de entorno y, a continuación, 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=example_custom_container_image
export IMAGE_TAG=example_image_tag
export IMAGE_URI=gcr.io/$PROJECT_ID/$IMAGE_REPO_NAME:$IMAGE_TAG

docker build -f Dockerfile -t $IMAGE_URI ./

  2. Verifica la imagen mediante su ejecución de forma local. Ten en cuenta que la marca --epochs se pasa a la secuencia de comandos del entrenador.

    docker run $IMAGE_URI --epochs 1

Envía el contenedor a Container Registry

Si la ejecución local funciona, puedes enviar el contenedor a Container Registry en tu proyecto.

Envía tu contenedor a Container Registry. Primero, ejecuta gcloud auth configure-docker si aún no lo has hecho.

docker push $IMAGE_URI

Administra los permisos de Container Registry

Si usas una imagen de Container Registry dentro del mismo proyecto que usas a fin de ejecutar el entrenamiento en AI Platform Training, no es necesario configurar permisos para este instructivo, y puedes continuar con el siguiente paso.

El control de acceso para Container Registry se basa en un bucket de Cloud Storage en segundo plano, por lo que configurar los permisos de Container Registry es muy similar a configurar los permisos de Cloud Storage.

Si deseas extraer una imagen de Container Registry en un proyecto diferente, debes permitir que tu cuenta de servicio de AI Platform Training acceda a la imagen desde el otro proyecto.

  • Busca el depósito de Cloud Storage subyacente para tus permisos de Container Registry.
  • Otorga una función (como visualizador de objetos de almacenamiento) que incluya los permisos storage.objects.get y storage.objects.list a tu cuenta de servicio de AI Platform Training.

Si deseas enviar la imagen de Docker a un proyecto diferente al que usas para enviar trabajos de entrenamiento de AI Platform Training, debes otorgar acceso de extracción de imágenes a la cuenta de servicio de AI Platform Training en el proyecto que tiene tus repositorios de Container Registry. La cuenta de servicio tiene el formato service-$CMLE_PROJ_NUM@cloud-ml.google.com.iam.gserviceaccount.com y se puede encontrar en la consola de IAM.

Con el siguiente comando, se agrega la cuenta de servicio de AI Platform Training a tu otro proyecto de Container Registry:

export GCR_PROJ_ID=[YOUR-PROJECT-ID-FOR-GCR]
export CMLE_PROJ_NUM=[YOUR-PROJECT-NUMBER-FOR-CMLE-JOB-SUBMISSION]
export \
SVC_ACCT=service-$CMLE_PROJ_NUM@cloud-ml.google.com.iam.gserviceaccount.com

gcloud projects add-iam-policy-binding $GCR_PROJ_ID \
    --member serviceAccount:$SVC_ACCOUNT --role roles/ml.serviceAgent

Obtén más información sobre cómo configurar el control de acceso para Container Registry.

Envía tu trabajo de entrenamiento

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:

export BUCKET_NAME=custom_containers
export MODEL_DIR=example_model_$(date +%Y%m%d_%H%M%S)

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

Ajuste de hiperparámetros con contenedores personalizados

Para realizar ajustes de hiperparámetros con contenedores personalizados, debes hacer lo siguiente:

  • En tu Dockerfile, instala cloudml-hypertune.
  • En tu código de entrenamiento:
    • Usa cloudml-hypertune a fin de informar los resultados de cada prueba. Para ello, llama a su función auxiliar, report_hyperparameter_tuning_metric.
    • Agrega argumentos de línea de comandos para cada hiperparámetro y controla el análisis de argumentos con un analizador de argumentos como argparse.
  • En la solicitud de trabajo, agrega un HyperparameterSpec al objeto TrainingInput.

Consulta un ejemplo de entrenamiento con contenedores personalizados mediante el ajuste de hiperparámetro.

Cómo usar GPU con contenedores personalizados

Para el entrenamiento con GPU, tu contenedor personalizado debe cumplir con algunos requisitos especiales. Debes compilar una imagen de Docker diferente de la que usarías para entrenar con CPU.

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

    Si la configuración de entrenamiento usa GPU NVIDIA A100, el contenedor debe usar CUDA 11 o una versión posterior.

  • Instala dependencias adicionales, como wget, curl, pip, y cualquier otra que necesite tu aplicación de entrenamiento.

Consulta un ejemplo de Dockerfile para el entrenamiento con GPU.

Usa TPU con contenedores personalizados

Si realizas un entrenamiento distribuido con TensorFlow, puedes usar TPU en las VM de trabajador. Para hacer esto, debes configurar tu trabajo de entrenamiento de modo que use TPU y especificar el campo tpuTfVersion cuando envíes tu trabajo de entrenamiento.

Entrenamiento distribuido con contenedores personalizados

Cuando ejecutas un trabajo de entrenamiento distribuido con contenedores personalizados, puedes especificar solo una imagen para usar como instancia principal, trabajador y servidor de parámetros. También tienes la opción de compilar y especificar diferentes imágenes para la instancia principal, el trabajador y el servidor de parámetros. En este caso, es probable que las dependencias sean las mismas en las tres imágenes, y puedes ejecutar una lógica de código diferente dentro de cada imagen.

En tu código, puedes usar las variables de entorno TF_CONFIG y CLUSTER_SPEC. Mediante estas variables de entorno se describe la estructura general del clúster, y AI Platform Training las propaga por ti en cada nodo del clúster de entrenamiento. Obtén más información sobre CLUSTER_SPEC.

Puedes especificar tus imágenes dentro del objeto TrainingInput cuando envíes un trabajo, o a través de sus marcas correspondientes en gcloud ai-platform submit training.

En este ejemplo, supongamos que ya definiste tres Dockerfiles independientes, uno para cada tipo de máquina (instancia principal, trabajador y servidor de parámetros). A continuación, nombra, compila, prueba y envía tus imágenes a Container Registry. Por último, envía un trabajo de entrenamiento que especifica tus diferentes imágenes junto con la configuración de la máquina para el clúster.

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

export PROJECT_ID=$(gcloud config list project --format "value(core.project)")
export BUCKET_NAME=custom_containers
export MASTER_IMAGE_REPO_NAME=master_image_name
export MASTER_IMAGE_TAG=master_tag
export MASTER_IMAGE_URI=gcr.io/$PROJECT_ID/$MASTER_IMAGE_REPO_NAME:$MASTER_IMAGE_TAG
export WORKER_IMAGE_REPO_NAME=worker_image_name
export WORKER_IMAGE_TAG=worker_tag
export WORKER_IMAGE_URI=gcr.io/$PROJECT_ID/$WORKER_IMAGE_REPO_NAME:$WORKER_IMAGE_TAG
export PS_IMAGE_REPO_NAME=ps_image_name
export PS_IMAGE_TAG=ps_tag
export PS_IMAGE_URI=gcr.io/$PROJECT_ID/$PS_IMAGE_REPO_NAME:$PS_IMAGE_TAG
export MODEL_DIR=distributed_example_$(date +%Y%m%d_%H%M%S)
export REGION=us-central1
export JOB_NAME=distributed_container_job_$(date +%Y%m%d_%H%M%S)

docker build -f Dockerfile-master -t $MASTER_IMAGE_URI ./
docker build -f Dockerfile-worker -t $WORKER_IMAGE_URI ./
docker build -f Dockerfile-ps -t $PS_IMAGE_URI ./

docker run $MASTER_IMAGE_URI --epochs 1
docker run $WORKER_IMAGE_URI --epochs 1
docker run $PS_IMAGE_URI --epochs 1

docker push $MASTER_IMAGE_URI
docker push $WORKER_IMAGE_URI
docker push $PS_IMAGE_URI

gcloud ai-platform jobs submit training $JOB_NAME \
  --region $REGION \
  --master-machine-type complex_model_m \
  --master-image-uri $MASTER_IMAGE_URI \
  --worker-machine-type complex_model_m \
  --worker-image-uri $WORKER_IMAGE_URI \
  --worker-count 9 \
  --parameter-server-machine-type large_model \
  --parameter-server-image-uri $PS_IMAGE_URI \
  --parameter-server-count 3 \
  -- \
  --model-dir=gs://$BUCKET_NAME/$MODEL_DIR \
  --epochs=10

Credenciales predeterminadas en contenedores personalizados

Cuando ejecutas un trabajo de entrenamiento con contenedores personalizados, tu aplicación se ejecuta de forma predeterminada como la identidad del agente de servicio de Cloud ML. Puedes encontrar el ID de la cuenta de servicio del agente del servicio de Cloud ML para tu proyecto en la página de IAM en la consola de Google Cloud. Este ID tiene el siguiente formato:

service-PROJECT_NUMBER@cloud-ml.google.com.iam.gserviceaccount.com

Reemplaza PROJECT_NUMBER por el número del proyecto de Google Cloud.

AI Platform Training usa de forma automática las credenciales del agente de servicio de Cloud ML para configurar la autenticación y la autorización si usas Tensorflow tfds, bibliotecas cliente de Google Cloud o cualquier otra herramienta que use la estrategia de credenciales predeterminadas de la aplicación.

¿Qué sigue?

Anterior
Descripción general de los contenedores
Siguiente
Entrenamiento distribuido con contenedores