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 Videoreihe Prototyping to Production. Schließen Sie die vorherigen Labs ab, bevor Sie mit diesem beginnen. Weitere Informationen erhalten Sie in der begleitenden 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 das Lab in Google Cloud belaufen sich auf 2$.

2. Einführung in Vertex AI

In diesem Lab wird das neueste KI-Produktangebot von Google Cloud verwendet. Vertex AI bindet die ML-Angebote in Google Cloud in eine nahtlose Entwicklungsumgebung ein. Zuvor waren mit AutoML trainierte und benutzerdefinierte Modelle über separate Dienste zugänglich. Das neue Angebot vereint beides in einer einzigen API sowie weitere neue Produkte. Sie können auch vorhandene Projekte zu Vertex AI migrieren.

Vertex AI enthält viele verschiedene Produkte zur Unterstützung von End-to-End-ML-Workflows. In diesem Lab liegt der Schwerpunkt auf den unten aufgeführten Produkten: Training und Workbench.

3. Verteiltes Training – Übersicht

Wenn Sie eine einzelne GPU haben, verwendet TensorFlow diesen Beschleuniger, um das Modelltraining ohne zusätzlichen Aufwand für Sie zu beschleunigen. Wenn Sie jedoch durch die Verwendung mehrerer GPUs zusätzliche Leistung erzielen möchten, müssen Sie tf.distribute verwenden. Das Modul von TensorFlow ist das Modul zur Ausführung einer Berechnung auf mehreren Geräten.

Im ersten Abschnitt dieses Labs wird tf.distribute.MirroredStrategy verwendet. Sie können Ihren Trainingsanwendungen mit nur wenigen Codeänderungen hinzufügen. Mit dieser Strategie wird eine Kopie des Modells auf jeder GPU auf Ihrem Computer erstellt. Die nachfolgenden Gradientenaktualisierungen erfolgen synchron. Dies bedeutet, dass jede GPU den Vor- und Rückwärtsdurchlauf durch das Modell anhand eines anderen Segments der Eingabedaten berechnet. Die berechneten Gradienten aus jedem dieser Segmente werden dann über alle GPUs aggregiert und in einem als All-Reduce bezeichneten Prozess gemittelt. Modellparameter werden mithilfe dieser gemittelten Farbverläufe aktualisiert.

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

Die Details sind für dieses Lab nicht erforderlich, aber wenn Sie 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 auf einer einzelnen Maschine, mit mehreren GPUs

Zum Senden des verteilten Trainingsjobs an Vertex AI fügen Sie den Trainingsanwendungscode in einen Docker-Container ein und übertragen diesen Container per Push in Google Artifact Registry. Mit diesem Ansatz können Sie ein Modell trainieren, das mit einem beliebigen Framework erstellt wurde.

Öffnen Sie zuerst 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 fügen Sie es mit cd ein:

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 die Sie den Code unten einfügen.

mkdir trainer
touch trainer/task.py

In Ihrem flowers-multi-gpu/-Verzeichnis sollte nun Folgendes vorhanden sein:

+ trainer/
    + task.py

Öffnen Sie als Nächstes die soeben erstellte Datei task.py und kopieren Sie den unten stehenden Code.

Sie müssen {your-gcs-bucket} in BUCKET_ROOT durch den Cloud Storage-Bucket ersetzen, in dem Sie das Blumen-Dataset 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, werfen wir einen genaueren Blick auf den Code. Es gibt einige Komponenten, die für die Verwendung von verteiltem Training spezifisch sind.

• In der main()-Funktion wird das MirroredStrategy-Objekt erstellt. Als Nächstes schließen Sie die Erstellung Ihrer Modellvariablen in den Bereich der Strategie ein. In diesem Schritt wird TensorFlow mitgeteilt, welche Variablen in den GPUs gespiegelt werden sollen.
• Die Batchgröße wird um num_replicas_in_sync hochskaliert. Das Skalieren der Batchgröße ist eine Best Practice bei der Verwendung von Strategien zur synchronen Datenparallelität in TensorFlow. Weitere Informationen

Schritt 2: Dockerfile erstellen

Zum Containerisieren Ihres Codes müssen Sie ein Dockerfile erstellen. In das Dockerfile geben Sie alle Befehle ein, die zum Ausführen des Images erforderlich sind. Damit werden alle erforderlichen Bibliotheken installiert und der Einstiegspunkt für den Trainingscode eingerichtet.

Erstellen Sie im Terminal im Stammverzeichnis Ihres Blumenverzeichnisses ein leeres Dockerfile:

touch Dockerfile

In Ihrem flowers-multi-gpu/-Verzeichnis sollte nun Folgendes vorhanden sein:

+ 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 gcloud config list --format 'value(core.project)' in Ihrem Terminal 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 in Artifact Registry eine Variable mit dem URI Ihres Container-Images:

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 im Stammverzeichnis Ihres flowers-multi-gpu-Verzeichnisses Folgendes ausführen:

docker build ./ -t $IMAGE_URI

Laden Sie es zuletzt in Artifact Registry hoch:

docker push $IMAGE_URI

Nachdem der Container 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.

Du musst {PROJECT_ID} in container_uri und {YOUR_BUCKET} in staging_bucket ersetzen.

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}')

Sobald der Job definiert ist, können Sie ihn ausführen. Sie legen die Anzahl der Beschleuniger auf 2 fest. Wenn wir nur 1 GPU verwenden würden, gilt dies nicht als verteiltes Training. Bei einem verteilten Training auf einer einzelnen Maschine werden mindestens zwei Beschleuniger verwendet.

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 des Jobs sehen.

6. [Optional] Schulung für mehrere Mitarbeiter

Sie haben verteiltes Training jetzt auf einer einzigen Maschine mit mehreren GPUs ausprobiert. Jetzt können Sie Ihre Fähigkeiten für verteiltes Training auf mehreren Rechnern trainieren. Um die Kosten niedrig zu halten, fügen wir diesen Maschinen keine GPUs hinzu. Sie können aber experimentieren und GPUs hinzufügen, wenn Sie das möchten.

Öffnen Sie in Ihrer Notebookinstanz ein neues Terminalfenster:

Schritt 1: Trainingscode schreiben

Erstellen Sie ein neues Verzeichnis mit dem Namen flowers-multi-machine und fügen Sie es mit cd ein:

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 die Sie den Code unten einfügen.

mkdir trainer
touch trainer/task.py

In Ihrem flowers-multi-machine/-Verzeichnis sollte nun Folgendes vorhanden sein:

+ trainer/
    + task.py

Öffnen Sie als Nächstes die soeben erstellte Datei task.py und kopieren Sie den unten stehenden Code.

Sie müssen {your-gcs-bucket} in BUCKET_ROOT durch den Cloud Storage-Bucket ersetzen, in dem Sie das Blumen-Dataset 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, werfen wir einen genaueren Blick auf den Code. Der Code enthält einige Komponenten, die erforderlich sind, damit die Trainingsanwendung mit MultiWorkerMirroredStrategy funktioniert.

• In der main()-Funktion wird das MultiWorkerMirroredStrategy-Objekt erstellt. Als Nächstes schließen Sie die Erstellung Ihrer Modellvariablen in den Bereich der Strategie ein. In diesem wichtigen Schritt wird TensorFlow mitgeteilt, welche Variablen in den Replikaten gespiegelt werden sollen.
• Die Batchgröße wird um num_replicas_in_sync hochskaliert. Das Skalieren der Batchgröße ist eine Best Practice bei der Verwendung von Strategien zur synchronen Datenparallelität in TensorFlow.
• Bei mehreren Workern ist das Speichern des Modells etwas komplizierter, da das Ziel für jeden Worker unterschiedlich sein muss. Der Chief Worker speichert das Modell im gewünschten Modellverzeichnis, während die anderen Worker das Modell in temporären Verzeichnissen speichern. Es ist wichtig, dass diese temporären Verzeichnisse eindeutig sind, um zu verhindern, dass mehrere Worker in denselben Speicherort schreiben. Das Speichern kann kollektive Operationen umfassen, was bedeutet, dass alle Worker retten müssen und nicht nur der Chief. Die Funktionen _is_chief(), _get_temp_dir(), write_filepath() und main() enthalten Boilerplate-Code, mit dem das Modell gespeichert werden kann.

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, sodass Sie diese Variable nicht auf jeder Maschine im Cluster definieren müssen.

Schritt 2: Dockerfile erstellen

Zum Containerisieren Ihres Codes müssen Sie ein Dockerfile erstellen. In das Dockerfile geben Sie alle Befehle ein, die zum Ausführen des Images erforderlich sind. Damit werden alle erforderlichen Bibliotheken installiert und der Einstiegspunkt für den Trainingscode eingerichtet.

Erstellen Sie im Terminal im Stammverzeichnis Ihres Blumenverzeichnisses ein leeres Dockerfile:

touch Dockerfile

In Ihrem flowers-multi-machine/-Verzeichnis sollte nun Folgendes vorhanden sein:

+ 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 gcloud config list --format 'value(core.project)' in Ihrem Terminal 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 in Google Artifact Registry eine Variable mit dem URI Ihres Container-Images:

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 im Stammverzeichnis Ihres flowers-multi-machine-Verzeichnisses Folgendes ausführen:

docker build ./ -t $IMAGE_URI

Laden Sie es zuletzt in Artifact Registry hoch:

docker push $IMAGE_URI

Nachdem der Container 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 worker_pool_specs.

Vertex AI bietet 4 Worker-Pools, um die verschiedenen Arten von Maschinenaufgaben abzudecken.

In Worker-Pool 0 wird der Primär-, Chief-, Planer- oder „Master“ konfiguriert. In MultiWorkerMirroredStrategy werden alle Maschinen als Worker festgelegt. Das sind die physischen Maschinen, auf denen die replizierte Berechnung ausgeführt wird. Zusätzlich dazu, dass jeder Rechner ein Worker ist, muss es einen Worker geben, der zusätzliche Arbeit übernimmt, z. B. das Speichern von Prüfpunkten und das Schreiben von Zusammenfassungsdateien in TensorBoard. Diese Maschine wird als Chief bezeichnet. Es gibt immer nur einen Chief Worker, sodass Ihre Worker-Anzahl für Worker-Pool 0 immer 1 ist.

Im Worker-Pool 1 konfigurieren Sie die zusätzlichen Worker für den Cluster.

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

Sie müssen {PROJECT_ID} in image_uri ersetzen.

# 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 Sie als Nächstes einen CustomJob und führen Sie ihn 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 des Jobs sehen.

🎉 Glückwunsch! 🎉

Sie haben gelernt, wie Sie mit Vertex AI Folgendes tun können:

• Verteilte Trainingsjobs mit TensorFlow ausführen

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

7. Bereinigen

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

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