Questa guida spiega come creare un container personalizzato per l'esecuzione di job su AI Platform Training.
Passaggi per l'utilizzo dei container
I passaggi seguenti mostrano la procedura di base per l'addestramento con container personalizzati:
- Configurare un progetto Google Cloud e il tuo ambiente locale.
- Crea un container personalizzato:
- Scrivi un Dockerfile che configuri il container in modo che funzioni con AI Platform Training e includa le dipendenze necessarie per la tua applicazione di addestramento.
- Crea e testa il tuo container Docker in locale.
- Esegui il push del container in Container Registry.
- Invia un job di addestramento eseguito sul tuo container personalizzato.
L'uso dell'ottimizzazione degli iperparametri o delle GPU richiede alcune modifiche, ma il processo di base è lo stesso.
Prima di iniziare
Utilizza Cloud Shell o qualsiasi ambiente in cui è installato gcloud CLI.
Completa i passaggi seguenti per configurare un account Google Cloud, abilitare le API richieste e installare e attivare Cloud SDK.
- 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.
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API AI Platform Training & Prediction, Compute Engine and Container Registry.
- Installa Google Cloud CLI.
-
Per initialize gcloud CLI, esegui questo comando:
gcloud init
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API AI Platform Training & Prediction, Compute Engine and Container Registry.
- Installa Google Cloud CLI.
-
Per initialize gcloud CLI, esegui questo comando:
gcloud init
- Installa Docker.
Se utilizzi un sistema operativo basato su Linux, come Ubuntu o Debian, aggiungi il tuo nome utente al gruppo
docker
in modo da poter eseguire Docker senza utilizzaresudo
:sudo usermod -a -G docker ${USER}
Potrebbe essere necessario riavviare il sistema dopo esserti aggiunto al gruppo
docker
. - Apri Docker. Per assicurarti che Docker sia in esecuzione, esegui il comando Docker seguente,
che restituisce la data e l'ora attuali:
docker run busybox date
- Utilizza
gcloud
come helper delle credenziali per Docker:gcloud auth configure-docker
-
(Facoltativo) Se vuoi eseguire il container utilizzando la GPU localmente, installa
nvidia-docker
.
Creazione di un container personalizzato
La creazione di un container personalizzato comporta la scrittura di un Dockerfile per configurare l'immagine Docker che utilizzerai per il job di addestramento. Dopodiché, devi creare e testare l'immagine localmente.
Nozioni di base su Dockerfile per AI Platform Training
Quando crei un container personalizzato, utilizzi un Dockerfile per specificare tutti i comandi necessari per creare l'immagine.
Questa sezione illustra un esempio generico di Dockerfile. Puoi trovare esempi specifici in ogni tutorial sui container personalizzati e negli esempi correlati.
Per l'utilizzo 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 codice di addestramento
Il Dockerfile potrebbe includere logica aggiuntiva, a seconda delle tue esigenze. Scopri di più sulla scrittura di Dockerfile e per ulteriori informazioni su ciascun comando specifico, consulta la documentazione di riferimento sui Dockerfile.
Comando Dockerfile | Descrizione | Esempi |
---|---|---|
FROM image:tag |
Specifica un'immagine di base e il relativo tag. | Esempi di immagini di base con tag:
|
WORKDIR /path/to/directory |
Specifica la directory sull'immagine in cui vengono eseguite le istruzioni successive. | /root |
|
Installa pacchetti aggiuntivi utilizzando pip .Nota: se l'immagine di base non ha |
Pacchetti di esempio:
|
COPY src/foo.py dest/foo.py |
Copia il codice dell'applicazione di addestramento nell'immagine. A seconda di come è strutturata l'applicazione di addestramento, è probabile che vengano inclusi più file. | Nomi di esempio di file nella tua applicazione di addestramento:
|
|
Configura il punto di ingresso per richiamare il codice di addestramento da eseguire. | ["python", "task.py"] |
La logica nel Dockerfile può variare in base alle tue esigenze, ma in generale ha il seguente aspetto:
# 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
Crea l'URI dell'immagine corretto utilizzando le variabili di ambiente, quindi crea l'immagine Docker. Il flag
-t
assegna all'immagine il nome e il tag con le tue scelte perIMAGE_REPO_NAME
eIMAGE_TAG
. Puoi scegliere un nome e un tag diversi 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 ./
Verifica l'immagine eseguendola localmente. Tieni presente che il flag
--epochs
viene passato allo script del formatore.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 nel tuo progetto.
Esegui il push del container in Container Registry. Innanzitutto, 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 utilizzi per eseguire l'addestramento su AI Platform Training, non devi configurare ulteriormente le autorizzazioni per questo tutorial e puoi andare al passaggio successivo.
Il controllo dell'accesso a Container Registry si basa su un bucket Cloud Storage dietro le quinte, pertanto la configurazione delle autorizzazioni di Container Registry è molto simile alla configurazione delle autorizzazioni di Cloud Storage.
Se vuoi pull un'immagine da Container Registry in un altro progetto, devi consentire all'account di servizio AI Platform Training di accedere all'immagine dall'altro progetto.
- Trova il bucket Cloud Storage sottostante per le tue autorizzazioni di Container Registry.
- Concedi un ruolo (ad esempio Visualizzatore oggetti Storage) che include le autorizzazioni
storage.objects.get
estorage.objects.list
al tuo account di servizio AI Platform Training.
Se vuoi push dell'immagine Docker a un progetto diverso da quello che stai utilizzando per inviare i job di addestramento di AI Platform Training, devi concedere l'accesso di pull dell'immagine all'account di servizio AI Platform Training nel progetto che contiene i tuoi repository Container Registry. L'account di servizio
è nel formato
service-$CMLE_PROJ_NUM@cloud-ml.google.com.iam.gserviceaccount.com
e
è disponibile nella
console IAM.
Il seguente comando aggiunge il tuo account di servizio AI Platform Training al tuo 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 controllo dell'accesso per Container Registry.
Invia il job di addestramento
Invia il job di addestramento ad AI Platform Training utilizzando gcloud CLI. Passa l'URI all'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 eseguire l'ottimizzazione degli iperparametri con container personalizzati, devi apportare le seguenti modifiche:
- Nel Dockerfile: installa
cloudml-hypertune
. - Nel codice di addestramento:
- Usa
cloudml-hypertune
per segnalare i risultati di ogni prova chiamando la relativa funzione di supporto,report_hyperparameter_tuning_metric
. - Aggiungi argomenti della riga di comando per ogni iperparametro e gestisci l'analisi degli argomenti con un parser di argomenti come
argparse
.
- Usa
- Nella richiesta del job, aggiungi
HyperparameterSpec
all'oggettoTrainingInput
.
Utilizzo di GPU con container personalizzati
Per l'addestramento con GPU, il container personalizzato deve soddisfare alcuni requisiti speciali. Devi creare un'immagine Docker diversa da quella che useresti per l'addestramento con le CPU.
Preinstalla il toolkit CUDA e cuDNN nel tuo contenitore. Il modo consigliato per risolvere questo problema è utilizzare l'immagine nvidia/cuda come immagine di base, perché il toolkit CUDA e cuDNN sono preinstallati e ti aiuta a configurare correttamente le variabili di ambiente correlate.
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 tutte le altre necessarie dall'applicazione di addestramento.
Vedi un Dockerfile di esempio per l'addestramento con GPU.
Utilizzo di TPU con container personalizzati
Se esegui l'addestramento distribuito con TensorFlow, puoi utilizzare le TPU sulle VM worker. A questo scopo, devi configurare il job di addestramento per l'utilizzo delle TPU e specificare il campo tpuTfVersion
quando invii il 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 server master, worker e parametri. Hai anche la possibilità di creare e specificare diverse immagini per il server master, worker e dei parametri. In questo caso, le dipendenze saranno probabilmente le stesse in tutte e tre le immagini e potrai eseguire logica di codice diversa all'interno di ogni immagine.
Nel codice, puoi utilizzare le variabili di ambiente TF_CONFIG
e CLUSTER_SPEC
. Queste variabili di ambiente descrivono la struttura complessiva del cluster e AI Platform Training le completa automaticamente in ciascun nodo del 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 in gcloud ai-platform submit training
.
Per questo esempio, supponiamo di aver già definito tre Dockerfile separati, uno per ogni tipo di macchina (master, worker e server dei parametri). Successivamente, dovrai denominare, creare, testare ed eseguire il push delle tue immagini in Container Registry. Infine, invierai un job di addestramento che specifica le diverse immagini 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
Credenziali predefinite in container personalizzati
Quando esegui un job di addestramento con container personalizzati, l'applicazione viene eseguita per impostazione predefinita come identità dell'agente di servizio Cloud ML. Puoi trovare l'ID dell'account di servizio dell'agente di servizio Cloud ML per il tuo progetto nella pagina IAM della console Google Cloud. Questo ID ha il formato seguente:
service-PROJECT_NUMBER@cloud-ml.google.com.iam.gserviceaccount.com
Sostituisci PROJECT_NUMBER con il numero di progetto del progetto Google Cloud.
AI Platform Training utilizza automaticamente le credenziali dell'agente di servizio Cloud ML per configurare l'autenticazione e l'autorizzazione se utilizzi TensorFlow tfds
, librerie client di Google Cloud o altri strumenti che usano la strategia delle credenziali predefinite dell'applicazione.
Tuttavia, se vuoi che il job del container personalizzato acceda a Google Cloud in altri modi, potresti dover eseguire una configurazione aggiuntiva. Ad esempio, se utilizzi gsutil
per copiare dati da Cloud Storage e utilizzi la libreria boto
per caricare le credenziali da un file di configurazione, aggiungi un comando al tuo Dockerfile per assicurarti che gsutil
utilizzi le credenziali predefinite dell'agente Cloud ML Servce:
RUN echo '[GoogleCompute]\nservice_account = default' > /etc/boto.cfg
Passaggi successivi
- Scopri di più sui concetti relativi all'utilizzo dei container.
- Addestra un modello PyTorch utilizzando container personalizzati.
- Scopri di più sull'addestramento distribuito con container personalizzati.