Utiliser des conteneurs sur AI Platform Training

Ce guide décrit comment créer votre propre conteneur personnalisé pour exécuter des tâches sur AI Platform Training.

Étapes à suivre pour utiliser des conteneurs

Les étapes suivantes montrent le processus de base de l'entraînement avec des conteneurs personnalisés :

  1. Configurez un projet Google Cloud et votre environnement local.
  2. Créez un conteneur personnalisé :
    1. Écrivez un fichier Dockerfile configurant votre conteneur pour qu'il fonctionne avec AI Platform Training, et comprenant les dépendances nécessaires à l'application d'entraînement.
    2. Créez et testez votre conteneur Docker localement.
  3. Stockez le conteneur dans Container Registry.
  4. Envoyez un job d'entraînement qui s'exécute sur votre conteneur personnalisé.

L'utilisation du réglage d'hyperparamètres ou des GPU nécessite quelques ajustements, mais le processus de base est le même.

Avant de commencer

Utilisez Cloud Shell ou tout environnement dans lequel le SDK Cloud est installé.

Pour configurer un compte GCP, activer les API requises, puis installer et activer le SDK Cloud, procédez comme suit :

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API AI Platform Training & Prediction, Compute Engine and Container Registry.

    Activer les API

  5. Installez et initialisez le SDK Cloud.
  6. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  7. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  8. Activer les API AI Platform Training & Prediction, Compute Engine and Container Registry.

    Activer les API

  9. Installez et initialisez le SDK Cloud.
  10. Installez Docker.

    Si vous utilisez un système d'exploitation Linux, tel qu'Ubuntu ou Debian, ajoutez votre nom d'utilisateur au groupe docker afin de pouvoir exécuter Docker sans utiliser sudo :

    sudo usermod -a -G docker ${USER}

    Une fois que vous vous serez ajouté au groupe docker, vous devrez peut-être redémarrer votre système.

  11. Ouvrez Docker. Pour vérifier que Docker est en cours d'exécution, exécutez la commande Docker suivante, qui renvoie la date et l'heure actuelles :
    docker run busybox date
  12. Utilisez gcloud comme assistant d'identification pour Docker :
    gcloud auth configure-docker
  13. Facultatif : Si vous souhaitez exécuter le conteneur à l'aide d'un GPU en local, installez nvidia-docker.

Créer un conteneur personnalisé

Pour créer un conteneur personnalisé, vous devez écrire un fichier Dockerfile afin de configurer l'image Docker que vous utiliserez dans le cadre du job d'entraînement. Ensuite, vous devez créer et tester l'image localement.

Principes de base des fichiers Dockerfile pour AI Platform Training

Lorsque vous créez un conteneur personnalisé, vous spécifiez toutes les commandes nécessaires à la création de votre image au moyen d'un fichier Dockerfile.

Cette section présente un exemple générique de fichier Dockerfile. Vous pouvez trouver des exemples spécifiques dans chaque tutoriel sur les conteneurs personnalisés et dans les exemples associés.

En cas d'utilisation avec AI Platform Training, le fichier Dockerfile doit inclure des commandes couvrant les tâches suivantes :

  • Choisir une image de base
  • Installer des dépendances supplémentaires
  • Copier le code d'entraînement dans l'image
  • Configurer le point d'entrée d'AI Platform Training pour appeler le code d'entraînement

Le fichier Dockerfile peut inclure une logique supplémentaire, en fonction de vos besoins. Pour en savoir plus sur l'écriture de fichiers Dockerfile et sur chaque commande spécifique, consultez la documentation de référence sur les fichiers Dockerfile.

Commande Dockerfile Description Exemple(s)
FROM image:tag Spécifie une image de base et son tag.

Exemples d'images de base avec des tags :

  • pytorch/pytorch:latest
  • tensorflow/tensorflow:nightly
  • python:2.7.15-jessie
  • nvidia/cuda:9.0-cudnn7-runtime
WORKDIR /path/to/directory Spécifie le répertoire sur l'image où les instructions suivantes sont exécutées. /root
RUN pip install pkg1 pkg2 pkg3 Installe des packages supplémentaires à l'aide de pip.

Remarque : Si votre image de base ne contient pas pip, vous devez inclure une commande pour l'installer avant d'installer d'autres packages.

Exemples de packages :

  • google-cloud-storage
  • cloudml-hypertune
  • pandas
COPY src/foo.py dest/foo.py Copie le code de l'application d'entraînement dans l'image. Selon la structure de l'application d'entraînement, cela peut inclure plusieurs fichiers.

Exemples de noms de fichiers dans l'application d'entraînement :

  • model.py
  • task.py
  • data_utils.py
ENTRYPOINT ["exec", "file"] Configure le point d'entrée pour appeler le code d'entraînement à exécuter. ["python", "task.py"]

La logique du fichier Dockerfile peut varier en fonction de vos besoins, mais elle ressemble généralement à ceci :

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

Créer et tester le conteneur Docker localement

  1. Créez l'URI d'image correct à l'aide de variables d'environnement, puis compilez l'image Docker. L'indicateur -t nomme l'image et lui ajoute un tag comportant vos choix pour IMAGE_REPO_NAME et IMAGE_TAG. Vous pouvez choisir un nom et un tag différents pour votre image.

    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. Validez l'image en l'exécutant localement. Notez que l'indicateur --epochs est transmis au script de l'outil d'entraînement.

    docker run $IMAGE_URI --epochs 1
    

Stocker le conteneur dans Container Registry

Si l'exécution locale fonctionne, vous pouvez stocker le conteneur dans l'instance Container Registry de votre projet.

Stockez votre conteneur dans Container Registry. Si vous ne l'avez pas déjà fait, exécutez préalablement la commande gcloud auth configure-docker.

docker push $IMAGE_URI

Gérer les autorisations Container Registry

Si vous utilisez une image Container Registry dans le même projet avec lequel vous exécutez l'entraînement sur AI Platform Training, il n'est plus nécessaire de configurer les autorisations pour suivre ce tutoriel. Vous pouvez passer à l'étape suivante.

Le contrôle des accès pour Container Registry repose sur un bucket Cloud Storage en arrière-plan. Par conséquent, la configuration des autorisations Container Registry ressemble beaucoup à celle des autorisations Cloud Storage.

Si vous souhaitez extraire une image Container Registry dans un autre projet, vous devez autoriser votre compte de service AI Platform Training à accéder à l'image à partir de l'autre projet.

  • Recherchez le bucket Cloud Storage sous-jacent pour vos autorisations Container Registry.
  • Attribuez à votre compte de service AI Platform Training un rôle (par exemple, Lecteur des objets de l'espace de stockage) qui inclut les autorisations storage.objects.get et storage.objects.list.

Si vous voulez stocker l'image Docker dans un projet différent de celui avec lequel vous envoyez les tâches d'entraînement AI Platform Training, vous devez accorder au compte de service AI Platform Training un accès lui permettant d'extraire des images dans le projet où se trouvent vos dépôts Container Registry. Le compte de service est au format service-$CMLE_PROJ_NUM@cloud-ml.google.com.iam.gserviceaccount.com. Vous pouvez le trouver dans la console IAM.

La commande suivante ajoute votre compte de service AI Platform Training à votre projet Container Registry distinct :

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

Apprenez-en plus sur la configuration du contrôle des accès pour Container Registry.

Envoyer le job d'entraînement

Envoyez la tâche d'entraînement à AI Platform à l'aide de l'outil gcloud. Transmettez l'URI à votre image Docker à l'aide de l'indicateur --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

Régler les hyperparamètres avec des conteneurs personnalisés

Pour régler les hyperparamètres avec des conteneurs personnalisés, vous devez procéder aux ajustements suivants :

  • Dans votre Dockerfile, installez cloudml-hypertune.
  • Dans votre code d'entraînement :
    • Utilisez cloudml-hypertune pour signaler les résultats de chaque essai en appelant sa fonction d'aide, report_hyperparameter_tuning_metric.
    • Ajoutez des arguments de ligne de commande pour chaque hyperparamètre et gérez l'argument d'analyse avec un analyseur d'arguments tel que argparse.
  • Dans votre requête de tâche, ajoutez un élément HyperparameterSpec à l'objet TrainingInput.

Consultez un exemple d'entraînement avec des conteneurs personnalisés utilisant le réglage d'hyperparamètres.

Utiliser des GPU avec des conteneurs personnalisés

En cas d'entraînement avec des GPU, votre conteneur personnalisé doit répondre à quelques exigences particulières. Vous devez créer une image Docker différente de celle que vous utiliseriez pour l'entraînement avec des processeurs.

  • Pré-installez CUDA Toolkit et cuDNN dans votre conteneur. L'utilisation de l'image nvidia/cuda en tant qu'image de base est la méthode recommandée, car CUDA Toolkit et cuDNN y sont préinstallés, ce qui vous aide à configurer correctement les variables d'environnement associées.

    Si votre configuration d'entraînement utilise des GPU NVIDIA A100, votre conteneur doit utiliser CUDA 11 ou une version ultérieure.

  • Installez des dépendances supplémentaires, telles que wget, curl, pip et toute autre dépendance requise par votre application d'entraînement.

Consultez un exemple de fichier Dockerfile pour l'entraînement avec des GPU.

Utiliser des TPU avec des conteneurs personnalisés

Si vous procédez à un entraînement distribué avec TensorFlow, vous pouvez utiliser des TPU sur vos VM de nœud de calcul. Pour ce faire, vous devez configurer votre tâche d'entraînement pour qu'elle utilise les TPU et spécifier le champ tpuTfVersion lorsque vous envoyez votre tâche d'entraînement.

Entraînement distribué avec des conteneurs personnalisés

Lorsque vous exécutez un job d'entraînement distribué avec des conteneurs personnalisés, vous pouvez spécifier une seule image à utiliser en tant que maître, nœud de calcul et serveur de paramètres. Vous avez également la possibilité de créer et de spécifier différentes images pour le maître, le nœud de calcul et le serveur de paramètres. Dans ce cas, les dépendances seront probablement les mêmes dans les trois images, et vous pourrez exécuter une logique de code différente dans chacune d'entre elles.

Dans votre code, vous pouvez utiliser les variables d'environnement TF_CONFIG et CLUSTER_SPEC. Ces variables d'environnement décrivent la structure générale du cluster. AI Platform Training les définit automatiquement dans chaque nœud du cluster d'entraînement. Apprenez-en plus sur CLUSTER_SPEC.

Vous pouvez spécifier vos images dans l'objet TrainingInput lors de l'envoi d'une tâche ou via les indicateurs correspondants dans gcloud ai-platform submit training.

Pour cet exemple, supposons que vous ayez déjà défini trois fichiers Dockerfile distincts, un pour chaque type de machine (maître, nœud de calcul et serveur de paramètres). Vous devez ensuite nommer, créer et tester vos images, puis les stocker dans Container Registry. Enfin, vous devez envoyer une tâche d'entraînement qui spécifie les différentes images ainsi que la configuration des machines pour votre cluster.

Commencez par exécuter gcloud auth configure-docker si vous ne l'avez pas déjà fait.

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

Identifiant par défaut dans les conteneurs personnalisés

Lorsque vous exécutez une tâche d'entraînement avec des conteneurs personnalisés, votre application s'exécute par défaut en tant qu'agent de service Cloud ML. Vous pouvez trouver l'ID du compte de service de l'agent de service Cloud ML pour votre projet sur la page "IAM" de Cloud Console. Cet ID est au format suivant :

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

Remplacez PROJECT_NUMBER par le numéro de projet de votre projet Google Cloud.

AI Platform Training utilise automatiquement les identifiants de l'agent de service Cloud ML pour configurer l'authentification et l'autorisation si vous utilisez un module tfds de Tensorflow, des bibliothèques clientes Google Cloud ou d'autres outils utilisant la stratégie des identifiants par défaut de l'application.

Toutefois, si vous souhaitez que votre tâche de conteneur personnalisée accède à Google Cloud par d'autres moyens, vous devrez peut-être effectuer une configuration supplémentaire. Par exemple, si vous utilisez gsutil pour copier des données depuis Cloud Storage et la bibliothèque boto pour charger des identifiants à partir d'un fichier de configuration, ajoutez une commande au fichier Dockerfile. Cela permet de garantir que gsutil utilise les identifiants par défaut de l'agent de service Cloud ML :

RUN echo '[GoogleCompute]\nservice_account = default' > /etc/boto.cfg

Étape suivante