Modelle in Vertex AI importieren

In dieser Anleitung wird beschrieben, wie Sie Modelle in Model Registry importieren. Nachdem Sie das Modell importiert haben, ist es in Model Registry sichtbar. In Model Registry können Sie das importierte Modell auf einem Endpunkt bereitstellen und Vorhersagen ausführen.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Vertex AI-Nutzer (roles/aiplatform.user) für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Importieren von Modellen benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Vordefinierte oder benutzerdefinierte Container

Wenn Sie ein Modell importieren, verknüpfen Sie es mit einem Container, damit Vertex AI Anfragen für Vorhersagen ausführen kann. Sie können vordefinierte Container von Vertex AI verwenden. Alternativ haben Sie die Möglichkeit, eigene benutzerdefinierte Container zu verwenden, die Sie erstellen und per Push in Artifact Registry übertragen.

Sie können einen vordefinierten Container verwenden, wenn Ihr Modell die folgenden Anforderungen erfüllt:

Wenn Sie ein AutoML-Tabellenmodell importieren, das Sie zuvor exportiert haben, müssen Sie einen bestimmten benutzerdefinierten Container verwenden, der von Vertex AI bereitgestellt wird.

Erstellen Sie andernfalls einen neuen benutzerdefinierten Container oder verwenden Sie einen vorhandenen benutzerdefinierten Container in Artifact Registry.

Modellartefakte in Cloud Storage hochladen

Sie müssen Ihre Modellartefakte in einem Cloud Storage-Bucket speichern, wobei die Region des Buckets mit dem von Ihnen verwendeten regionalen Endpunkt übereinstimmt.

Wenn sich Ihr Cloud Storage-Bucket in einem anderen Google Cloud-Projekt befindet, müssen Sie Vertex AI Zugriff gewähren, um Ihre Modellartefakte zu lesen.

Wenn Sie einen vordefinierten Container verwenden, achten Sie darauf, dass die Modellartefakte Dateinamen haben, die exakt mit den folgenden Beispielen übereinstimmen:

  • TensorFlow SavedModel: saved_model.pb
  • PyTorch: model.mar
  • scikit-learn: model.joblib oder model.pkl
  • XGBoost: model.bst, model.joblib oder model.pkl

Modellartefakte für Vorhersagen exportieren

Modell mit Google Cloud Console importieren

So importieren Sie ein Modell mithilfe der Google Cloud Console:

  1. Rufen Sie in der Cloud Console die Seite Vertex AI-Modelle auf.

    Zur Seite "Modelle"

  2. Klicken Sie auf Importieren.

  3. Wählen Sie Als neues Modell importieren aus, um ein neues Modell zu importieren.

  4. Wählen Sie Als neue Version importieren aus, um ein Modell als Version eines vorhandenen Modells zu importieren. Weitere Informationen zur Versionsverwaltung finden Sie unter Modellversionsverwaltung.

  5. Name und Region: Geben Sie einen Namen für das Modell ein. Wählen Sie die Region aus, die der Region des Buckets und dem regionalen Vertex AI-Endpunkt entspricht, den Sie verwenden. Klicken Sie auf Weiter.

  6. Wenn Sie Erweiterte Optionen maximieren, können Sie optional einen vom Kunden verwalteten Verschlüsselungsschlüssel hinzufügen.

Wählen Sie je nach Typ des verwendeten Containers unten den entsprechenden Tab aus.

Vordefinierter Container

  1. Wählen Sie Modellartefakte in einen neuen vordefinierten Container importieren aus.

  2. Wählen Sie das Modell-Framework und die Modell-Framework-Version aus, die Sie zum Trainieren Ihres Modells verwendet haben.

  3. Wenn Sie GPUs für Vorhersagen verwenden möchten, setzen Sie den Beschleunigertyp auf GPUs.

    Sie wählen den GPU-Typ später aus, wenn Sie das Modell auf einem Endpunkt bereitstellen.

  4. Geben Sie den Cloud Storage-Pfad zum Verzeichnis an, das die Modellartefakte enthält.

    Zum Beispiel gs://BUCKET_NAME/models/.

  5. Lassen Sie die Vorhersageschemas leer.

  6. Wenn Sie Ihr Modell ohne Vertex Explainable AI-Einstellungen importieren möchten, klicken Sie auf Importieren.

    Wenn der Import abgeschlossen ist, wird das Modell auf der Seite Modelle angezeigt.

    Setzen Sie andernfalls die Konfiguration Ihres Modells fort, indem Sie auf dem Tab Erklärbarkeit Ihre Erklärbarkeitseinstellungen eingeben. Weitere Informationen zu den Erklärbarkeitseinstellungen.

Benutzerdefinierter Container

  1. Wählen Sie Vorhandenen benutzerdefinierten Container importieren aus.

  2. Legt den URI des Container-Images fest.

  3. Wenn Sie Modellartefakte zusätzlich zu einem Container-Image bereitstellen möchten, geben Sie den Cloud Storage-Pfad zum Verzeichnis an, das Ihre Modellartefakte enthält.

    z. B. gs://BUCKET_NAME/models/.

  4. Geben Sie Werte für die anderen Felder an.

    Weitere Informationen zu diesen optionalen Feldern.

  5. Wenn Sie Ihr Modell ohne Vertex Explainable AI-Einstellungen importieren möchten, klicken Sie auf Importieren.

    Wenn der Import abgeschlossen ist, wird das Modell auf der Seite Modelle angezeigt.

    Setzen Sie andernfalls die Konfiguration Ihres Modells fort, indem Sie auf dem Tab Erklärbarkeit Ihre Erklärbarkeitseinstellungen eingeben. Weitere Informationen zu den Erklärbarkeitseinstellungen.

Tabellarischer AutoML-Container

  1. Wählen Sie Vorhandenen benutzerdefinierten Container importieren aus.

  2. Geben Sie im Feld Container-Image MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1:latest ein.

    Ersetzen Sie MULTI_REGION durch us, europe oder asia, um das Docker-Repository auszuwählen, aus dem Sie das Docker-Image abrufen möchten. Jedes Repository stellt dasselbe Docker-Image bereit. Es kann jedoch die Latenz verringern, die Multi-Region der Artifact Registry auszuwählen, die der Maschine am nächsten ist, auf der Sie Docker ausführen.

  3. Geben Sie im Feld Paketspeicherort den Cloud Storage-Pfad zum Verzeichnis an, das Ihre Modellartefakte enthält.

    Der Pfad sieht in etwa so aus wie im folgenden Beispiel:

    gs://BUCKET_NAME/models-MODEL_ID/tf-saved-model/TIMESTAMP/

  4. Lassen Sie alle anderen Felder leer.

  5. Klicken Sie auf Importieren.

    Wenn der Import abgeschlossen ist, wird das Modell auf der Seite Modelle angezeigt. Sie können dieses Modell wie andere tabellarische AutoML-Modelle verwenden. Allerdings unterstützen importierte tabellarische AutoML-Modelle nicht Vertrex Explainable AI.

Modell programmgesteuert importieren

Die folgenden Beispiele zeigen, wie Sie ein Modell mit verschiedenen Tools importieren:

gcloud

Im folgenden Beispiel wir der Befehl gcloud ai models upload verwendet:

gcloud ai models upload \
  --region=LOCATION \
  --display-name=MODEL_NAME \
  --container-image-uri=IMAGE_URI \
  --artifact-uri=PATH_TO_MODEL_ARTIFACT_DIRECTORY

Ersetzen Sie dabei Folgendes:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • MODEL_NAME: Ein Anzeigename für Model.
  • IMAGE_URI: Der URI des Container-Images zum Bereitstellen von Vorhersagen. Beispiel: us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest Verwenden Sie einen vordefinierten Container oder einen benutzerdefinierten Container.
  • PATH_TO_MODEL_ARTIFACT_DIRECTORY: Der Cloud Storage-URI (beginnend mit gs://) eines Verzeichnisses in Cloud Storage, das Ihre Modellartefakte enthält.

Das vorherige Beispiel zeigt alle Flags, die zum Importieren der meisten Modelle erforderlich sind. Wenn Sie keinen vordefinierten Container für die Vorhersage verwenden, müssen Sie wahrscheinlich einige zusätzliche optionale Flags angeben, damit Vertex AI Ihr Container-Image verwenden kann. Diese Flags, die mit --container- beginnen, entsprechen Feldern von containerSpec Ihres Model.

REST

Verwenden Sie das folgende Codebeispiel, um ein Modell mithilfe der Methode upload der Ressource model hochzuladen.

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • PROJECT_ID: Ihre Projekt-ID.
  • MODEL_NAME: Ein Anzeigename für Model.
  • MODEL_DESCRIPTION: Optional. Eine Beschreibung für das Modell.
  • IMAGE_URI: Der URI des Container-Images zum Bereitstellen von Vorhersagen. Beispiel: us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest Verwenden Sie einen vordefinierten Container oder einen benutzerdefinierten Container.
  • PATH_TO_MODEL_ARTIFACT_DIRECTORY: Der Cloud Storage-URI (beginnend mit gs://) eines Verzeichnisses in Cloud Storage, das Ihre Modellartefakte enthält. Diese Variable und das Feld artifactUri sind optional, wenn Sie einen benutzerdefinierten Container verwenden.
  • labels: Optional. Alle Schlüssel/Wert-Paare 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/models:upload

JSON-Text der Anfrage:

{
  "model": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "IMAGE_URI"
    },
    "artifactUri": "PATH_TO_MODEL_ARTIFACT_DIRECTORY",
    "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/models:upload"

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/models:upload" | Select-Object -Expand Content

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.api.gax.longrunning.OperationFuture;
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.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import com.google.cloud.aiplatform.v1.UploadModelOperationMetadata;
import com.google.cloud.aiplatform.v1.UploadModelResponse;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class UploadModelSample {
  public static void main(String[] args)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String modelDisplayName = "YOUR_MODEL_DISPLAY_NAME";
    String metadataSchemaUri =
        "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml";
    String imageUri = "YOUR_IMAGE_URI";
    String artifactUri = "gs://your-gcs-bucket/artifact_path";
    uploadModel(project, modelDisplayName, metadataSchemaUri, imageUri, artifactUri);
  }

  static void uploadModel(
      String project,
      String modelDisplayName,
      String metadataSchemaUri,
      String imageUri,
      String artifactUri)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);

      ModelContainerSpec modelContainerSpec =
          ModelContainerSpec.newBuilder().setImageUri(imageUri).build();

      Model model =
          Model.newBuilder()
              .setDisplayName(modelDisplayName)
              .setMetadataSchemaUri(metadataSchemaUri)
              .setArtifactUri(artifactUri)
              .setContainerSpec(modelContainerSpec)
              .build();

      OperationFuture<UploadModelResponse, UploadModelOperationMetadata> uploadModelResponseFuture =
          modelServiceClient.uploadModelAsync(locationName, model);
      System.out.format(
          "Operation name: %s\n", uploadModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      UploadModelResponse uploadModelResponse = uploadModelResponseFuture.get(5, TimeUnit.MINUTES);

      System.out.println("Upload Model Response");
      System.out.format("Model: %s\n", uploadModelResponse.getModel());
    }
  }
}

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Node.js-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Node.js 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. 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 */

// const modelDisplayName = 'YOUR_MODEL_DISPLAY_NAME';
// const metadataSchemaUri = 'YOUR_METADATA_SCHEMA_URI';
// const imageUri = 'YOUR_IMAGE_URI';
// const artifactUri = 'YOUR_ARTIFACT_URI';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service Client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function uploadModel() {
  // Configure the parent resources
  const parent = `projects/${project}/locations/${location}`;
  // Configure the model resources
  const model = {
    displayName: modelDisplayName,
    metadataSchemaUri: '',
    artifactUri: artifactUri,
    containerSpec: {
      imageUri: imageUri,
      command: [],
      args: [],
      env: [],
      ports: [],
      predictRoute: '',
      healthRoute: '',
    },
  };
  const request = {
    parent,
    model,
  };

  console.log('PARENT AND MODEL');
  console.log(parent, model);
  // Upload Model request
  const [response] = await modelServiceClient.uploadModel(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  const result = response.result;

  console.log('Upload model response ');
  console.log(`\tModel : ${result.model}`);
}
uploadModel();

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. 

from typing import Dict, Optional, Sequence

from google.cloud import aiplatform
from google.cloud.aiplatform import explain


def upload_model_sample(
    project: str,
    location: str,
    display_name: str,
    serving_container_image_uri: str,
    artifact_uri: Optional[str] = None,
    serving_container_predict_route: Optional[str] = None,
    serving_container_health_route: Optional[str] = None,
    description: Optional[str] = None,
    serving_container_command: Optional[Sequence[str]] = None,
    serving_container_args: Optional[Sequence[str]] = None,
    serving_container_environment_variables: Optional[Dict[str, str]] = None,
    serving_container_ports: Optional[Sequence[int]] = None,
    instance_schema_uri: Optional[str] = None,
    parameters_schema_uri: Optional[str] = None,
    prediction_schema_uri: Optional[str] = None,
    explanation_metadata: Optional[explain.ExplanationMetadata] = None,
    explanation_parameters: Optional[explain.ExplanationParameters] = None,
    sync: bool = True,
):

    aiplatform.init(project=project, location=location)

    model = aiplatform.Model.upload(
        display_name=display_name,
        artifact_uri=artifact_uri,
        serving_container_image_uri=serving_container_image_uri,
        serving_container_predict_route=serving_container_predict_route,
        serving_container_health_route=serving_container_health_route,
        instance_schema_uri=instance_schema_uri,
        parameters_schema_uri=parameters_schema_uri,
        prediction_schema_uri=prediction_schema_uri,
        description=description,
        serving_container_command=serving_container_command,
        serving_container_args=serving_container_args,
        serving_container_environment_variables=serving_container_environment_variables,
        serving_container_ports=serving_container_ports,
        explanation_metadata=explanation_metadata,
        explanation_parameters=explanation_parameters,
        sync=sync,
    )

    model.wait()

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

Informationen zum Importieren eines Modells mit aktivierten Einstellungen für Vertex Explainable AI-Einstellungen finden Sie in den Beispielen für das Importieren von Vertex Explainable AI-Modellen.

Vorgangsstatus abrufen

Einige Anfragen starten lang andauernde Vorgänge, die viel Zeit in Anspruch nehmen. Diese Anfragen geben einen Vorgangsnamen zurück, mit dem Sie den Status des Vorgangs aufrufen oder den Vorgang abbrechen können. Vertex AI stellt Hilfsmethoden bereit, um Aufrufe für Vorgänge mit langer Laufzeit auszuführen. Weitere Informationen finden Sie unter Mit lang andauernden Vorgängen arbeiten.

Beschränkungen

  • Die maximal unterstützte Modellgröße beträgt 10 GiB.

Nächste Schritte