Esegui il deployment di un carico di lavoro di machine learning in batch

prepara l'ambiente

1. Clona il repository di esempio utilizzato in questo tutorial:

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

2. Crea un cluster GKE Autopilot:

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

   Il completamento di questo passaggio può richiedere fino a 5 minuti.

Configura l'archiviazione dei set di dati con un file system di rete (NFS)

Il carico di lavoro di machine learning richiede una soluzione di archiviazione per i set di dati e i file di output. In questa sezione creerai un'istanza Filestore e fornisci l'accesso all'istanza utilizzando un PersistentVolume e un PersistentVolumeClaim.

Per saperne di più, consulta come progettare una strategia di archiviazione ottimale e come accedere alle istanze Filestore dai cluster GKE.

Crea un'istanza di Filestore

1. Crea un'istanza di Filestore:

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

   Questo comando specifica le seguenti opzioni:

   • tier: il livello di servizio per l'istanza Filestore. In questo esempio viene utilizzato il livello base. Per saperne di più sulle altre opzioni, consulta Livelli di servizio.

   • network=name: il nome della rete Virtual Private Cloud (VPC) per l'istanza Filestore. Il cluster GKE deve trovarsi nella stessa rete VPC dell'istanza Filestore.

   • capacity: la dimensione desiderata del volume. Specifica il valore di archiviazione in una delle unità supportate descritte in Quantità delle risorse.

2. Verifica che sia stato eseguito il deployment dell'istanza Filestore:

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

   Sostituisci PROJECT_ID con l'ID progetto Google Cloud.

   L'output è simile al seguente:

   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. Prendi nota del valore del campo IP_ADDRESS da utilizzare nella sezione seguente.

Crea un PersistentVolume

Una specifica di Kubernetes PersistentVolume consente al cluster GKE di connettersi all'istanza Filestore.

1. Aggiorna il file kubernetes-manifests/persistent-volume.yaml con l'indirizzo IP dell'istanza Filestore:

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

   Sostituisci IP_ADDRESS con l'indirizzo IP che hai annotato durante la creazione dell'istanza Filestore nella sezione precedente.

2. Esegui il deployment del PersistentVolume:

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

Crea un PersistentVolumeClaim

Un oggetto PersistentVolumeClaim di Kubernetes consente ai pod e ai job Kubernetes di accedere alle risorse di archiviazione di un PersistentVolume.

Esegui il deployment di PersistentVolumeClaim:

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

Utilizzare PersistentVolumeClaim

Con PersistentVolume e PersistentVolumeClaim configurati sul cluster GKE, puoi configurare il server Redis e i job batch per consumare PersistentVolumeClaim. Appare come volume di archiviazione montabile.

Esamina i file kubernetes-manifests/redis-pod.yaml e kubernetes-manifests/workload.yaml. Le configurazioni del file manifest sono simili alle seguenti:

  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

In questo file manifest:

• spec.volumes specifica l'oggetto PersistentVolumeClaim da utilizzare.
• spec.containers.volumeMounts specifica il percorso file locale da cui il pod può accedere alla condivisione file Filestore.

Configura una coda di job Redis

Il carico di lavoro elabora i dati in batch per addestrare iterativamente un modello di rilevamento di attività fraudolente. Per gestire i set di dati attualmente in fase di elaborazione o ancora in coda, esegui il deployment del server Redis nel cluster GKE.

Per questo tutorial, avvierai una singola istanza di Redis. Per eseguire il deployment di Redis in modo scalabile e ridondante, consulta Creare un'applicazione web multi-livello con Redis e PHP.

1. Esegui il deployment della specifica del server Redis.

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

2. Verifica che il pod sia in esecuzione:

   kubectl get pods
   

   L'output è simile al seguente:

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

   L'esecuzione del pod potrebbe richiedere fino a due minuti.

3. Trasferisci i file contenenti i set di dati di addestramento e test nel volume NFS.

   sh scripts/transfer-datasets.sh
   

   Questo script copia i file dal repository del codice campione alla directory /mnt/fileserver/datasets/ nel pod redis-leader.

4. Popola la coda Redis.

   sh scripts/queue-jobs.sh
   

   Questo script esegue il push dei percorsi di file per i set di dati di addestramento in un elenco denominato datasets nel database Redis. Questa coda verrà utilizzata dal carico di lavoro per individuare il successivo set di dati da elaborare.

5. Esegui il deployment del servizio per rendere il server Redis rilevabile all'interno del cluster GKE.

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

Esegui il carico di lavoro batch

A questo punto, hai preparato il cluster GKE, la coda del job Redis e la condivisione di file. Ora puoi eseguire il carico di lavoro in batch.

In questa sezione utilizzerai un'immagine container di un carico di lavoro di esempio per addestrare un modello di rilevamento delle frodi utilizzando batch di dati di transazioni finanziarie. Il processo di addestramento può essere sintetizzato come segue:

1. Un client Redis rivendica i job (percorsi di file ai set di dati) nella coda Redis e li rimuove dalla coda al termine.

2. Una classe di gestore di addestramento dei modelli, FraudDetectionModelTrainer, carica un nuovo batch di dati e, facoltativamente, lo stato salvato di un modello di machine learning. Il set di dati viene utilizzato per perfezionare il modello (un processo noto come addestramento"avviamento a caldo").

3. Il nuovo stato del modello e un report con i dettagli e i punteggi delle prestazioni del batch vengono salvati nel volume NFS di Filestore, a cui è possibile accedere nel cluster GKE utilizzando un PersistentVolumeClaim.

Per saperne di più, esplora il codice sorgente.

Definisci il job

Il seguente manifest descrive il job Kubernetes per l'immagine del carico di lavoro batch.

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

Esegui il deployment del carico di lavoro

1. Esegui il deployment del job:

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

2. Controlla se lo stato del pod workload-XXX è Completed:

   watch kubectl get pods
   

   L'operazione potrebbe richiedere alcuni secondi. Puoi tornare alla riga di comando premendo Ctrl+C.

   L'output è simile al seguente:

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

3. Controlla i log del job workload:

   kubectl logs job/workload
   

   L'output è simile al seguente:

   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
   

   I file .pkl sono serializzazioni di set di dati contenenti un batch di transazioni con carte di credito, contrassegnate come valide o fraudolente. Il job workload esegue l'iterazione su questi file, decomprimendo i set di dati e utilizzandoli per addestrare il modello di machine learning, prima di rimuoverli dalla coda Redis. Il carico di lavoro continua a elaborare i dati in batch, finché la coda Redis non viene svuotata, prima di essere chiuso correttamente.

Esplora il volume NFS

Durante il funzionamento, il carico di lavoro crea file nel volume NFS montato, accessibili nel cluster da altri job batch o applicazioni online.

1. Elenca i file creati dal carico di lavoro:

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

   L'output dovrebbe essere simile all'esempio seguente:

   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
   

   I punti di controllo per il modello addestrato (nomi di file come model_cpt_XXX.pkl) e un report sulle prestazioni del modello (report.txt) sono stati creati nella directory /mnt/fileserver/output sul volume NFS.

2. Esamina il report sulle prestazioni del modello:

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

   Di seguito è riportato uno snippet dell'output:

   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
   

   Il file contiene le voci che descrivono nel dettaglio la data/ora di addestramento, il set di dati utilizzato, l'accuratezza raggiunta e il nome file del checkpoint del modello associato all'addestramento.

Per scoprire di più sui volumi NFS, consulta le guide di Filestore.