Cómo usar los contenedores en AI Platform

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

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 Platform y tu entorno local.
  2. Crea un contenedor personalizado:
    1. Escribe un Dockerfile que configure tu contenedor de modo que funcione con AI Platform y, además, incluya las dependencias necesarias para tu aplicación de entrenamiento.
    2. Compila y prueba tu 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é instalado el SDK de Cloud.

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

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En GCP Console, ve a la página Administrar recursos y selecciona o crea un proyecto.

    Ir a la página Administrar recursos

  3. Asegúrate de tener habilitada la facturación para tu proyecto.

    Aprende a habilitar la facturación

  4. Habilita las AI Platform ("Cloud Machine Learning Engine"), Compute Engine and Container Registry API necesarias.

    Habilita las API

  5. Realiza la instalación y la inicialización del SDK de Cloud.
  6. 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.

  7. 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
  8. Usa gcloud como auxiliar de credenciales para Docker:
    gcloud auth configure-docker
  9. Opcional: Si deseas ejecutar el contenedor con el uso de 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 tu imagen de forma local.

Conceptos básicos de Dockerfile para AI Platform

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 pueda utilizarse con AI Platform, tu Dockerfile debe incluir comandos que cubran las siguientes:

  • 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 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 al 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 utilizas para ejecutar el entrenamiento en AI Platform, 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 depósito 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 acceda a la imagen desde el otro proyecto.

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

Si deseas enviar la imagen de Docker a un proyecto diferente al que utilizas para enviar trabajos de entrenamiento de AI Platform, debes otorgar acceso de extracción de imágenes a la cuenta de servicio de AI Platform 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.

El siguiente comando agrega tu cuenta de servicio de AI Platform a tu proyecto de Container Registry por separado:

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 mediante 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 realizar 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 tu 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.
  • Instala dependencias adicionales, como wget, curl, pip, además de cualquier otra que necesite tu aplicación de entrenamiento.

Consulta un ejemplo de Dockerfile para el entrenamiento con GPU.

Uso de 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. Estas variables de entorno describen la estructura general del clúster y AI Platform las propaga para ti en cada nodo de tu 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 has hecho.

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

Próximos pasos

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

¿Necesitas ayuda? Visita nuestra página de asistencia.