Questa versione precedente di AI Platform Training è ritirata e non sarà più disponibile su Google Cloud dopo il 31 gennaio 2025. Esegui la migrazione delle tue risorse all'addestramento personalizzato di Vertex AI per accedere a nuove funzionalità di machine learning non disponibili in AI Platform.

Utilizzo dei container su AI Platform Training

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:
1. 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.
2. 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.

Vai al selettore progetti

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

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

Abilita le API

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.

Vai al selettore progetti

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

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

Abilita le API

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 utilizzare sudo:
```
sudo usermod -a -G docker ${USER}
```
Attenzione: il gruppo docker equivale all'utente root. Consulta la documentazione di Docker per i dettagli su come questo influisce sulla sicurezza del tuo sistema.

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: `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 vengono eseguite le istruzioni successive.	`/root`
`RUN pip install pkg1 pkg2 pkg3`	Installa pacchetti aggiuntivi utilizzando `pip`. Nota: se l'immagine di base non ha `pip`, devi includere 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 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: `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 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 per IMAGE_REPO_NAME e IMAGE_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 e storage.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.
Nella richiesta del job, aggiungi HyperparameterSpec all'oggetto TrainingInput.

Vedi 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 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.

Indietro

Panoramica dei container

Avanti

Addestramento distribuito con container