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 :

Créer un cluster GKE Autopilot (Vous pouvez également utiliser un cluster GKE Standard pour ce tutoriel.)
Créer un volume NFS Filestore
créer une file d'attente de tâches Redis dans le cluster ;
Transférez 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.
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 :

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

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.

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

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

Activer les API Compute Engine, GKE, and Filestore.

Activer les API

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

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

Activer les API Compute Engine, GKE, and Filestore.

Activer les API

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

Préparer l'environnement

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

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

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.

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

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.

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.

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.

Déployez la spécification du serveur Redis.

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

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.
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.
Complétez la file d'attente Redis.
```
sh scripts/queue-jobs.sh
```
Ce script transfère les chemins d'accès aux 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.
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 :

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

Déployer la charge de travail

Déployez le job :

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

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

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.

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.

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

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

Supprimez l'instance Filestore :

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

Supprimer le projet

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez é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.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

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