Cette page a été traduite par l'API Cloud Translation.

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

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.

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 \
    --location=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 objet PersistentVolume

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 le job

Le fichier manifeste suivant décrit le job Kubernetes pour l'image de charge de travail par lot. Dans Kubernetes, un contrôleur Job crée un ou plusieurs pods et s'assure qu'ils exécutent correctement une tâche spécifique.

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.