Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Mask R-CNN mit Cloud TPU und GKE trainieren

In dieser Anleitung wird beschrieben, wie Sie das Modell "Mask RCNN" in Cloud TPU und GKE trainieren.

Ziele

  • Cloud Storage-Bucket zum Speichern der Dataset- und Modellausgabe erstellen
  • GKE-Cluster zum Verwalten Ihrer Cloud TPU-Ressourcen erstellen
  • Kubernetes-Jobspezifikation herunterladen, in der die Ressourcen beschrieben sind, die zum Trainieren des Mask RCNN-Modells mit TensorFlow in einer Cloud TPU benötigt werden
  • Job im GKE-Cluster ausführen, um mit dem Training des Modells zu beginnen
  • Logs und die Ausgabe des Modells überprüfen

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, darunter:

  • Compute Engine
  • Cloud TPU
  • Cloud Storage

Sie können mithilfe des Preisrechners die Kosten für Ihre voraussichtliche Nutzung kalkulieren. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweis

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

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

  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

    4. Wenn Sie Cloud TPU mit GKE verwenden, verwendet Ihr Projekt kostenpflichtige Komponenten von Google Cloud. Preisinformationen zur Kostenkalkulation finden Sie unter Cloud TPU-Preise und GKE-Preise. Wenn Sie Ressourcen nicht mehr benötigen, folgen Sie der Anleitung Ressourcen bereinigen.

  4. Aktivieren Sie die für diese Anleitung erforderlichen APIs, indem Sie die folgenden Links in der Cloud Console öffnen:

Cloud Storage-Bucket erstellen

Zum Speichern der Daten, die Sie zum Trainieren Ihres Modells verwenden, und zum Speichern der Trainingsergebnisse benötigen Sie einen Cloud Storage-Bucket. Das in dieser Anleitung verwendete Tool ctpu up richtet Standardberechtigungen für das Cloud TPU-Dienstkonto ein. Wenn Sie weitere Berechtigungen benötigen, können Sie die Berechtigungen auf Zugriffsebene anpassen.

  1. Rufen Sie die Cloud Storage-Seite in der Cloud Console auf.

    Zur Cloud Storage-Seite

  2. Erstellen Sie durch die Angabe der folgenden Optionen einen neuen Bucket:

    • Eindeutiger Name Ihrer Wahl
    • Standard-Speicherklasse: Regional
    • Speicherort für die Daten auswählen: region Standort: us-central1
    • Wählen Sie eine Standardspeicherklasse für Ihre Daten aus: Standard
    • Wählen Sie aus, wie der Zugriff auf Objekte gesteuert werden soll: Legen Sie Berechtigungen auf Objekt- und Bucket-Ebene fest

Cluster in GKE erstellen

Folgen Sie der Anleitung unten, um Ihre Umgebung einzurichten und mit dem gcloud-Befehlszeilentool einen GKE-Cluster mit Cloud TPU-Unterstützung zu erstellen.

  1. Öffnen Sie ein Cloud Shell-Fenster.

    Zu Cloud Shell

  2. Konfigurieren Sie das gcloud-Befehlszeilentool für das Projekt, in dem Sie eine Cloud TPU erstellen möchten.

    gcloud config set project ${PROJECT_ID}

    Wenn Sie diesen Befehl zum ersten Mal in einer neuen Cloud Shell-VM ausführen, wird die Seite Authorize Cloud Shell angezeigt. Klicken Sie auf Authorize unten auf der Seite, um es gcloud zu erlauben, GCP API-Aufrufe mit Ihren Anmeldedaten durchzuführen.

  3. Erstellen Sie ein Dienstkonto für das Cloud TPU-Projekt.

    gcloud beta services identity create --service tpu.googleapis.com --project $PROJECT_ID

    Der Befehl gibt ein Cloud TPU-Dienstkonto im folgenden Format zurück:

    service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com

  4. Cloud TPU Zugriff auf den Cloud Storage-Bucket gewähren

    Ihre Cloud TPU braucht Lese-/Schreibzugriff auf Ihre Cloud Storage-Objekte. Dazu müssen Sie den erforderlichen Zugriff auf das Dienstkonto gewähren, das von Cloud TPU verwendet wird. Folgen Sie dem Leitfaden, um Zugriff auf Ihren Storage-Bucket zu gewähren.

  5. Geben Sie die Zone an, in der Sie eine Cloud TPU-Ressource nutzen möchten. Verwenden Sie für dieses Beispiel die Zone us-central1-b:

    $ gcloud config set compute/zone us-central1-b

  6. Erstellen Sie mit dem Befehl gcloud container clusters in GKE einen Cluster mit Cloud TPU-Unterstützung. Der GKE-Cluster und seine Knotenpools müssen in einer Zone erstellt werden, in der Cloud TPU verfügbar ist, wie oben im Abschnitt über Umgebungsvariablen beschrieben. Mit dem folgenden Befehl wird ein Cluster mit dem Namen tpu-models-cluster erstellt:

    $ gcloud container clusters create tpu-models-cluster \
--cluster-version=1.13 \
--scopes=cloud-platform \
--enable-ip-alias \
--enable-tpu \
--machine-type=n1-standard-4

    Dabei gilt:

    • --cluster-version=1.13 gibt an, dass der Cluster die neueste Version von Kubernetes 1.16 verwendet. Sie müssen mindestens die Version 1.13.4-gke.5 verwenden.
    • --scopes=cloud-platform sorgt dafür, dass alle Knoten im Cluster Zugriff auf Ihren Cloud Storage-Bucket in Google Cloud haben, der oben als project-name definiert ist. Der Cluster und der Storage-Bucket müssen sich in demselben Projekt befinden. Beachten Sie, dass die Pods standardmäßig die Bereiche der Knoten übernehmen, für die sie bereitgestellt werden. Dieses Flag weist allen Pods, die im Cluster ausgeführt werden, den Bereich cloud-platform zu. Informationen dazu, wie Sie den Zugriff für einzelne Pods einschränken können, finden Sie im GKE-Leitfaden unter Mit Dienstkonten bei der Cloud Platform authentifizieren.
    • --enable-ip-alias gibt an, dass der Cluster Alias-IP-Bereiche verwendet. Dies ist für die Nutzung von Cloud TPU in GKE erforderlich.
    • --enable-tpu gibt an, dass der Cluster Cloud TPU unterstützen muss.
    • machine-type=n1-standard-4 ist erforderlich, um diesen Job auszuführen.

    Nachdem der Befehl beendet ist, wird eine Bestätigungsmeldung ähnlich der folgenden angezeigt:

    kubeconfig entry generated for tpu-models-cluster.
NAME                LOCATION       MASTER_VERSION   MASTER_IP      MACHINE_TYPE   NODE_VERSION   NUM_NODES  STATUS
tpu-models-cluster  us-central1-b  1.13.6-gke.5     35.232.204.86  n1-standard-4  1.13.6-gke.5   3          RUNNING

Trainingsdaten verarbeiten

Erstellen Sie nun einen Job. In Google Kubernetes Engine ist ein Job ein Controllerobjekt, das eine endliche Task darstellt. Der erste Job, den Sie erstellen, lädt das COCO-Dataset, das zum Trainieren des Mask RCNN-Modells verwendet wird, herunter und verarbeitet es.

  1. Erstellen Sie in Ihrer Shell-Umgebung eine Datei mit dem Namen download_and_preprocess_coco_k8s.yaml, wie unten gezeigt. Sie können diese Datei auch von GitHub herunterladen.

    tools/datasets/download_and_preprocess_coco_k8s.yaml 
    # Download and preprocess the COCO dataset.
#
# Instructions:
#   1. Follow the instructions on https://cloud.google.com/tpu/docs/kubernetes-engine-setup
#      to create a Kubernetes Engine cluster. The Job must be running at least
#      on a n1-standard-4 machine.
#   2. Change the environment variable DATA_BUCKET below to the path of the
#      Google Cloud Storage bucket where you want to store the training data.
#   3. Run `kubectl create -f download_and_preprocess_coco_k8s.yaml`.

apiVersion: batch/v1
kind: Job
metadata:
  name: download-and-preprocess-coco
spec:
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: download-and-preprocess-coco
        # The official TensorFlow 1.13 TPU model image built from https://github.com/tensorflow/tpu/blob/r1.13/tools/docker/Dockerfile.
        image: gcr.io/tensorflow/tpu-models:r1.13
        command:
          - /bin/bash
          - -c
          - >
            DEBIAN_FRONTEND=noninteractive apt-get update &&
            cd /tensorflow_tpu_models/tools/datasets &&
            bash download_and_preprocess_coco.sh /scratch-dir &&
            gsutil -m cp /scratch-dir/*.tfrecord ${DATA_BUCKET}/coco &&
            gsutil cp /scratch-dir/raw-data/annotations/*.json ${DATA_BUCKET}/coco
        env:
          # [REQUIRED] Must specify the Google Cloud Storage location where the
          # COCO dataset will be stored.
        - name: DATA_BUCKET
          value: "gs://<my-data-bucket>/data/coco"
        volumeMounts:
        - mountPath: /scratch-dir
          name: scratch-volume
      volumes:
      - name: scratch-volume
        persistentVolumeClaim:
          claimName: scratch-disk-coco
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: scratch-disk-coco
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 100Gi

  2. Suchen Sie die Umgebungsvariable DATA_BUCKET. Aktualisieren Sie value für diese Variable auf den Pfad, in dem Sie das COCO-Dataset im Cloud Storage-Bucket speichern möchten. Beispiel: "gs://my-maskrcnn-bucket/coco/"

  3. Führen Sie den folgenden Befehl aus, um den Job im Cluster zu erstellen:

    kubectl create -f download_and_preprocess_coco_k8s.yaml

Das Starten von Jobs kann einige Minuten dauern. Mit dem folgenden Befehl können Sie den Status der Jobs aufrufen, die im Cluster ausgeführt werden:

kubectl get pods -w

Dieser Befehl gibt Informationen über alle Jobs zurück, die im Cluster ausgeführt werden. Beispiel:

NAME                                 READY     STATUS      RESTARTS   AGE
download-and-preprocess-coco-xmx9s   0/1       Pending     0          10s

Mit dem Flag -w wird der Befehl angewiesen, nach Statusänderungen eines Pods zu suchen. Nach einigen Minuten sollte sich der Status des Jobs in Running ändern.

Wenn mit dem Job Probleme auftreten, können Sie ihn löschen und es noch einmal versuchen. Führen Sie dazu erst den Befehl kubectl delete -f download_and_preprocess_coco_k8s.yaml und anschließend den Befehl kubectl create noch einmal aus.

Nachdem der Download und die Vorverarbeitung abgeschlossen wurden, können Sie das Modell ausführen.

Mask RCNN-Modell ausführen

Jetzt können Sie das Mask RCNN-Modell mit Cloud TPU und GKE ausführen.

  1. Erstellen Sie in Ihrer Shell-Umgebung eine Datei mit dem Namen mask_rcnn_k8s.yaml, wie unten gezeigt. Sie können diese Datei auch von GitHub herunterladen.

    models/experimental/mask_rcnn/mask_rcnn_k8s.yaml 
    # Train Mask-RCNN with Coco dataset using Cloud TPU and Google Kubernetes Engine.
#
# [Training Data]
#   Download and preprocess the COCO dataset using https://github.com/tensorflow/tpu/blob/r1.13/tools/datasets/download_and_preprocess_coco_k8s.yaml
#   if you don't already have the data.
#
# [Instructions]
#   1. Follow the instructions on https://cloud.google.com/tpu/docs/kubernetes-engine-setup
#      to create a Kubernetes Engine cluster.
#   2. Change the environment variable MODEL_BUCKET in the Job spec to the
#      Google Cloud Storage location where you want to store the output model.
#   3. Run `kubectl create -f mask_rcnn_k8s.yaml`.

apiVersion: batch/v1
kind: Job
metadata:
  name: mask-rcnn-gke-tpu
spec:
  template:
    metadata:
      annotations:
        # The Cloud TPUs that will be created for this Job must support
        # TensorFlow 1.13. This version MUST match the TensorFlow version that
        # your model is built on.
        tf-version.cloud-tpus.google.com: "1.13"
    spec:
      restartPolicy: Never
      containers:
      - name: mask-rcnn-gke-tpu
        # The official TensorFlow 1.13 TPU model image built from https://github.com/tensorflow/tpu/blob/r1.13/tools/docker/Dockerfile.
        image: gcr.io/tensorflow/tpu-models:r1.13
        command:
        - /bin/sh
        - -c
        - >
            DEBIAN_FRONTEND=noninteractive apt-get update &&
            DEBIAN_FRONTEND=noninteractive apt-get install -y python-dev python-tk libsm6 libxrender1 libxrender-dev libgtk2.0-dev libxext6 libglib2.0 &&
            pip install Cython matplotlib opencv-python-headless &&
            pip install 'git+https://github.com/cocodataset/cocoapi#egg=pycocotools&subdirectory=PythonAPI' &&
            python /tensorflow_tpu_models/models/experimental/mask_rcnn/mask_rcnn_main.py
            --model_dir=${MODEL_BUCKET}
            --iterations_per_loop=500
            --config=resnet_checkpoint=${RESNET_CHECKPOINT},resnet_depth=50,use_bfloat16=true,train_batch_size=64,eval_batch_size=8,training_file_pattern=${DATA_BUCKET}/train-*,validation_file_pattern=${DATA_BUCKET}/val-*,val_json_file=${DATA_BUCKET}/instances_val2017.json,total_steps=22500
        env:
          # The Google Cloud Storage location to store dataset.
        - name: DATA_BUCKET
          value: "gs://<my-data-bucket>"
        - name: MODEL_BUCKET
          value: "gs://<my-model-bucket>/mask_rcnn"
        - name: RESNET_CHECKPOINT
          value: "gs://cloud-tpu-artifacts/resnet/resnet-nhwc-2018-02-07/model.ckpt-112603"

          # Point PYTHONPATH to the top level models folder
        - name: PYTHONPATH
          value: "/tensorflow_tpu_models/models"
        resources:
          limits:
            # Request a single v3-8 Cloud TPU device to train the model.
            # A single v3-8 Cloud TPU device consists of 4 chips, each of which
            # has 2 cores, so there are 8 cores in total.
            cloud-tpus.google.com/v3: 8

  2. Suchen Sie die Umgebungsvariable DATA_BUCKET. Aktualisieren Sie value für diese Variable auf den Pfad zu der Datei DATA_BUCKET, die Sie im Skript download_and_preprocess_coco_k8s.yaml angegeben haben.

  3. Suchen Sie die Umgebungsvariable MODEL_BUCKET. Aktualisieren Sie value für diese Variable auf den Pfad zu Ihrem Cloud Storage-Bucket. An diesem Ort speichert das Skript die Trainingsausgabe. Wenn der angegebene MODEL_BUCKET nicht vorhanden ist, wird er beim Ausführen des Jobs erstellt.

  4. Führen Sie den folgenden Befehl aus, um den Job im Cluster zu erstellen:

    kubectl create -f mask_rcnn_k8s.yaml

    Wenn Sie diesen Befehl ausführen, wird die folgende Bestätigungsnachricht angezeigt:

    job "mask-rcnn-gke-tpu" created

Wie im Abschnitt Trainingsdaten verarbeiten erwähnt, kann es einige Minuten dauern, bis ein Job gestartet wird. Mit dem folgenden Befehl können Sie den Status der Jobs aufrufen, die im Cluster ausgeführt werden:

kubectl get pods -w

Trainingsstatus ansehen

Sie können den Trainingsstatus mit dem kubectl-Befehlszeilentool verfolgen.

  1. Führen Sie den folgenden Befehl aus, um den Status des Jobs abzurufen:

    kubectl get pods

    Während des Trainingsprozesses sollte der Status des Pods RUNNING lauten.

  2. Führen Sie den folgenden Befehl aus, um weitere Informationen zum Trainingsprozess abzurufen:

    $ kubectl logs job name

    Dabei ist job name der vollständige Name des Jobs, z. B. mask-rcnn-gke-tpu-abcd.

    Sie können die Ausgabe auch auf dem GKE-Dashboard "Arbeitslasten" in der Cloud Console aufrufen.

    Es kann eine Weile dauern, bis der erste Eintrag im Log angezeigt wird. Sie können etwa folgende Ausgabe erwarten:

    I0622 18:14:31.617954 140178400511808 tf_logging.py:116] Calling model_fn.
I0622 18:14:40.449557 140178400511808 tf_logging.py:116] Create CheckpointSaverHook.
I0622 18:14:40.697138 140178400511808 tf_logging.py:116] Done calling model_fn.
I0622 18:14:44.004508 140178400511808 tf_logging.py:116] TPU job name worker
I0622 18:14:45.254548 140178400511808 tf_logging.py:116] Graph was finalized.
I0622 18:14:48.346483 140178400511808 tf_logging.py:116] Running local_init_op.
I0622 18:14:48.506665 140178400511808 tf_logging.py:116] Done running local_init_op.
I0622 18:14:49.135080 140178400511808 tf_logging.py:116] Init TPU system
I0622 18:15:00.188153 140178400511808 tf_logging.py:116] Start infeed thread controller
I0622 18:15:00.188635 140177578452736 tf_logging.py:116] Starting infeed thread controller.
I0622 18:15:00.188838 140178400511808 tf_logging.py:116] Start outfeed thread controller
I0622 18:15:00.189151 140177570060032 tf_logging.py:116] Starting outfeed thread controller.
I0622 18:15:07.316534 140178400511808 tf_logging.py:116] Enqueue next (100) batch(es) of data to infeed.
I0622 18:15:07.316904 140178400511808 tf_logging.py:116] Dequeue next (100) batch(es) of data from outfeed.
I0622 18:16:13.881397 140178400511808 tf_logging.py:116] Saving checkpoints for 100 into gs://<bucket-name>/mask_rcnn/model.ckpt.
I0622 18:16:21.147114 140178400511808 tf_logging.py:116] loss = 1.589756, step = 0
I0622 18:16:21.148168 140178400511808 tf_logging.py:116] loss = 1.589756, step = 0
I0622 18:16:21.150870 140178400511808 tf_logging.py:116] Enqueue next (100) batch(es) of data to infeed.
I0622 18:16:21.151168 140178400511808 tf_logging.py:116] Dequeue next (100) batch(es) of data from outfeed.
I0622 18:17:00.739207 140178400511808 tf_logging.py:116] Enqueue next (100) batch(es) of data to infeed.
I0622 18:17:00.739809 140178400511808 tf_logging.py:116] Dequeue next (100) batch(es) of data from outfeed.
I0622 18:17:36.598773 140178400511808 tf_logging.py:116] global_step/sec: 2.65061
I0622 18:17:37.040504 140178400511808 tf_logging.py:116] examples/sec: 2698.56
I0622 18:17:37.041333 140178400511808 tf_logging.py:116] loss = 2.63023, step = 200 (75.893 sec)

  3. Rufen Sie das trainierte Modell unter gs://<bucket-name>/mask-rcnn/model.ckpt auf.

    gsutil ls -r gs://bucket-name/mask-rcnn/model.ckpt

Clean-up

Wenn Sie mit Cloud TPU in GKE fertig sind, bereinigen Sie die Ressourcen, um zusätzliche Kosten für Ihr Google Cloud-Konto zu vermeiden.

Falls Sie das Projekt und die Zone für diese Sitzung noch nicht festgelegt haben, holen Sie dies jetzt nach. Die Anleitung hierzu finden Sie weiter oben in diesem Leitfaden. Befolgen Sie dann diese Schritte zur Bereinigung:

  1. Führen Sie den folgenden Befehl aus, um den GKE-Cluster tpu-models-cluster zu löschen. Ersetzen Sie dabei project-name durch den Namen Ihres Google Cloud-Projekts:

    $ gcloud container clusters delete tpu-models-cluster --project=project-name

  2. Wenn Sie mit dem Untersuchen der Daten fertig sind, löschen Sie mit dem Befehl gsutil alle Cloud Storage-Buckets, die Sie in dieser Anleitung erstellt haben. Ersetzen Sie bucket-name durch den Namen Ihres Cloud Storage-Buckets.

    $ gsutil rm -r gs://bucket-name

    Unter Cloud Storage-Preise finden Sie Informationen zu den Limits für die kostenlose Speichernutzung sowie weitere Preisinformationen.

Weitere Informationen