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 Von Prototyp zur Produktion. 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 einem einzelnen Computer 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-Angebot von Google Cloud verwendet. Vertex AI bindet die ML-Angebote in Google Cloud in eine nahtlose Entwicklungsumgebung ein. Bisher konnten auf mit AutoML trainierte Modelle und benutzerdefinierte Modelle über separate Dienste zugegriffen werden. Das neue Angebot kombiniert beide zusammen mit anderen neuen Produkten in einer einzigen API. 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, beschleunigt TensorFlow das Modelltraining mit diesem Beschleuniger, ohne dass Sie etwas tun müssen. Wenn Sie jedoch eine zusätzliche Leistungssteigerung 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 Ihren Trainingsanwendungen mit nur wenigen Codeänderungen hinzufügen können. Mit dieser Strategie wird eine Kopie des Modells auf jeder GPU auf Ihrem Computer erstellt. Die nachfolgenden Farbverlaufsaktualisierungen erfolgen synchron. Das bedeutet, dass jede GPU die Vorwärts- und Rückwärtsdurchläufe durch das Modell für einen anderen Ausschnitt der Eingabedaten berechnet. Die berechneten Gradienten aus jedem dieser Ausschnitte werden dann über alle GPUs hinweg aggregiert und in einem Prozess, der als All-Reduce bezeichnet wird, gemittelt. Die Modellparameter werden anhand dieser gemittelten Gradienten aktualisiert.

Im optionalen Abschnitt am Ende des Labs wird tf.distribute.MultiWorkerMirroredStrategy verwendet. Dieser Befehl ähnelt MirroredStrategy, funktioniert jedoch auf mehreren Maschinen. 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 Rechnern 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 Video unten 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 einer einzelnen Maschine und mehreren GPUs

Sie reichen Ihren verteilten Trainingsjob bei Vertex AI ein, indem Sie den Code Ihrer Trainingsanwendung in einen Docker-Container einfügen und diesen Container in die Google Artifact Registry hochladen. 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 wechseln Sie dorthin:

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

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

mkdir trainer
touch trainer/task.py

Ihr flowers-multi-gpu/-Verzeichnis sollte jetzt so aussehen:

+ trainer/
    + task.py

Öffnen Sie als Nächstes die soeben 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 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, sehen wir uns den Code genauer an. Es gibt einige Komponenten, die für verteiltes Training spezifisch sind.

• In der Funktion main() wird das MirroredStrategy-Objekt erstellt. Als Nächstes legen Sie fest, dass die Modellvariablen im Geltungsbereich der Strategie erstellt werden. In diesem Schritt wird TensorFlow mitgeteilt, welche Variablen auf den GPUs gespiegelt werden sollen.
• Die Batchgröße wird um num_replicas_in_sync hochskaliert. Die Batchgröße zu skalieren, ist eine Best Practice bei der Verwendung von Strategien für die synchrone Datenparallelität in TensorFlow. Weitere Informationen

Schritt 2: Dockerfile erstellen

Wenn Sie Ihren Code containerisieren möchten, müssen Sie ein Dockerfile erstellen. Im Dockerfile geben Sie alle Befehle an, die zum Ausführen des Images erforderlich sind. Dadurch 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

Ihr flowers-multi-gpu/-Verzeichnis sollte jetzt so aussehen:

+ Dockerfile
+ trainer/
    + task.py

Öffnen Sie das Dockerfile und fügen Sie Folgendes ein:

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 ermitteln, 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 von flowers-multi-gpu Folgendes ausführen:

docker build ./ -t $IMAGE_URI

Laden Sie es zuletzt in Artifact Registry hoch:

docker push $IMAGE_URI

Nachdem der Container in Artifact Registry gepusht 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 eine GPU verwenden würden, würde dies nicht als verteiltes Training betrachtet. 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] Training mit mehreren Mitarbeitern

Nachdem Sie verteiltes Training auf einem einzelnen Computer mit mehreren GPUs ausprobiert haben, können Sie Ihre Fähigkeiten im Bereich verteiltes Training auf die nächste Stufe heben, indem Sie das Training auf mehreren Maschinen durchführen. Um die Kosten niedrig zu halten, werden diesen Maschinen keine GPUs hinzugefügt. Sie können aber gerne GPUs hinzufügen, um sie zu testen.

Öffnen Sie ein neues Terminalfenster in Ihrer Notebookinstanz:

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

Ihr flowers-multi-machine/-Verzeichnis sollte jetzt so aussehen:

+ trainer/
    + task.py

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

Ersetzen Sie {your-gcs-bucket} in BUCKET_ROOT durch den Cloud Storage-Bucket, 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, sehen wir uns den Code genauer an. Der Code enthält einige Komponenten, die erforderlich sind, damit Ihre Trainingsanwendung mit MultiWorkerMirroredStrategy funktioniert.

• In der Funktion main() wird das MultiWorkerMirroredStrategy-Objekt erstellt. Als Nächstes schließen Sie die Erstellung Ihrer Modellvariablen in den Bereich der Strategie ein. Bei diesem wichtigen Schritt wird TensorFlow mitgeteilt, welche Variablen über die Replikate hinweg gespiegelt werden sollen.
• Die Batchgröße wird um num_replicas_in_sync hochskaliert. Die Batchgröße zu skalieren, ist eine Best Practice bei der Verwendung von Strategien für die synchrone Datenparallelität in TensorFlow.
• Das Speichern Ihres Modells ist im Fall mehrerer Worker etwas komplizierter, da das Ziel für jeden Worker unterschiedlich sein muss. Der Haupt-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, damit nicht mehrere Worker an 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, der beim Speichern des Modells hilft.

Wenn Sie MultiWorkerMirroredStrategy bereits 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

Wenn Sie Ihren Code containerisieren möchten, müssen Sie ein Dockerfile erstellen. Im Dockerfile geben Sie alle Befehle an, die zum Ausführen des Images erforderlich sind. Dadurch werden alle erforderlichen Bibliotheken installiert und der Einstiegspunkt für den Trainingscode eingerichtet.

Erstellen Sie über Ihr Terminal ein leeres Dockerfile im Stammverzeichnis des Verzeichnisses „flowers“:

touch Dockerfile

Ihr flowers-multi-machine/-Verzeichnis sollte jetzt so aussehen:

+ Dockerfile
+ trainer/
    + task.py

Öffnen Sie das Dockerfile und fügen Sie Folgendes ein:

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 ermitteln, 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 eine Variable mit dem URI Ihres Container-Images in der 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 im Stammverzeichnis Ihres flowers-multi-machine-Verzeichnisses Folgendes ausführen:

docker build ./ -t $IMAGE_URI

Übertragen Sie es dann per Push in die Artifact Registry:

docker push $IMAGE_URI

Nachdem der Container in Artifact Registry gepusht 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.

Mit Worker-Pool 0 wird der Primary, Chief, Scheduler oder „Master“ konfiguriert. In MultiWorkerMirroredStrategy werden alle Maschinen als Worker bezeichnet. 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. Die Anzahl der Worker für Worker-Pool 0 ist daher immer 1.

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

Das erste Dictionary in der Liste worker_pool_specs steht für Worker-Pool 0 und das zweite Dictionary für Worker-Pool 1. In diesem Beispiel sind die beiden Konfigurationen identisch. Wenn Sie das Training jedoch auf drei Maschinen durchführen 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 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 dieselbe 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 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 Vertex AI für Folgendes verwenden:

• 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 nach 60 Minuten Inaktivität ein Zeitlimit erreicht wird, müssen wir uns keine Gedanken über das Herunterfahren der Instanz machen. Wenn Sie die Instanz manuell herunterfahren möchten, klicken Sie in der Console im Bereich „Vertex AI Workbench“ auf die Schaltfläche „Beenden“. Wenn Sie das Notizbuch vollständig löschen möchten, klicken Sie auf die Schaltfläche „Löschen“.

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