Von Prototyp zur Produktion: Verteiltes Training in Vertex AI

1. Übersicht

In diesem Lab verwenden Sie Vertex AI, um einen verteilten Trainingsjob in Vertex AI Training mit TensorFlow auszuführen.

Dieses Lab ist Teil der Videoserie Prototype to Production. Sie sollten die vorherigen Labs abgeschlossen haben, bevor Sie dieses Lab ausprobieren. Weitere Informationen finden Sie in der zugehörigen Videoserie:

.

Lerninhalte

Die folgenden Themen werden behandelt:

• Verteiltes Training auf einer einzelnen Maschine mit mehreren GPUs ausführen
• Verteiltes Training auf mehreren Maschinen ausführen

Die Gesamtkosten für die Ausführung dieses Labs in Google Cloud betragen etwa 2$.

2. Einführung in Vertex AI

In diesem Lab wird das neueste KI-Produkt von Google Cloud verwendet. Vertex AI vereint die ML-Angebote von Google Cloud in einer nahtlosen Entwicklungsumgebung. Bisher musste auf mit AutoML trainierte und benutzerdefinierte Modelle über verschiedene Dienste zugegriffen werden. Das neue Angebot kombiniert diese und weitere, neue Produkte zu einer einzigen API. Sie können auch vorhandene Projekte zu Vertex AI migrieren.

Vertex AI umfasst viele verschiedene Produkte zur Unterstützung von End-to-End-ML-Workflows. In diesem Lab konzentrieren wir uns auf die unten hervorgehobenen Produkte: Training und Workbench.

3. Überblick über verteiltes Training

Wenn Sie eine einzelne GPU haben, verwendet TensorFlow diesen Beschleuniger, um das Modelltraining zu beschleunigen, ohne dass Sie etwas tun müssen. Wenn Sie jedoch einen zusätzlichen Leistungsschub durch die Verwendung mehrerer GPUs erzielen möchten, müssen Sie tf.distribute verwenden. Das ist das TensorFlow-Modul zum Ausführen einer Berechnung auf mehreren Geräten.

Im ersten Abschnitt dieses Labs wird tf.distribute.MirroredStrategy verwendet, das Sie mit nur wenigen Codeänderungen zu Ihren Trainingsanwendungen hinzufügen können. Mit dieser Strategie wird eine Kopie des Modells auf jeder GPU auf Ihrer Maschine erstellt. Die nachfolgenden Gradientenaktualisierungen erfolgen synchron. Das bedeutet, dass jede GPU die Vorwärts- und Rückwärtsübergänge durch das Modell auf einer anderen Slice der Eingabedaten berechnet. Die berechneten Gradienten aus jeder dieser Slices werden dann auf alle GPUs aggregiert und in einem Prozess namens All-Reduce gemittelt. Die Modellparameter werden mit diesen gemittelten Gradienten aktualisiert.

Im optionalen Abschnitt am Ende des Labs wird tf.distribute.MultiWorkerMirroredStrategy verwendet, das MirroredStrategy ähnelt, aber auf mehreren Maschinen funktioniert. Jede dieser Maschinen kann auch mehrere GPUs haben. Wie MirroredStrategy ist MultiWorkerMirroredStrategy eine synchrone Datenparallelitätsstrategie, die Sie mit nur wenigen Codeänderungen verwenden können. Der Hauptunterschied beim Übergang von der synchronen Datenparallelität auf einer Maschine zu vielen besteht darin, dass die Gradienten am Ende jedes Schritts jetzt auf allen GPUs auf einer Maschine und auf allen Maschinen im Cluster synchronisiert werden müssen.

Sie müssen die Details nicht kennen, um dieses Lab abzuschließen. Wenn Sie jedoch mehr darüber erfahren möchten, wie verteiltes Training in TensorFlow funktioniert, sehen Sie sich das folgende Video an:

4. Umgebung einrichten

Führen Sie die Schritte im Lab Benutzerdefinierte Modelle mit Vertex AI trainieren aus, um Ihre Umgebung einzurichten.

5. Training mit mehreren GPUs auf einer einzelnen Maschine

Sie senden Ihren verteilten Trainingsjob an Vertex AI, indem Sie den Code Ihrer Trainingsanwendung in einen Docker-Container packen und diesen Container in Google Artifact Registry übertragen. Mit dieser Methode können Sie ein Modell trainieren, das mit einem beliebigen Framework erstellt wurde.

Öffnen Sie dazu im Launcher-Menü des Workbench-Notebooks, das Sie in den vorherigen Labs erstellt haben, ein Terminalfenster.

Schritt 1: Trainingscode schreiben

Erstellen Sie ein neues Verzeichnis mit dem Namen flowers-multi-gpu und wechseln Sie in dieses Verzeichnis:

mkdir flowers-multi-gpu
cd flowers-multi-gpu

Führen Sie den folgenden Befehl aus, um ein Verzeichnis für den Trainingscode und eine Python-Datei zu erstellen, in der Sie den folgenden Code hinzufügen.

mkdir trainer
touch trainer/task.py

Das Verzeichnis flowers-multi-gpu/ sollte jetzt Folgendes enthalten:

+ trainer/
    + task.py

Öffnen Sie als Nächstes die gerade erstellte Datei task.py und kopieren Sie den folgenden Code.

Sie müssen {your-gcs-bucket} in BUCKET_ROOT durch den Cloud Storage-Bucket ersetzen, in dem Sie das Dataset „flowers“ in Lab 1 gespeichert haben.

import tensorflow as tf
import numpy as np
import os

## Replace {your-gcs-bucket} !!
BUCKET_ROOT='/gcs/{your-gcs-bucket}'

# Define variables
NUM_CLASSES = 5
EPOCHS=10
BATCH_SIZE = 32

IMG_HEIGHT = 180
IMG_WIDTH = 180

DATA_DIR = f'{BUCKET_ROOT}/flower_photos'

def create_datasets(data_dir, batch_size):
  '''Creates train and validation datasets.'''

  train_dataset = tf.keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="training",
    seed=123,
    image_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=batch_size)

  validation_dataset = tf.keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="validation",
    seed=123,
    image_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=batch_size)

  train_dataset = train_dataset.cache().shuffle(1000).prefetch(buffer_size=tf.data.AUTOTUNE)
  validation_dataset = validation_dataset.cache().prefetch(buffer_size=tf.data.AUTOTUNE)

  return train_dataset, validation_dataset


def create_model():
  '''Creates model.'''

  model = tf.keras.Sequential([
    tf.keras.layers.Resizing(IMG_HEIGHT, IMG_WIDTH),
    tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
    tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
  ])
  return model

def main():  

  # Create distribution strategy
  strategy = tf.distribute.MirroredStrategy()

  # Get data
  GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
  train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)

  # Wrap model creation and compilation within scope of strategy
  with strategy.scope():
    model = create_model()
    model.compile(optimizer=tf.keras.optimizers.Adam(),
                  loss=tf.keras.losses.SparseCategoricalCrossentropy(),
                  metrics=['accuracy'])

  history = model.fit(
    train_dataset,
    validation_data=validation_dataset,
    epochs=EPOCHS
  )

  model.save(f'{BUCKET_ROOT}/model_output')


if __name__ == "__main__":
    main()

Bevor Sie den Container erstellen, sehen wir uns den Code genauer an. Es gibt einige Komponenten, die speziell für das verteilte Training verwendet werden.

• In der Funktion main() wird das Objekt MirroredStrategy erstellt. Als Nächstes umschließen Sie die Erstellung Ihrer Modellvariablen mit dem Bereich der Strategie. Mit diesem Schritt wird TensorFlow mitgeteilt, welche Variablen auf den GPUs gespiegelt werden sollen.
• Die Batchgröße wird mit num_replicas_in_sync skaliert. Das Skalieren der Batchgröße ist eine Best Practice bei der Verwendung synchroner Datenparallelitätsstrategien in TensorFlow. Weitere Informationen hier.

Schritt 2: Dockerfile erstellen

Um Ihren Code in einen Container zu packen, müssen Sie ein Dockerfile erstellen. Das Dockerfile enthält alle Befehle, die zum Ausführen des Images erforderlich sind. Es installiert alle erforderlichen Bibliotheken und richtet den Einstiegspunkt für den Trainingscode ein.

Erstellen Sie im Terminal ein leeres Dockerfile im Stammverzeichnis Ihres Verzeichnisses „flowers“:

touch Dockerfile

Das Verzeichnis flowers-multi-gpu/ sollte jetzt Folgendes enthalten:

+ Dockerfile
+ trainer/
    + task.py

Öffnen Sie das Dockerfile und kopieren Sie Folgendes hinein:

FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8

WORKDIR /

# Copies the trainer code to the docker image.
COPY trainer /trainer

# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]

Schritt 3: Container erstellen

Führen Sie im Terminal den folgenden Befehl aus, um eine Umgebungsvariable für Ihr Projekt zu definieren. Ersetzen Sie dabei your-cloud-project durch die ID Ihres Projekts:

Sie können Ihre Projekt-ID abrufen, indem Sie im Terminal gcloud config list --format 'value(core.project)' ausführen.

PROJECT_ID='your-cloud-project'

Erstellen Sie ein Repository in Artifact Registry. Wir verwenden das Repository, das wir im ersten Lab erstellt haben.

REPO_NAME='flower-app'

Definieren Sie eine Variable mit dem URI Ihres Container-Images in Artifact Registry:

IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:single_machine

Docker konfigurieren

gcloud auth configure-docker \
    us-central1-docker.pkg.dev

Erstellen Sie dann den Container, indem Sie den folgenden Befehl im Stammverzeichnis Ihres Verzeichnisses flowers-multi-gpu ausführen:

docker build ./ -t $IMAGE_URI

Übertragen Sie ihn schließlich per Push an Artifact Registry:

docker push $IMAGE_URI

Nachdem der Container per Push an Artifact Registry übertragen wurde, können Sie den Trainingsjob starten.

Schritt 4: Job mit dem SDK ausführen

In diesem Abschnitt erfahren Sie, wie Sie den verteilten Trainingsjob mit dem Vertex AI Python SDK konfigurieren und starten.

Erstellen Sie im Launcher ein TensorFlow 2-Notebook.

Importieren Sie das Vertex AI SDK.

from google.cloud import aiplatform

Definieren Sie dann einen CustomContainerTrainingJob.

Ersetzen Sie {PROJECT_ID} in container_uri und {YOUR_BUCKET} in staging_bucket.

job = aiplatform.CustomContainerTrainingJob(display_name='flowers-multi-gpu',
                                            container_uri='us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:single_machine',
                                            staging_bucket='gs://{YOUR_BUCKET}')

Nachdem der Job definiert wurde, können Sie ihn ausführen. Legen Sie die Anzahl der Beschleuniger auf 2 fest. Wenn wir nur eine GPU verwenden würden, wäre dies kein verteiltes Training. Verteiltes Training auf einer einzelnen Maschine bedeutet, dass Sie zwei oder mehr Beschleuniger verwenden.

my_custom_job.run(replica_count=1,
                  machine_type='n1-standard-4',
                  accelerator_type='NVIDIA_TESLA_V100',
                  accelerator_count=2)

In der Konsole können Sie den Fortschritt Ihres Jobs sehen.

6. [Optional] Training mit mehreren Workern

Nachdem Sie das verteilte Training auf einer einzelnen Maschine mit mehreren GPUs ausprobiert haben, können Sie Ihre Kenntnisse im verteilten Training verbessern, indem Sie auf mehreren Maschinen trainieren. Um die Kosten zu senken, fügen wir diesen Maschinen keine GPUs hinzu. Sie können aber auch mit dem Hinzufügen von GPUs experimentieren.

Öffnen Sie in Ihrer Notebook-Instanz ein neues Terminalfenster:

Schritt 1: Trainingscode schreiben

Erstellen Sie ein neues Verzeichnis mit dem Namen flowers-multi-machine und wechseln Sie in dieses Verzeichnis:

mkdir flowers-multi-machine
cd flowers-multi-machine

Führen Sie den folgenden Befehl aus, um ein Verzeichnis für den Trainingscode und eine Python-Datei zu erstellen, in der Sie den folgenden Code hinzufügen.

mkdir trainer
touch trainer/task.py

Das Verzeichnis flowers-multi-machine/ sollte jetzt Folgendes enthalten:

+ trainer/
    + task.py

Öffnen Sie als Nächstes die gerade erstellte Datei task.py und kopieren Sie den folgenden Code.

Sie müssen {your-gcs-bucket} in BUCKET_ROOT durch den Cloud Storage-Bucket ersetzen, in dem Sie das Dataset „flowers“ in Lab 1 gespeichert haben.

import tensorflow as tf
import numpy as np
import os

## Replace {your-gcs-bucket} !!
BUCKET_ROOT='/gcs/{your-gcs-bucket}'

# Define variables
NUM_CLASSES = 5
EPOCHS=10
BATCH_SIZE = 32

IMG_HEIGHT = 180
IMG_WIDTH = 180

DATA_DIR = f'{BUCKET_ROOT}/flower_photos'
SAVE_MODEL_DIR = f'{BUCKET_ROOT}/multi-machine-output'

def create_datasets(data_dir, batch_size):
  '''Creates train and validation datasets.'''

  train_dataset = tf.keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="training",
    seed=123,
    image_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=batch_size)

  validation_dataset = tf.keras.utils.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="validation",
    seed=123,
    image_size=(IMG_HEIGHT, IMG_WIDTH),
    batch_size=batch_size)

  train_dataset = train_dataset.cache().shuffle(1000).prefetch(buffer_size=tf.data.AUTOTUNE)
  validation_dataset = validation_dataset.cache().prefetch(buffer_size=tf.data.AUTOTUNE)

  return train_dataset, validation_dataset


def create_model():
  '''Creates model.'''

  model = tf.keras.Sequential([
    tf.keras.layers.Resizing(IMG_HEIGHT, IMG_WIDTH),
    tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
    tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
  ])
  return model

def _is_chief(task_type, task_id):
  '''Helper function. Determines if machine is chief.'''

  return task_type == 'chief'


def _get_temp_dir(dirpath, task_id):
  '''Helper function. Gets temporary directory for saving model.'''

  base_dirpath = 'workertemp_' + str(task_id)
  temp_dir = os.path.join(dirpath, base_dirpath)
  tf.io.gfile.makedirs(temp_dir)
  return temp_dir


def write_filepath(filepath, task_type, task_id):
  '''Helper function. Gets filepath to save model.'''

  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id):
    dirpath = _get_temp_dir(dirpath, task_id)
  return os.path.join(dirpath, base)

def main():
  # Create distribution strategy
  strategy = tf.distribute.MultiWorkerMirroredStrategy()

  # Get data
  GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
  train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)

  # Wrap variable creation within strategy scope
  with strategy.scope():
    model = create_model()
    model.compile(optimizer=tf.keras.optimizers.Adam(),
                  loss=tf.keras.losses.SparseCategoricalCrossentropy(),
                  metrics=['accuracy'])

  history = model.fit(
    train_dataset,
    validation_data=validation_dataset,
    epochs=EPOCHS
  )

  # Determine type and task of the machine from
  # the strategy cluster resolver
  task_type, task_id = (strategy.cluster_resolver.task_type,
                        strategy.cluster_resolver.task_id)

  # Based on the type and task, write to the desired model path
  write_model_path = write_filepath(SAVE_MODEL_DIR, task_type, task_id)
  model.save(write_model_path)

if __name__ == "__main__":
    main()

Bevor Sie den Container erstellen, sehen wir uns den Code genauer an. Es gibt einige Komponenten im Code, die erforderlich sind, damit Ihre Trainingsanwendung mit MultiWorkerMirroredStrategy funktioniert.

• In der Funktion main() wird das Objekt MultiWorkerMirroredStrategy erstellt. Als Nächstes umschließen Sie die Erstellung Ihrer Modellvariablen mit dem Bereich der Strategie. Mit diesem wichtigen Schritt wird TensorFlow mitgeteilt, welche Variablen auf den Replikaten gespiegelt werden sollen.
• Die Batchgröße wird mit num_replicas_in_sync skaliert. Das Skalieren der Batchgröße ist eine Best Practice bei der Verwendung synchroner Datenparallelitätsstrategien in TensorFlow.
• Das Speichern Ihres Modells ist im Fall mit mehreren Workern etwas komplizierter, da das Ziel für jeden Worker unterschiedlich sein muss. Der Chief-Worker speichert im gewünschten Modellverzeichnis, während die anderen Worker das Modell in temporären Verzeichnissen speichern. Diese temporären Verzeichnisse müssen eindeutig sein, damit nicht mehrere Worker an denselben Speicherort schreiben. Das Speichern kann kollektive Vorgänge enthalten. Das bedeutet, dass alle Worker speichern müssen und nicht nur der Chief-Worker. Die Funktionen _is_chief(), _get_temp_dir(), write_filepath() sowie die Funktion main() enthalten Boilerplate-Code, mit dem das Modell gespeichert wird.

Wenn Sie MultiWorkerMirroredStrategy in einer anderen Umgebung verwendet haben, haben Sie möglicherweise die Umgebungsvariable TF_CONFIG eingerichtet. Vertex AI legt TF_CONFIG automatisch für Sie fest. Sie müssen diese Variable also nicht auf jeder Maschine in Ihrem Cluster definieren.

Schritt 2: Dockerfile erstellen

Um Ihren Code in einen Container zu packen, müssen Sie ein Dockerfile erstellen. Das Dockerfile enthält alle Befehle, die zum Ausführen des Images erforderlich sind. Es installiert alle erforderlichen Bibliotheken und richtet den Einstiegspunkt für den Trainingscode ein.

Erstellen Sie im Terminal ein leeres Dockerfile im Stammverzeichnis Ihres Verzeichnisses „flowers“:

touch Dockerfile

Das Verzeichnis flowers-multi-machine/ sollte jetzt Folgendes enthalten:

+ Dockerfile
+ trainer/
    + task.py

Öffnen Sie das Dockerfile und kopieren Sie Folgendes hinein:

FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8

WORKDIR /

# Copies the trainer code to the docker image.
COPY trainer /trainer

# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]

Schritt 3: Container erstellen

Führen Sie im Terminal den folgenden Befehl aus, um eine Umgebungsvariable für Ihr Projekt zu definieren. Ersetzen Sie dabei your-cloud-project durch die ID Ihres Projekts:

Sie können Ihre Projekt-ID abrufen, indem Sie im Terminal gcloud config list --format 'value(core.project)' ausführen.

PROJECT_ID='your-cloud-project'

Erstellen Sie ein Repository in Artifact Registry. Wir verwenden das Repository, das wir im ersten Lab erstellt haben.

REPO_NAME='flower-app'

Definieren Sie eine Variable mit dem URI Ihres Container-Images in Google Artifact Registry:

IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:multi_machine

Docker konfigurieren

gcloud auth configure-docker \
    us-central1-docker.pkg.dev

Erstellen Sie dann den Container, indem Sie den folgenden Befehl im Stammverzeichnis Ihres Verzeichnisses flowers-multi-machine ausführen:

docker build ./ -t $IMAGE_URI

Übertragen Sie ihn schließlich per Push an Artifact Registry:

docker push $IMAGE_URI

Nachdem der Container per Push an Artifact Registry übertragen wurde, können Sie den Trainingsjob starten.

Schritt 4: Job mit dem SDK ausführen

In diesem Abschnitt erfahren Sie, wie Sie den verteilten Trainingsjob mit dem Vertex AI Python SDK konfigurieren und starten.

Erstellen Sie im Launcher ein TensorFlow 2-Notebook.

Importieren Sie das Vertex AI SDK.

from google.cloud import aiplatform

Definieren Sie dann die worker_pool_specs.

Vertex AI bietet vier Worker-Pools für die verschiedenen Arten von Maschinenaufgaben.

Worker-Pool 0 konfiguriert den Primary-, Chief-, Scheduler- oder Master-Worker. In MultiWorkerMirroredStrategy werden alle Maschinen als Worker bezeichnet. Das sind die physischen Maschinen, auf denen die replizierte Berechnung ausgeführt wird. Neben jedem Worker muss es einen Worker geben, der zusätzliche Aufgaben übernimmt, z. B. das Speichern von Checkpoints und das Schreiben von Zusammenfassungsdateien in TensorBoard. Diese Maschine wird als Chief-Worker bezeichnet. Es gibt immer nur einen Chief-Worker. Die Anzahl der Worker für Worker-Pool 0 ist also immer 1.

In Worker-Pool 1 konfigurieren Sie die zusätzlichen Worker für Ihren Cluster.

Das erste Wörterbuch in der Liste worker_pool_specs steht für Worker-Pool 0 und das zweite Wörterbuch für Worker-Pool 1. In diesem Beispiel sind die beiden Konfigurationen identisch. Wenn Sie jedoch auf drei Maschinen trainieren möchten, fügen Sie Worker-Pool 1 zusätzliche Worker hinzu, indem Sie replica_count auf 2 festlegen. Wenn Sie GPUs hinzufügen möchten, müssen Sie die Argumente accelerator_type und accelerator_count der machine_spec für beide Worker-Pools hinzufügen. Wenn Sie GPUs mit MultiWorkerMirroredStrategy verwenden möchten, muss jede Maschine im Cluster die gleiche Anzahl von GPUs haben. Andernfalls schlägt der Job fehl.

Ersetzen Sie {PROJECT_ID} in image_uri.

# The spec of the worker pools including machine type and Docker image
# Be sure to replace PROJECT_ID in the "image_uri" with your project.

worker_pool_specs=[
     {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-4",
        },
        "container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
      },
      {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-4",
        },
        "container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
      }
          ]

Erstellen und führen Sie als Nächstes einen CustomJob aus. Ersetzen Sie dabei {YOUR_BUCKET} in staging_bucket durch einen Bucket in Ihrem Projekt für das Staging.

my_custom_job = aiplatform.CustomJob(display_name='flowers-multi-worker',
                                     worker_pool_specs=worker_pool_specs,
                                     staging_bucket='gs://{YOUR_BUCKET}')

my_custom_job.run()

In der Konsole können Sie den Fortschritt Ihres Jobs sehen.

🎉 Das wars! 🎉

Sie haben gelernt, wie Sie mit Vertex AI Folgendes tun:

• Verteilte Trainingsjobs mit TensorFlow ausführen

Weitere Informationen zu den verschiedenen Bereichen von Vertex finden Sie in der Dokumentation.

7. Bereinigen

Da wir das Notebook so konfiguriert haben, dass es nach 60 Minuten Inaktivität eine Zeitüberschreitung auslöst, müssen wir uns nicht um das Herunterfahren der Instanz kümmern. Wenn Sie die Instanz manuell herunterfahren möchten, klicken Sie in der Konsole im Bereich „Vertex AI Workbench“ auf die Schaltfläche „Beenden“. Wenn Sie das Notebook vollständig löschen möchten, klicken Sie auf die Schaltfläche „Löschen“.

Wenn Sie den Storage-Bucket löschen möchten, rufen Sie im Navigationsmenü der Cloud Console „Storage“ auf, wählen Sie Ihren Bucket aus und klicken Sie auf „Löschen“: