Cloud TPU-Anwendungen in GKE ausführen

In diesem Leitfaden wird Folgendes beschrieben:

Es gibt auch eine ausführliche Anleitung zum Trainieren eines TensorFlow ResNet-50-Modells mit Cloud TPU und GKE.

Vorteile der Ausführung von Cloud TPU-Anwendungen in GKE

Cloud TPU-Trainingsanwendungen können so konfiguriert werden, dass sie in GKE-Containern in GKE-Pods ausgeführt werden. Sollte dies der Fall sein, haben Sie folgende Vorteile:

  • Einfachere Einrichtung und Verwaltung: Wenn Sie Cloud TPU verwenden, benötigen Sie eine Compute Engine VM, um Ihre Arbeitslast auszuführen, und einen CIDR-Block (Classless Inter-Domain Routing) für Cloud TPU. GKE richtet die VM und den CIDR-Block ein und verwaltet die VM für Sie.

  • Optimierte Kosten: Sie zahlen nur dann für die TPU, wenn der Job aktiv ist. GKE erstellt und löscht gemäß den Ressourcenanforderungen eines Jobs automatisch TPUs.

  • Flexible Verwendung: Sie müssen nur eine einzige Zeile in Ihrer Pod-Spezifikation für einen anderen Hardwarebeschleuniger (CPU, GPU oder TPU) ändern:

    kind: Pod
    spec:
      containers:
      - name: example-container
        resources:
          limits:
            cloud-tpus.google.com/v2: 8
            # See the line above for TPU, or below for CPU / GPU.
            # cpu: 2
            # nvidia.com/gpu: 1
    
  • Skalierbarkeit: GKE bietet APIs (Job und Deployment), die Ressourcen problemlos auf Hunderte von Pods und Cloud TPU-Knoten skalieren können.

  • Fehlertoleranz: Die Job API von GKE stellt in Verbindung mit dem TensorFlow-Prüfpunktmechanismus die Semantik für die vollständige Ausführung bereit. Falls in den VM-Instanzen oder Cloud TPU-Knoten Fehler auftreten sollten, werden Ihre Trainingsjobs automatisch noch einmal ausgeführt, wobei der zuletzt vom Prüfpunkt gelesene Zustand verwendet wird.

Cloud TPU- und GKE-Konfigurationsanforderungen und -einschränkungen

Beachten Sie Folgendes, wenn Sie Ihre GKE-Konfiguration definieren:

  • Sie müssen mindestens die GKE-Version 1.13.4-gke.5 verwenden. Sie können die Version angeben, indem Sie wie unten beschrieben den Parameter --cluster-version dem Befehl gcloud container clusters create hinzufügen. Weitere Informationen zur Version finden Sie in der SDK-Dokumentation.
  • Sie müssen mindestens TensorFlow 1.15.5 verwenden. Geben Sie die TensorFlow-Version an, die von der Cloud TPU in Ihrer Kubernetes Pod-Spezifikation verwendet wird, wie unten beschrieben.
  • Sie müssen Ihren GKE-Cluster und die Knotenpools in einer Zone erstellen, in der die Cloud TPU verfügbar ist. Sie müssen außerdem die Cloud Storage-Buckets zum Speichern Ihrer Trainingsdaten und Modelle in derselben Region erstellen, in der sich auch Ihr GKE-Cluster befindet. Die folgenden Zonen sind verfügbar:

    USA

    TPU-Typ (v2) TPU v2-Kerne Gesamter TPU-Arbeitsspeicher Region/Zone
    v2–8 8 64 GiB us-central1-b
    us-central1-c
    us-central1-f
    v2–32 32 256 GiB us-central1-a
    v2-128 128 1 TiB us-central1-a
    v2-256 256 2 TiB us-central1-a
    v2-512 512 4 TiB us-central1-a
    TPU-Typ (v3) TPU v3-Kerne Gesamter TPU-Arbeitsspeicher Verfügbare Zonen
    v3–8 8 128 GiB us-central1-a
    us-central1-b
    us-central1-f

    Europa

    TPU-Typ (v2) TPU v2-Kerne Gesamter TPU-Arbeitsspeicher Region/Zone
    v2–8 8 64 GiB europe-west4-a
    v2–32 32 256 GiB europe-west4-a
    v2-128 128 1 TiB europe-west4-a
    v2-256 256 2 TiB europe-west4-a
    v2-512 512 4 TiB europe-west4-a
    TPU-Typ (v3) TPU v3-Kerne Gesamter TPU-Arbeitsspeicher Verfügbare Zonen
    v3–8 8 128 GiB europe-west4-a
    v3-32 32 512 GiB europe-west4-a
    v3–64 64 1 TiB europe-west4-a
    v3–128 128 2 TiB europe-west4-a
    v3–256 256 4 TiB europe-west4-a
    v3–512 512 8 TiB europe-west4-a
    v3–1024 1.024 16 TiB europe-west4-a
    v3–2048 2.048 32 TiB europe-west4-a

    Asiatisch-pazifischer Raum

    TPU-Typ (v2) TPU v2-Kerne Gesamter TPU-Arbeitsspeicher Region/Zone
    v2–8 8 64 GiB asia-east1-c
  • Jeder Container kann höchstens eine Cloud TPU anfordern. Mehrere Container in einem Pod können jedoch jeweils eine Cloud TPU anfordern.
  • Cluster Autoscaler unterstützt Cloud TPU ab GKE 1.13.4-gke.5.

Hinweis

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  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. Schauen Sie sich die Cloud TPU-Preise und die GKE-Preise an, um Ihre Kosten zu schätzen, und folgen Sie dann der Anleitung zum Bereinigen von Ressourcen, die nicht mehr gebraucht werden.

  5. Aktivieren Sie die folgenden APIs in der Cloud Console:

Dienstkonto und Cloud Storage-Bucket erstellen

Sie benötigen einen Cloud Storage-Bucket, um die Ergebnisse des Trainings Ihres Modells für maschinelles Lernen zu speichern.

  1. Öffnen Sie ein Cloud Shell-Fenster.

    Zu Cloud Shell

  2. Erstellen Sie eine Variable für Ihre Projekt-ID.

    export PROJECT_ID=project-id
    
  3. Erstellen Sie mit der gcloud API 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. Erstellen Sie durch die Angabe der folgenden Optionen einen neuen Bucket:

    • Eindeutiger Name Ihrer Wahl
    • Standorttyp: region
    • Speicherort: us-central1
    • Standard-Speicherklasse: Standard
    • Zugriffsteuerung: fine-grained

    Bevor Sie den Storage-Bucket verwenden können, müssen Sie dem Cloud TPU-Dienstkonto Zugriff auf den Bucket gewähren. Richten Sie präzise ACLs für Ihr Cloud TPU-Dienstkonto ein.

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.

Neuen Cluster mit Cloud TPU-Unterstützung erstellen

Sie können einen Cluster mit Cloud TPU-Unterstützung erstellen. Verwenden Sie dazu die Cloud Console oder das gcloud-Tool.

Wählen Sie nachstehend eine Option aus, um die entsprechende Anleitung aufzurufen.

Console

So erstellen Sie einen GKE-Cluster mit Cloud TPU-Unterstützung:

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

    Zur Seite "GKE"

  2. Klicken Sie auf Cluster erstellen.

  3. Geben Sie einen Namen für Ihren Cluster ein. Dieser darf nicht mehrfach innerhalb des Projekts oder der Zone vergeben werden.

  4. Wählen Sie als Standorttyp zonale und dann die gewünschte Zone aus, in der Sie eine Cloud TPU-Ressource verwenden möchten. Wählen Sie beispielsweise die Zone us-central1-b aus.

  5. Achten Sie darauf, dass die Masterversion auf 1.13.4-gke.5 oder eine höhere Version gesetzt ist, damit Cloud TPU unterstützt werden kann.

  6. Klicken Sie im Navigationsbereich unter dem Knotenpool, den Sie konfigurieren möchten, auf Sicherheit.

  7. Wählen Sie Uneingeschränkten Zugriff auf alle Cloud-APIs zulassen aus Dadurch wird allen Knoten im Cluster der Zugriff auf Ihren Cloud Storage-Bucket ermöglicht. Der Cluster und der Storage-Bucket müssen sich in demselben Projekt befinden, damit dies funktioniert. Standardmäßig übernehmen Kubernetes-Pods die Bereiche der Knoten, für die sie bereitgestellt werden. 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.

  8. Klicken Sie im Navigationsbereich unter Cluster auf Netzwerk.

  9. Wählen Sie VPC-natives Traffic-Routing aktivieren (verwendet Alias-IP-Adresse) aus. Sie müssen ein VPC-Netzwerk erstellen, wenn für das aktuelle Projekt noch keines vorhanden ist.

  10. Klicken Sie im Navigationsbereich unter Cluster auf Features.

  11. Wählen Sie Cloud TPU aktivieren aus.

  12. Konfigurieren Sie die verbleibenden Optionen für Ihre Cluster wie gewünscht. Sie können die Optionen mit den Standardwerten belassen.

  13. Klicken Sie auf Erstellen.

  14. Als Nächstes erstellen Sie die Verbindung zum Cluster: Wählen Sie dazu Ihren Cluster auf der Seite mit den Kubernetes-Clustern der Console aus und klicken Sie auf die Schaltfläche VERBINDEN. Der gcloud-Befehl zur Ausführung in Cloud Shell wird angezeigt.

gcloud

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

  1. Installieren Sie die gcloud-Komponenten, die Sie zum Ausführen von GKE mit Cloud TPU benötigen:

    $ gcloud components install kubectl 
  2. Konfigurieren Sie gcloud mit Ihrer Google Cloud-Projekt-ID.

    $ gcloud config set project project-name
    

    Ersetzen Sie project-name durch den Namen des Google Cloud-Projekts.

    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. Konfigurieren Sie gcloud mit der Zone, in der Sie eine Cloud TPU-Ressource verwenden möchten. Verwenden Sie für diese Anleitung die Zone us-central1-b:

    $ gcloud config set compute/zone us-central1-b
    
  4. Verwenden Sie den Befehl gcloud container clusters create, um in GKE einen Cluster mit Unterstützung für Cloud TPU zu erstellen. Ersetzen Sie im folgenden Befehl cluster-name durch einen Clusternamen Ihrer Wahl:

    $ gcloud container clusters create cluster-name \
      --cluster-version=1.16 \
      --scopes=cloud-platform \
      --enable-ip-alias \
      --enable-tpu
    

    Beschreibung der Befehls-Flags

    cluster-version
    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
    Stellt sicher, dass alle Knoten im Cluster Zugriff auf Ihren Cloud Storage-Bucket haben. Der Cluster und der Storage-Bucket müssen sich im selben Projekt befinden, damit dies funktioniert. Beachten Sie, dass die Kubernetes Pods standardmäßig die Bereiche der Knoten übernehmen, für die sie bereitgestellt werden. Daher teilt scopes=cloud-platform allen Kubernetes 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.
    tpu-ipv4-cidr (optional, oben nicht angegeben)
    Gibt den CIDR-Bereich an, der für Cloud TPU verwendet werden soll. Geben Sie die IP_RANGE im Format IP/20 an, z. B. 10.100.0.0/20. Wenn Sie dieses Flag nicht angeben, wird automatisch ein CIDR-Bereich mit einer Größe von /20 zugeordnet und zugewiesen.

    Wenn der Cluster erstellt wurde, sollte eine Meldung wie die folgende angezeigt werden:

    NAME             LOCATION       MASTER_VERSION    MASTER_IP     MACHINE_TYPE   NODE_VERSION      NUM_NODES  STATUS
    cluster-resnet  us-central1-b  1.16.15-gke.4901  34.71.245.25  n1-standard-1  1.16.15-gke.4901  3          RUNNING
    

Clustervorgänge ansehen

Wenn Sie die Cloud TPU-Unterstützung aktivieren, wird ein Aktualisierungsvorgang gestartet. Bei zonalen Clustern dauert dieser Vorgang etwa 5 Minuten, bei regionalen Clustern je nach Clusterregion etwa 15 Minuten.

Führen Sie folgenden Befehl aus, um alle ausgeführten und abgeschlossenen Vorgänge in Ihrem Cluster aufzulisten:

   $ gcloud container operations list
   

Führen Sie folgenden Befehl aus, um weitere Informationen zu einem bestimmten Vorgang abzurufen:

   $ gcloud container operations describe operation-id
   

Ersetzen Sie operation-id durch die ID des jeweiligen Vorgangs.

Cloud TPU in der Kubernetes Pod-Spezifikation anfordern

In der Kubernetes Pod-Spezifikation:

  • Geben Sie mit der folgenden Pod-Anmerkung die TensorFlow-Version an, die von den Cloud TPU-Knoten verwendet wird:

    tf-version.cloud-tpus.google.com: "x.y"
    

    Dabei ist x.y die von der Cloud TPU unterstützte TensorFlow-Version. Sie müssen mindestens TensorFlow 1.15.5 verwenden. Alle für einen Pod erstellten Cloud TPU-Instanzen müssen dieselbe TensorFlow-Version verwenden. Sie müssen alle Modelle in Ihren Containern mit derselben TensorFlow-Version erstellen. Siehe die unterstützten Versionen

  • Geben Sie die Cloud TPU-Ressource in der Containerspezifikation im Bereich limits unter dem Feld resource an.

    Die Einheit der Cloud TPU-Ressource ist die Anzahl der Cloud TPU-Kerne. Alle gültigen Ressourcenanfragen werden in der folgenden Tabelle aufgeführt.

    Wenn die zu verwendende Ressource ein Cloud TPU Pod ist, müssen Sie ein Kontingent anfordern, da das Standardkontingent für Cloud TPU Pod null ist.

    Ressourcenanfrage Cloud TPU-Typ Erforderliche GKE-Version
    cloud-tpus.google.com/v2: 8 Ein Cloud TPU v2-Gerät (8 Kerne) 1.10.4-gke.2 oder höher
    cloud-tpus.google.com/v2: 32 Ein v2-32 Cloud TPU Pod (32 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v2: 128 Ein v2-128 Cloud TPU Pod (128 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v2: 256 Ein v2-256 Cloud TPU Pod (256 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v2: 512 Ein v2-512 Cloud TPU Pod (512 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v3: 32 Ein v3-32 Cloud TPU Pod (32 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v3: 64 Ein v3-64 Cloud TPU Pod (64 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v3: 128 Ein v3-128 Cloud TPU Pod (128 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v3: 256 Ein v3-256 Cloud TPU Pod (256 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v3: 512 Ein v3-512 Cloud TPU Pod (512 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v3: 1024 Ein v3-1024 Cloud TPU Pod (1024 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/v3: 2048 Ein v3-2048 Cloud TPU Pod (2048 Kerne) (Beta) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/preemptible-v2: 8 Ein Cloud TPU v2-Gerät auf Abruf (8 Kerne) 1.10.6-gke.1 oder höher
    cloud-tpus.google.com/v3: 8 Ein Cloud TPU v3-Gerät (8 Kerne) 1.10.7-gke.6 oder höher
    cloud-tpus.google.com/preemptible-v3: 8 Ein Cloud TPU v3-Gerät auf Abruf (8 Kerne) 1.10.7-gke.6 oder höher

    Weitere Informationen zur Angabe von Ressourcen und Limits in der Pod-Spezifikation finden Sie in der Kubernetes-Dokumentation.

Die folgende beispielhafte Jobspezifikation fordert ein Cloud TPU v2-Gerät auf Abruf mit TensorFlow 2.3 an. Außerdem wird ein TensorBoard-Prozess gestartet.

Die Lebensdauer von Cloud TPU-Knoten ist an die Kubernetes Pods gebunden, die diese anfordern. Die Cloud TPU wird nach Bedarf beim Planen des Kubernetes Pods erstellt und beim Löschen des Kubernetes Pods anderweitig verwendet.

apiVersion: batch/v1
kind: Job
metadata:
  name: resnet-tpu
spec:
  template:
    metadata:
      annotations:
        # The Cloud TPUs that will be created for this Job will support
        # TensorFlow 2.3. This version MUST match the
        # TensorFlow version that your model is built on.
        tf-version.cloud-tpus.google.com: "2.3"
    spec:
      restartPolicy: Never
      containers:
      - name: resnet-tpu
        # The official TensorFlow 2.3.0 image.
        # https://hub.docker.com/r/tensorflow/tensorflow
        image: tensorflow/tensorflow:2.3.0
        command:
        - bash
        - -c
        - |
          pip install tf-models-official==2.3.0
          python3 -m official.vision.image_classification.resnet.resnet_ctl_imagenet_main \
            --tpu=$(KUBE_GOOGLE_CLOUD_TPU_ENDPOINTS) \
            --distribution_strategy=tpu \
            --steps_per_loop=500 \
            --log_steps=500 \
            --use_synthetic_data=true \
            --dtype=fp32 \
            --enable_tensorboard=true \
            --train_epochs=90 \
            --epochs_between_evals=1 \
            --batch_size=1024 \
            --model_dir=gs://bucket-name/resnet
        resources:
          limits:
            # Request a single Preemptible v2-8 Cloud TPU device to train the
            # model. A single v2-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/preemptible-v2: 8
      - name: tensorboard
        image: tensorflow/tensorflow:2.2.0
        command:
        - bash
        - -c
        - |
          pip install tensorboard-plugin-profile==2.3.0 cloud-tpu-client
          tensorboard --logdir=gs://bucket-name/resnet --port=6006
        ports:
        - containerPort: 6006

Job erstellen

Führen Sie folgende Schritte aus, um den Job im GKE-Cluster zu erstellen und kubectl zu installieren:

  1. Erstellen Sie mit einem Texteditor eine Jobspezifikation (example-job.yaml) und kopieren Sie sie in die oben gezeigte Jobspezifikation. Achten Sie darauf, die Variable bucket-name im Parameter --model_dir und im Tensorboard-Befehl durch den Namen Ihres Storage-Buckets zu ersetzen.

  2. Führen Sie den Job aus:

    $ kubectl create -f example-job.yaml
    
    job "resnet-tpu" created

    Dieser Befehl erstellt den Job, der den Pod automatisch plant.

  3. Prüfen Sie, dass der Pod geplant und die Cloud TPU-Knoten bereitgestellt wurden. Ein Pod, der Cloud TPU-Knoten anfordert, kann vor der Ausführung 5 Minuten lang den Status "Pending" (Ausstehend) haben. Bis der Pod geplant ist, ähnelt die Ausgabe der unten gezeigten.

    $ kubectl get pods -w
    
    NAME               READY     STATUS    RESTARTS   AGE
    resnet-tpu-cmvlf   0/1       Pending   0          1m
    

    Nach 5 Minuten sollten Sie in etwa Folgendes sehen:

    NAME               READY     STATUS    RESTARTS   AGE
    resnet-tpu-cmvlf   1/1       Running   0          6m
    

Cloud TPU-Status und Logs ansehen

Führen Sie die folgenden Schritte aus, um den Status zu überprüfen und die Logs der von Ihren Kubernetes-Pods verwendeten Cloud TPU-Instanzen aufzurufen.

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

    Zur Seite "GKE"

  2. Klicken Sie in der linken Navigationsleiste auf Arbeitslasten.

  3. Wählen Sie Ihren Job aus. Dadurch wird eine Seite mit der Überschrift Verwaltete Pods aufgerufen.

  4. Wählen Sie unter Verwaltete Pods Ihren Kubernetes Pod aus. Dadurch gelangen Sie zu einer Seite mit der Überschrift Container.

    Unter Container wird eine Liste der Container angezeigt. Die Liste enthält alle Cloud TPU-Instanzen. Für jeden Container werden diese Informationen angezeigt:

    • Ausführungsstatus
    • Link zu den Containerlogs

Mit TensorBoard Messwerte visualisieren und die Leistung überwachen

TensorBoard stellt eine Gruppe von Tools für die visuelle Darstellung von TensorFlow-Daten bereit. TensorBoard kann Sie dabei unterstützen, Verarbeitungsengpässe zu identifizieren, und liefert Vorschläge zur Verbesserung der Leistung.

TPU Profiler ist ein TensorBoard-Plug-in zum Erfassen eines Profils für eine einzelne Cloud TPU oder ein Cloud TPU Pod, das in TensorBoard visualisiert werden kann. Die Cloud TPU-Toolauswahl wird in der TensorBoard-Menüleiste auf dem Tab Profil verfügbar, wenn Sie mithilfe von TPU Profiler Trace-Informationen aus einem laufenden TensorFlow-Modell erfasst haben.

TensorBoard in einem GKE-Cluster ausführen

Führen Sie die folgenden Schritte aus, um TensorBoard im GKE-Cluster auszuführen:

  1. Führen Sie die Schritte aus, um den TensorBoard-Status anzuzeigen und zu prüfen, ob die TensorBoard-Instanz in einem Container ausgeführt wird.

  2. Portweiterleitung zum TensorBoard-Kubernetes Pod:

    $ kubectl port-forward pod/resnet-tpu-pod-id 6006
    

    Dabei ist pod-id die letzte Ziffernfolge Ihres GKE-Pod-Namens, die in der Console angezeigt wird: Kubernetes Engine > Arbeitslasten > Verwaltete Pods. Beispiel: resnet-tpu-wxskc.

  3. Klicken Sie in der Leiste oben rechts in der Cloud Shell auf die Schaltfläche Webvorschau und öffnen Sie Port 6006, um die TensorBoard-Ausgabe anzusehen. Die TensorBoard-UI wird als Tab in Ihrem Browser angezeigt.

  4. Wählen Sie oben rechts auf der TensorBoard-Seite im Drop-down-Menü PROFILE aus.

  5. Klicken Sie auf der Seite PROFILE auf die Schaltfläche CAPTURE PROFILE.

  6. Wählen Sie im Pop-up-Menü den TPU-Namensadresstyp aus und geben Sie den TPU-Namen ein. Der TPU-Name wird in der Cloud Console auf der Seite Compute Engine > TPUs in diesem Format angezeigt:

    gke-cluster-name-cluster-id-tpu-tpu-id
    
    Beispiel:
    gke-demo-cluster-25cee208-tpu-4b90f4c5

  7. Wählen Sie im Pop-up-Menü die Schaltfläche CAPTURE aus, um mit der Profilerstellung zu beginnen. Warten Sie dann einige Sekunden, bis das Profil erstellt ist.

  8. Aktualisieren Sie den Browser, damit die Tracing-Daten auf dem Tab PROFILE in TensorBoard angezeigt werden.

Weitere Informationen zum Erfassen und Interpretieren von Profilen finden Sie in der TensorFlow-Profiler-Anleitung.

Ihr Modell im Docker-Image erstellen und containerisieren

Sie können entweder ein offizielles TPU-Modell verwenden, das in Docker-Images containerisiert wurde, oder Ihr eigenes Modell erstellen und containerisieren.

  • Offizielle TPU-Modelle verwenden

    Die neuesten offiziellen TPU-Modelle. Container sind in Docker-Images containerisiert. Diese Docker-Images umfassen ein Dockerfile.

  • Eigenes Modell erstellen

    Die Colab-Notebooks in der TensorFlow-Dokumentation enthalten Beispiele zum Erstellen Ihres eigenen Modells.

    Wenn Sie Ihr eigenes Modell erstellen möchten, führen Sie die folgenden Schritte aus, um das Modell in einem Docker-Image zu containerisieren und es in die Google Container Registry zu verschieben.

    1. Aktivieren Sie die folgenden APIs in der Cloud Console:

    2. Erstellen Sie ein Dockerfile mit den folgenden Zeilen.

      FROM tensorflow/tensorflow:2.3.0
      
      RUN pip install tf-models-official==2.3.0 tensorboard-plugin-profile==2.3.0 cloud-tpu-client
      
    3. Führen Sie den folgenden Befehl im selben Verzeichnis wie das Dockerfile aus, um das Docker-Image zu erstellen und zu taggen. Ersetzen Sie die Variable my-project durch den Namen Ihres Projekts und ersetzen Sie die Variable my-image durch einen Image-Namen.

      gcloud builds submit . -t gcr.io/my-project/my-image
      

      Das Präfix gcr.io bezieht sich auf die Container Registry, in der das Image gehostet wird. Durch Ausführen dieses Befehls wird das Image nicht hochgeladen.

    4. Führen Sie den Befehl docker images aus, um zu prüfen, ob der Build erfolgreich war:

       docker images
      
      Ausgabe:
      REPOSITORY                     TAG                 IMAGE ID            CREATED             SIZE
      gcr.io/my-project/my-image     v1                  25cfadb1bf28        10 seconds ago      54 MB
      
    5. Aktualisieren Sie die Jobspezifikation, um das Docker-Image zu verwenden. Ersetzen Sie die Variablen my-project und my-image durch Ihren Projektnamen und einen von Ihnen definierten Image-Namen. Ersetzen Sie außerdem die Variable bucket-name durch den Namen eines Buckets, in dem Sie die Trainingsausgabe Ihres Modells speichern.

        image: gcr.io/my-project/my-image
        command:
          - python3
          - -m
          - official.vision.image_classification.resnet.resnet_ctl_imagenet_main
          -  --tpu=$(KUBE_GOOGLE_CLOUD_TPU_ENDPOINTS)
          -  --distribution_strategy=tpu
          -  --steps_per_loop=500
          -  --log_steps=500
          -  --use_synthetic_data=true
          -  --dtype=fp32
          -  --enable_tensorboard=true
          -  --train_epochs=90
          -  --epochs_between_evals=1
          -  --batch_size=1024
          -  --model_dir=gs://<bucket-name>/resnet-output
      
    6. Erstellen und führen Sie den Job wie bei einem offiziellen TPU-Modell aus.

Cloud TPU für einen vorhandenen Cluster aktivieren

Führen Sie folgende Schritte im gcloud-Befehlszeilentool aus, um die Cloud TPU-Unterstützung für einen vorhandenen GKE-Cluster zu aktivieren:

  1. Aktivieren Sie die Cloud TPU-Unterstützung:

    gcloud beta container clusters update cluster-name --enable-tpu
    

    Ersetzen Sie cluster-name durch den Namen Ihres Clusters.

  2. Aktualisieren Sie den kubeconfig-Eintrag:

    gcloud container clusters get-credentials cluster-name
    

Benutzerdefinierten CIDR-Bereich festlegen

Standardmäßig weist GKE den vom Cluster bereitgestellten TPUs einen CIDR-Block mit der Größe /20 zu. Sie können einen benutzerdefinierten CIDR-Bereich für die Cloud TPU angeben. Führen Sie dazu folgenden Befehl aus:

gcloud beta container clusters update cluster-name \
  --enable-tpu \
  --tpu-ipv4-cidr 10.100.0.0/20

Dabei gilt:

  • cluster-name ist der Name Ihres vorhandenen Clusters.
  • 10.100.0.0/20: Ihr benutzerdefinierter CIDR-Bereich.

Cloud TPU in einem Cluster deaktivieren

Führen Sie folgende Schritte im gcloud-Befehlszeilentool aus, um die Cloud TPU-Unterstützung für einen vorhandenen GKE-Cluster zu deaktivieren:

  1. Prüfen Sie, dass keine Ihrer Arbeitslasten Cloud TPU verwendet:

    $ kubectl get tpu
    
  2. Deaktivieren Sie die Cloud TPU-Unterstützung in Ihrem Cluster:

    $ gcloud beta container clusters update cluster-name --no-enable-tpu
    

    Ersetzen Sie cluster-name durch den Namen Ihres Clusters.

    Bei zonalen Clustern dauert dieser Vorgang etwa 5 Minuten, bei regionalen Clustern je nach Clusterregion etwa 15 Minuten.

  3. Sobald die Vorgänge ohne Fehler abgeschlossen sind, können Sie prüfen, ob die vom Cluster bereitgestellten TPUs entfernt wurden:

    $ gcloud compute tpus list
    

    Die Namen der von Cloud TPU erstellten TPUs haben folgendes Format:

    $ gke-cluster-name-cluster-id-tpu-tpu-id
    

    Dabei gilt:

    • cluster-name ist der Name Ihres vorhandenen Clusters.
    • cluster-id ist die ID Ihres vorhandenen Clusters.
    • tpu-id ist die ID der Cloud TPU.

    Wenn TPUs angezeigt werden, können Sie sie mit folgendem Befehl manuell löschen:

    $ gcloud compute tpus delete gke-cluster-name-cluster-id-tpu-tpu-id
    

Bereinigen

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

Konsole

So löschen Sie den GKE-Cluster:

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

    Zur Seite "GKE"

  2. Klicken Sie auf das Kästchen neben dem Cluster, den Sie löschen möchten.

  3. Klicken Sie auf Löschen.

Wenn Sie mit der Prüfung der Daten fertig sind, löschen Sie den von Ihnen erstellten Cloud Storage-Bucket:

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

    Zur Cloud Storage-Seite

  2. Klicken Sie auf das Kästchen neben dem Bucket, den Sie löschen möchten.

  3. Klicken Sie auf Löschen.

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

gcloud

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 zu löschen. Ersetzen Sie dabei cluster-name durch den Clusternamen und project-name durch den Namen des Google Cloud-Projekts:

    $ gcloud container clusters delete cluster-name --project=project-name
    
  2. Wenn Sie mit dem Untersuchen der Daten fertig sind, löschen Sie mit dem Befehl gsutil alle von Ihnen erstellten Cloud Storage-Buckets. 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

  • Mit der Anleitung das TensorFlow ResNet-50-Modell in Cloud TPU und GKE trainieren
  • Weitere Modelle und Dataset-Abrufjobs mit einer der folgenden Jobspezifikationen ausführen:
  • COCO-Dataset in GKE herunterladen und vorverarbeiten
  • ImageNet in GKE herunterladen und vorverarbeiten
  • AmoebaNet-D mit Cloud TPU und GKE trainieren
  • Inception v3 mit Cloud TPU und GKE trainieren
  • RetinaNet mit Cloud TPU und GKE trainieren