Benutzerdefinierten Container für Vorhersagen verwenden

Wenn Sie anpassen möchten, wie Vertex AI Onlinevorhersagen aus dem benutzerdefinierten Modell bereitstellt, können Sie anstelle eines vordefinierten Containers einen benutzerdefinierten Container festlegen, wenn Sie eine Model-Ressource erstellen. Wenn Sie einen benutzerdefinierten Container verwenden, führt Vertex AI einen Docker-Container Ihrer Wahl auf jedem Vorhersageknoten aus.

Benutzerdefinierte Container können aus folgenden Gründen verwendet werden:

• Sie möchten Vorhersagen aus einem ML-Modell bereitstellen, das mit einem Framework trainiert wurde, das nicht als vordefinierter Container verfügbar ist.
• Sie möchten Vorhersaganfragen vorverarbeiten oder die von Ihrem Modell generierten Vorhersagen nachbearbeiten.
• Sie möchten einen Vorhersageserver ausführen, der in einer Programmiersprache Ihrer Wahl geschrieben ist.
• Sie möchten Abhängigkeiten installieren, mit denen Sie Vorhersagen anpassen können.

In diesem Leitfaden wird beschrieben, wie Sie ein Modell erstellen, das einen benutzerdefinierten Container verwendet. Er enthält keine detaillierten Anleitungen zum Erstellen eines Docker-Container-Images.

Container-Image vorbereiten

Wenn Sie eine Model erstellen möchten, die einen benutzerdefinierten Container verwendet, müssen Sie ein Docker-Container-Image als Grundlage dieses Containers bereitstellen. Dieses Container-Image muss die Anforderungen erfüllen, die unter Anforderungen für benutzerdefinierte Container beschrieben sind.

Wenn Sie ein vorhandenes Container-Image verwenden möchten, das von einem Drittanbieter erstellt wurde, dem Sie vertrauen, können Sie möglicherweise einen oder beide der folgenden Abschnitte überspringen.

Container-Image erstellen

Entwerfen und erstellen Sie ein Docker-Container-Image, das die Anforderungen an Container-Images erfüllt.

Die Grundlagen zum Entwerfen und Erstellen eines Docker-Container-Image finden Sie in der Kurzanleitung der Docker-Dokumentation.

Container-Image per Push an Artifact Registry übertragen

Übertragen Sie Ihr Container-Image per Push in ein Artifact Registry-Repository.

Informationen zum Hochladen eines Container-Images in Artifact Registry

Model erstellen

Führen Sie einen der folgenden Schritte aus, um ein Model mit einem benutzerdefinierten Container zu erstellen:

• Benutzerdefiniert trainiertes Modell importieren

• Erstellen Sie eine TrainingPipeline, die einen CustomJob ausführt und die resultierenden Artefakte als Model importiert.

In den folgenden Abschnitten wird gezeigt, wie Sie die auf benutzerdefinierte Container bezogenen API-Felder konfigurieren, wenn Sie ein Model auf eine dieser Arten erstellen.

Containerbezogene API-Felder

Achten Sie beim Erstellen des Model darauf, das Feld containerSpec mit den Details des benutzerdefinierten Containers zu konfigurieren, nicht mit einem vordefinierten Container.

Geben Sie im Feld Model.containerSpec eine ModelContainerSpec-Nachricht an. In dieser Nachricht können Sie die folgenden untergeordneten Felder angeben.

imageUri (erforderlich)

Artifact Registry-URI Ihres Container-Images.

Wenn Sie den Befehl gcloud ai models uploadverwenden, können Sie dieses Feld mit dem Flag --container-image-uri angeben.

command (optional)

Ein Array aus einer ausführbaren Datei und Argumenten zum Überschreiben des Felds ENTRYPOINT des Containers. Weitere Informationen zum Formatieren dieses Felds und zur Interaktion mit dem Feld args finden Sie in der API-Referenz zu ModelContainerSpec.

Wenn Sie den gcloud ai models uploadBefehl --container-command verwenden, können Sie dieses Feld mit dem Flag angeben.

args (optional)

Ein Array aus einer ausführbaren Datei und Argumenten zum Überschreiben des Felds CMD des Containers. Weitere Informationen zum Formatieren dieses Felds und zur Interaktion mit dem Feld command finden Sie in der API-Referenz zu ModelContainerSpec.

Wenn Sie den gcloud ai models uploadBefehl --container-args verwenden, können Sie dieses Feld mit dem Flag angeben.

ports (optional)

Ein Array von Ports. Vertex AI sendet Aktivitätsprüfungen, Systemdiagnosen und Vorhersageanfragen an den Container am ersten aufgeführten Port oder standardmäßig an 8080. Die Angabe zusätzlicher Ports hat keine Auswirkungen.

Wenn Sie den gcloud ai models uploadBefehl --container-ports verwenden, können Sie dieses Feld mit dem Flag angeben.

env (optional)

Ein Array von Umgebungsvariablen, auf die der ENTRYPOINT-Anweisung des Containers sowie die Felder command und args verweisen können. Weitere Informationen dazu, wie andere Felder auf diese Umgebungsvariablen verweisen können, finden Sie in der API-Referenz zu ModelContainerSpec.

Wenn Sie den gcloud ai models upload-Befehl verwenden, können Sie dieses Feld mit dem Flag --container-env-vars angeben.

healthRoute (optional)

Der Pfad auf dem HTTP-Server Ihres Containers, an den Vertex AI Systemdiagnosen senden soll.

Wenn Sie dieses Feld nicht angeben, wird beim Bereitstellen vonModel alsDeployedModel für eine Endpoint-Ressource standardmäßig /v1/endpoints/ENDPOINT/deployedModels/DEPLOYED_MODEL verwendet, wobei ENDPOINT durch das letzte Segment des name-Feld von Endpoint (nach endpoints/) undDEPLOYED_MODEL durch das id-Feld von DeployedModel ersetzt wird.

Wenn Sie den gcloud ai models upload-Befehl verwenden, können Sie dieses Feld mit dem Flag --container-health-route angeben.

predictRoute (optional)

Der Pfad auf dem HTTP-Server Ihres Containers, an den Vertex AI Vorhersageanfragen weiterleiten soll.

Wenn Sie dieses Feld nicht angeben, wird beim Bereitstellen vonModel alsDeployedModel für eine Endpoint-Ressource standardmäßig /v1/endpoints/ENDPOINT/deployedModels/DEPLOYED_MODEL:predict verwendet, wobei ENDPOINT durch das letzte Segment des name-Feld von Endpoint (nach endpoints/) undDEPLOYED_MODEL durch das id-Feld von DeployedModel ersetzt wird.

Wenn Sie den gcloud ai models upload-Befehl verwenden, können Sie dieses Feld mit dem Flag --container-predict-route angeben.

sharedMemorySizeMb (optional)

Die Menge des VM-Speichers, der in einem gemeinsam genutzten Speicher-Volume für das Modell in Megabyte reserviert werden soll.

Gemeinsam genutzter Speicher ist ein IPC-Mechanismus (Inter-Process Communication), der es mehreren Prozessen ermöglicht, auf einen gemeinsamen Speicherblock zuzugreifen und diesen zu bearbeiten. Die Größe des erforderlichen gemeinsamen Speichers ist ein Implementierungsdetail Ihres Containers und Modells. Weitere Informationen finden Sie in der Dokumentation Ihres Modellservers.

Wenn Sie den gcloud ai models upload-Befehl verwenden, können Sie dieses Feld mit dem Flag --container-shared-memory-size-mb angeben.

startupProbe (optional)

Spezifikation für die Prüfung, die prüft, ob die Containeranwendung gestartet wurde.

Wenn Sie den gcloud ai models upload-Befehl verwenden, können Sie dieses Feld mit dem Flag --container-startup-probe-exec, --container-startup-probe-period-seconds, --container-startup-probe-timeout-seconds angeben.

healthProbe (optional)

Spezifikation für die Prüfung, die prüft, ob ein Container bereit ist, Traffic anzunehmen.

Wenn Sie den gcloud ai models upload-Befehl verwenden, können Sie dieses Feld mit dem Flag --container-health-probe-exec, --container-health-probe-period-seconds, --container-health-probe-timeout-seconds angeben.

Neben den Variablen, die Sie im Feld Model.containerSpec.env festlegen, legt Vertex AI mehrere andere Variablen auf der Grundlage Ihrer Konfiguration fest. Weitere Informationen zur Verwendung der Umgebungsvariablen in diesen Feldern und in der ENTRYPOINT-Anweisung des Containers

Beispiele für den Modellimport

Die folgenden Beispiele zeigen, wie Sie beim Importieren eines Modells containerbezogene API-Felder angeben.

Hinweis: Wenn Sie TrainingPipeline zum Erstellen eines Model verwenden, müssen Sie diese Felder in einem anderen Kontext angeben. Sie können die Google Cloud CLI nicht verwenden, um eine TrainingPipeline zu erstellen. Weitere Informationen zum Erstellen benutzerdefinierter TrainingPipeline-Ressourcen

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 \
  --container-command=COMMAND \
  --container-args=ARGS \
  --container-ports=PORTS \
  --container-env-vars=ENV \
  --container-health-route=HEALTH_ROUTE \
  --container-predict-route=PREDICT_ROUTE \
  --container-shared-memory-size-mb=SHARED_MEMORY_SIZE \
  --container-startup-probe-exec=STARTUP_PROBE_EXEC \
  --container-startup-probe-period-seconds=STARTUP_PROBE_PERIOD \
  --container-startup-probe-timeout-seconds=STARTUP_PROBE_TIMEOUT \
  --container-health-probe-exec=HEALTH_PROBE_EXEC \
  --container-health-probe-period-seconds=HEALTH_PROBE_PERIOD \
  --container-health-probe-timeout-seconds=HEALTH_PROBE_TIMEOUT \
  --artifact-uri=PATH_TO_MODEL_ARTIFACT_DIRECTORY

Das Flag --container-image-uri ist erforderlich. Alle anderen Flags, die mit --container- beginnen, sind optional. Weitere Informationen zu den Werten für diese Felder finden Sie im vorherigen Abschnitt dieses Leitfadens.

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

Weitere Informationen finden Sie in der Anleitung zum Modellimport.

Vorhersageanfragen senden

Folgen Sie der Anleitung unter Vorhersagen von einem benutzerdefinierten Modell abrufen, um eine Onlinevorhersageanfrage an Model zu senden. Dieser Vorgang funktioniert unabhängig davon, ob Sie einen benutzerdefinierten Container verwenden.

Weitere Informationen zu Anforderungen an Vorhersageanfragen und Antworten für benutzerdefinierte Container.

Nächste Schritte

• Wenn Sie einen benutzerdefinierten Container für die Verwendung mit Vertex AI erstellen möchten, lesen Sie die Anforderungen für benutzerdefinierte Container.