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

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

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 tâches et des VM spot économiques, et à configurer une file d'attente de tâches Redis dans le cluster sur GKE.

Expérience

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:

Schéma de l'architecture

Ce tutoriel couvre les étapes suivantes :

  1. Créer un cluster GKE avec des pools de nœuds VM standards et Spot.
  2. Créez un volume NFS Filestore.
  3. créer une file d'attente de tâches Redis dans le cluster ;
  4. 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.
  5. Exécuter un exemple de charge de travail de machine learning par lot sur le cluster GKE

Coûts

Ce tutoriel utilise 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

Configurer votre projet

  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, cliquez sur Créer un projet pour commencer à créer un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

  4. Activer les API Compute Engine, GKE, and Filestore.

    Activer les API

  5. Dans Google Cloud Console, sur la page de sélection du projet, cliquez sur Créer un projet pour commencer à créer un projet Google Cloud.

    Accéder au sélecteur de projet

  6. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

  7. Activer les API Compute Engine, GKE, and Filestore.

    Activer les API

Configurer votre environnement

Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées sur Google Cloud. Cloud Shell est préinstallé avec Docker et les CLI kubectl et gcloud.

Pour utiliser Cloud Shell afin de configurer votre environnement, procédez comme suit :

  1. Dans Google Cloud Console, démarrez une instance Cloud Shell.
    Ouvrir Cloud Shell

  2. Téléchargez le code source pour cet exemple d'application.

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    
    cd kubernetes-engine-samples/batch/aiml-workloads
    
  3. Mettez à jour le fichier scripts/variables.sh avec les informations de votre projet:

    sed -i "\
      s/<YOUR_PROJECT_ID>/PROJECT_ID/g; \
      s/<YOUR_REGION>/REGION/g; \
      s/<YOUR_ZONE>/ZONE/g" \
      scripts/variables.sh
    

    Remplacez les éléments suivants :

  4. Définissez les variables d'environnement et les valeurs par défaut gcloud nécessaires.

    source scripts/variables.sh
    gcloud config set project ${PROJECT_ID}
    gcloud config set compute/region ${REGION}
    gcloud config set compute/zone ${ZONE}
    gcloud config set filestore/zone ${ZONE}
    

Créer un cluster GKE

Créer un cluster GKE avec deux pools de nœuds dans lesquels GKE héberge le volume persistant et exécute la charge de travail avec la file d'attente de tâches Redis.

  1. Créez un cluster GKE standard. Ce cluster initialise un pool de nœuds avec des configurations par défaut.

    gcloud container clusters create ${CLUSTER_NAME} \
      --machine-type=e2-standard-2 --num-nodes=3
    
  2. Vérifiez que le cluster GKE est en cours d'exécution:

    gcloud container clusters list
    

    La valeur STATUS est RUNNING pour le cluster batch-aiml.

  3. Créez un deuxième pool de nœuds dans le cluster GKE qui sera activé avec les VM Spot:

    gcloud beta container node-pools create batch-node-pool \
      --cluster=${CLUSTER_NAME} --spot
    

    Vous déploierez la charge de travail par lot sur ce pool de nœuds de VM spot plus tard dans le tutoriel.

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 ce tutoriel, vous allez créer une instance Filestore, qui est accessible par tous les nœuds (opérations de lectureet d'écriture) dans un cluster GKE via un Volume persistant (PV) et une Revendication de volume persistant (PVC).

Pour en savoir plus, consultez les pages Concevoir une stratégie de stockage optimale et Accéder aux partages de fichiers depuis les clusters GKE.

Créer une instance Filestore

  1. Créez une instance Filestore :

    gcloud filestore instances create ${FILESTORE_ID} \
      --tier=BASIC_HDD \
      --file-share=name="NFSVol",capacity=1TB \
      --network=name="default"
    

    où :

    • tier est le niveau de service pour l'instance Filestore. Cet exemple utilise l'offre de base, mais vous pouvez en savoir plus sur les autres options sur les niveaux de service.

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

    • capacity correspond à la 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.

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

    gcloud filestore instances list --project=${PROJECT_ID} --zone=${ZONE}
    

    Le résultat ressemble à ce qui suit, où la valeur STATE est READY pour l'instance batch-aiml-filestore:

    INSTANCE_NAME: batch-aiml-filestore
    LOCATION: us-central1-b
    TIER: BASIC_HDD
    CAPACITY_GB: 1024
    FILE_SHARE_NAME: NFSVol
    IP_ADDRESS: 10.152.101.10
    STATE: READY
    CREATE_TIME: 2022-03-15T18:23:51
    
  3. Dans le résultat, notez la valeur IP_ADDRESS. Vous allez l'utiliser dans la section suivante.

Créer un volume persistant

Une spécification de Volume persistant (PV) Kubernetes 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 la valeur que vous avez notée lors de la création de l'instance Filestore.

  2. Déployez la spécification du PV:

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

Créer une revendication de volume persistant

Une spécification de revendication de volume persistant (PVC) Kubernetes permet aux pods Kubernetes et aux tâches d'accéder aux ressources de stockage d'un volume persistant.

Déployez la spécification PVC:

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

Utiliser la revendication de volume persistant

Avec le volume persistant et la revendication de volume persistant configurés sur le cluster GKE, vous pouvez configurer le serveur Redis et les tâches par lot pour qu'ils utilisent le PVC. Il s'agira d'un volume de stockage installable dans la VM exécutant les ressources Kubernetes.

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

où :

  • spec.volumes spécifie les revendications de volume persistant à utiliser.

  • spec.containers.volumeMounts spécifie le chemin d'accès au fichier local sur la VM où le partage de fichiers Filestore est accessible.

Configurer une file d'attente de tâches Redis

La charge de travail traitera les données par lots pour entraîner le 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.

Pour des raisons de simplicité, vous démarrez une seule instance de Redis dans cet exemple. Pour obtenir un exemple de déploiement Redis redondant et de manière évolutive, découvrez comment créer un livre d'or avec Redis et PHP.

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

    kubectl apply -f kubernetes-manifests/redis-pod.yaml
    
  2. Vérifiez que le pod est en cours d'exécution avant de continuer. Dans le résultat de la commande suivante, le champ STATUS pour le pod redis-leader doit être Running.

    kubectl get pods
    

    Le résultat ressemble à ce qui suit :

    NAME           READY   STATUS    RESTARTS   AGE
    redis-leader   1/1     Running   0          118s
    
  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 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.

  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 allez utiliser 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 tâches (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 revendication de volume persistant dans le cluster GKE.

Pour en savoir plus, explorer le code source.

Définir la tâche

Le fichier manifeste suivant décrit la spécification de tâche par lot pour l'image de charge de travail. Ce fichier manifeste utilise la ressource de tâche Kubernetes.

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

  1. Appliquez la spécification pour la tâche par lot.

    kubectl apply -f ./kubernetes-manifests/workload.yaml
    
  2. Vérifiez si l'état du pod workload-XXX est terminé.

    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 à l'ensemble du cluster à d'autres tâches par lots ou à des applications en ligne. Pour explorer les fichiers du volume NFS, procédez comme suit:

  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.

Pour supprimer les ressources individuelles créées pour ce tutoriel, procédez comme suit:

sh scripts/cleanup.sh

Étape suivante