Vorhersagen von einem benutzerdefinierten Modell abrufen

Auf dieser Seite wird gezeigt, wie Sie mit der Google Cloud Console oder der Vertex AI API Onlinevorhersagen und Batchvorhersagen von Ihren trainierten Modellen abrufen.

Unterschied zwischen Online- und Batchvorhersagen

Onlinevorhersagen sind synchrone Anfragen an einen Modellendpunkt. Verwenden Sie Onlinevorhersagen, wenn Sie Anfragen als Reaktion auf Anwendungseingaben stellen oder in Situationen, in denen eine zeitnahe Inferenz erforderlich ist.

Batchvorhersagen sind asynchrone Anfragen. Sie können Batchvorhersagen direkt von der Modellressource anfordern, ohne das Modell auf einem Endpunkt bereitstellen zu müssen. Verwenden Sie Batchvorhersagen, wenn Sie nicht sofort eine Antwort benötigen und akkumulierte Daten in einer einzigen Anfrage verarbeiten möchten.

Modell lokal testen

In der Entwicklungs- und Testphase können Sie Ihr Modell auf einem lokalen Endpunkt anstelle eines Online-Endpunkts bereitstellen. So können Sie sowohl schneller iterieren als auch das Modell testen, ohne dass Vorhersagekosten anfallen. Die lokale Bereitstellung ist für lokale Entwicklung und Tests vorgesehen, nicht für die Produktionsbereitstellung.

Wenn Sie ein Modell lokal bereitstellen möchten, verwenden Sie das Vertex AI SDK für Python und stellen Sie einen LocalModel in einem LocalEndpoint bereit. Eine Demonstration finden Sie in diesem Notebook.

Auch wenn Ihr Client nicht in Python geschrieben ist, können Sie das Vertex AI SDK für Python verwenden, um den Container und den Server zu starten, sodass Sie Anfragen von Ihrem Client testen können.

Onlinevorhersagen abrufen

Modell auf einem Endpunkt bereitstellen

Sie müssen ein Modell auf einem Endpunkt bereitstellen, bevor es für Onlinevorhersagen verwendet werden kann. Durch die Bereitstellung eines Modells werden dem Modell physische Ressourcen zugeordnet, sodass es Onlinevorhersagen mit niedriger Latenz bereitstellen kann.

Sie können mehrere Modelle auf einem Endpunkt bereitstellen und ein Modell auf mehreren Endpunkten bereitstellen. Weitere Informationen zu Optionen und Anwendungsfällen für die Bereitstellung von Modellen finden Sie unter Modelle bereitstellen.

Verwenden Sie eine der folgenden Methoden, um ein Modell bereitzustellen:

Google Cloud Console

  1. Rufen Sie in der Google Cloud Console im Abschnitt "Vertex AI" die Seite Modelle auf.

    Zur Seite "Modelle"

  2. Klicken Sie auf den Namen des Modells, das Sie bereitstellen möchten, um die Detailseite zu öffnen.

  3. Wählen Sie den Tab Deploy & Test (Bereitstellen und testen) aus.

    Wenn Ihr Modell bereits für Endpunkte bereitgestellt ist, werden diese im Abschnitt Modell bereitstellen aufgeführt.

  4. Klicken Sie auf In Endpunkt bereitstellen.

  5. Wählen Sie Neuen Endpunkt erstellen aus und geben Sie einen Namen für den neuen Endpunkt an, um Ihr Modell auf einem neuen Endpunkt bereitzustellen. Zum Bereitstellen des Modells auf einem vorhandenen Endpunkt wählen Sie Zu vorhandenem Endpunkt hinzufügen und anschließend den Endpunkt aus der Drop-down-Liste aus.

    Sie können einem Endpunkt mehrere Modelle hinzufügen und ein Modell mehreren Endpunkten hinzufügen. Weitere Informationen

  6. Wenn Sie das Modell auf einem vorhandenen Endpunkt bereitstellen, auf dem ein oder mehrere Modelle bereitgestellt werden, müssen Sie den Prozentsatz für die Trafficaufteilung für das bereitzustellende Modell und die bereits bereitgestellten Modelle aktualisieren, sodass alle Prozentwerte zusammengenommen 100 % ergeben.

  7. Wenn Sie Ihr Modell auf einem neuen Endpunkt bereitstellen, akzeptieren Sie für die Trafficaufteilung 100. Andernfalls passen Sie die Werte der Trafficaufteilung für alle Modelle auf dem Endpunkt an, sodass sie 100 ergeben.

  8. Geben Sie die Mindestanzahl von Computing-Knoten ein, die Sie für das Modell bereitstellen möchten.

    Dies ist die Anzahl der Knoten, die für dieses Modell verfügbar sind.

    Unabhängig davon, ob die Vorhersagelast oder ein Standby-Knoten verarbeitet wird, werden Ihnen die Kosten für die verwendeten Knoten in Rechnung gestellt – auch ohne Vorhersagetraffic. Weitere Informationen finden Sie auf der Seite "Preise".

  9. Geben Sie für die Verwendung von Autoscaling die maximale Anzahl von Rechenknoten ein, auf die Vertex AI hochskaliert werden soll.

    Die Anzahl der Computing-Knoten kann erhöht werden, wenn dies zur Verarbeitung des Vorhersagetraffics erforderlich ist. Sie übersteigt jedoch nie die maximale Knotenanzahl.

  10. Wählen Sie den Maschinentyp aus.

    Größere Maschinenressourcen erhöhen die Vorhersageleistung und erhöhen die Kosten. Vergleichen Sie die verfügbaren Maschinentypen.

  11. Wählen Sie einen Beschleunigertyp und eine Anzahl der Beschleuniger aus.

    Diese Option wird nur angezeigt, wenn Sie den Beschleuniger beim Importieren oder beim Erstellen des Modells aktiviert haben.

    Die Anzahl der Beschleuniger finden Sie in der GPU-Tabelle, die eine gültige Anzahl von GPUs ermittelt, die Sie mit jedem Maschinentyp verwenden können. Die Anzahl der Beschleuniger bezieht sich auf die Anzahl der Beschleuniger pro Knoten, nicht auf die Gesamtzahl der Beschleuniger in Ihrer Bereitstellung.

  12. Wenn Sie ein benutzerdefiniertes Dienstkonto für die Bereitstellung verwenden möchten, wählen Sie im Drop-down-Menü Dienstkonto ein Dienstkonto aus.

  13. Standardeinstellungen für das Vorhersage-Logging ändern

  14. Klicken Sie für Ihr Modell auf Fertig. Wenn alle Prozentsätze für Trafficaufteilung korrekt sind, klicken Sie auf Weiter.

    Die Region, in der Ihr bereitgestelltes Modell angezeigt wird. Dies muss die Region sein, in der Sie Ihr Modell erstellt haben.

  15. Klicken Sie auf Deploy, um Ihr Modell auf dem Endpunkt bereitzustellen.

API

Wenn Sie ein Modell mit der Vertex AI API bereitstellen, führen Sie die folgenden Schritte aus:

  1. Create Sie bei Bedarf einen Endpunkt.
  2. Get Sie die Endpunkt-ID.
  3. Deploy Sie das Modell am Endpunkt.

Endpunkt erstellen

Wenn Sie ein Modell auf einem vorhandenen Endpunkt bereitstellen, können Sie diesen Schritt überspringen.

gcloud

Im folgenden Beispiel wir der Befehl gcloud ai endpoints create verwendet:

gcloud ai endpoints create \
  --region=LOCATION \
  --display-name=ENDPOINT_NAME

Dabei gilt:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.

Es kann einige Sekunden dauern, bis das Google Cloud CLI den Endpunkt erstellt.

REST

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • LOCATION_ID: Ihre Region.
  • PROJECT_ID: Ihre Projekt-ID.
  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.
  • PROJECT_NUMBER: Projektnummer für Ihr Projekt

HTTP-Methode und URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints

JSON-Text anfordern:

{
  "display_name": "ENDPOINT_NAME"
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.CreateEndpointOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-11-05T17:45:42.812656Z",
      "updateTime": "2020-11-05T17:45:42.812656Z"
    }
  }
}
Sie können den Status des Vorgangs abfragen, bis in der Antwort "done": true angegeben wird.

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Vertex AI finden Sie unter Vertex AI-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.CreateEndpointOperationMetadata;
import com.google.cloud.aiplatform.v1.Endpoint;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateEndpointSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String endpointDisplayName = "YOUR_ENDPOINT_DISPLAY_NAME";
    createEndpointSample(project, endpointDisplayName);
  }

  static void createEndpointSample(String project, String endpointDisplayName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.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 (EndpointServiceClient endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);
      Endpoint endpoint = Endpoint.newBuilder().setDisplayName(endpointDisplayName).build();

      OperationFuture<Endpoint, CreateEndpointOperationMetadata> endpointFuture =
          endpointServiceClient.createEndpointAsync(locationName, endpoint);
      System.out.format("Operation name: %s\n", endpointFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      Endpoint endpointResponse = endpointFuture.get(300, TimeUnit.SECONDS);

      System.out.println("Create Endpoint Response");
      System.out.format("Name: %s\n", endpointResponse.getName());
      System.out.format("Display Name: %s\n", endpointResponse.getDisplayName());
      System.out.format("Description: %s\n", endpointResponse.getDescription());
      System.out.format("Labels: %s\n", endpointResponse.getLabelsMap());
      System.out.format("Create Time: %s\n", endpointResponse.getCreateTime());
      System.out.format("Update Time: %s\n", endpointResponse.getUpdateTime());
    }
  }
}

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Vertex AI finden Sie unter Vertex AI-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.\
 * (Not necessary if passing values as arguments)
 */

// const endpointDisplayName = 'YOUR_ENDPOINT_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

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

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

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function createEndpoint() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const endpoint = {
    displayName: endpointDisplayName,
  };
  const request = {
    parent,
    endpoint,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.createEndpoint(request);
  console.log(`Long running operation : ${response.name}`);

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

  console.log('Create endpoint response');
  console.log(`\tName : ${result.name}`);
  console.log(`\tDisplay name : ${result.displayName}`);
  console.log(`\tDescription : ${result.description}`);
  console.log(`\tLabels : ${JSON.stringify(result.labels)}`);
  console.log(`\tCreate time : ${JSON.stringify(result.createTime)}`);
  console.log(`\tUpdate time : ${JSON.stringify(result.updateTime)}`);
}
createEndpoint();

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Vertex AI finden Sie unter Vertex AI-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Python 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. 

def create_endpoint_sample(
    project: str,
    display_name: str,
    location: str,
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint.create(
        display_name=display_name,
        project=project,
        location=location,
    )

    print(endpoint.display_name)
    print(endpoint.resource_name)
    return endpoint

Endpunkt-ID abrufen

Sie benötigen die Endpunkt-ID, um das Modell bereitzustellen.

gcloud

Im folgenden Beispiel wir der Befehl gcloud ai endpoints list verwendet:

gcloud ai endpoints list \
  --region=LOCATION \
  --filter=display_name=ENDPOINT_NAME

Dabei gilt:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.

Notieren Sie sich die Zahl, die in der Spalte ENDPOINT_ID angezeigt wird. Verwenden Sie diese ID im folgenden Schritt.

REST

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • PROJECT_ID: Ihre Projekt-ID.
  • ENDPOINT_NAME: Der Anzeigename für den Endpunkt.
  • PROJECT_NUMBER: Projektnummer für Ihr Projekt

HTTP-Methode und URL:

GET https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "endpoints": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID",
      "displayName": "ENDPOINT_NAME",
      "etag": "AMEw9yPz5pf4PwBHbRWOGh0PcAxUdjbdX2Jm3QO_amguy3DbZGP5Oi_YUKRywIE-BtLx",
      "createTime": "2020-04-17T18:31:11.585169Z",
      "updateTime": "2020-04-17T18:35:08.568959Z"
    }
  ]
}
Beachten Sie die ENDPOINT_ID.

Modell bereitstellen

Wählen Sie unten den Tab für Ihre Sprache oder Umgebung aus:

gcloud

In den folgenden Beispielen wird der Befehl gcloud ai endpoints deploy-model verwendet.

Im folgenden Beispiel wird ein Model in einem Endpoint bereitgestellt, ohne GPUs zu verwenden, um die Vorhersagebereitstellung zu beschleunigen, ohne den Traffic auf mehrere DeployedModel-Ressourcen aufzuteilen:

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • ENDPOINT_ID: Die ID des Endpunkts.
  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • DEPLOYED_MODEL_NAME: Ein Name für DeployedModel. Sie können auch den Anzeigenamen von Model für DeployedModel verwenden.
  • MIN_REPLICA_COUNT: Die minimale Anzahl von Knoten für diese Bereitstellung. Die Knotenzahl kann je nach der Vorhersagelast erhöht oder verringert werden, bis zur maximalen Anzahl von Knoten und niemals auf weniger als diese Anzahl von Knoten.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Knoten für diese Bereitstellung. Die Knotenzahl kann je nach der Vorhersagelast erhöht oder verringert werden, bis zu dieser Anzahl von Knoten und niemals auf weniger als die minimale Anzahl von Knoten. Wenn Sie das Flag --max-replica-count weglassen, wird die maximale Anzahl von Knoten auf den Wert von --min-replica-count festgelegt.

Führen Sie den Befehl gcloud ai endpoints deploy-model aus:

Linux, macOS oder Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=100

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME `
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=100

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=100
 

Traffic aufteilen

Das Flag --traffic-split=0=100 in den vorherigen Beispielen sendet 100 % des Vorhersagetraffics, den der Endpoint empfängt, an das neue DeployedModel, das durch die temporäre ID 0 dargestellt wird. Wenn Ihr Endpoint bereits andere DeployedModel-Ressourcen hat, können Sie den Traffic zwischen dem neuen DeployedModel und den alten aufteilen. Um z. B. 20 % des Traffics an das neue DeployedModel und 80% an ein älteres zu senden, führen Sie den folgenden Befehl aus:

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • OLD_DEPLOYED_MODEL_ID: die ID des vorhandenen DeployedModel.

Führen Sie den Befehl gcloud ai endpoints deploy-model aus:

Linux, macOS oder Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME \
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME \
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80
 

REST

Modell bereitstellen

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.
  • PROJECT_ID: Ihre Projekt-ID.
  • ENDPOINT_ID: Die ID des Endpunkts.
  • MODEL_ID: Die ID des bereitzustellenden Modells.
  • DEPLOYED_MODEL_NAME: Ein Name für DeployedModel. Sie können auch den Anzeigenamen von Model für DeployedModel verwenden.
  • MACHINE_TYPE: Optional. Die für jeden Knoten dieser Bereitstellung verwendeten Maschinenressourcen. Die Standardeinstellung ist n1-standard-2. Weitere Informationen zu Maschinentypen.
  • ACCELERATOR_TYPE: Der Typ des Beschleunigers, der an die Maschine angehängt werden soll. Optional, wenn ACCELERATOR_COUNT nicht angegeben oder null ist. Nicht empfohlen für AutoML-Modelle oder benutzerdefinierte Modelle, die keine GPU-Images verwenden. Weitere Informationen
  • ACCELERATOR_COUNT: Die Anzahl der Beschleuniger, die für jedes Replikat verwendet werden soll. Optional. Sollte für AutoML-Modelle oder benutzerdefiniert trainierte Modelle, die keine GPU-Images verwenden, null oder nicht angegeben sein.
  • MIN_REPLICA_COUNT: Die minimale Anzahl von Knoten für diese Bereitstellung. Die Knotenzahl kann je nach der Vorhersagelast erhöht oder verringert werden, bis zur maximalen Anzahl von Knoten und niemals auf weniger als diese Anzahl von Knoten. Dieser Wert muss größer oder gleich 1 sein.
  • MAX_REPLICA_COUNT: Die maximale Anzahl von Knoten für diese Bereitstellung. Die Knotenzahl kann je nach der Vorhersagelast erhöht oder verringert werden, bis zu dieser Anzahl von Knoten und niemals auf weniger als die minimale Anzahl von Knoten.
  • TRAFFIC_SPLIT_THIS_MODEL: Der Prozentsatz des Vorhersagetraffics an diesen Endpunkt, der an das Modell mit diesem Vorgang weitergeleitet werden soll. Die Standardeinstellung ist 100. Alle Traffic-Prozentsätze müssen zusammen 100 % ergeben. Weitere Informationen zu Traffic-Splits
  • DEPLOYED_MODEL_ID_N: Optional. Wenn andere Modelle für diesen Endpunkt bereitgestellt werden, müssen Sie die Prozentsätze der Trafficaufteilung aktualisieren, sodass alle Prozentsätze zusammen 100 % ergeben.
  • TRAFFIC_SPLIT_MODEL_N: Der Prozentwert der Trafficaufteilung für den bereitgestellten Modell-ID-Schlüssel.
  • PROJECT_NUMBER: Projektnummer für Ihr Projekt

HTTP-Methode und URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel

JSON-Text anfordern:

{
  "deployedModel": {
    "model": "projects/PROJECT/locations/us-central1/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_NAME",
    "dedicatedResources": {
       "machineSpec": {
         "machineType": "MACHINE_TYPE",
         "acceleratorType": "ACCELERATOR_TYPE",
         "acceleratorCount": "ACCELERATOR_COUNT"
       },
       "minReplicaCount": MIN_REPLICA_COUNT,
       "maxReplicaCount": MAX_REPLICA_COUNT
     },
  },
  "trafficSplit": {
    "0": TRAFFIC_SPLIT_THIS_MODEL,
    "DEPLOYED_MODEL_ID_1": TRAFFIC_SPLIT_MODEL_1,
    "DEPLOYED_MODEL_ID_2": TRAFFIC_SPLIT_MODEL_2
  },
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-19T17:53:16.502088Z",
      "updateTime": "2020-10-19T17:53:16.502088Z"
    }
  }
}

Java

Informationen zum Installieren und Verwenden der Clientbibliothek für Vertex AI finden Sie unter Vertex AI-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.DedicatedResources;
import com.google.cloud.aiplatform.v1.DeployModelOperationMetadata;
import com.google.cloud.aiplatform.v1.DeployModelResponse;
import com.google.cloud.aiplatform.v1.DeployedModel;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;

public class DeployModelCustomTrainedModelSample {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String endpointId = "ENDPOINT_ID";
    String modelName = "MODEL_NAME";
    String deployedModelDisplayName = "DEPLOYED_MODEL_DISPLAY_NAME";
    deployModelCustomTrainedModelSample(project, endpointId, modelName, deployedModelDisplayName);
  }

  static void deployModelCustomTrainedModelSample(
      String project, String endpointId, String model, String deployedModelDisplayName)
      throws IOException, ExecutionException, InterruptedException {
    EndpointServiceSettings settings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // 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 (EndpointServiceClient client = EndpointServiceClient.create(settings)) {
      MachineSpec machineSpec = MachineSpec.newBuilder().setMachineType("n1-standard-2").build();
      DedicatedResources dedicatedResources =
          DedicatedResources.newBuilder().setMinReplicaCount(1).setMachineSpec(machineSpec).build();

      String modelName = ModelName.of(project, location, model).toString();
      DeployedModel deployedModel =
          DeployedModel.newBuilder()
              .setModel(modelName)
              .setDisplayName(deployedModelDisplayName)
              // `dedicated_resources` must be used for non-AutoML models
              .setDedicatedResources(dedicatedResources)
              .build();
      // key '0' assigns traffic for the newly deployed model
      // Traffic percentage values must add up to 100
      // Leave dictionary empty if endpoint should not accept any traffic
      Map<String, Integer> trafficSplit = new HashMap<>();
      trafficSplit.put("0", 100);
      EndpointName endpoint = EndpointName.of(project, location, endpointId);
      OperationFuture<DeployModelResponse, DeployModelOperationMetadata> response =
          client.deployModelAsync(endpoint, deployedModel, trafficSplit);

      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Operation name: %s\n", response.getInitialFuture().get().getName());

      // OperationFuture.get() will block until the operation is finished.
      DeployModelResponse deployModelResponse = response.get();
      System.out.format("deployModelResponse: %s\n", deployModelResponse);
    }
  }
}

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Vertex AI finden Sie unter Vertex AI-Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Python 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. 

def deploy_model_with_dedicated_resources_sample(
    project,
    location,
    model_name: str,
    machine_type: str,
    endpoint: Optional[aiplatform.Endpoint] = None,
    deployed_model_display_name: Optional[str] = None,
    traffic_percentage: Optional[int] = 0,
    traffic_split: Optional[Dict[str, int]] = None,
    min_replica_count: int = 1,
    max_replica_count: int = 1,
    accelerator_type: Optional[str] = None,
    accelerator_count: Optional[int] = None,
    explanation_metadata: Optional[explain.ExplanationMetadata] = None,
    explanation_parameters: Optional[explain.ExplanationParameters] = None,
    metadata: Optional[Sequence[Tuple[str, str]]] = (),
    sync: bool = True,
):
    """
    model_name: A fully-qualified model resource name or model ID.
          Example: "projects/123/locations/us-central1/models/456" or
          "456" when project and location are initialized or passed.
    """

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

    model = aiplatform.Model(model_name=model_name)

    # The explanation_metadata and explanation_parameters should only be
    # provided for a custom trained model and not an AutoML model.
    model.deploy(
        endpoint=endpoint,
        deployed_model_display_name=deployed_model_display_name,
        traffic_percentage=traffic_percentage,
        traffic_split=traffic_split,
        machine_type=machine_type,
        min_replica_count=min_replica_count,
        max_replica_count=max_replica_count,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        explanation_metadata=explanation_metadata,
        explanation_parameters=explanation_parameters,
        metadata=metadata,
        sync=sync,
    )

    model.wait()

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

Node.js

Informationen zum Installieren und Verwenden der Clientbibliothek für Vertex AI finden Sie unter Vertex AI-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. 

const automl = require('@google-cloud/automl');
const client = new automl.v1beta1.AutoMlClient();

/**
 * Demonstrates using the AutoML client to create a model.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const datasetId = '[DATASET_ID]' e.g., "TBL2246891593778855936";
// const tableId = '[TABLE_ID]' e.g., "1991013247762825216";
// const columnId = '[COLUMN_ID]' e.g., "773141392279994368";
// const modelName = '[MODEL_NAME]' e.g., "testModel";
// const trainBudget = '[TRAIN_BUDGET]' e.g., "1000",
// `Train budget in milli node hours`;

// A resource that represents Google Cloud Platform location.
const projectLocation = client.locationPath(projectId, computeRegion);

// Get the full path of the column.
const columnSpecId = client.columnSpecPath(
  projectId,
  computeRegion,
  datasetId,
  tableId,
  columnId
);

// Set target column to train the model.
const targetColumnSpec = {name: columnSpecId};

// Set tables model metadata.
const tablesModelMetadata = {
  targetColumnSpec: targetColumnSpec,
  trainBudgetMilliNodeHours: trainBudget,
};

// Set datasetId, model name and model metadata for the dataset.
const myModel = {
  datasetId: datasetId,
  displayName: modelName,
  tablesModelMetadata: tablesModelMetadata,
};

// Create a model with the model metadata in the region.
client
  .createModel({parent: projectLocation, model: myModel})
  .then(responses => {
    const initialApiResponse = responses[1];
    console.log(`Training operation name: ${initialApiResponse.name}`);
    console.log('Training started...');
  })
  .catch(err => {
    console.error(err);
  });

Standardeinstellungen für das Vorhersage-Logging ändern

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.

Modellbereitstellung konfigurieren

Bei der Modellbereitstellung müssen Sie für die Ausführung der Onlinevorhersage für folgende Bereiche Festlegungen treffen:

Erstellte Ressource Einstellung bei der Ressourcenerstellung
Endpunkt Speicherort zur Ausführung von Vorhersagen
Modell Zu verwendender Container (ModelContainerSpec)
DeployedModel Maschinen für die Onlinevorhersage

Nach der ersten Erstellung des Modells oder Endpunkts können Sie die oben aufgeführten Einstellungen nicht mehr ändern. Sie können sie auch nicht in der Anfrage für eine Onlinevorhersage überschreiben. Wenn Sie diese Einstellungen ändern möchten, müssen Sie das Modell neu bereitstellen.

Eingabe für Onlinevorhersagen formatieren

In diesem Abschnitt wird gezeigt, wie Sie die Instanzen der Vorhersageeingabe im JSON-Format formatieren und codieren. Dies ist erforderlich, wenn Sie eine der Methoden predict oder explain verwenden. Es ist nicht erforderlich, wenn Sie die Methode rawPredict verwenden. Informationen zur Auswahl der Methode finden Sie unter Anfrage an einen Endpunkt senden.

Wenn Sie das Vertex AI SDK für Python verwenden, um Vorhersageanfragen zu senden, geben Sie die Liste der Instanzen ohne das Feld instances an. Geben Sie beispielsweise [ ["the","quick","brown"], ... ] anstelle von { "instances": [ ["the","quick","brown"], ... ] } an.

Wenn Ihr Modell einen benutzerdefinierten Container nutzt, muss Ihre Eingabe im JSON-Format angegeben werden. Außerdem gibt es ein zusätzliches Feld parameters, das für Ihren Container verwendet werden kann. Weitere Informationen zum Formatieren von Vorhersageeingaben mit benutzerdefinierten Containern finden Sie in diesem Artikel.

Instanzen als JSON-Strings formatieren

Das Basisformat für Onlinevorhersagen ist eine Liste mit Dateninstanzen. Dies können einfache Wertelisten oder Mitglieder eines JSON-Objekts sein, je nachdem, wie Sie die Eingaben in der Trainingsanwendung konfiguriert haben. TensorFlow-Modelle akzeptieren auch komplexere Eingaben. Die meisten scikit-learn- und XGBoost-Modelle erwarten dagegen eine Liste von Zahlen als Eingabe.

Dieses Beispiel zeigt einen Eingabetensor und einen Instanzschlüssel für ein TensorFlow-Modell:

{"values": [1, 2, 3, 4], "key": 1}

Die Zusammensetzung des JSON-Stri