Schulungspipelines erstellen

Mit Trainingspipelines können Sie benutzerdefiniertes ML-Training ausführen und automatisch eine Model-Ressource basierend auf Ihrer Trainingsausgabe erstellen.

Vor dem Erstellen einer Pipeline

Bevor Sie eine Trainingspipeline in Vertex AI erstellen, müssen Sie eine Python-Trainingsanwendung oder einen benutzerdefinierten Container erstellen, um den Trainingscode und die Abhängigkeiten zu definieren, die Sie in Vertex AI ausführen möchten. Wenn Sie eine Python-Trainingsanwendung mit TensorFlow, scikit-learn oder XGBoost erstellen, können Sie den Code mit unseren vordefinierten Containern ausführen. Weitere Informationen zur Auswahl dieser Optionen finden Sie in den Anforderungen an den Trainingscode.

Optionen für Trainingspipeline

Eine Trainingspipeline schließt Trainingsjobs mit zusätzlichen Schritten mit ein. In diesem Leitfaden werden zwei verschiedene Trainingspipelines erläutert:

  • Starten eines CustomJob und Hochladen des resultierenden Modells in Vertex AI
  • Starten eines Hyperparameter-Abstimmungsjobs und Hochladen des resultierenden Modells in Vertex AI

Darüber hinaus können Sie verwaltete Datasets in Ihrer Trainingspipeline verwenden. Trainingspipeline für die Verwendung eines verwalteten Datasets konfigurieren.

Einstellungen für CustomJob

Beim Erstellen eines benutzerdefinierten Jobs legen Sie Einstellungen fest, die Vertex AI zum Ausführen des Trainingscodes ausführen muss. Dazu gehören:

Innerhalb der Worker-Pools können Sie die folgenden Einstellungen festlegen:

Informationen zum Erstellen eines eigenständigen benutzerdefinierten Jobs außerhalb einer Vertex AI-Trainingspipeline finden Sie im Leitfaden zu benutzerdefinierten Jobs.

Pipeline für die Verwendung eines verwalteten Datasets konfigurieren

Innerhalb der Trainingspipeline können Sie Ihren benutzerdefinierten Trainingsjob oder Hyperparameter-Abstimmungsjob für die Verwendung eines verwalteten Datasets konfigurieren. Mit verwalteten Datasets können Sie Ihre Datasets mit Ihren Trainingsanwendungen und -modellen verwalten.

So verwenden Sie ein verwaltetes Dataset in Ihrer Trainingspipeline:

  1. Dataset erstellen.
  2. Aktualisieren Sie Ihre Trainingsanwendung, um ein verwaltetes Dataset zu verwenden. Weitere Informationen finden Sie unter Wie Vertex AI Ihr Dataset an Ihre Trainingsanwendung übergibt.

  3. Geben Sie beim Erstellen der Trainingspipeline ein verwaltetes Dataset an. Wenn Sie beispielsweise Ihre Trainingspipeline mithilfe der REST API erstellen, geben Sie die Dataset-Einstellungen im Abschnitt inputDataConfig an.

    Sie müssen die Trainingspipeline in derselben Region erstellen, in der Sie das Dataset erstellt haben.

Weitere Informationen finden Sie in der API-Referenz für TrainingPipeline.

Verteiltes Training konfigurieren

Innerhalb der Trainingspipeline können Sie Ihren benutzerdefinierten Trainingsjob oder Hyperparameter-Abstimmungsjob für verteiltes Training konfigurieren. Dazu müssen Sie mehrere Worker-Pools angeben.

Alle Beispiele auf dieser Seite enthalten Trainingsjobs mit einem Replikat und einem Worker-Pool. So ändern Sie diese für verteiltes Training:

  • Verwenden Sie Ihren ersten Worker-Pool für die Konfiguration des primären Replikats und setzen Sie die Anzahl der Replikate auf 1.
  • Fügen Sie weitere Worker-Pools hinzu, um Worker-Replikate, Parameterserver-Replikate oder Evaluator-Replikate zu konfigurieren, wenn Ihr Framework für maschinelles Lernen diese zusätzlichen Clusteraufgaben für verteiltes Training unterstützt.

Verteiltes Training verwenden

Upload von CustomJobs und Modellen

Diese Trainingspipeline umfasst einen benutzerdefinierten Job mit einem zusätzlichen praktischen Schritt, der das Bereitstellen Ihres Modells nach dem Training in Vertex AI vereinfacht. Diese Trainingspipeline hat zwei Hauptaspekte:

  1. Die Trainingspipeline erstellt eine CustomJob-Ressource. Der benutzerdefinierte Job führt die Trainingsanwendung mit den Rechenressourcen aus, die Sie angegeben haben.

  2. Wenn der benutzerdefinierte Job abgeschlossen ist, sucht die Trainingspipeline die Modellartefakte, die Ihre Trainingsanwendung im Ausgabeverzeichnis erstellt, das Sie für Ihren Cloud Storage-Bucket angegeben haben. Sie verwendet diese Artefakte, um eine Modellressource zu erstellen, die Sie für die Modellbereitstellung vorbereitet.

Es gibt zwei Möglichkeiten, den Standort für Ihre Modellartefakte festzulegen:

  • Wenn Sie ein baseOutputDirectory für Ihren Trainingsjob festlegen, prüfen Sie, ob der Trainingscode Ihre Modellartefakte an diesem Speicherort speichert. Verwenden Sie dazu die von Vertex AI festgelegte Umgebungsvariable $AIP_MODEL_DIR. Nach Abschluss des Trainingsjobs sucht Vertex AI in gs://BASE_OUTPUT_DIRECTORY/model nach den resultierenden Modellartefakten.

  • Wenn Sie das Feld modelToUpload.artifactUri festlegen, lädt die Trainingspipeline die Modellartefakte von diesem URI hoch. Sie müssen dieses Feld festlegen, wenn Sie baseOutputDirectory nicht festgelegt haben.

Wenn Sie sowohl baseOutputDirectory als auch modelToUpload.artifactUri angeben, verwendet Vertex AI modelToUpload.artifactUri.

So erstellen Sie diese Art von Trainingspipeline:

Console

  1. Rufen Sie in der Google Cloud Console im Abschnitt "Vertex AI" die Seite Trainingspipelines auf.

    Zur Trainingspipeline

  2. Klicken Sie auf Erstellen, um den Bereich Neues Modell trainieren zu öffnen.

  3. Legen Sie im Schritt Trainingsmethode die folgenden Einstellungen fest:

    1. Wenn Sie ein verwaltetes Dataset für das Training verwenden möchten, geben Sie ein Dataset und einen Annotationssatz an.

      Wählen Sie andernfalls in der Drop-down-Liste Dataset die Option Kein verwaltetes Dataset aus.

    2. Wählen Sie Benutzerdefiniertes Training (erweitert) aus.

    Klicken Sie auf Weiter.

  4. Wählen Sie im Schritt Modelldetails die Option Neues Modell trainieren oder Neue Version trainieren aus. Wenn Sie „Neues Modell trainieren” auswählen, geben Sie einen Namen Ihrer Wahl (MODEL_NAME) für Ihr Modell ein. Klicken Sie auf Weiter.

  5. Legen Sie im Schritt Trainingscontainer die folgenden Einstellungen fest:

    1. Wählen Sie, ob ein vordefinierter Container oder ein benutzerdefinierter Container für das Training verwendet werden soll.

    2. Führen Sie je nach Auswahl einen der folgenden Schritte aus:

    3. Im Feld Modellausgabeverzeichnis können Sie den Cloud Storage-URI eines Verzeichnisses in einem Bucket angeben, auf den Sie Zugriff haben. Das Verzeichnis muss noch nicht vorhanden sein.

      Dieser Wert wird Vertex AI im API-Feld baseOutputDirectory übergeben. Dadurch werden mehrere Umgebungsvariablen festgelegt, auf die Ihre Trainingsanwendung zugreifen kann, wenn sie ausgeführt wird.

      Am Ende des Trainings sucht Vertex AI nach Modellartefakten in einem Unterverzeichnis dieses URI, um ein Model zu erstellen. (Dieses Unterverzeichnis ist für den Trainingscode als Umgebungsvariable AIP_MODEL_DIR verfügbar.)

      Wenn Sie die Hyperparameter-Abstimmung nicht verwenden, erwartet Vertex AI Modellartefakte in BASE_OUTPUT_DIRECTORY/model/.

    4. Optional: Im Feld Argumente können Sie Argumente angeben, die Vertex AI beim Ausführen des Trainingscodes verwenden soll. Die maximale Länge aller Argumente zusammen beträgt 100.000 Zeichen. Das Verhalten dieser Argumente hängt davon ab, welchen Containertyp Sie verwenden:

    Klicken Sie auf Weiter.

  6. Achten Sie darauf, dass im Schritt Hyperparameter-Abstimmung das Kästchen Hyperparameter-Abstimmung aktivieren nicht angeklickt ist. Klicken Sie auf Weiter.

  7. Legen Sie im Schritt Computing und Preise die folgenden Einstellungen fest:

    1. Wählen Sie in der Drop-down-Liste Region eine Region aus, die benutzerdefiniertes Training unterstützt.

    2. Geben Sie im Abschnitt Worker-Pool 0 die Computing-Ressourcen für das Training an.

      Wenn Sie Beschleuniger angeben, muss der von Ihnen ausgewählte Beschleuniger in der ausgewählten Region verfügbar sein.

      Wenn Sie ein verteiltes Training durchführen möchten, klicken Sie auf Weitere Worker-Pools hinzufügen und geben Sie für jeden zusätzlichen Worker-Pool, den Sie wollen, weitere Compute-Ressourcen an.

    Klicken Sie auf Weiter.

  8. Legen Sie im Schritt Vorhersagecontainer die folgenden Einstellungen fest:

    1. Wählen Sie aus: Festlegen, ob Sie einen vordefinierten Container oder einen benutzerdefinierten Container verwenden möchten, um Vorhersagen aus Ihrem trainierten Modell bereitzustellen.

    2. Führen Sie je nach Auswahl einen der folgenden Schritte aus:

    3. Das Feld Modellverzeichnis enthält den Wert, den Sie zuvor im Feld Modellausgabeverzeichnis des Schritts Trainingscontainer festgelegt haben. Das Ändern eines dieser Felder hat den gleichen Effekt. Weitere Informationen zu diesem Feld finden Sie in der vorherigen Anweisung.

    4. Lassen Sie die Felder im Abschnitt Schemata vorhersagen leer.

  9. Klicken Sie auf Training starten, um die benutzerdefinierte Trainingspipeline zu starten.

REST

Im folgenden Codebeispiel wird eine Trainingspipeline mit der Methode create der Ressource trainingPipeline erstellt.

Hinweis: Wenn Sie diese Pipeline zum Erstellen einer neuen Modellversion festlegen möchten, können Sie optional PARENT_MODEL im Feld trainingPipeline hinzufügen.

Weitere Informationen finden Sie unter Modellversionsverwaltung mit Vertex AI Model Registry.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION_ID: Die Region, in der der Trainingscode ausgeführt wird und das Model gespeichert wird.
  • PROJECT_ID: Ihre Projekt-ID.
  • TRAINING_PIPELINE_NAME: erforderlich. Ein Anzeigename für die trainingPipeline.
  • Wenn Ihre Trainingsanwendung ein Vertex-AI-Dataset verwendet, geben Sie Folgendes an:
    • DATASET_ID: Die ID des Datasets.
    • ANNOTATIONS_FILTER: Filtert das Dataset nach den von Ihnen angegebenen Annotationen.
    • ANNOTATION_SCHEMA_URI: Filtert das Dataset nach den angegebenen Annotationsschema-URI.
    • Verwenden Sie eine der folgenden Optionen, um anzugeben, wie Datenelemente in Trainings-, Validierungs- und Test-Datasets aufgeteilt werden.
      • Geben Sie Folgendes an, um das Dataset anhand von Anteilen aufzuteilen, die die Größe der einzelnen Datasets definieren:
        • TRAINING_FRACTION: Der Anteil des Datasets, der zum Trainieren Ihres Modells verwendet wird.
        • VALIDATION_FRACTION: Der Anteil des Datasets, der zum Validieren des Modells verwendet wird.
        • TEST_FRACTION: Der Anteil des Datasets, der zum Bewerten des Modells verwendet wird.
      • Wenn Sie das Dataset basierend auf Filtern aufteilen möchten, geben Sie Folgendes an:
        • TRAINING_FILTER: Filtert das Dataset nach Datenelementen, die zum Trainieren Ihres Modells verwendet werden.
        • VALIDATION_FILTER: Filtert das Dataset nach Datenelementen, die zur Validierung Ihres Modells verwendet werden.
        • TEST_FILTER: Filtert das Dataset nach Datenelementen, die zur Bewertung Ihres Modells verwendet werden.
      • Wenn Sie eine vordefinierte Aufteilung verwenden möchten, geben Sie Folgendes an:
        • PREDEFINED_SPLIT_KEY: Der Name der Spalte, die zum Aufteilen des Datasets verwendet werden soll. Zulässige Werte in dieser Spalte sind „training“, „validation“ und „test“.
      • Geben Sie Folgendes an, um das Dataset basierend auf dem Zeitstempel der Datenelemente aufzuteilen:
        • TIMESTAMP_TRAINING_FRACTION: Der Anteil des Datasets, der zum Trainieren Ihres Modells verwendet wird.
        • TIMESTAMP_VALIDATION_FRACTION: Der Anteil des Datasets, der zum Validieren des Modells verwendet wird.
        • TIMESTAMP_TEST_FRACTION: Der Anteil des Datasets, der zum Bewerten des Modells verwendet wird.
        • TIMESTAMP_SPLIT_KEY: Der Name der Zeitstempelspalte, die zum Aufteilen des Datasets verwendet werden soll.
    • OUTPUT_URI_PREFIX: Der Cloud Storage-Speicherort, an den Vertex AI Ihr Trainings-Dataset exportiert, sobald es in Trainings-, Validierungs- und Test-Datasets aufgeteilt wurde.
  • Definieren Sie den benutzerdefinierten Trainingsjob:
    • MACHINE_TYPE: Der Maschinentyp. Hier finden Sie die verfügbaren Maschinentypen für das Training.
    • ACCELERATOR_TYPE: (Optional) Der Typ des Beschleuniger, der an jeden Test angehängt werden soll.
    • ACCELERATOR_COUNT: (Optional) Die Anzahl der Beschleuniger, die an jeden Test angehängt werden sollen.
    • REPLICA_COUNT: Die Anzahl der Worker-Replikate, die pro Test verwendet werden sollen.
    • Wenn Ihre Trainingsanwendung in einem benutzerdefinierten Container ausgeführt wird, geben Sie Folgendes an:
      • CUSTOM_CONTAINER_IMAGE_URI: Der URI eines Container-Images in Artifact Registry, Container Registry oder Docker Hub, der auf jedem Worker-Replikat ausgeführt werden soll.
      • CUSTOM_CONTAINER_COMMAND: (Optional) Der Befehl, der beim Start des Containers aufgerufen werden soll. Mit diesem Befehl wird der Standardeinstiegspunkt des Containers überschrieben.
      • CUSTOM_CONTAINER_ARGS: (Optional) Die Argumente, die beim Starten des Containers übergeben werden. Die maximale Länge aller Argumente zusammen beträgt 100.000 Zeichen.
    • Wenn Ihre Trainingsanwendung ein Python-Paket ist, das in einem vordefinierten Container ausgeführt wird, geben Sie Folgendes an:
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: Der URI des Container-Images, das das bereitgestellte Python-Paket ausführt. Siehe Verfügbare vordefinierte Container für das Training.
      • PYTHON_PACKAGE_URIS: Der Cloud Storage-Speicherort der Python-Paketdateien, die das Trainingsprogramm und dessen abhängige Pakete sind. Die maximale Anzahl der Paket-URIs beträgt 100.
      • PYTHON_MODULE: Der Name des Python-Moduls, das nach der Installation der Pakete ausgeführt werden soll.
      • PYTHON_PACKAGE_ARGS: (Optional) Befehlszeilenargumente, die an das Python-Modul übergeben werden sollen. Die maximale Länge aller Argumente zusammen beträgt 100.000 Zeichen.
    • TIMEOUT: (Optional) Die maximale Ausführungszeit für den Job.
  • MODEL_NAME: Ein Anzeigename für das von der TrainingPipeline hochgeladene (erstellte) Modell.
  • MODEL_DESCRIPTION: Eine Beschreibung für das Modell.
  • IMAGE_URI: Der URI des Container-Images zum Ausführen von Vorhersagen. Beispiel: us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Verwenden Sie vordefinierte Container oder benutzerdefinierte Container.
  • modelToUpload.labels: Beliebiger Satz von Schlüssel/Wert-Paaren zum Organisieren Ihrer Modelle. Beispiel:
    • "env": "prod"
    • "tier": "backend"
  • Geben Sie LABEL_NAME und LABEL_VALUE für alle Labels an, die Sie auf diese Trainingspipeline anwenden möchten.

HTTP-Methode und URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines

JSON-Text der Anfrage:

{
  "displayName": "TRAINING_PIPELINE_NAME",
  "inputDataConfig": {
    "datasetId": DATASET_ID,
    "annotationsFilter": ANNOTATIONS_FILTER,
    "annotationSchemaUri": ANNOTATION_SCHEMA_URI,

    // Union field split can be only one of the following:
    "fractionSplit": {
      "trainingFraction": TRAINING_FRACTION,
      "validationFraction": VALIDATION_FRACTION,
      "testFraction": TEST_FRACTION
    },
    "filterSplit": {
      "trainingFilter": TRAINING_FILTER,
      "validationFilter": VALIDATION_FILTER,
      "testFilter": TEST_FILTER
    },
    "predefinedSplit": {
      "key": PREDEFINED_SPLIT_KEY
    },
    "timestampSplit": {
      "trainingFraction": TIMESTAMP_TRAINING_FRACTION,
      "validationFraction": TIMESTAMP_VALIDATION_FRACTION,
      "testFraction": TIMESTAMP_TEST_FRACTION,
      "key": TIMESTAMP_SPLIT_KEY
    }
    // End of list of possible types for union field split.
    "gcsDestination": {
      "outputUriPrefix": OUTPUT_URI_PREFIX
    }
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "workerPoolSpecs": [
        {
          "machineSpec": {
            "machineType": MACHINE_TYPE,
            "acceleratorType": ACCELERATOR_TYPE,
            "acceleratorCount": ACCELERATOR_COUNT
          },
          "replicaCount": REPLICA_COUNT,

          // Union field task can be only one of the following:
          "containerSpec": {
            "imageUri": CUSTOM_CONTAINER_IMAGE_URI,
            "command": [
              CUSTOM_CONTAINER_COMMAND
            ],
            "args": [
              CUSTOM_CONTAINER_ARGS
            ]
          },
          "pythonPackageSpec": {
            "executorImageUri": PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,
            "packageUris": [
              PYTHON_PACKAGE_URIS
            ],
            "pythonModule": PYTHON_MODULE,
            "args": [
              PYTHON_PACKAGE_ARGS
            ]
          }
          // End of list of possible types for union field task.
        }
      ],
      "scheduling": {
        "TIMEOUT": TIMEOUT
      }
    }
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "IMAGE_URI"
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines"

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

Die Antwort enthält Informationen zu Spezifikationen sowie die TRAININGPIPELINE_ID.

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Java-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Java API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.Model;
import com.google.cloud.aiplatform.v1.ModelContainerSpec;
import com.google.cloud.aiplatform.v1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1.PipelineServiceSettings;
import com.google.cloud.aiplatform.v1.TrainingPipeline;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class CreateTrainingPipelineCustomJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelDisplayName = "MODEL_DISPLAY_NAME";
    String containerImageUri = "CONTAINER_IMAGE_URI";
    String baseOutputDirectoryPrefix = "BASE_OUTPUT_DIRECTORY_PREFIX";
    createTrainingPipelineCustomJobSample(
        project, displayName, modelDisplayName, containerImageUri, baseOutputDirectoryPrefix);
  }

  static void createTrainingPipelineCustomJobSample(
      String project,
      String displayName,
      String modelDisplayName,
      String containerImageUri,
      String baseOutputDirectoryPrefix)
      throws IOException {
    PipelineServiceSettings settings =
        PipelineServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PipelineServiceClient client = PipelineServiceClient.create(settings)) {
      JsonObject jsonMachineSpec = new JsonObject();
      jsonMachineSpec.addProperty("machineType", "n1-standard-4");

      // A working docker image can be found at
      // gs://cloud-samples-data/ai-platform/mnist_tfrecord/custom_job
      // This sample image accepts a set of arguments including model_dir.
      JsonObject jsonContainerSpec = new JsonObject();
      jsonContainerSpec.addProperty("imageUri", containerImageUri);
      JsonArray jsonArgs = new JsonArray();
      jsonArgs.add("--model_dir=$(AIP_MODEL_DIR)");
      jsonContainerSpec.add("args", jsonArgs);

      JsonObject jsonJsonWorkerPoolSpec0 = new JsonObject();
      jsonJsonWorkerPoolSpec0.addProperty("replicaCount", 1);
      jsonJsonWorkerPoolSpec0.add("machineSpec", jsonMachineSpec);
      jsonJsonWorkerPoolSpec0.add("containerSpec", jsonContainerSpec);

      JsonArray jsonWorkerPoolSpecs = new JsonArray();
      jsonWorkerPoolSpecs.add(jsonJsonWorkerPoolSpec0);

      JsonObject jsonBaseOutputDirectory = new JsonObject();
      // The GCS location for outputs must be accessible by the project's AI Platform
      // service account.
      jsonBaseOutputDirectory.addProperty("output_uri_prefix", baseOutputDirectoryPrefix);

      JsonObject jsonTrainingTaskInputs = new JsonObject();
      jsonTrainingTaskInputs.add("workerPoolSpecs", jsonWorkerPoolSpecs);
      jsonTrainingTaskInputs.add("baseOutputDirectory", jsonBaseOutputDirectory);

      Value.Builder trainingTaskInputsBuilder = Value.newBuilder();
      JsonFormat.parser().merge(jsonTrainingTaskInputs.toString(), trainingTaskInputsBuilder);
      Value trainingTaskInputs = trainingTaskInputsBuilder.build();
      String trainingTaskDefinition =
          "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml";
      String imageUri = "gcr.io/cloud-aiplatform/prediction/tf-cpu.1-15:latest";
      ModelContainerSpec containerSpec =
          ModelContainerSpec.newBuilder().setImageUri(imageUri).build();
      Model modelToUpload =
          Model.newBuilder()
              .setDisplayName(modelDisplayName)
              .setContainerSpec(containerSpec)
              .build();
      TrainingPipeline trainingPipeline =
          TrainingPipeline.newBuilder()
              .setDisplayName(displayName)
              .setTrainingTaskDefinition(trainingTaskDefinition)
              .setTrainingTaskInputs(trainingTaskInputs)
              .setModelToUpload(modelToUpload)
              .build();
      LocationName parent = LocationName.of(project, location);
      TrainingPipeline response = client.createTrainingPipeline(parent, trainingPipeline);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }
}

Python

Informationen zum Installieren oder Aktualisieren von Python finden Sie unter Vertex AI SDK für Python installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Python API.

In den folgenden Beispielen wird gezeigt, wie Sie mit dem Vertex AI SDK für Python eine benutzerdefinierte Trainingspipeline erstellen. Legen Sie fest, ob Sie einen benutzerdefinierten Container oder einen vordefinierten Container für das Training verwenden möchten:

Vordefinierter Container

Wenn Sie mit dem Vertex AI SDK for Python eine Trainingspipeline erstellen, die Ihren Python-Code in einem vordefinierten Container ausführt, können Sie Ihren Trainingscode auf eine der folgenden Arten angeben:

  • Geben Sie den URI eines Python-Quelldistributionspakets in Cloud Storage an.

    (Diese Option ist auch verfügbar, wenn Sie eine Trainingspipeline erstellen, ohne das Vertex AI SDK für Python zu verwenden.)

  • Geben Sie den Pfad zu einem Python-Skript auf Ihrem lokalen Computer an. Bevor eine Trainingspipeline erstellt wird, verpackt das Vertex AI SDK for Python das Skript als Quelldistribution und lädt es in den Cloud Storage-Bucket Ihrer Wahl hoch.

    Diese Option ist nur verfügbar, wenn Sie das Vertex AI SDK für Python verwenden.

Klicken Sie auf den entsprechenden Tab, um ein Codebeispiel für jede dieser Optionen aufzurufen:

Paket

Im folgenden Beispiel wird die Klasse CustomPythonPackageTrainingJob verwendet.

def create_training_pipeline_custom_package_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    python_package_gcs_uri: str,
    python_module_name: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 1,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomPythonPackageTrainingJob(
        display_name=display_name,
        python_package_gcs_uri=python_package_gcs_uri,
        python_module_name=python_module_name,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Script

Im folgenden Beispiel wird die Klasse CustomTrainingJob verwendet.

def create_training_pipeline_custom_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    script_path: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 0,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomTrainingJob(
        display_name=display_name,
        script_path=script_path,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Benutzerdefinierter Container

Im folgenden Beispiel wird die Klasse CustomContainerTrainingJob verwendet.

def create_training_pipeline_custom_container_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 1,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomContainerTrainingJob(
        display_name=display_name,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Hyperparameter-Abstimmungsjob und Modellupload

Diese Trainingspipeline umfasst einen Hyperparameter-Abstimmungsjob mit einem zusätzlichen praktischen Schritt, der das Bereitstellen Ihres Modells nach dem Training in Vertex AI vereinfacht. Diese Trainingspipeline hat zwei Hauptaspekte:

  1. Die Trainingspipeline erstellt eine Ressource für den Hyperparameter-Abstimmungsjob. Der Hyperparameter-Abstimmungsjob erstellt mehrere Tests. Für jeden Test führt ein benutzerdefinierter Job Ihre Trainingsanwendung mit den von Ihnen angegebenen Rechenressourcen und Hyperparametern aus.

  2. Nachdem der Hyperparameter-Abstimmungsjob abgeschlossen ist, ermittelt die Trainingspipeline die Modellartefakte aus der besten Testversion im Ausgabeverzeichnis baseOutputDirectory, das Sie für Ihren Cloud Storage-Bucket angegeben haben. Die Trainingspipeline verwendet diese Artefakte, um eine Modellressource zu erstellen, die Sie für die Modellbereitstellung vorbereitet.

In dieser Trainingspipeline müssen Sie ein baseOutputDirectory angeben, worin Vertex AI die Modellartefakte aus dem besten Test sucht.

Für Hyperparameter-Abstimmungsjobs stehen zusätzliche Einstellungen zur Verfügung. Weitere Informationen zu den Einstellungen für einen HyperparameterTuningJob

REST

Im folgenden Codebeispiel wird eine Trainingspipeline mit der Methode create der Ressource trainingPipeline erstellt.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION_ID: Die Region Ihres Projekts.
  • PROJECT_ID: Ihre Projekt-ID.
  • TRAINING_PIPELINE_NAME: erforderlich. Ein Anzeigename für die trainingPipeline.
  • Wenn Ihre Trainingsanwendung ein Vertex-AI-Dataset verwendet, geben Sie Folgendes an:
    • DATASET_ID: Die ID des Datasets.
    • ANNOTATIONS_FILTER: Filtert das Dataset nach den von Ihnen angegebenen Annotationen.
    • ANNOTATION_SCHEMA_URI: Filtert das Dataset nach den angegebenen Annotationsschema-URI.
    • Verwenden Sie eine der folgenden Optionen, um anzugeben, wie Datenelemente in Trainings-, Validierungs- und Test-Datasets aufgeteilt werden.
      • Geben Sie Folgendes an, um das Dataset anhand von Anteilen aufzuteilen, die die Größe der einzelnen Datasets definieren:
        • TRAINING_FRACTION: Der Anteil des Datasets, der zum Trainieren Ihres Modells verwendet wird.
        • VALIDATION_FRACTION: Der Anteil des Datasets, der zum Validieren des Modells verwendet wird.
        • TEST_FRACTION: Der Anteil des Datasets, der zum Bewerten des Modells verwendet wird.
      • Wenn Sie das Dataset basierend auf Filtern aufteilen möchten, geben Sie Folgendes an:
        • TRAINING_FILTER: Filtert das Dataset nach Datenelementen, die zum Trainieren Ihres Modells verwendet werden.
        • VALIDATION_FILTER: Filtert das Dataset nach Datenelementen, die zur Validierung Ihres Modells verwendet werden.
        • TEST_FILTER: Filtert das Dataset nach Datenelementen, die zur Bewertung Ihres Modells verwendet werden.
      • Wenn Sie eine vordefinierte Aufteilung verwenden möchten, geben Sie Folgendes an:
        • PREDEFINED_SPLIT_KEY: Der Name der Spalte, die zum Aufteilen des Datasets verwendet werden soll. Zulässige Werte in dieser Spalte sind „training“, „validation“ und „test“.
      • Geben Sie Folgendes an, um das Dataset basierend auf dem Zeitstempel der Datenelemente aufzuteilen:
        • TIMESTAMP_TRAINING_FRACTION: Der Anteil des Datasets, der zum Trainieren Ihres Modells verwendet wird.
        • TIMESTAMP_VALIDATION_FRACTION: Der Anteil des Datasets, der zum Validieren des Modells verwendet wird.
        • TIMESTAMP_TEST_FRACTION: Der Anteil des Datasets, der zum Bewerten des Modells verwendet wird.
        • TIMESTAMP_SPLIT_KEY: Der Name der Zeitstempelspalte, die zum Aufteilen des Datasets verwendet werden soll.
    • OUTPUT_URI_PREFIX: Der Cloud Storage-Speicherort, an den Vertex AI Ihr Trainings-Dataset exportiert, nachdem es in Trainings-, Validierungs- und Test-Datasets aufgeteilt wurde.
  • Hyperparameter-Abstimmungsjob angeben:
    • Die Messwerte angeben:
      • METRIC_ID: Der Name dieses Messwerts.
      • METRIC_GOAL: Das Ziel dieses Messwerts. Kann MAXIMIZE oder MINIMIZE sein.
    • Damit legen Sie Hyperparameter fest:
      • PARAMETER_ID: Der Name dieses Hyperparameters.
      • PARAMETER_SCALE: (Optional) Skalierungsart des Parameters. Lassen Sie das Feld für kategoriale Parameter leer. Kann UNIT_LINEAR_SCALE, UNIT_LOG_SCALE, UNIT_REVERSE_LOG_SCALE oder SCALE_TYPE_UNSPECIFIED sein.
      • Wenn der Typ dieses Hyperparameters DOUBLE ist, geben Sie die Mindest- (DOUBLE_MIN_VALUE) und Höchstwerte (DOUBLE_MAX_VALUE) für diesen Hyperparameter an.
      • Wenn der Typ dieses Hyperparameters INTEGER ist, geben Sie die Mindest- (INTEGER_MIN_VALUE) und Höchstwerte (INTEGER_MAX_VALUE) für diesen Hyperparameter an.
      • Wenn der Typ dieses Hyperparameters CATEGORICAL ist, geben Sie die zulässigen Werte (CATEGORICAL_VALUES) als Array von Strings an.
      • Wenn der Typ dieses Hyperparameters DISCRETE ist, geben Sie die zulässigen Werte (DISCRETE_VALUES) als Array von Zahlen an.
    • ALGORITHM: (Optional) Der Suchalgorithmus, der in diesem Hyperparameter-Abstimmungsjob verwendet werden soll. Kann ALGORITHM_UNSPECIFIED, GRID_SEARCH oder RANDOM_SEARCH sein.
    • MAX_TRIAL_COUNT: Die maximale Anzahl an Tests, die in diesem Job ausgeführt werden sollen.
    • PARALLEL_TRIAL_COUNT: Die maximale Anzahl an Tests, die parallel ausgeführt werden können.
    • MAX_FAILED_TRIAL_COUNT: Die Anzahl der Jobs, die fehlschlagen können, bevor der Hyperparameter-Abstimmungsjob fehlschlägt.
    • Definieren Sie den benutzerdefinierten Trainingsjob:
      • MACHINE_TYPE: Der Maschinentyp. Hier finden Sie die verfügbaren Maschinentypen für das Training.
      • ACCELERATOR_TYPE: (Optional) Der Beschleunigertyp, der an jeden Test angehängt werden soll.
      • ACCELERATOR_COUNT: (Optional) Die Anzahl der Beschleuniger, die an jeden Test angehängt werden sollen.
      • REPLICA_COUNT: Die Anzahl der Worker-Replikate, die pro Test verwendet werden sollen.
      • Wenn Ihre Trainingsanwendung in einem benutzerdefinierten Container ausgeführt wird, geben Sie Folgendes an:
        • CUSTOM_CONTAINER_IMAGE_URI: Der URI eines Container-Images in Artifact Registry, Container Registry oder Docker Hub, der auf jedem Worker-Replikat ausgeführt werden soll.
        • CUSTOM_CONTAINER_COMMAND: (Optional) Der Befehl, der beim Start des Containers aufgerufen werden soll. Mit diesem Befehl wird der Standardeinstiegspunkt des Containers überschrieben.
        • CUSTOM_CONTAINER_ARGS: (Optional) Die Argumente, die beim Starten des Containers übergeben werden.
      • Wenn Ihre Trainingsanwendung ein Python-Paket ist, das in einem vordefinierten Container ausgeführt wird, geben Sie Folgendes an:
        • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: Der URI des Container-Images, das das bereitgestellte Python-Paket ausführt. Siehe Verfügbare vordefinierte Container für das Training.
        • PYTHON_PACKAGE_URIS: Der Cloud Storage-Speicherort der Python-Paketdateien, die das Trainingsprogramm und dessen abhängige Pakete sind. Die maximale Anzahl der Paket-URIs beträgt 100.
        • PYTHON_MODULE: Der Name des Python-Moduls, das nach der Installation der Pakete ausgeführt werden soll.
        • PYTHON_PACKAGE_ARGS: (Optional) Befehlszeilenargumente, die an das Python-Modul übergeben werden sollen.
    • Optionen für die Jobplanung
    • TIMEOUT: (Optional) Maximale Ausführungszeit für jeden Test.
    • Geben Sie LABEL_NAME und LABEL_VALUE für alle Labels an, die Sie auf diesen Hyperparameter-Abstimmungsjob anwenden möchten.
  • MODEL_NAME: Ein Anzeigename für das von der TrainingPipeline hochgeladene (erstellte) Modell.
  • MODEL_DESCRIPTION: Optional. Eine Beschreibung für das Modell.
  • PREDICTION_IMAGE_URI: erforderlich. Geben Sie eine der folgenden Optionen an:
  • modelToUpload.labels: Optional. Beliebiger Satz von Schlüssel/Wert-Paaren, um Ihre Modelle zu organisieren. Beispiel:
    • "env": "prod"
    • "tier": "backend"
  • Geben Sie LABEL_NAME und LABEL_VALUE für alle Labels an, die Sie auf diese Trainingspipeline anwenden möchten.

HTTP-Methode und URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines

JSON-Text der Anfrage:

{
  "displayName": "TRAINING_PIPELINE_NAME",
  "inputDataConfig": {
    "datasetId": DATASET_ID,
    "annotationsFilter": ANNOTATIONS_FILTER,
    "annotationSchemaUri": ANNOTATION_SCHEMA_URI,

    // Union field split can be only one of the following:
    "fractionSplit": {
      "trainingFraction": TRAINING_FRACTION,
      "validationFraction": VALIDATION_FRACTION,
      "testFraction": TEST_FRACTION
    },
    "filterSplit": {
      "trainingFilter": TRAINING_FILTER,
      "validationFilter": VALIDATION_FILTER,
      "testFilter": TEST_FILTER
    },
    "predefinedSplit": {
      "key": PREDEFINED_SPLIT_KEY
    },
    "timestampSplit": {
      "trainingFraction": TIMESTAMP_TRAINING_FRACTION,
      "validationFraction": TIMESTAMP_VALIDATION_FRACTION,
      "testFraction": TIMESTAMP_TEST_FRACTION,
      "key": TIMESTAMP_SPLIT_KEY
    }
    // End of list of possible types for union field split.
    "gcsDestination": {
      "outputUriPrefix": OUTPUT_URI_PREFIX
    }
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/hyperparameter_tuning_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "studySpec": {
    "metrics": [
      {
        "metricId": METRIC_ID,
        "goal": METRIC_GOAL
      }
    ],
    "parameters": [
      {
        "parameterId": PARAMETER_ID,
        "scaleType": PARAMETER_SCALE,

        // Union field parameter_value_spec can be only one of the following:
        "doubleValueSpec": {
            "minValue": DOUBLE_MIN_VALUE,
            "maxValue": DOUBLE_MAX_VALUE
        },
        "integerValueSpec": {
            "minValue": INTEGER_MIN_VALUE,
            "maxValue": INTEGER_MAX_VALUE
        },
        "categoricalValueSpec": {
            "values": [
              CATEGORICAL_VALUES
            ]
        },
        "discreteValueSpec": {
            "values": [
              DISCRETE_VALUES
            ]
        }
        // End of list of possible types for union field parameter_value_spec.
      }
    ],
    "ALGORITHM": ALGORITHM
  },
  "maxTrialCount": MAX_TRIAL_COUNT,
  "parallelTrialCount": PARALLEL_TRIAL_COUNT,
  "maxFailedTrialCount": MAX_FAILED_TRIAL_COUNT,
  "trialJobSpec": {
      "workerPoolSpecs": [
        {
          "machineSpec": {
            "machineType": MACHINE_TYPE,
            "acceleratorType": ACCELERATOR_TYPE,
            "acceleratorCount": ACCELERATOR_COUNT
          },
          "replicaCount": REPLICA_COUNT,

          // Union field task can be only one of the following:
          "containerSpec": {
            "imageUri": CUSTOM_CONTAINER_IMAGE_URI,
            "command": [
              CUSTOM_CONTAINER_COMMAND
            ],
            "args": [
              CUSTOM_CONTAINER_ARGS
            ]
          },
          "pythonPackageSpec": {
            "executorImageUri": PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,
            "packageUris": [
              PYTHON_PACKAGE_URIS
            ],
            "pythonModule": PYTHON_MODULE,
            "args": [
              PYTHON_PACKAGE_ARGS
            ]
          }
          // End of list of possible types for union field task.
        }
      ],
      "scheduling": {
        "TIMEOUT": TIMEOUT
      }
    },
    "labels": {
      LABEL_NAME_1": LABEL_VALUE_1,
      LABEL_NAME_2": LABEL_VALUE_2
    }
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "description": "MODEL_DESCRIPTION",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "PREDICTION_IMAGE_URI"
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines"

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

Die Antwort enthält Informationen zu Spezifikationen sowie die TRAININGPIPELINE_ID.

Training überwachen

So rufen Sie Trainingslogs auf:

  1. Rufen Sie in der Google Cloud Console im Abschnitt „Vertex AI” die Seite Training auf.

    Zur Seite „Training“

  2. Klicken Sie auf den Namen des Jobs, um die Seite mit den benutzerdefinierten Jobs aufzurufen.

  3. Klicken Sie auf Logs ansehen.

Sie können auch eine interaktive Shell verwenden, um Ihre Trainingscontainer während der Ausführung der Trainingspipeline zu prüfen.

Trainiertes Modell ansehen

Wenn die benutzerdefinierte Trainingspipeline abgeschlossen ist, finden Sie das trainierte Modell in der Google Cloud Console im Abschnitt „Vertex AI“ auf der Seite Modelle.

Zur Seite "Modelle"

Nächste Schritte