Addestra un modello ML con container personalizzati

AI Platform Training supporta l'addestramento in container personalizzati, consentendo agli utenti di utilizzare i propri container Docker con qualsiasi framework o algoritmo ML preinstallato da eseguire su AI Platform Training. Questo tutorial fornisce una procedura dettagliata introduttiva che mostra come addestrare un modello PyTorch sull'AI Platform Training con un container personalizzato.

Panoramica

Questa guida introduttiva illustra il processo di addestramento con container personalizzati su AI Platform Training, utilizzando un modello base che classifica le cifre scritte a mano in base al set di dati MNIST.

Questa guida illustra i seguenti passaggi:

  • Configurazione di progetti e ambienti locali
  • 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 di container personalizzato
  • Invia un job di ottimizzazione iperparametri
  • Utilizzo di GPU con un container personalizzato

Prima di iniziare

Per questa guida introduttiva, utilizza qualsiasi ambiente in cui è installata Google Cloud CLI.

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

Completa i passaggi seguenti 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. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  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. Installa Google Cloud CLI.
  6. Per initialize gcloud CLI, esegui questo comando:

    gcloud init
  7. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  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. Installa Google Cloud CLI.
  11. Per initialize gcloud CLI, esegui questo comando:

    gcloud init
  12. 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}

    Potrebbe essere necessario riavviare il sistema dopo esserti aggiunto al gruppo docker.

  13. 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
  14. Utilizza gcloud come helper delle credenziali per Docker:
    gcloud auth configure-docker
  15. (Facoltativo) Se vuoi eseguire il container utilizzando la GPU localmente, installa nvidia-docker.

Configura il bucket Cloud Storage

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

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

    BUCKET_NAME="YOUR_BUCKET_NAME"

    Ad esempio, utilizza il nome del progetto con -aiplatform aggiunto:

    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 job di AI Platform Training. Consulta le regioni disponibili per i servizi di AI Platform Training.

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

    REGION=us-central1
  4. Crea il nuovo bucket:

    gsutil mb -l $REGION gs://$BUCKET_NAME

Scarica il codice per questo tutorial

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

    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 directory cloudml-samples-master > pytorch > containers > quickstart > mnist. I comandi di questa procedura dettagliata devono essere eseguiti dalla directory mnist.

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

Creazione di un container personalizzato

Per creare un container personalizzato, la prima cosa da fare è definire un Dockerfile per installare le dipendenze richieste per il job di addestramento. Quindi, dovrai creare e testare 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 completa i seguenti 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 l'ottimizzazione degli iperparametri.
  3. Copia nel container il codice dell'applicazione di addestramento.
  4. Configura il punto di ingresso per AI Platform Training per l'esecuzione del codice di addestramento all'avvio del container.

Il Dockerfile potrebbe includere logica aggiuntiva, a seconda delle tue 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 dell'immagine corretto utilizzando le variabili di ambiente e crea l'immagine Docker. L'-t segnala il nome e l'etichetta dell'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 del formatore.

    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 in Container Registry nel tuo progetto.

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 indica una nuova directory con timestamp all'interno del bucket Cloud Storage, in cui viene archiviato il file del modello salvato al termine dell'addestramento.
    • REGION specifica una 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 monitorarne lo stato e trasmettere i log:

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

Invia un job di ottimizzazione iperparametri

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

  • Il Dockerfile di esempio include il pacchetto cloudml-hypertune per installarlo nel container personalizzato.
  • Il codice campione (mnist.py):
    • Utilizza cloudml-hypertune per segnalare i risultati di ogni prova chiamando la relativa funzione di supporto, report_hyperparameter_tuning_metric. Il codice campione segnala i risultati dell'ottimizzazione degli iperparametri dopo la valutazione, a meno che il job non venga inviato come job di ottimizzazione degli iperparametri.
    • Aggiunge argomenti della riga di comando per ogni iperparametro e gestisce l'analisi dell'argomento con argparse.
  • La richiesta del job include HyperparameterSpec nell'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 le specifiche degli iperparametri. Ridefinisci MODEL_DIR e JOB_NAME. Se non lo hai già fatto, definisci REGION:

    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'immagine Docker diversa da quella utilizzata in precedenza. Abbiamo fornito un Dockerfile di esempio da utilizzare con GPU che soddisfa i seguenti requisiti:

  • Preinstalla il toolkit CUDA e cuDNN nel tuo contenitore. Il modo consigliato è utilizzare l'immagine nvidia/cuda come immagine di base, poiché il toolkit CUDA e cuDNN sono preinstallati e consente di configurare correttamente le variabili di ambiente correlate.
  • Installa dipendenze aggiuntive, come wget, curl, pip e tutte le altre necessarie dall'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 job di addestramento GPU utilizzando il Dockerfile GPU. Per evitare di eseguire l'override dell'immagine CPU, devi ridefinire IMAGE_REPO_NAME e IMAGE_TAG con nomi diversi da quelli utilizzati 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 tua macchina sono disponibili GPU e hai installato nvidia-docker, puoi verificare l'immagine eseguendola localmente:

    docker run --runtime=nvidia $IMAGE_URI --epochs 1
    
  3. Esegui il push dell'immagine Docker a 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 GPU.

  1. Ridefinisci MODEL_DIR e JOB_NAME. Definisci REGION se non l'hai già 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