Erste Schritte: Training mit benutzerdefinierten Containern

AI Platform unterstützt das Training in benutzerdefinierten Containern. So können Nutzer ihre eigenen Docker-Container mit einem beliebigen vorinstallierten ML-Framework oder -Algorithmus auf AI Platform ausführen. Diese Schritt-für-Schritt-Anleitung zeigt einführend, wie ein PyTorch-Modell auf AI Platform mit einem benutzerdefinierten Container trainiert wird.

Übersicht

In diesem Startleitfaden wird das Training mit benutzerdefinierten Containern auf AI Platform anhand eines Grundmodells veranschaulicht, das handschriftliche Ziffern basierend auf dem MNIST-Dataset klassifiziert.

Der Leitfaden behandelt folgende Schritte:

  • Projekt und lokale Umgebung einrichten
  • Benutzerdefinierten Container erstellen
    • Dockerfile schreiben
    • Docker-Image lokal erstellen und testen
  • Image in Container Registry hochladen
  • Benutzerdefinierten Container-Trainingsjob senden
  • Hyperparameter-Abstimmungsjob senden
  • GPUs mit einem benutzerdefinierten Container verwenden

Hinweis

Sie können für diesen Startleitfaden jede beliebige Umgebung verwenden, in der das Cloud SDK installiert ist.

Optional: Lesen Sie die Erläuterungen zu den Konzepten für das Training mit benutzerdefinierten Containern.

Führen Sie die folgenden Schritte aus, um ein GCP-Konto einzurichten, die erforderlichen APIs zu aktivieren sowie das Cloud SDK zu installieren und zu aktivieren.

  1. Melden Sie sich in Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, registrieren Sie sich hier für ein neues Konto.

  2. Wählen Sie in der GCP Console auf der Projektauswahlseite ein GCP-Projekt aus oder erstellen Sie ein Projekt.

    Zur Projektauswahl

  3. Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Platform-Projekt aktiviert ist. So bestätigen Sie die Abrechnung für Ihr Projekt.

  4. Aktivieren Sie die AI Platform ("Cloud Machine Learning Engine"), Compute Engine and Container Registryerforderlichen APIs.

    APIs aktivieren

  5. Installieren und initialisieren Sie das Cloud SDK.
  6. Installieren Sie Docker.

    Wenn Sie ein Linux-basiertes Betriebssystem wie Ubuntu oder Debian verwenden, fügen Sie der Gruppe docker Ihren Nutzernamen hinzu, damit Sie Docker ohne sudo ausführen können:

    sudo usermod -a -G docker ${USER}

    Möglicherweise müssen Sie Ihr System neu starten, wenn Sie sich zur Gruppe docker hinzugefügt haben.

  7. Öffnen Sie Docker. Prüfen Sie, ob Docker ausgeführt wird. Führen Sie dazu den folgenden Docker-Befehl aus, der die aktuelle Zeit und das aktuelle Datum zurückgibt:
    docker run busybox date
  8. Verwenden Sie gcloud als Credential Helper für Docker:
    gcloud auth configure-docker
  9. Optional: Wenn Sie den Container mit GPU lokal ausführen möchten, installieren Sie nvidia-docker.

Cloud Storage-Bucket einrichten

In diesem Abschnitt wird gezeigt, wie Sie einen neuen Bucket erstellen. Sie können auch einen vorhandenen Bucket verwenden. Dieser muss sich aber in der Region befinden, in der Sie AI Platform-Jobs ausführen. Hinzu kommt: Wenn der Bucket nicht in dem Projekt ist, das Sie für die Ausführung von AI Platform verwenden, müssen Sie den AI Platform-Dienstkonten explizit Zugriff gewähren.

  1. Geben Sie einen Namen für den neuen Bucket an. Der Name muss sich von allen anderen Bucket-Namen in Cloud Storage unterscheiden:

    BUCKET_NAME="your_bucket_name"

    Verwenden Sie beispielsweise den Projektnamen mit angehängtem -mlengine:

    PROJECT_ID=$(gcloud config list project --format "value(core.project)")
    BUCKET_NAME=${PROJECT_ID}-mlengine
  2. Prüfen Sie den erstellten Bucketnamen.

    echo $BUCKET_NAME
  3. Wählen Sie eine Region für den Bucket aus und legen Sie eine REGION-Umgebungsvariable fest.

    Verwenden Sie die Region, in der Sie auch AI Platform-Jobs ausführen möchten. Hier finden Sie die Regionen, in denen AI Platform-Dienste verfügbar sind.

    Mit dem folgenden Code wird beispielsweise REGION erstellt und dafür der Wert us-central1 festgelegt:

    REGION=us-central1
  4. Erstellen Sie den neuen Bucket:

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

Code für diese Anleitung herunterladen

  1. Laden Sie die Beispiel-ZIP-Datei für AI Platform mit folgendem Befehl herunter:

    wget https://github.com/GoogleCloudPlatform/cloudml-samples/archive/master.zip
    
  2. Entpacken Sie die Datei, um das Verzeichnis cloudml-samples-master zu extrahieren.

    unzip master.zip
    
  3. Wechsel Sie zum Verzeichnis cloudml-samples-master > pytorch > containers > quickstart > mnist. Die Befehle in dieser Schritt-für-Schritt-Anleitung müssen im Verzeichnis mnist ausgeführt werden.

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

Benutzerdefinierten Container erstellen

Bei der Erstellung eines benutzerdefinierten Containers besteht der erste Schritt in der Definition eines Dockerfile zur Installation der für den Trainingsjob erforderlichen Abhängigkeiten. Anschließend erstellen und testen Sie Ihr Docker-Image lokal, bevor Sie es mit AI Platform verwenden.

Dockerfile schreiben

Mit dem in dieser Anleitung angegebenen Beispiel-Dockerfile werden die folgenden Schritte ausgeführt:

  1. Python 2.7-Basis-Image mit integrierten Python-Abhängigkeiten verwenden
  2. Zusätzliche Abhängigkeiten, einschließlich PyTorch, Cloud SDK und cloudml-hypertune für die Hyperparameter-Abstimmung installieren
  3. Code für Ihre Trainingsanwendung in den Container kopieren
  4. Einstiegspunkt für AI Platform konfigurieren, damit Ihr Trainingscode beim Starten des Containers ausgeführt wird

Ihr Dockerfile kann je nach Ihren Anforderungen eine zusätzliche Logik enthalten. Weitere Informationen finden Sie auf der Seite zum Schreiben von Dockerfiles.

# 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.15-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"]

Docker-Image lokal erstellen und testen

  1. Erstellen Sie den richtigen Image-URI mithilfe von Umgebungsvariablen und anschließend das Docker-Image. Mit dem -t-Flag wird das Image mit den ausgewählten Optionen für IMAGE_REPO_NAME und IMAGE_TAG benannt und mit Tags versehen. Sie können für Ihr Image auch einen anderen Namen und ein anderes Tag auswählen.

    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. Prüfen Sie das Image und führen Sie es dazu lokal in einem neuen Container aus. Beachten Sie, dass das Flag --epochs an das Trainerskript übergeben wird.

    docker run $IMAGE_URI --epochs 1
    

Image in Container Registry hochladen

Wenn das Docker-Image korrekt lokal ausgeführt wird, können Sie es nach Container Registry in Ihrem Projekt übertragen.

Führen Sie als Erstes gcloud auth configure-docker aus, falls noch nicht geschehen.

docker push $IMAGE_URI

Job senden und überwachen

  1. Definieren Sie Umgebungsvariablen für Ihre Jobanfrage.

    • MODEL_DIR benennt ein neues Verzeichnis mit Zeitstempel in Ihrem Cloud Storage-Bucket, in dem Ihre Modelldatei nach Abschluss des Trainings gespeichert wird.
    • REGION gibt eine gültige Region für das AI Platform-Training an.
    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. Senden Sie den Trainingsjob mit dem gcloud-Tool an AI Platform. Übergeben Sie den URI mit dem Flag --master-image-uri an Ihr Docker-Image:

    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. Nachdem Sie Ihren Job gesendet haben, können Sie den Jobstatus und die Streamlogs überwachen:

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

Hyperparameter-Abstimmungsjob senden

Für einen Hyperparameter-Abstimmungsjob sind einige Anpassungen nötig. Beachten Sie die folgenden Bereiche im Beispielcode:

  • Das Beispiel-Dockerfile mit dem cloudml-hypertune-Paket, das im benutzerdefinierten Container installiert wird.
  • Der Beispielcode (mnist.py):
    • Verwendet cloudml-hypertune, um die Ergebnisse der einzelnen Testversionen durch Aufrufen der Helper-Funktion report_hyperparameter_tuning_metric zu melden. Der Beispielcode übergibt nach der Bewertung die Ergebnisse der Hyperparameter-Abstimmung, sofern der Job als Hyperparameter-Abstimmungsjob gesendet wurde.
    • Fügt Befehlszeilenargumente für jeden Hyperparameter hinzu und führt das Parsen des Arguments mit argparse aus.
  • Die Jobanfrage enthält HyperparameterSpec im Objekt TrainingInput. Im vorliegenden Fall optimieren wir --lr und --momentum, um den Modellverlust zu minimieren.
  1. Erstellen Sie eine Datei config.yaml für die Definition Ihrer Hyperparameter-Spezifikation. Definieren Sie MODEL_DIR und JOB_NAME neu. Definieren Sie REGION, falls noch nicht geschehen:

    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. Senden Sie den Hyperparameter-Abstimmungsjob an AI Platform:

    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"
    

GPUs mit benutzerdefinierten Containern verwenden

Zum Senden eines Jobs mit benutzerdefiniertem Container, der GPUs verwenden soll, müssen Sie ein anderes Docker-Image als das zuvor verwendete erstellen. Wir haben ein Beispiel-Dockerfile zur Verwendung mit GPUs bereitgestellt, das die folgenden Anforderungen erfüllt:

  • CUDA-Toolkit und cuDNN sind im Container vorinstalliert. Die Verwendung des Images nvidia/cuda als Basis-Image ist die empfohlene Vorgehensweise. Hier sind das CUDA-Toolkit und cuDNN vorinstalliert und die zugehörigen Umgebungsvariablen können korrekt eingerichtet werden.
  • Installieren Sie zusätzliche Abhängigkeiten, wie z. B. wget, curl und pip sowie alle anderen von Ihrer Trainingsanwendung benötigten Abhängigkeiten.
# 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"]

GPU-Docker-Image lokal erstellen und testen

  1. Erstellen Sie mit dem GPU-Dockerfile ein neues Image für Ihren GPU-Trainingsjob. Damit das CPU-Image nicht überschrieben wird, müssen Sie IMAGE_REPO_NAME und IMAGE_TAG mit anderen Namen neu definieren als jene, die Sie zuvor in der Anleitung verwendet haben:

    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. Wenn auf Ihrem Computer GPUs verfügbar sind und nvidia-docker installiert ist, können Sie das Image durch lokale Ausführung prüfen:

    docker run --runtime=nvidia $IMAGE_URI --epochs 1
    
  3. Laden Sie das Docker-Image in Container Registry hoch. Führen Sie als Erstes gcloud auth configure-docker aus, falls noch nicht geschehen.

    docker push $IMAGE_URI
    

Job senden

In diesem Beispiel wird für die Trainingsjobanfrage die einfache GPU-Skalierungsstufe verwendet. Hier finden Sie weitere Maschinenoptionen zum Trainieren mit GPUs.

  1. Definieren Sie MODEL_DIR und JOB_NAME neu. Definieren Sie auch REGION, falls noch nicht geschehen:

    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. Senden Sie den Trainingsjob mit dem gcloud-Tool an AI Platform. Übergeben Sie den URI mit dem Flag --master-image-uri an Ihr Docker-Image.

    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
    

Weitere Informationen