Modelle in die Gemini Enterprise Agent Platform importieren

In dieser Anleitung wird beschrieben, wie Sie Modelle in die Model Registry der Gemini Enterprise Agent Platform 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 Inferenzanfragen ausführen.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Agent Platform-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 die Agent Platform Inferenzanfragen ausführen kann. Sie können von der Agent Platform bereitgestellte vordefinierte Container 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 der Agent Platform 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 der Agent Platform 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
  • XGBoost: model.bst oder model.joblib

Modellartefakte für Inferenzanfragen exportieren .

Modell mit der Google Cloud console importieren

So importieren Sie ein Modell mit der Google Cloud console:

  1. Rufen Sie in der Google Cloud console die Seite Modelle der Agent Platform 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, die der Region des Buckets entspricht, und den regionalen Endpunkt der Agent Platform aus, den Sie verwenden. Klicken Sie auf Weiter.

  6. Wenn Sie Erweiterte Optionen maximieren, können Sie optional einen kundenverwalteten 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 das Bereitstellen von Inferenzanfragen 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 gcloud ai models upload Befehl 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 Folgendes:

  • LOCATION_ID: Die Region, in der Sie die Agent Platform verwenden.
  • MODEL_NAME: Ein Anzeigename für das Model.
  • IMAGE_URI: Der URI des Container-Images zum Bereitstellen von Inferenzanfragen. Zum 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 Inferenzanfragen verwenden, müssen Sie wahrscheinlich einige zusätzliche optionale Flags angeben, damit die Agent Platform Ihr Container-Image verwenden kann. Diese Flags, die mit --container- beginnen, entsprechen Feldern von Model's containerSpec.

REST

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

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION_ID: Die Region, in der Sie die Agent Platform verwenden.
  • PROJECT_ID: Ihre [Projekt-ID](/resource-manager/docs/creating-managing-projects#identifiers). .
  • MODEL_NAME: Ein Anzeigename für das Model.
  • MODEL_DESCRIPTION: Optional. Eine Beschreibung für das Modell.
  • IMAGE_URI: Der URI des Container-Images zum Bereitstellen von Inferenzanfragen. Zum 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

Folgen Sie der Java Einrichtungsanleitung in der Kurzanleitung zur Verwendung von Clientbibliotheken für die Agent Platform, bevor Sie dieses Beispiel anwenden.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Agent Platform zu authentifizieren. 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

Folgen Sie der Node.js Einrichtungsanleitung in der Kurzanleitung zur Verwendung von Clientbibliotheken für die Agent Platform, bevor Sie dieses Beispiel anwenden.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Agent Platform zu authentifizieren. 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 Python API-Referenzdokumentation. 

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 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. Die Agent Platform 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 maximale Modellgröße, die von Model Registry unterstützt wird, beträgt 1 TB.

Nächste Schritte