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

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

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

Premesse

Un carico di lavoro in batch è un processo solitamente progettato per avere un punto di inizio e una di completamento. Dovresti considerare 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, ad esempio addestramento di modelli offline, previsione in batch, analisi di dati, simulazione di sistemi fisici ed elaborazione di video.

Progettando carichi di lavoro batch containerizzati, puoi sfruttare i seguenti vantaggi di GKE:

  • Un servizio aperto standard, community ampia e gestita.
  • Efficienza dei costi da un'efficace orchestrazione dei carichi di lavoro e dell'infrastruttura e risorse di calcolo specializzate.
  • Isolamento e portabilità della containerizzazione, che consente l'utilizzo del cloud come capacità di overflow mantenendo la sicurezza dei dati.
  • Disponibilità di capacità di burst, seguita da scale down rapido dei cluster GKE.

Obiettivi

Questo tutorial è rivolto ai tecnici del machine learning o ai data scientist che vogliono imparare a eseguire carichi di lavoro di machine learning in 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 di VM standard e VM spot.
  2. Crea un volume Filestore NFS.
  3. Creare una coda di job Redis nel cluster.
  4. Trasferire i set di dati nel volume NFS e accodarli per l'utilizzo da parte del carico di lavoro.
  5. Eseguire un carico di lavoro di esempio del machine learning in batch 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.


Per seguire le indicazioni dettagliate per questa attività direttamente in Google Cloud Console, fai clic su Procedura guidata:

Procedura guidata


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. Nella pagina del selettore dei progetti nella console di Google Cloud, fai clic su Crea progetto per iniziare a creare un nuovo progetto di 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. Nella pagina del selettore dei progetti nella console di Google Cloud, fai clic su Crea progetto per iniziare a creare un nuovo progetto di 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 è preinstallato in Docker e nell'interfaccia a riga di comando kubectl e gcloud.

Per utilizzare Cloud Shell per configurare il tuo ambiente:

  1. Nella console Google Cloud, 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 i valori predefiniti gcloud necessari.

    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 VM Spot:

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

    Eseguirai il deployment del carico di lavoro in batch in questo pool di nodi VM Spot più avanti nel tutorial.

Configurare l'archiviazione del 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) in un cluster GKE tramite un volume permanente (PV) e una rivendicazione del volume permanente (PVC).

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

Crea un'istanza di Filestore

  1. Crea un'istanza di 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 è connessa l'istanza. Il cluster GKE deve trovarsi nella stessa rete VPC dell'istanza di Filestore.

    • capacity è la dimensione del volume che vuoi. 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, dove 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; verrà utilizzato nella sezione successiva.

Crea un volume permanente

Una specifica del 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 di 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 rivendicazione di volume permanente

Una specifica di Richiesta di volume permanente (PVC) 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

Utilizza la rivendicazione del volume permanente

Dopo aver configurato le richieste di volumi permanenti e volumi permanenti nel cluster GKE, puoi configurare il server Redis e i job batch per consumare la PVC. Questo 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 del 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.

Configura una coda di job Redis

Il carico di lavoro elaborerà i dati in batch per addestrare in modo iterativo il 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 semplicità, avvii una singola istanza di Redis in questo esempio. Per un esempio di deployment di Redis in modo 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. Verifica che il pod sia in esecuzione prima di procedere. Nell'output del comando seguente, il 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 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 rilevabile il server Redis nel 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 dei job Redis e la condivisione 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 di attività fraudolente utilizzando gruppi di dati di transazione finanziaria. Il processo di addestramento può essere sintetizzato in questo modo:

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

  2. Una classe gestore addestramento 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 addestramento "warm-start").

  3. Il nuovo stato del modello e un report con i dettagli e i punteggi delle prestazioni del batch vengono salvati nel volume NFS 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. Verifica che lo stato del pod workload-XXX sia stato completato.

    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 ripete questi file, estrae i set di dati e li utilizza per addestrare il 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 a quando la coda Redis non viene svuotata.

Esplora il volume NFS

Durante l'operazione, il carico di lavoro crea file nel volume NFS montato, accessibile da tutto il cluster ad altri job batch o applicazioni online. Per esplorare i file nel volume NFS, segui questi passaggi:

  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 saperne di più 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