Schulungspipelines erstellen

Console

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

   Zur Trainingspipeline

2. Klicken Sie auf add_box 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:

      • Wenn Sie einen vordefinierten Container für das Training verwenden möchten, müssen Sie Vertex AI die erforderlichen Informationen zur Verwendung des Trainingspakets bereitstellen, das Sie in Cloud Storage hochgeladen haben:

        1. Verwenden Sie die Drop-down-Listen Modell-Framework und Modell-Framework-Version, um den vordefinierten Container anzugeben, den Sie verwenden möchten.

        2. Geben Sie im Feld Paketstandort den Cloud Storage-URI der Python-Trainingsanwendung an, die Sie erstellt und hochgeladen haben. Diese Datei endet normalerweise mit .tar.gz.

        3. Geben Sie im Feld Python-Modul den Modulnamen des Einstiegspunkts Ihrer Trainingsanwendung ein.

      • Wenn Sie einen benutzerdefinierten Container für das Training verwenden möchten, geben Sie im Feld Container-Image die Artifact Registry oder den Docker Hub-URI Ihres Container-Image an.

   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 keinen Hyperparameter 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:

      • Wenn Sie einen vordefinierten Container verwenden, übergibt Vertex AI die Argumente als Befehlszeilen-Flags an Ihr Python-Modul.

      • Wenn Sie einen benutzerdefinierten Container verwenden, überschreibt Vertex AI die CMD-Anweisung Ihres Containers mit den Argumenten.

   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:

      • Wenn Sie einen vordefinierten Container für Vorhersagen verwenden möchten, verwenden Sie die FelderModell-Framework, Modell-Framework-Version und Beschleunigertyp, um auszuwählen, welchen vorkonfigurierten Vorhersagecontainer für Vorhersagen verwendet werden sollen.

        Gleichen Sie das Modell-Framework und die Modell-Framework-Version mit dem Framework für maschinelles Lernen ab, das Sie für das Training verwendet haben. Geben Sie einen Beschleunigertyp nur an, wenn Sie später GPUs für Online- oder Batchvorhersagen verwenden möchten.

      • Wenn Sie für die Bereitstellung von Vorhersagen einen benutzerdefinierten Container verwenden möchten, gehen Sie so vor:

        1. Geben Sie im Feld Container-Image den Artifact Registry-URI Ihres Container-Images an.

        2. Optional können Sie einen Befehl angeben, um die Anweisung ENTRYPOINT des Containers zu überschreiben.

   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 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 -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"

$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.

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines/TRAININGPIPELINE_ID",
  "displayName": "TRAINING_PIPELINE_NAME",
  "input_data_config" {
    "dataset_id": "1234567891011121314"
    "gcs_destination" {
      "output_uri_prefix": "gs://BUCKET_NAME/data/20200915191342"
    }
    "annotation_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/annotation/image_classification_1.0.0.yaml"
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": "n1-standard-4"
        },
        "replicaCount": "1",
        "pythonPackageSpec": {
          "executorImageUri": "us-docker.pkg.dev/vertex-ai/training/training-tf-cpu.2-1:latest",
          "packageUris": [
            "gs://BUCKET_NAME/training/hello-custom-training-1.0.tar.gz"
          ],
          "pythonModule": "trainer.task",
          "args": [
            "--model-dir=gs://BUCKET_NAME/output/"
          ]
        }
      }
    ]
  },
  "trainingTaskMetadata": {
    "backingCustomJob": "projects/PROJECT_ID/locations/LOCATION_ID/customJobs/CUSTOM_JOB_ID"
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest"
    }
  },
  "state": "PIPELINE_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}

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 zur Installation des Vertex AI SDK for Python finden Sie unter Vertex AI SDK for 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:

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

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

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

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 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:
  • Der Image-URI des vorkonfigurierten Containers für die Vorhersage, z. B. „tf2-cpu.2-1:latest“.
  • Der Image-URI Ihres eigenen benutzerdefinierten Containers für die Vorhersage.
• 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 -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"

$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.

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines/TRAININGPIPELINE_ID",
  "displayName": "TRAINING_PIPELINE_NAME",
  "input_data_config" {
    "dataset_id": "1234567891011121314"
    "gcs_destination" {
      "output_uri_prefix": "gs://BUCKET_NAME/data/20200915191342"
    }
    "annotation_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/annotation/image_classification_1.0.0.yaml"
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "name": "projects/12345/locations/us-central1/hyperparameterTuningJobs/6789",
  "displayName": "myHyperparameterTuningJob",
  "studySpec": {
    "metrics": [
      {
        "metricId": "myMetric",
        "goal": "MINIMIZE"
      }
    ],
    "parameters": [
      {
        "parameterId": "myParameter1",
        "integerValueSpec": {
          "minValue": "1",
          "maxValue": "128"
        },
        "scaleType": "UNIT_LINEAR_SCALE"
      },
      {
        "parameterId": "myParameter2",
        "doubleValueSpec": {
          "minValue": 1e-07,
          "maxValue": 1
        },
        "scaleType": "UNIT_LINEAR_SCALE"
      }
    ],
    "ALGORITHM": "RANDOM_SEARCH"
  },
  "maxTrialCount": 20,
  "parallelTrialCount": 1,
  "trialJobSpec": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": "n1-standard-4"
        },
        "replicaCount": "1",
        "pythonPackageSpec": {
          "executorImageUri": "us-docker.pkg.dev/vertex-ai/training/training-tf-cpu.2-1:latest",
          "packageUris": [
            "gs://my-bucket/my-training-application/trainer.tar.bz2"
          ],
          "pythonModule": "my-trainer.trainer"
        }
      }
    ]
  },
  "state": "PIPELINE_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}