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é

Avant de commencer

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

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

  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, vous pouvez utiliser 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 la variable REGION et la définit sur us-central1 :

    REGION=us-central1

  4. Créez le bucket :

    gcloud storage buckets create gs://$BUCKET_NAME --location=$REGION

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.

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
.

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) réalisé les actions suivantes :
    • 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é de GPU de base pour envoyer la requête de tâche d'entraînement. Consultez les autres options relatives aux machines pour l'entraînement avec des GPU.

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

    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

Étape suivante