Modelle in Vertex AI importieren

In dieser Anleitung wird gezeigt, wie Sie vorhandene Modelle importieren, die Sie außerhalb von Vertex AI trainiert oder mit Vertex AI trainiert und exportiert haben. Nach dem Import des Modells haben Sie ein Modell in Vertex AI, das Sie auf einem Endpunkt bereitstellen und mit ihm dann Vorhersagen anfordern können.

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 Container Registry oder 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 Container Registry oder 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. Die Gesamtdateigröße der Modellartefakte darf maximal 10 GB betragen.

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
  • scikit-learn: model.joblib oder model.pkl
  • XGBoost: model.bst

Modellartefakte für Vorhersagen exportieren

Modell mit Cloud Console importieren

So importieren Sie ein Modell mithilfe der Cloud Console:

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

    Zur Seite "Modelle"

  2. Klicken Sie auf Importieren.

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

  4. 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 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 beta ai models upload verwendet:

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

Dabei gilt:

  • LOCATION: 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 UND BEFEHLSZEILE

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: Die Region, in der Sie Vertex AI verwenden.
  • PROJECT_ID: Ihre Projekt-ID oder Projektnummer
  • 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-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/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 application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/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 application-default 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-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/models:upload" | Select-Object -Expand Content

Java


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

/**
 * 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

In diesem Beispiel wird das Vertex SDK for Python verwendet. Bevor Sie das folgende Codebeispiel ausführen, müssen Sie die Authentifizierung einrichten.

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 Explainable AI-Einstellungen finden Sie in den Beispielen für das Importieren von 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.

Nächste Schritte