Addestra un modello ML con container personalizzati

Addestra un modello ML con container personalizzati

AI Platform Training supporta l'addestramento in container personalizzati, i propri container Docker con framework o algoritmi ML preinstallati su AI Platform Training. Questo tutorial fornisce un'introduzione procedura dettagliata che mostra come addestrare un modello PyTorch su AI Platform Training con un container personalizzato.

Panoramica

Questa guida introduttiva illustra il processo di addestramento di container su AI Platform Training, usando un modello di base che classifica cifre scritte a mano libera basate sul set di dati MNIST.

Questa guida illustra i seguenti passaggi:

• Configurazione del progetto e dell'ambiente locale
• Crea un container personalizzato
  • Scrivi un Dockerfile
  • crea e testa la tua immagine Docker in locale
• esegui il push dell'immagine in Container Registry
• Invia un job di addestramento container personalizzato
• Invia un job di ottimizzazione degli iperparametri
• Utilizzo di GPU con un container personalizzato

Nota: Container Registry è l'unico supportato per l'addestramento di container personalizzato.

Prima di iniziare

Per questa guida introduttiva, utilizza qualsiasi ambiente in cui Google Cloud CLI sia installato.

Nota: ambienti con risorse di calcolo e memoria limitate, ad esempio Cloud Shell potrebbe non essere in grado di creare o eseguire Immagini Docker utilizzate in questo tutorial. Se riscontri problemi con Docker nel tuo ambiente locale, valuta la possibilità di eseguire questo tutorial in un ambiente Compute Engine con più risorse di calcolo e memoria di archiviazione rispetto alla macchina locale. In alternativa, puoi creare la tua immagine Docker ed eseguirne il push in Container Registry utilizzando Cloud Build anziché eseguire Docker sulla tua macchina locale.

(Facoltativo) Rivedi informazioni concettuali sull'addestramento con container personalizzati.

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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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. 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}

    Attenzione: il gruppo docker equivale all'utente root. Consulta Documentazione di Docker per maggiori dettagli su come influisce sulla sicurezza del tuo sistema.

    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

Configura il tuo bucket Cloud Storage

Questa sezione mostra come creare un nuovo bucket. Puoi utilizzare un modello esistente ma deve trovarsi nella stessa regione in cui prevedi di eseguire AI Platform di lavoro. Inoltre, se non fa parte del progetto che utilizzi per eseguire AI Platform Training, devi esplicitamente concedere agli account di servizio AI Platform Training.

1. Specifica un nome per il nuovo bucket. Il nome deve essere univoco in tutti in Cloud Storage.

   BUCKET_NAME="YOUR_BUCKET_NAME"

   Ad esempio, utilizza il nome del progetto aggiungendo -aiplatform:

   PROJECT_ID=$(gcloud config list project --format "value(core.project)")
   BUCKET_NAME=${PROJECT_ID}-aiplatform

2. Controlla il nome del bucket che hai creato.

   echo $BUCKET_NAME

3. Seleziona una regione per il bucket e imposta una variabile di ambiente REGION.

   Utilizza la stessa regione in cui prevedi di eseguire AI Platform Training di lavoro. Scopri le regioni in cui è disponibile per e i servizi di AI Platform Training.

   Ad esempio, il seguente codice crea REGION e lo imposta su us-central1:

   REGION=us-central1

4. Crea il nuovo bucket:

   gcloud storage buckets create gs://$BUCKET_NAME --location=$REGION

Scarica il codice per questo tutorial

1. Inserisci il comando seguente per scaricare AI Platform Training file ZIP di esempio:

   wget https://github.com/GoogleCloudPlatform/cloudml-samples/archive/master.zip
   

2. Decomprimi il file per estrarre la directory cloudml-samples-master.

   unzip master.zip
   

3. Vai alla sezione cloudml-samples-master > pytorch > containers > quickstart > mnist . I comandi in questa procedura dettagliata devono essere eseguiti dal mnist .

   cd cloudml-samples-master/pytorch/containers/quickstart/mnist
   

Creazione di un container personalizzato

Per creare un container personalizzato, la prima cosa da fare è definisci un Dockerfile da installare le dipendenze necessarie per il job di addestramento. Quindi, crei e testerai l'immagine Docker in locale per verificarla prima di utilizzarla con AI Platform Training.

Scrivi un Dockerfile

Il Dockerfile di esempio fornito in questo tutorial esegue le seguenti operazioni passaggi:

1. Utilizza un'immagine di base Python 2.7 con dipendenze Python integrate.
2. Installa dipendenze aggiuntive, tra cui PyTorch, gcloud CLI e cloudml-hypertune per dell'ottimizzazione degli iperparametri.
3. Copia il codice per l'applicazione di addestramento nel container.
4. Configura il punto di ingresso per AI Platform Training per eseguire l'addestramento del codice all'avvio del container.

Il Dockerfile potrebbe includere logica aggiuntiva, a seconda delle esigenze. Scopri di più sulla scrittura di Dockerfile.

# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the \"License\");
# you may not use this file except in compliance with the License.\n",
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an \"AS IS\" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Dockerfile
FROM python:2.7.16-jessie
WORKDIR /root

# Installs pytorch and torchvision.
RUN pip install torch==1.0.0 torchvision==0.2.1

# Installs cloudml-hypertune for hyperparameter tuning.
# It’s not needed if you don’t want to do hyperparameter tuning.
RUN pip install cloudml-hypertune

# Installs google cloud sdk, this is mostly for using gsutil to export model.
RUN wget -nv \
    https://dl.google.com/dl/cloudsdk/release/google-cloud-sdk.tar.gz && \
    mkdir /root/tools && \
    tar xvzf google-cloud-sdk.tar.gz -C /root/tools && \
    rm google-cloud-sdk.tar.gz && \
    /root/tools/google-cloud-sdk/install.sh --usage-reporting=false \
        --path-update=false --bash-completion=false \
        --disable-installation-options && \
    rm -rf /root/.config/* && \
    ln -s /root/.config /config && \
    # Remove the backup directory that gcloud creates
    rm -rf /root/tools/google-cloud-sdk/.install/.backup

# Path configuration
ENV PATH $PATH:/root/tools/google-cloud-sdk/bin
# Make sure gsutil will use the default service account
RUN echo '[GoogleCompute]\nservice_account = default' > /etc/boto.cfg

# Copies the trainer code 
RUN mkdir /root/trainer
COPY trainer/mnist.py /root/trainer/mnist.py

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

crea e testa la tua immagine Docker in locale

1. Crea l'URI immagine corretto utilizzando le variabili di ambiente e crea il Docker. La bandiera -t assegna un nome e tagga l'immagine 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=mnist_pytorch_custom_container
   export IMAGE_TAG=mnist_pytorch_cpu
   export IMAGE_URI=gcr.io/$PROJECT_ID/$IMAGE_REPO_NAME:$IMAGE_TAG
   
   docker build -f Dockerfile -t $IMAGE_URI ./
   

2. Verifica l'immagine eseguendola localmente in un nuovo container. Tieni presente che Il flag --epochs viene passato allo script di addestramento.

   docker run $IMAGE_URI --epochs 1
   

esegui il push dell'immagine in Container Registry

Se l'esecuzione locale funziona, puoi eseguire il push dell'immagine Docker a Container Registry nel tuo progetto.

Nota: se le immagini di Container Registry e AI Platform Training si trovano in progetti Google Cloud diversi, devi configurare le autorizzazioni in modo che che il tuo progetto AI Platform Training possa accedere a Container Registry progetto. Consulta come gestire le autorizzazioni di Container Registry per ulteriori informazioni informazioni.

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

docker push $IMAGE_URI

Invia e monitora il job

1. Definisci le variabili di ambiente per la richiesta del job.

   • MODEL_DIR nomina una nuova directory con timestamp all'interno di Cloud Storage in cui è archiviato il file del modello salvato al termine dell'addestramento.
   • REGION specifica un regione valida per l'addestramento di AI Platform Training.

   export MODEL_DIR=pytorch_model_$(date +%Y%m%d_%H%M%S)
   export REGION=us-central1
   export JOB_NAME=custom_container_job_$(date +%Y%m%d_%H%M%S)
   

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

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

3. Dopo aver inviato il job, puoi monitorare lo stato del job e trasmettere i log:

   gcloud ai-platform jobs describe $JOB_NAME
   gcloud ai-platform jobs stream-logs $JOB_NAME
   

Nota: puoi anche specificare immagini diverse da utilizzare per i worker e il parametro server nell'addestramento distribuito, usando i flag gcloud --worker-image-uri e --parameter-server-image-uri. Scopri di più su addestramento distribuito con container personalizzati.

Invia un job di ottimizzazione degli iperparametri

Ci sono alcune modifiche da apportare per un job di ottimizzazione degli iperparametri. Prendi nota di queste aree nel codice campione:

• Il Dockerfile di esempio include cloudml-hypertune pacchetto in ordine per installarlo nel container personalizzato.
• Il codice campione (mnist.py):
  • Utilizza cloudml-hypertune per segnalare i risultati di ogni prova richiamando la relativa funzione helper, report_hyperparameter_tuning_metric Il codice campione riporta i risultati dell'ottimizzazione degli iperparametri dopo la valutazione a meno che il job non venga inviato come job di ottimizzazione degli iperparametri.
  • Aggiunge gli argomenti della riga di comando per ogni iperparametro e gestisce il l'analisi dell'argomento con argparse.
• La richiesta di lavoro include HyperparameterSpec in l'oggetto TrainingInput. In questo caso, ottimizziamo --lr e --momentum per ridurre al minimo la perdita del modello.

1. Crea un file config.yaml per definire la specifica del tuo iperparametro. Ridefinisci MODEL_DIR e JOB_NAME. Definisci REGION se non l'hai ancora fatto:

   export MODEL_DIR=pytorch_hptuning_model_$(date +%Y%m%d_%H%M%S)
   export REGION=us-central1
   export JOB_NAME=custom_container_job_hptuning_$(date +%Y%m%d_%H%M%S)
   
   # Creates a YAML file with job request.
   cat > config.yaml <<EOF
   trainingInput:
     hyperparameters:
       goal: MINIMIZE
       hyperparameterMetricTag: "my_loss"
       maxTrials: 20
       maxParallelTrials: 5
       enableTrialEarlyStopping: True
       params:
       - parameterName: lr
         type: DOUBLE
         minValue: 0.0001
         maxValue: 0.1
       - parameterName: momentum
         type: DOUBLE
         minValue: 0.2
         maxValue: 0.8
   EOF
   

2. Invia il job di ottimizzazione degli iperparametri ad AI Platform Training:

   gcloud ai-platform jobs submit training $JOB_NAME \
     --scale-tier BASIC \
     --region $REGION \
     --master-image-uri $IMAGE_URI \
     --config config.yaml \
     -- \
     --epochs=5 \
     --model-dir="gs://$BUCKET_NAME/$MODEL_DIR"
   

Utilizzo di GPU con container personalizzati

Per inviare un job di container personalizzato utilizzando GPU, devi creare un Docker diverso rispetto a quella usata in precedenza. Abbiamo fornito un Dockerfile di esempio da utilizzare con GPU che soddisfano i requisiti seguenti:

• Preinstalla il toolkit CUDA e il cuDNN nel tuo container. L'utilizzo del nvidia/cuda come immagine di base è consigliata per la gestione di questo problema, poiché ha il toolkit CUDA e cuDNN preinstallati, e ti aiuta a impostare correttamente le variabili di ambiente correlate.
• Installa dipendenze aggiuntive, come wget, curl, pip e altre richiesta dalla tua applicazione di addestramento.

# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the \"License\");
# you may not use this file except in compliance with the License.\n",
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an \"AS IS\" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Dockerfile-gpu
FROM nvidia/cuda:9.0-cudnn7-runtime

# Installs necessary dependencies.
RUN apt-get update && apt-get install -y --no-install-recommends \
         wget \
         curl \
         python-dev && \
     rm -rf /var/lib/apt/lists/*

# Installs pip.
RUN curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \
    python get-pip.py && \
    pip install setuptools && \
    rm get-pip.py

WORKDIR /root

# Installs pytorch and torchvision.
RUN pip install torch==1.0.0 torchvision==0.2.1

# Installs cloudml-hypertune for hyperparameter tuning.
# It’s not needed if you don’t want to do hyperparameter tuning.
RUN pip install cloudml-hypertune

# Installs google cloud sdk, this is mostly for using gsutil to export model.
RUN wget -nv \
    https://dl.google.com/dl/cloudsdk/release/google-cloud-sdk.tar.gz && \
    mkdir /root/tools && \
    tar xvzf google-cloud-sdk.tar.gz -C /root/tools && \
    rm google-cloud-sdk.tar.gz && \
    /root/tools/google-cloud-sdk/install.sh --usage-reporting=false \
        --path-update=false --bash-completion=false \
        --disable-installation-options && \
    rm -rf /root/.config/* && \
    ln -s /root/.config /config && \
    # Remove the backup directory that gcloud creates
    rm -rf /root/tools/google-cloud-sdk/.install/.backup

# Path configuration
ENV PATH $PATH:/root/tools/google-cloud-sdk/bin
# Make sure gsutil will use the default service account
RUN echo '[GoogleCompute]\nservice_account = default' > /etc/boto.cfg

# Copies the trainer code 
RUN mkdir /root/trainer
COPY trainer/mnist.py /root/trainer/mnist.py

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

Crea e testa l'immagine Docker GPU in locale

1. Crea una nuova immagine per il tuo job di addestramento GPU utilizzando il Dockerfile GPU. A evitare di eseguire l'override dell'immagine CPU, devi ridefinire IMAGE_REPO_NAME e IMAGE_TAG con nomi diversi da quelli usati in precedenza nel tutorial.

   export PROJECT_ID=$(gcloud config list project --format "value(core.project)")
   export IMAGE_REPO_NAME=mnist_pytorch_gpu_container
   export IMAGE_TAG=mnist_pytorch_gpu
   export IMAGE_URI=gcr.io/$PROJECT_ID/$IMAGE_REPO_NAME:$IMAGE_TAG
   
   docker build -f Dockerfile-gpu -t $IMAGE_URI ./
   

2. Se sulla macchina sono disponibili GPU e hai installato nvidia-docker, verifica l'immagine eseguendola in locale:

   docker run --runtime=nvidia $IMAGE_URI --epochs 1
   

3. Eseguire il push dell'immagine Docker in Container Registry. Innanzitutto, esegui gcloud auth configure-docker, se non l'hai ancora fatto.

   docker push $IMAGE_URI
   

Invia il job

Questo esempio utilizza il livello di scalabilità GPU di base per inviare la richiesta del job di addestramento. Vedi altre opzioni per le macchine per l'addestramento con le GPU.

1. Ridefinisci MODEL_DIR e JOB_NAME. Definisci REGION se non lo hai già fatto Fatto:

   export MODEL_DIR=pytorch_model_gpu_$(date +%Y%m%d_%H%M%S)
   export REGION=us-central1
   export JOB_NAME=custom_container_job_gpu_$(date +%Y%m%d_%H%M%S)
   

2. Invia il job di addestramento ad AI Platform Training utilizzando gcloud CLI. Passa l'URI all'immagine Docker utilizzando il flag --master-image-uri.

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

Passaggi successivi

• Scopri di più su i concetti relativi all'utilizzo dei container.
• Informazioni su addestramento distribuito con container personalizzati.