Deployment di un carico di lavoro di machine learning in batch


Questo tutorial mostra come utilizzare Google Kubernetes Engine (GKE) per gestire i carichi di lavoro in batch a tolleranza di errore mantenendo bassi i costi. Segui questo tutorial per scoprire come utilizzare i job e le VM Spot ottimizzate per i costi nonché come configurare una coda di job Redis su cluster su GKE.

Contesto

Un carico di lavoro batch è un processo generalmente progettato per avere un punto di inizio e di completamento. Ti conviene prendere in considerazione i carichi di lavoro in batch su GKE se la tua architettura prevede l'importazione, l'elaborazione e l'output dei dati, invece di utilizzare dati non elaborati. Aree come machine learning, intelligenza artificiale e computing ad alte prestazioni (HPC) presentano diversi tipi di carichi di lavoro in batch, come addestramento di modelli offline, previsioni in batch, analisi di dati, simulazione di sistemi fisici ed elaborazione video.

La progettazione di carichi di lavoro in batch containerizzati ti consente di sfruttare i seguenti vantaggi di GKE:

  • Un servizio aperto, ampio e gestito dalla community.
  • Efficienza in termini di costi grazie all'orchestrazione efficiente del carico di lavoro e dell'infrastruttura e a risorse di calcolo specializzate.
  • Isolamento e portabilità della containerizzazione, che consente di utilizzare il cloud come capacità di overflow mantenendo al contempo la sicurezza dei dati.
  • Disponibilità della capacità dei burst, seguita da una rapida scalabilità dei cluster GKE.

Obiettivi

Questo tutorial è rivolto agli ingegneri del machine learning o ai data scientist che vogliono imparare a eseguire carichi di lavoro di machine learning batch su GKE, sulla seguente architettura scalabile e conveniente:

Diagramma dell'architettura

Questo tutorial illustra i seguenti passaggi:

  1. Creare un cluster GKE con pool di nodi VM standard e Spot.
  2. Crea un volume Filestore NFS.
  3. Crea una coda di job Redis nel cluster.
  4. Trasferisci i set di dati al volume NFS e mettili in coda per utilizzarli al carico di lavoro.
  5. Esegui un carico di lavoro di machine learning in batch di esempio sul cluster GKE.

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono beneficiare di una prova gratuita.

Prima di iniziare

Configura il progetto

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. In Google Cloud Console, nella pagina del selettore dei progetti, fai clic su Crea progetto per iniziare a creare un nuovo progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API Compute Engine, GKE, and Filestore.

    Abilita le API

  5. In Google Cloud Console, nella pagina del selettore dei progetti, fai clic su Crea progetto per iniziare a creare un nuovo progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  7. Abilita le API Compute Engine, GKE, and Filestore.

    Abilita le API

Configura l'ambiente

In questo tutorial, utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell viene fornito preinstallato con Docker e tramite l'interfaccia a riga di comando kubectl e gcloud.

Per utilizzare Cloud Shell per configurare il tuo ambiente:

  1. In Google Cloud Console, avvia un'istanza di Cloud Shell.
    Apri Cloud Shell

  2. Scarica il codice sorgente per questa app di esempio.

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    
    cd kubernetes-engine-samples/batch/aiml-workloads
    
  3. Aggiorna il file scripts/variables.sh con le informazioni del progetto:

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

    Sostituisci quanto segue:

  4. Imposta le variabili di ambiente e le impostazioni predefinite di gcloud necessarie.

    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}
    

Crea un cluster GKE

Crea un cluster GKE con due pool di nodi in cui GKE ospita il volume permanente ed esegue il carico di lavoro con la coda dei job Redis.

  1. Crea un cluster GKE standard. Questo cluster inizializza un pool di nodi con configurazioni predefinite.

    gcloud container clusters create ${CLUSTER_NAME} \
      --machine-type=e2-standard-2 --num-nodes=3
    
  2. Verifica che il cluster GKE sia in esecuzione:

    gcloud container clusters list
    

    Il valore STATUS è RUNNING per il cluster batch-aiml.

  3. Crea un secondo pool di nodi nel cluster GKE che verrà abilitato con le Spot VM:

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

    Eseguirai il deployment del carico di lavoro in batch nel pool di nodi VM Spot in un secondo momento nel tutorial.

Configurare 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 questo tutorial, creerai un'istanza Filestore, accessibile da tutti i nodi (operazioni di lettura e scrittura) in un cluster GKE tramite un volume permanente (PV) e una rivendicazione del volume permanente (PVC).

Per saperne di più, scopri come progettare una strategia di archiviazione ottimale e come accedere alle condivisioni file dai cluster GKE.

Creazione di un'istanza Filestore

  1. Crea un'istanza Filestore:

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

    dove:

    • tier è il livello di servizio per l'istanza Filestore. Questo esempio utilizza l'offerta di base, ma puoi scoprire le altre opzioni in Livelli di servizio.

    • network=name è il nome della rete Virtual Private Cloud (VPC) di Compute Engine a cui è collegata l'istanza. Il cluster GKE deve trovarsi nella stessa rete VPC dell'istanza Filestore.

    • capacity indica la dimensione del volume desiderata. 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=${ZONE}
    

    L'output è simile al seguente, in cui il valore STATE è READY per l'istanza 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. Dall'output, prendi nota del valore IP_ADDRESS, che verrà utilizzato nella sezione successiva.

Crea un volume permanente

Una specifica di Volume permanente (PV) di Kubernetes consente al cluster GKE di connettersi all'istanza di 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 il valore indicato durante la creazione dell'istanza Filestore.

  2. Esegui il deployment della specifica PV:

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

Crea una richiesta di volume permanente

Una specifica di Richiesta di volume permanente (PVC) di Kubernetes consente ai pod e ai job di Kubernetes di accedere alle risorse di archiviazione di un volume permanente.

Esegui il deployment della specifica PVC:

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

Consuma la rivendicazione di volume permanente

Dopo aver configurato la richiesta di volumi permanenti sul cluster GKE, puoi configurare il server Redis e i job batch per consumare la PVC. Verrà visualizzato come volume di archiviazione montabile nella VM che esegue le risorse Kubernetes.

Esamina i file kubernetes-manifests/redis-pod.yaml e kubernetes-manifests/workload.yaml. Le configurazioni dei 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

dove:

  • spec.volumes specifica le richieste di volumi permanenti da consumare.

  • spec.containers.volumeMounts specifica il percorso del file locale sulla VM in cui è possibile accedere alla condivisione file di Filestore.

Configurare una coda di job Redis

Il carico di lavoro elabora i dati in batch per addestrare iterativo il modello di rilevamento delle frodi. 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 semplicità, avvii una singola istanza di Redis in questo esempio. Per un esempio di deployment di Redis scalabile e ridondante, scopri come creare un guestbook con Redis e PHP.

  1. Esegui il deployment della specifica del server Redis.

    kubectl apply -f kubernetes-manifests/redis-pod.yaml
    
  2. Prima di procedere, verifica che il pod sia in esecuzione. Nell'output del comando seguente, STATUS per il pod redis-leader dovrebbe essere Running.

    kubectl get pods
    

    L'output è simile al seguente:

    NAME           READY   STATUS    RESTARTS   AGE
    redis-leader   1/1     Running   0          118s
    
  3. Trasferisci i file contenenti i set di dati di addestramento e test al volume NFS.

    sh scripts/transfer-datasets.sh
    

    Questo script copia i file dal repository di codice di esempio nella directory /mnt/fileserver/datasets/ del pod redis-leader.

  4. Completa la coda Redis.

    sh scripts/queue-jobs.sh
    

    Questo script esegue il push dei percorsi dei file per i set di dati di addestramento a un elenco denominato datasets nel database Redis. Questa coda verrà utilizzata dal carico di lavoro per individuare il set di dati successivo 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 in batch

A questo punto, hai preparato il cluster GKE, la coda del job Redis e la condivisione file. Ora, puoi eseguire il tuo 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 attività fraudolente utilizzando gruppi di dati delle transazioni finanziarie. Il processo di formazione può essere riepilogati come:

  1. Un client Redis rivendica i job (percorso dei file ai set di dati) nella coda Redis e li rimuove dalla coda una volta completata.

  2. Una classe gestore di addestramento di modelli, FraudDetectionModelTrainer, carica un nuovo gruppo di dati e, facoltativamente, uno stato salvato di un modello di machine learning. Il set di dati viene utilizzato per perfezionare il modello (un processo noto come "warm-start" addestramento).

  3. Il nuovo stato del modello e un report dei dettagli dei batch e dei punteggi delle prestazioni vengono salvati nel volume NFS di Filestore, a cui è possibile accedere nel cluster GKE tramite una richiesta di volume permanente.

Per saperne di più, esplora il codice sorgente.

Definisci il job

Il file manifest seguente descrive la specifica del job batch per l'immagine del carico di lavoro. Questo manifest utilizza la risorsa del job 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

Esegui il deployment del carico di lavoro

  1. Applica la specifica per il job batch.

    kubectl apply -f ./kubernetes-manifests/workload.yaml
    
  2. Controlla che lo stato del pod workload-XXX sia completo.

    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 serie di set di dati contenenti un gruppo di transazioni con carta di credito contrassegnate come valide o fraudolente. Il job workload ripete l'iterazione di questi file, decomprimendo i set di dati e utilizzandoli per l'addestramento del modello di machine learning, prima di rimuoverli dalla coda Redis. Prima di uscire con successo, il carico di lavoro continua a elaborare i dati in batch, fino all'svuotamento della coda Redis.

Esplora il volume NFS

Durante il suo funzionamento, il carico di lavoro crea file nel volume NFS montato, accessibile in tutto il cluster ad altri job batch o applicazioni online. Per esplorare i file nel volume NFS:

  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 il 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 rapporto sulle prestazioni del modello (report.txt) sono stati creati nella directory /mnt/fileserver/output sul volume NFS.

  2. Esamina il report sul rendimento 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 voci che descrivono i dettagli dell'ora per l'addestramento, il set di dati utilizzato, la precisione raggiunta e il nome file del checkpoint del modello associato all'addestramento.

Per ulteriori informazioni sui volumi NFS, consulta le guide di Filestore.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Per rimuovere le singole risorse create per questo tutorial:

sh scripts/cleanup.sh

Passaggi successivi