Déployer une charge de travail de machine learning par lot

Autopilot Standard

---

Ce tutoriel explique comment utiliser Google Kubernetes Engine (GKE) pour gérer des charges de travail par lot tolérantes aux pannes tout en limitant les coûts. Suivez ce tutoriel pour apprendre à utiliser des jobs et des pods Spot économiques, et à configurer une file d'attente de jobs Redis dans un cluster sur GKE.

Contexte

Une charge de travail par lot est un processus généralement conçu pour comporter un point de départ et un point d'achèvement. Vous devez envisager d'utiliser des charges de travail par lot sur GKE si votre architecture implique l'ingestion, le traitement et la génération de données au lieu d'utiliser des données brutes. Des domaines tels que le machine learning, l'intelligence artificielle et le calcul hautes performances comprennent différents types de charges de travail par lot, tels que l'entraînement de modèles hors connexion, la prédiction par lot, l'analyse de données, la simulation de systèmes physiques et le traitement de vidéos.

En concevant des charges de travail par lots conteneurisées, vous pouvez exploiter les avantages suivants de GKE:

• Un standard ouvert, une vaste communauté et un service géré.
• Optimiser la rentabilité grâce à une orchestration efficace de la charge de travail et de l'infrastructure, et à des ressources de calcul spécialisées.
• Isolation et portabilité de la conteneurisation, permettant l'utilisation du cloud comme capacité de débordement tout en maintenant la sécurité des données.
• Disponibilité de la capacité d'utilisation intensive, suivie d'un scaling à la baisse rapide des clusters GKE.

Objectifs

Ce tutoriel s'adresse aux ingénieurs en machine learning ou aux data scientists qui souhaitent apprendre à exécuter des charges de travail de machine learning par lots sur GKE, sur l'architecture économique et évolutive suivante:

Ce tutoriel couvre les étapes suivantes :

1. Créer un cluster GKE Autopilot (Vous pouvez également utiliser un cluster GKE Standard pour ce tutoriel.)
2. Créer un volume NFS Filestore
3. Créer une file d'attente de tâches Redis dans le cluster.
4. Transférer les ensembles de données vers le volume NFS et mettez-les en file d'attente pour qu'ils soient utilisés par la charge de travail.
5. Exécuter un exemple de charge de travail de machine learning par lot sur le cluster GKE

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

• Compute Engine
• GKE Autopilot
• Filestore

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

---

Pour obtenir des instructions détaillées sur cette tâche directement dans la console Google Cloud, cliquez sur Visite guidée :

Visite guidée

---

Avant de commencer

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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Compute Engine, GKE, and Filestore APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the Compute Engine, GKE, and Filestore APIs.

   Enable the APIs

8. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Préparer l'environnement

1. Clonez l'exemple de dépôt utilisé dans ce tutoriel :

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/batch/aiml-workloads
   

2. Créez un cluster GKE Autopilot :

   gcloud container clusters create-auto batch-aiml \
       --region=us-central1
   

   Cette étape peut prendre jusqu'à cinq minutes.

Configurer le stockage d'un ensemble de données avec un système de fichiers réseau (NFS)

La charge de travail de machine learning nécessite une solution de stockage pour les ensembles de données et les fichiers de sortie. Dans cette section, vous allez créer une instance Filestore et la rendre accessible à l'aide d'un objet PersistentVolume et PersistentVolumeClaim.

Pour en savoir plus, consultez les sections Comment concevoir une stratégie de stockage optimale et Comment accéder aux instances Filestore à partir de clusters GKE..

Créer une instance Filestore

1. Créez une instance Filestore :

   gcloud filestore instances create batch-aiml-filestore \
       --zone=us-central1-b \
       --tier=BASIC_HDD \
       --file-share=name="NFSVol",capacity=1TB \
       --network=name="default"
   

   Cette commande spécifie les options suivantes :

   • tier : niveau de service pour l'instance Filestore. Cet exemple utilise le niveau de base. Pour en savoir plus sur les autres options, consultez la page Niveaux de service.

   • network=name : nom du réseau cloud privé virtuel (VPC) de l'instance Filestore. Le cluster GKE doit se trouver dans le même réseau VPC que l'instance Filestore.

   • capacity : taille souhaitée du volume. Spécifiez la valeur de stockage dans l'une des unités compatibles décrites dans la section Quantités de ressources.

   Remarque :Cette étape peut prendre jusqu'à cinq minutes.

2. Vérifiez que l'instance Filestore a été déployée:

   gcloud filestore instances list \
       --project=PROJECT_ID \
       --zone=us-central1-b
   

   Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

   Le résultat ressemble à ce qui suit :

   INSTANCE_NAME: batch-aiml-filestore
   LOCATION: us-central1-b
   TIER: BASIC_HDD
   CAPACITY_GB: 1024
   FILE_SHARE_NAME: NFSVol
   IP_ADDRESS: 203.0.113.54
   STATE: READY
   CREATE_TIME: 2022-03-15T18:23:51
   

3. Notez la valeur du champ IP_ADDRESS. Vous allez l'utiliser dans la section suivante.

Créer un volume persistant

Une spécification Kubernetes PersistentVolume permet au cluster GKE de se connecter à l'instance Filestore.

1. Mettez à jour le fichier kubernetes-manifests/persistent-volume.yaml avec l'adresse IP de l'instance Filestore:

   sed -i "\
     s/<FILESTORE_IP_ADDRESS>/IP_ADDRESS/g" \
     kubernetes-manifests/persistent-volume.yaml
   

   Remplacez IP_ADDRESS par l'adresse IP que vous avez notée lors de la création de l'instance Filestore dans la section précédente.

2. Déployez le PersistentVolume :

   kubectl apply -f kubernetes-manifests/persistent-volume.yaml
   

Créer un objet PersistentVolumeClaim

Un objet Kubernetes PersistentVolumeClaim permet aux pods Kubernetes et aux jobs d'accéder aux ressources de stockage d'un PersistentVolume.

Déployez le PersistentVolumeClaim :

kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml

Utiliser le PersistentVolumeClaim

Une fois les objets PersistentVolume et PersistentVolumeClaim définis sur le cluster GKE, vous pouvez configurer le serveur Redis et les jobs par lot pour qu'ils utilisent le PersistentVolumeClaim. Il s'agit d'un volume de stockage installable.

Inspectez les fichiers kubernetes-manifests/redis-pod.yaml et kubernetes-manifests/workload.yaml. Les configurations du fichier manifeste sont similaires à celles-ci:

  spec:
  …
  containers:
  - name: workload
    image: "us-central1-docker.pkg.dev/gke-batch-aiml/batch-aiml-docker-repo/workload"
    volumeMounts:
    - mountPath: /mnt/fileserver
      name: workload-pvc
  volumes:
  - name: workload-pvc
    persistentVolumeClaim:
      claimName: fileserver-claim
      readOnly: false

Dans le fichier manifeste :

• spec.volumes spécifie le PersistentVolumeClaim à utiliser.
• spec.containers.volumeMounts spécifie le chemin d'accès au fichier local qui permet au pod d'accéder au partage de fichiers Filestore.

Configurer une file d'attente de tâches Redis

La charge de travail traite les données par lot pour entraîner un modèle de détection de fraude de manière itérative. Pour gérer les ensembles de données en cours de traitement ou toujours dans la file d'attente, déployez le serveur Redis dans le cluster GKE.

Dans ce tutoriel, vous démarrez une seule instance de Redis. Pour déployer Redis de manière évolutive et redondante, consultez la page Créer une application Web à plusieurs niveaux avec Redis et PHP.

1. Déployez la spécification du serveur Redis.

   kubectl apply -f kubernetes-manifests/redis-pod.yaml
   

2. Vérifiez qu'il est en cours d'exécution :

   kubectl get pods
   

   Le résultat ressemble à ce qui suit :

   NAME           READY   STATUS    RESTARTS   AGE
   redis-leader   1/1     Running   0          118s
   

   Il peut s'écouler jusqu'à deux minutes avant que le pod ne commence à s'exécuter.

3. Transférez les fichiers contenant les ensembles de données d'entraînement et de test vers le volume NFS.

   sh scripts/transfer-datasets.sh
   

   Ce script copie les fichiers de l'exemple de dépôt de code vers le répertoire /mnt/fileserver/datasets/ du pod redis-leader.

4. Complétez la file d'attente Redis.

   sh scripts/queue-jobs.sh
   

   Ce script transfère les chemins d'accès de fichiers des ensembles de données d'entraînement vers une liste nommée datasets dans la base de données Redis. Cette file d'attente sera utilisée par la charge de travail pour localiser l'ensemble de données suivant à traiter.

5. Déployez le service pour rendre le serveur Redis visible dans le cluster GKE.

   kubectl apply -f ./kubernetes-manifests/redis-service.yaml
   

Exécuter la charge de travail par lot

À ce stade, vous avez préparé le cluster GKE, la file d'attente de tâches Redis et le partage de fichiers. Vous pouvez maintenant exécuter votre charge de travail par lot.

Dans cette section, vous utilisez une image de conteneur d'un exemple de charge de travail pour entraîner un modèle de détection de fraude à l'aide de lots de données de transaction financière. Le processus d'entraînement peut se résumer comme suit :

1. Un client Redis revendique les jobs (chemins d'accès vers les ensembles de données) dans la file d'attente Redis et les supprime de la file d'attente une fois cette opération terminée.

2. Une classe de gestionnaire d'entraînement de modèles, FraudDetectionModelTrainer, charge un nouveau lot de données et, éventuellement, un état enregistré d'un modèle de machine learning. L'ensemble de données est utilisé pour affiner le modèle (processus appelé entraînement avec démarrage à chaud).

3. Le nouvel état du modèle et un rapport sur les détails du lot et les scores de performances sont enregistrés dans le volume NFS Filestore, qui est accessible via le PersistentVolumeClaim dans le cluster GKE.

Pour en savoir plus, explorer le code source.

Définir la tâche

Le fichier manifeste suivant décrit le job Kubernetes pour l'image de charge de travail par lot.

apiVersion: batch/v1
kind: Job
metadata:
  name: workload
spec:
  parallelism: 1
  template:
    metadata:
      name: workload
    spec:
      nodeSelector:
        cloud.google.com/gke-spot: "true"
      containers:
      - name: workload
        image: "us-docker.pkg.dev/google-samples/containers/gke/batch-ml-workload"
        volumeMounts:
        - mountPath: /mnt/fileserver
          name: workload-pvc
      volumes:
      - name: workload-pvc
        persistentVolumeClaim:
          claimName: fileserver-claim
          readOnly: false
      restartPolicy: OnFailure

Remarque : Si vous configurez une charge de travail où les lots peuvent être exécutés en parallèle (par exemple, la classification de lots d'images, l'analyse de données de longue durée, etc.), vous pouvez augmenter la valeur parallelism pour permettre à de nombreux pods d'exécuter le job simultanément jusqu'à ce que la condition d'achèvement soit remplie. La spécification nodeSelector indique à GKE d'utiliser les pods Spot.

Déployer la charge de travail

1. Déployez le job :

   kubectl apply -f ./kubernetes-manifests/workload.yaml
   

2. Vérifiez si l'état du pod workload-XXX est Completed :

   watch kubectl get pods
   

   Cette opération peut prendre quelques secondes. Vous pouvez revenir à la ligne de commande en appuyant sur Ctrl+C.

   Le résultat ressemble à ce qui suit :

   NAME             READY   STATUS      RESTARTS   AGE
   redis-leader     1/1     Running     0          16m
   workload-4p55d   0/1     Completed   0          83s
   

3. Vérifiez les journaux de la tâche workload:

   kubectl logs job/workload
   

   Le résultat ressemble à ce qui suit :

   Worker with sessionID: b50f9459-ce7f-4da8-9f84-0ab5c3233a72
   Initial queue state: empty=False
   Processing dataset: datasets/training/2018-04-04.pkl
   Processing dataset: datasets/training/2018-04-03.pkl
   Processing dataset: datasets/training/2018-04-02.pkl
   Processing dataset: datasets/training/2018-04-01.pkl
   Queue empty, exiting
   

   Les fichiers .pkl sont des sérialisations d'ensembles de données contenant un lot de transactions par carte de crédit, marquées comme valides ou frauduleuses. La tâche workload parcourt ces fichiers de manière itérative, en décompressant les ensembles de données et en les utilisant pour entraîner le modèle de machine learning, avant de les supprimer de la file d'attente Redis. La charge de travail continue de traiter les données par lots jusqu'à ce que la file d'attente Redis soit vidée, avant de quitter avec succès.

Explorer le volume NFS

Pendant son fonctionnement, la charge de travail crée des fichiers dans le volume NFS installé, accessible dans le cluster à d'autres jobs par lot ou à des applications en ligne.

1. Répertoriez les fichiers créés par la charge de travail:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "ls -1 /mnt/fileserver/output"
   

   Un résultat semblable aux lignes suivantes doit s'afficher:

   model_cpt_2018-04-01.pkl
   model_cpt_2018-04-02.pkl
   model_cpt_2018-04-03.pkl
   model_cpt_2018-04-04.pkl
   report.txt
   

   Les points de contrôle du modèle entraîné (noms de fichiers tels que model_cpt_XXX.pkl) et un rapport sur les performances du modèle (report.txt) ont été créés dans le répertoire /mnt/fileserver/output du volume NFS.

2. Examinez le rapport sur les performances du modèle.

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "cat /mnt/fileserver/output/report.txt"
   

   Voici un extrait de la sortie:

   Report generated on: 2022-02-09 14:19:42.303619
   Training dataset: 2018-04-04.pkl
   Model checkpoint: model_cpt_2018-04-04.pkl
   ---
   Accuracy on training data: 0.9981112277019937
   Accuracy on testing data: 0.9977204434773599
   

   Le fichier contient des entrées précisant l'heure d'entraînement, l'ensemble de données utilisé, la précision obtenue et le nom de fichier du point de contrôle du modèle associé à l'entraînement.

Pour en savoir plus sur les volumes NFS, consultez les guides Filestore.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer des ressources individuelles

Pour supprimer les ressources individuelles créées dans ce tutoriel, exécutez les commandes suivantes.

1. Supprimez le cluster à l'aide de la commande suivante :

   gcloud container clusters delete batch-aiml \
       --region=us-central1
   

2. Supprimez l'instance Filestore :

   gcloud filestore instances delete batch-aiml-filestore \
       --zone=us-central1-b
   

Supprimer le projet

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Étapes suivantes

• Consultez la documentation GKE.

• Découvrez les Volumes persistants plus en détail.

• Apprenez-en plus sur les tâches sur GKE.

• Découvrez comment utiliser des VM spot pour exécuter des charges de travail tolérantes aux pannes.

• Découvrez d'autres tutoriels Kubernetes Engine.

• Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.