Benutzerdefinierten Container für die Inferenz verwenden

Wenn Sie anpassen möchten, wie Agent Platform 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 Agent Platform auf jedem Vorhersageknoten einen Docker-Container Ihrer Wahl 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 ein vordefinierter Container verfügbar ist.
• Sie möchten Vorhersageanfragen 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 der ENTRYPOINT Anweisung des Containers. Weitere Informationen zum Formatieren dieses Felds und zur Interaktion mit dem Feld args finden Sie in der API-Referenz fürModelContainerSpec.

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. Agent Platform sendet Aktivitätsprüfungen, System diagnosen und Vorhersage anfragen an den Container am ersten aufgeführten Port oder 8080 standardmäßig. 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 Agent Platform Systemdiagnosen senden soll.

Wenn Sie dieses Feld nicht angeben, wird beim Bereitstellen von Model als DeployedModel für eine Endpoint Ressource standardmäßig /v1/endpoints/ENDPOINT/deployedModels/DEPLOYED_MODEL verwendet, wobei ENDPOINT durch das letzte Segment des Endpoint's name Felds (nach endpoints/) und DEPLOYED_MODEL durch das DeployedModel's id Felds 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 Agent Platform Vorhersageanfragen weiterleiten soll.

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

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

invokeRoutePrefix (optional)

Präfix der Aufrufroute für den benutzerdefinierten Container. Wenn Sie dieses Feld auf „/*“ setzen, wird die beliebige Weiterleitung für das Modell aktiviert. Nach der Bereitstellung ist jede Nicht-Root-Route auf dem Modellserver mit einem HTTP-Aufruf zugänglich. So wird beispielsweise „/invoke/foo/bar“ als „/foo/bar“ an den Modellserver weitergeleitet. Diese Funktion befindet sich in der öffentlichen Vorschau. Folgen Sie der Anleitung zum Verwenden beliebiger benutzerdefinierter Routen, um ein Modell mit Aufruffunktion zu erstellen.

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 Befehl gcloud ai models upload 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 Agent Platform 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

Folgen Sie der Java Einrichtungsanleitung in der Kurzanleitung zu Agent Platform zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei 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 zu Agent Platform zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei 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

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 Ihr 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 Agent Platform erstellen möchten, lesen Sie die Anforderungen für benutzerdefinierte Container.