Utilizzo dei container su AI Platform Training

Questa guida spiega come creare il tuo container personalizzato su cui eseguire job e AI Platform Training.

I passaggi necessari per utilizzare i container

I passaggi seguenti mostrano la procedura di base per l'addestramento con container personalizzati:

  1. Configurare un progetto Google Cloud e il tuo ambiente locale.
  2. Crea un container personalizzato:
    1. Scrivi un Dockerfile che configuri il container con cui lavorare AI Platform Training e include le dipendenze necessarie per l'addestramento un'applicazione.
    2. Crea e testa il tuo container Docker in locale.
  3. Esegui il push del container in Container Registry.
  4. Invia un job di addestramento che viene eseguito sul tuo container personalizzato.

L'utilizzo dell'ottimizzazione degli iperparametri o delle GPU richiede alcune modifiche, ma le basi processo è lo stesso.

Prima di iniziare

Utilizza uno dei due Cloud Shell o qualsiasi in cui è installata l'interfaccia a riga di comando gcloud CLI.

Completa i seguenti passaggi per configurare un account Google Cloud, abilitare le API richieste e installare e attivare Cloud SDK.

  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 the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. Abilita le API AI Platform Training & Prediction, Compute Engine and Container Registry.

    Abilita le API

  5. Install the Google Cloud CLI.

  6. To initialize the gcloud CLI, run the following command: 

    gcloud init
    7.

  7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  8. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  9. Abilita le API AI Platform Training & Prediction, Compute Engine and Container Registry.

    Abilita le API

  10. Install the Google Cloud CLI.

  11. To initialize the gcloud CLI, run the following command: 

    gcloud init
    12.
  12. Installa Docker.

    Se utilizzi un sistema operativo basato su Linux, come Ubuntu o Debian, aggiungi il tuo nome utente gruppo docker in modo da poter eseguire Docker senza utilizzare sudo:

    sudo usermod -a -G docker ${USER}

    Dopo aver aggiunto il tuo account al gruppo docker, potresti dover riavviare il sistema.

  13. Apri Docker. Per assicurarti che Docker sia in esecuzione, esegui questo comando Docker, che restituisce la data e l'ora correnti: 
    docker run busybox date
  14. Usa gcloud come assistente per le credenziali per Docker: 
    gcloud auth configure-docker
  15. Facoltativo: se vuoi eseguire il container utilizzando la GPU in locale, installazione nvidia-docker

Creazione di un container personalizzato

La creazione di un container personalizzato implica la scrittura di un Dockerfile per configurare l'immagine Docker che utilizzerai per il job di addestramento. In seguito, creerai e testerai la tua immagine in locale.

Nozioni di base su Dockerfile per AI Platform Training

Quando crei un container personalizzato, utilizzi una Dockerfile per specificare tutte le necessari per creare l'immagine.

Questa sezione illustra un esempio generico di Dockerfile. Puoi visualizzare esempi specifici in ogni tutorial sui container personalizzati e esempi correlati.

Per essere utilizzato con AI Platform Training, il Dockerfile deve includere comandi che coprono le seguenti attività:

  • Scegli un'immagine di base
  • Installa dipendenze aggiuntive
  • Copia il codice di addestramento nell'immagine
  • Configura il punto di ingresso per AI Platform Training per richiamare il tuo addestramento codice

Il Dockerfile potrebbe includere logica aggiuntiva, a seconda delle esigenze. Scopri di più sulla scrittura di Dockerfile e Per ulteriori informazioni su ogni comando specifico, vedi Riferimento Dockerfile.

Comando Dockerfile Descrizione Esempi
FROM image:tag Specifica un'immagine di base e il relativo tag.

Esempi di immagini di base con tag:

  • pytorch/pytorch:latest
  • tensorflow/tensorflow:nightly
  • python:2.7.15-jessie
  • nvidia/cuda:9.0-cudnn7-runtime
WORKDIR /path/to/directory Specifica la directory sull'immagine in cui le istruzioni successive vengono eseguite correttamente. /root
RUN pip install pkg1 pkg2 pkg3 Installa pacchetti aggiuntivi utilizzando pip.

Nota: se l'immagine di base non ha pip, devi includi un comando per installarlo prima di installare altri pacchetti.

Pacchetti di esempio:

  • google-cloud-storage
  • cloudml-hypertune
  • pandas
COPY src/foo.py dest/foo.py Copia il codice per l'applicazione di addestramento nell'immagine. A seconda di come è strutturata l'applicazione di addestramento, include più file.

Nomi di esempio dei file nell'applicazione di addestramento:

  • model.py
  • task.py
  • data_utils.py
ENTRYPOINT ["exec", "file"] Configura il punto di ingresso per richiamare il codice di addestramento da eseguire. ["python", "task.py"]

La logica del Dockerfile può variare a seconda delle esigenze, ma in generale è simile a questo:

# Specifies base image and tag
FROM image:tag
WORKDIR /root

# Installs additional packages
RUN pip install pkg1 pkg2 pkg3

# Downloads training data
RUN curl https://example-url/path-to-data/data-filename --output /root/data-filename

# Copies the trainer code to the docker image.
COPY your-path-to/model.py /root/model.py
COPY your-path-to/task.py /root/task.py

# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "task.py"]

crea e testa il tuo container Docker in locale

  1. Crea l'URI immagine corretto utilizzando le variabili di ambiente, quindi l'immagine Docker. La bandiera -t assegna un nome e un tag all'immagine con le tue scelte per IMAGE_REPO_NAME e IMAGE_TAG. Puoi scegliere un nome diverso e per l'immagine.

    export PROJECT_ID=$(gcloud config list project --format "value(core.project)")
export IMAGE_REPO_NAME=example_custom_container_image
export IMAGE_TAG=example_image_tag
export IMAGE_URI=gcr.io/$PROJECT_ID/$IMAGE_REPO_NAME:$IMAGE_TAG

docker build -f Dockerfile -t $IMAGE_URI ./

  2. Verifica l'immagine eseguendola in locale. Tieni presente che il flag --epochs è passati allo script del trainer.

    docker run $IMAGE_URI --epochs 1

Esegui il push del container in Container Registry

Se l'esecuzione locale funziona, puoi eseguire il push del container in Container Registry in del progetto.

Esegui il push del container in Container Registry. Per prima cosa, esegui gcloud auth configure-docker, se non l'hai ancora fatto.

docker push $IMAGE_URI

Gestisci le autorizzazioni di Container Registry

Se utilizzi un'immagine di Container Registry all'interno dello stesso progetto che usi per eseguire l'addestramento su AI Platform Training, configurare le autorizzazioni per questo tutorial e passare al passaggio successivo.

Il controllo dell'accesso per Container Registry si basa su un bucket Cloud Storage dietro le quinte, per cui la configurazione delle autorizzazioni di Container Registry è molto in modo simile alla configurazione delle autorizzazioni di Cloud Storage.

Se vuoi eseguire il pull di un'immagine da Container Registry in un ambiente devi consentire al tuo account di servizio AI Platform Training di accedere l'immagine dell'altro progetto.

  • Trova il bucket Cloud Storage sottostante per il tuo Autorizzazioni di Container Registry.
  • Concedi un ruolo (ad esempio Visualizzatore oggetti Storage) che includa il parametro Autorizzazioni storage.objects.get e storage.objects.list per Account di servizio AI Platform Training.

Se vuoi eseguire il push dell'immagine Docker a un progetto diverso da uno che stai utilizzando per inviare i job di addestramento di AI Platform Training, concedi l'accesso al pull delle immagini all'account di servizio AI Platform Training in contenente i tuoi repository Container Registry. Account di servizio ha il formato service-$CMLE_PROJ_NUM@cloud-ml.google.com.iam.gserviceaccount.com e disponibile nel Console IAM.

Il comando seguente aggiunge il tuo account di servizio AI Platform Training al tuo in un progetto Container Registry separato:

export GCR_PROJ_ID=[YOUR-PROJECT-ID-FOR-GCR]
export CMLE_PROJ_NUM=[YOUR-PROJECT-NUMBER-FOR-CMLE-JOB-SUBMISSION]
export \
SVC_ACCT=service-$CMLE_PROJ_NUM@cloud-ml.google.com.iam.gserviceaccount.com

gcloud projects add-iam-policy-binding $GCR_PROJ_ID \
    --member serviceAccount:$SVC_ACCOUNT --role roles/ml.serviceAgent

Scopri di più su come configurare il controllo dell'accesso per Container Registry.

Inviare il job di addestramento

Invia il job di addestramento ad AI Platform Training utilizzando gcloud CLI. Superato l'URI dell'immagine Docker utilizzando il flag --master-image-uri:

export BUCKET_NAME=custom_containers
export MODEL_DIR=example_model_$(date +%Y%m%d_%H%M%S)

gcloud ai-platform jobs submit training $JOB_NAME \
  --region $REGION \
  --master-image-uri $IMAGE_URI \
  -- \
  --model-dir=gs://$BUCKET_NAME/$MODEL_DIR \
  --epochs=10

Ottimizzazione degli iperparametri con container personalizzati

Per ottimizzare gli iperparametri con container personalizzati, devi creare le seguenti modifiche:

Consulta un esempio di addestramento con container personalizzati utilizzando l'ottimizzazione degli iperparametri.

Utilizzo di GPU con container personalizzati

Per l'addestramento con GPU, il container personalizzato deve soddisfare alcuni requisiti i tuoi requisiti. Devi creare un'immagine Docker diversa da quella che useresti l'addestramento con le CPU.

  • Preinstalla il toolkit CUDA e il cuDNN nel tuo container. L'utilizzo del un'immagine nvidia/cuda come immagine di base è la soluzione consigliata per perché ha il toolkit CUDA e cuDNN preinstallati, e ti aiuta a impostare le variabili di ambiente correlate in modo corretto.

    Se la configurazione di addestramento utilizza GPU NVIDIA A100, il container deve utilizzare CUDA 11 o versioni successive.

  • Installa dipendenze aggiuntive, come wget, curl, pip e altre richiesta dalla tua applicazione di addestramento.

Consulta un Dockerfile di esempio per l'addestramento con GPU.

Utilizzo di TPU con container personalizzati

Se esegui distribuzioni addestramento con TensorFlow, puoi per utilizzare le TPU sulle VM worker. Per farlo, devi configurare il job di addestramento per utilizzare le TPU e specificare tpuTfVersion campo quando invii il tuo job di addestramento.

Addestramento distribuito con container personalizzati

Quando esegui un job di addestramento distribuito con container personalizzati, puoi specificare una sola immagine da utilizzare come master, worker e server dei parametri. Tu puoi anche creare e specificare immagini diverse per il worker e server dei parametri. In questo caso, probabilmente le dipendenze la stessa in tutte e tre le immagini e puoi eseguire logiche di codice diverse all'interno dell'immagine.

Nel codice, puoi utilizzare le variabili di ambiente TF_CONFIG e CLUSTER_SPEC. Queste variabili di ambiente descrivono la struttura generale al cluster e AI Platform Training li compila per te in ciascun nodo il tuo cluster di addestramento. Scopri di più su CLUSTER_SPEC.

Puoi specificare le immagini all'interno dell'oggetto TrainingInput quando invii un job o tramite i flag corrispondenti gcloud ai-platform submit training.

Per questo esempio, supponiamo di aver già definito tre Dockerfile, uno per ogni tipo di macchina (master, worker e server web). In seguito, assegnerai un nome, crei, test ed esegui il push delle immagini e Container Registry. Infine, devi inviare un job di addestramento che specifica immagini diverse insieme alla configurazione della macchina per il cluster.

Innanzitutto, esegui gcloud auth configure-docker se non l'hai ancora fatto.

export PROJECT_ID=$(gcloud config list project --format "value(core.project)")
export BUCKET_NAME=custom_containers
export MASTER_IMAGE_REPO_NAME=master_image_name
export MASTER_IMAGE_TAG=master_tag
export MASTER_IMAGE_URI=gcr.io/$PROJECT_ID/$MASTER_IMAGE_REPO_NAME:$MASTER_IMAGE_TAG
export WORKER_IMAGE_REPO_NAME=worker_image_name
export WORKER_IMAGE_TAG=worker_tag
export WORKER_IMAGE_URI=gcr.io/$PROJECT_ID/$WORKER_IMAGE_REPO_NAME:$WORKER_IMAGE_TAG
export PS_IMAGE_REPO_NAME=ps_image_name
export PS_IMAGE_TAG=ps_tag
export PS_IMAGE_URI=gcr.io/$PROJECT_ID/$PS_IMAGE_REPO_NAME:$PS_IMAGE_TAG
export MODEL_DIR=distributed_example_$(date +%Y%m%d_%H%M%S)
export REGION=us-central1
export JOB_NAME=distributed_container_job_$(date +%Y%m%d_%H%M%S)

docker build -f Dockerfile-master -t $MASTER_IMAGE_URI ./
docker build -f Dockerfile-worker -t $WORKER_IMAGE_URI ./
docker build -f Dockerfile-ps -t $PS_IMAGE_URI ./

docker run $MASTER_IMAGE_URI --epochs 1
docker run $WORKER_IMAGE_URI --epochs 1
docker run $PS_IMAGE_URI --epochs 1

docker push $MASTER_IMAGE_URI
docker push $WORKER_IMAGE_URI
docker push $PS_IMAGE_URI

gcloud ai-platform jobs submit training $JOB_NAME \
  --region $REGION \
  --master-machine-type complex_model_m \
  --master-image-uri $MASTER_IMAGE_URI \
  --worker-machine-type complex_model_m \
  --worker-image-uri $WORKER_IMAGE_URI \
  --worker-count 9 \
  --parameter-server-machine-type large_model \
  --parameter-server-image-uri $PS_IMAGE_URI \
  --parameter-server-count 3 \
  -- \
  --model-dir=gs://$BUCKET_NAME/$MODEL_DIR \
  --epochs=10

Credenziale predefinita nei container personalizzati

Quando esegui un job di addestramento con container personalizzati, l'applicazione per impostazione predefinita viene eseguito come identità dell'agente di servizio Cloud ML. Puoi trovare il servizio dell'agente di servizio Cloud ML per il tuo progetto nella pagina IAM in la console Google Cloud. Questo ID ha il seguente formato:

service-PROJECT_NUMBER@cloud-ml.google.com.iam.gserviceaccount.com

Sostituisci PROJECT_NUMBER con il progetto numero per del tuo progetto Google Cloud.

AI Platform Training utilizza automaticamente l'agente Cloud ML Servce credenziali per configurare l'autenticazione e l'autorizzazione se utilizzi Tensorflow tfds, client Google Cloud librerie o altri strumenti che usano le Credenziali predefinite dell'applicazione per il machine learning.

Passaggi successivi

Indietro
Panoramica dei container
Avanti
Addestramento distribuito con container