Entraîner un modèle de ML avec des conteneurs personnalisés

Entraîner un modèle de ML avec des conteneurs personnalisés

AI Platform Training est compatible avec l'entraînement dans des conteneurs personnalisés, ce qui permet aux utilisateurs d'exécuter leurs propres conteneurs Docker disposant d'un framework ou d'un algorithme de ML pré-installé. Ce tutoriel décrit sommairement comment entraîner un modèle PyTorch sur AI Platform Traning à l'aide d'un conteneur personnalisé.

Présentation

Ce guide de démarrage présente le processus d'entraînement avec des conteneurs personnalisés sur AI Platform Training, à l'aide d'un modèle de base qui classe les chiffres manuscrits d'après l'ensemble de données MNIST.

Ce guide couvre les étapes suivantes :

• Configurer l'environnement local et le projet
• Créer un conteneur personnalisé
  • Écrire un fichier Dockerfile
  • Créer et tester votre image Docker localement
• Stocker l'image dans Container Registry
• Envoyer une tâche d'entraînement avec des conteneurs personnalisés
• Envoyer une tâche de réglage d'hyperparamètres
• Utiliser des GPU avec un conteneur personnalisé

Remarque : Container Registry est le seul registre de conteneurs compatible pour l'entraînement avec des conteneurs personnalisés.

Avant de commencer

Pour ce guide de démarrage, utilisez un environnement dans lequel Google Cloud CLI est installé.

Remarque : Il est possible que les environnements disposant de ressources de calcul et de mémoire limitées, tels que Cloud Shell, ne puissent pas compiler ni exécuter les images Docker utilisées dans ce tutoriel. Si vous rencontrez des problèmes avec Docker dans votre environnement local, envisagez d'exécuter ce tutoriel sur une machine virtuelle Compute Engine disposant de plus de ressources de calcul et de mémoire que votre machine locale. Vous pouvez également créer votre image Docker et la stocker dans Container Registry à l'aide de Cloud Build au lieu d'exécuter Docker sur votre ordinateur local.

Facultatif : Consultez les informations conceptuelles sur l'entraînement avec des conteneurs personnalisés.

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.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

3. Vérifiez que la facturation est activée pour votre projet Google Cloud.

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

   Activer les API

5. Installez Google Cloud CLI.

6. Pour initialiser gcloudCLI, exécutez la commande suivante :

   gcloud init

7. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

   Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

   Accéder au sélecteur de projet

8. Vérifiez que la facturation est activée pour votre projet Google Cloud.

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

   Activer les API

10. Installez Google Cloud CLI.

11. Pour initialiser gcloudCLI, exécutez la commande suivante :

    gcloud init

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

    Attention : Le groupe docker équivaut à l'utilisateur root. Reportez-vous à la documentation de Docker pour découvrir plus en détail comment cela affecte la sécurité de votre système.

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

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

14. Utilisez gcloud comme assistant d'identification pour Docker :

    gcloud auth configure-docker

15. Facultatif: Si vous souhaitez exécuter le conteneur à l'aide d'un GPU en local, installez nvidia-docker.

Configurer un bucket Cloud Storage

Vous trouverez dans cette section la procédure à suivre pour créer un bucket. Vous pouvez utiliser un bucket existant, mais il doit se trouver dans la même région que celle où vous prévoyez d'exécuter des tâches AI Platform. En outre, s'il ne fait pas partie du projet que vous utilisez pour exécuter AI Platform Training, vous devez explicitement accorder l'accès aux comptes de service AI Platform Training.

1. Indiquez un nom pour votre nouveau bucket. Ce nom doit être unique par rapport à tous les buckets dans Cloud Storage.

   BUCKET_NAME="YOUR_BUCKET_NAME"

   Par exemple, utilisez le nom de votre projet en ajoutant -aiplatform:

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

2. Vérifiez le nom du bucket que vous avez créé.

   echo $BUCKET_NAME

3. Sélectionnez une région pour votre bucket, puis définissez une variable d'environnement REGION.

   Utilisez la même région que celle où vous prévoyez d'exécuter des tâches AI Platform Training. Consultez les régions disponibles pour les services AI Platform Training.

   Par exemple, le code suivant crée REGION et le définit sur us-central1:

   REGION=us-central1

4. Créez le bucket :

   gsutil mb -l $REGION gs://$BUCKET_NAME

Télécharger le code pour ce tutoriel

1. Saisissez la commande suivante pour télécharger le fichier ZIP AI Platform Training :

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

2. Décompressez le fichier pour extraire le répertoire cloudml-samples-master.

   unzip master.zip
   

3. Accédez au répertoire cloudml-samples-master > pytorch > containers > quickstart > mnist : Les commandes de cette présentation doivent être exécutées à partir du répertoire mnist.

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

Créer un conteneur personnalisé

Pour créer un conteneur personnalisé, la première étape consiste à définir un fichier Dockerfile afin d'installer les dépendances requises pour la tâche d'entraînement. Ensuite, vous créez et testez votre image Docker localement pour la vérifier avant de l'utiliser avec AI Platform Training.

Écrire un fichier Dockerfile

L'exemple de fichier Dockerfile fourni dans ce tutoriel réalise les étapes suivantes :

1. Il utilise une image de base Python 2.7 avec des dépendances Python intégrées.
2. Il installe des dépendances supplémentaires, y compris PyTorch, la CLI gcloud et cloudml-hypertune pour le réglage d'hyperparamètres.
3. Il copie le code de votre application d'entraînement dans le conteneur.
4. Il configure le point d'entrée pour AI Platform Training pour exécuter votre code d'entraînement lorsque le conteneur est en cours de démarrage.

Le fichier Dockerfile peut inclure une logique supplémentaire, en fonction de vos besoins. Apprenez-en plus sur l'écriture de fichiers 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"]

Créer et tester votre image 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=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. Vérifiez l'image en l'exécutant localement dans un nouveau conteneur. Notez que l'indicateur --epochs est transmis au script de l'outil d'entraînement.

   docker run $IMAGE_URI --epochs 1
   

Stocker l'image dans Container Registry

Si l'exécution locale fonctionne, vous pouvez stocker l'image Docker dans Container Registry pour votre projet.

Remarque : Si vos images Container Registry et vos tâches d'entraînement AI Platform se trouvent dans des projets Google Cloud différents, vous devez configurer les autorisations de sorte que votre projet AI Platform Training ait accès à votre projet Container Registry. Pour en savoir plus, consultez la section Gérer les autorisations Container Registry.

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

docker push $IMAGE_URI

Envoyer et surveiller la tâche

1. Définissez des variables d'environnement pour votre requête de tâche.

   • MODEL_DIR nomme un nouveau répertoire horodaté dans votre bucket Cloud Storage, dans lequel le fichier de modèle enregistré est stocké une fois l'entraînement terminé.
   • REGION spécifie une région valide pour l'entraînement AI Platform.

   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. Envoyez la tâche d'entraînement à AI Platform Training à l'aide de la CLI gcloud. Transmettez l'URI à votre image Docker à l'aide de l'indicateur --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. Une fois que vous avez envoyé la tâche, vous pouvez surveiller son état et diffuser des journaux :

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

Remarque : Vous pouvez également spécifier différentes images à utiliser pour les nœuds de calcul et les serveurs de paramètres dans l'entraînement distribué, à l'aide des indicateurs gcloud --worker-image-uri et --parameter-server-image-uri. Apprenez-en plus sur l'entraînement distribué avec des conteneurs personnalisés

.

Envoyer une tâche de réglage d'hyperparamètres

Une tâche de réglage d'hyperparamètres nécessite quelques ajustements. Notez les points suivants dans l'exemple de code :

• L'exemple de fichier Dockerfile inclut le package cloudml-hypertune afin de l'installer dans le conteneur personnalisé.
• L'exemple de code (mnist.py) :
  • Il utilise cloudml-hypertune pour signaler les résultats de chaque essai en appelant sa fonction d'aide, report_hyperparameter_tuning_metric. L'exemple de code rapporte les résultats du réglage d'hyperparamètres après l'évaluation, sauf si la tâche n'est pas envoyée en tant que tâche de réglage d'hyperparamètres.
  • Il ajoute des arguments de ligne de commande pour chaque hyperparamètre et gère l'analyse des arguments avec argparse.
• La requête de tâche inclut HyperparameterSpec dans l'objet TrainingInput. Dans ce cas, nous ajustons --lr et --momentum afin de minimiser la perte de modèle.

1. Créez un fichier config.yaml pour définir votre spécification d'hyperparamètres. Redéfinissez MODEL_DIR et JOB_NAME. Si vous ne l'avez pas déjà fait, définissez l'élément REGION :

   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. Envoyez la tâche de réglage des hyperparamètres à 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"
   

Utiliser des GPU avec des conteneurs personnalisés

Pour envoyer une tâche de conteneur personnalisé utilisant des GPU, vous devez créer une image Docker différente de celle que vous avez utilisée précédemment. Nous avons fourni un exemple de fichier Dockerfile destiné à être utilisé avec des GPU répondant aux exigences suivantes :

• 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.
• Installez des dépendances supplémentaires, telles que wget, curl, pip et toute autre dépendance requise par votre application d'entraînement.

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

Créer et tester l'image Docker de GPU localement

1. Créez une image pour votre tâche d'entraînement avec des GPU en utilisant le fichier Dockerfile du GPU. Pour éviter de remplacer l'image de processeur, vous devez redéfinir IMAGE_REPO_NAME et IMAGE_TAG avec des noms différents de ceux que vous avez utilisés précédemment dans ce tutoriel.

   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 des GPU sont disponibles sur votre machine et que vous avez installé nvidia-docker, vous pouvez valider l'image en l'exécutant localement :

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

3. Stockez l'image Docker dans Container Registry. Commencez par exécuter gcloud auth configure-docker si vous ne l'avez pas déjà fait.

   docker push $IMAGE_URI
   

Envoyer la tâche

Cet exemple utilise le niveau d'évolutivité d'évolutivité GPU de base pour envoyer la requête de tâche d'entraînement. Consultez les autres options de machine pour l'entraînement avec des GPU.

1. Redéfinissez MODEL_DIR et JOB_NAME. Si vous ne l'avez pas déjà fait, définissez REGION:

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

Étapes suivantes

• Découvrez les concepts liés à l'utilisation de conteneurs.
• Apprenez-en plus sur l'entraînement distribué avec des conteneurs personnalisés.