Onlinevorhersagen und Erläuterungen abrufen

Auf dieser Seite wird gezeigt, wie Sie mit der Google Cloud Console oder der Vertex AI API Onlinevorhersagen und -erläuterungen in Echtzeit aus Ihren Tabellenklassifizierungs- oder Regressionsmodellen abrufen.

Eine Onlinevorhersage ist eine synchrone Anfrage im Gegensatz zu einer Batchvorhersage, bei der es sich um eine asynchrone Anfrage handelt. Verwenden Sie Onlinevorhersagen, wenn Sie Anfragen als Reaktion auf Anwendungseingaben oder in Situationen stellen, in denen eine zeitnahe Inferenz erforderlich ist.

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.

Dabei werden folgende Themen behandelt:

  1. Modell auf einem Endpunkt bereitstellen
  2. Mit dem bereitgestellten Modell eine Onlinevorhersage treffen
  3. Mit dem bereitgestellten Modell eine Online-Erläuterung erhalten

Hinweis

Bevor Sie Onlinevorhersagen abrufen können, müssen Sie zuerst ein Klassifizierungs- oder Regressionsmodell trainieren und es auf Genauigkeit bewerten.

Modell auf einem Endpunkt bereitstellen

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. Konfigurieren Sie auf der Seite Endpunkt definieren Folgendes:

    1. Sie können Ihr Modell auf einem neuen oder vorhandenen Endpunkt bereitstellen.

      • 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

    2. Klicken Sie auf Weiter.

  6. Konfigurieren Sie auf der Seite Modelleinstellungen Folgendes:

    1. Wenn Sie das Modell auf einem neuen Endpunkt bereitstellen, akzeptieren Sie für die Trafficaufteilung 100. 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.

    2. 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".

    3. Wählen Sie den Maschinentyp aus.

      Größere Maschinenressourcen erhöhen die Vorhersageleistung und erhöhen die Kosten.

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

    5. Klicken Sie auf Weiter.

  7. Klicken Sie auf der Seite Modellmonitoring auf Weiter.

  8. Konfigurieren Sie auf der Seite Monitoringziele Folgendes:

    1. Geben Sie den Speicherort Ihrer Trainingsdaten ein.
    2. Geben Sie den Namen der Zielspalte ein.

  9. 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. Erstellen Sie bei Bedarf einen Endpunkt.
  2. Rufen Sie die Endpunkt-ID ab.
  3. Stellen Sie das Modell für den Endpunkt bereit.

Endpunkt erstellen

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

gcloud

Das folgende Beispiel verwendet den Befehl gcloud ai endpoints create:

  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 diese Werte in den folgenden Anfragedaten:

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

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 in etwa folgende JSON-Antwort 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

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

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.\
 * (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 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. 

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

Das folgende Beispiel verwendet den Befehl gcloud ai endpoints list:

  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 diese Werte in den folgenden Anfragedaten:

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

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 in etwa folgende JSON-Antwort 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 den 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.
  • MACHINE_TYPE: Optional. Die für jeden Knoten dieser Bereitstellung verwendeten Maschinenressourcen. Die Standardeinstellung ist n1-standard-2. Weitere Informationen zu Maschinentypen.
  • 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. Wenn das Flag --min-replica-count weggelassen wird, wird der Wert standardmäßig auf 1 gesetzt.
  • 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 \
  --machine-type=MACHINE_TYPE \
  --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 `
  --machine-type=MACHINE_TYPE `
  --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 ^
  --machine-type=MACHINE_TYPE ^
  --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 \ 
  --machine-type=MACHINE_TYPE \
  --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 \ 
  --machine-type=MACHINE_TYPE `
  --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 \ 
  --machine-type=MACHINE_TYPE ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80
 

REST

Mit der Methode endpoints.predict können Sie eine Onlinevorhersage anfordern.

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: Die automatisch generierte Projektnummer Ihres Projekts.

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 in etwa folgende JSON-Antwort 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

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

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

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. 

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.

Mit dem bereitgestellten Modell eine Onlinevorhersage erhalten

Um eine Onlinevorhersage zu erstellen, senden Sie ein oder mehrere Testelemente zur Analyse an ein Modell. Das Modell gibt dann Ergebnisse zurück, die auf den Zielen des Modells basieren. Verwenden Sie die Google Cloud Console oder die Vertex AI API, um eine Onlinevorhersage anzufordern.

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 in der Liste der Modelle auf den Namen des Modells, von dem Sie Vorhersagen anfordern möchten.

  3. Wählen Sie den Tab Bereitstellen und Testen aus.

  4. Fügen Sie im Abschnitt Modell testen Testelemente hinzu, um eine Vorhersage anzufordern. Die Basisvorhersagedaten sind bereits ausgefüllt. Sie können auch Ihre eigenen Vorhersagedaten eingeben und auf Vorhersagen klicken.

    Nach Abschluss der Vorhersage gibt Vertex AI die Ergebnisse in der Konsole zurück.

API: Klassifizierung

gcloud

  1. Erstellen Sie eine Datei mit dem Namen request.json und mit folgendem Inhalt: 

          {
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}

    Dabei gilt:

    • PREDICTION_DATA_ROW: Ein JSON-Objekt mit Schlüsseln als Merkmalsnamen und Werten als entsprechende Merkmalswerte. Ein Beispiel: Bei einem Dataset mit einer Zahl, einem Array von Strings und einer Kategorie kann die Datenzeile wie in der folgenden Beispielanfrage aussehen:

      "length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]

      Für jedes im Training enthaltene Merkmal muss ein Wert angegeben werden. Das Format der für die Vorhersage verwendeten Daten muss mit dem Format für das Training übereinstimmen. Weitere Informationen finden Sie unter Datenformat für Vorhersagen.

  2. Führen Sie dazu diesen Befehl aus:

    gcloud ai endpoints predict ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json

    Dabei gilt:

    • ENDPOINT_ID: Die ID des Endpunkts.
    • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.

REST

Mit der Methode endpoints.predict können Sie eine Onlinevorhersage anfordern.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION_ID: Die Region, in der sich der Endpunkt befindet. Beispiel: us-central1.
  • PROJECT_ID: Ihre Projekt-ID.
  • ENDPOINT_ID: Die ID des Endpunkts.

  • PREDICTION_DATA_ROW: Ein JSON-Objekt mit Schlüsseln als Merkmalsnamen und Werten als entsprechende Merkmalswerte. Ein Beispiel: Bei einem Dataset mit einer Zahl, einem Array von Strings und einer Kategorie kann die Datenzeile wie in der folgenden Beispielanfrage aussehen:

    "length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]

    Für jedes im Training enthaltene Merkmal muss ein Wert angegeben werden. Das Format der für die Vorhersage verwendeten Daten muss mit dem Format für das Training übereinstimmen. Weitere Informationen finden Sie unter Datenformat für Vorhersagen.

  • DEPLOYED_MODEL_ID: Ausgabe durch die Methode predict und als Eingabe durch die Methode explain akzeptiert. Die ID des Modells, das zum Generieren der Vorhersage verwendet wird. Wenn Sie Erläuterungen zu einer zuvor angeforderten Vorhersage erhalten möchten und Sie mehr als ein Modell bereitgestellt haben, können Sie mit dieser ID festlegen, dass die Erläuterungen für das Modell zurückgegeben werden, aus dem die vorherige Vorhersage erstellt wurde.

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}

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/endpoints/ENDPOINT_ID:predict"

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/endpoints/ENDPOINT_ID:predict" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

   {
     "predictions": [
      {
         "scores": [
           0.96771615743637085,
           0.032283786684274673
         ],
         "classes": [
           "0",
           "1"
         ]
      }
     ]
     "deployedModelId": "2429510197"
   }

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.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.cloud.aiplatform.v1.schema.predict.prediction.TabularClassificationPredictionResult;
import com.google.protobuf.ListValue;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.List;

public class PredictTabularClassificationSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String instance = "[{ “feature_column_a”: “value”, “feature_column_b”: “value”}]";
    String endpointId = "YOUR_ENDPOINT_ID";
    predictTabularClassification(instance, project, endpointId);
  }

  static void predictTabularClassification(String instance, String project, String endpointId)
      throws IOException {
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.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 (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings)) {
      String location = "us-central1";
      EndpointName endpointName = EndpointName.of(project, location, endpointId);

      ListValue.Builder listValue = ListValue.newBuilder();
      JsonFormat.parser().merge(instance, listValue);
      List<Value> instanceList = listValue.getValuesList();

      Value parameters = Value.newBuilder().setListValue(listValue).build();
      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instanceList, parameters);
      System.out.println("Predict Tabular Classification Response");
      System.out.format("\tDeployed Model Id: %s\n", predictResponse.getDeployedModelId());

      System.out.println("Predictions");
      for (Value prediction : predictResponse.getPredictionsList()) {
        TabularClassificationPredictionResult.Builder resultBuilder =
            TabularClassificationPredictionResult.newBuilder();
        TabularClassificationPredictionResult result =
            (TabularClassificationPredictionResult)
                ValueConverter.fromValue(resultBuilder, prediction);

        for (int i = 0; i < result.getClassesCount(); i++) {
          System.out.printf("\tClass: %s", result.getClasses(i));
          System.out.printf("\tScore: %f", result.getScores(i));
        }
      }
    }
  }
}

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.\
 * (Not necessary if passing values as arguments)
 */

// const endpointId = 'YOUR_ENDPOINT_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {prediction} =
  aiplatform.protos.google.cloud.aiplatform.v1.schema.predict;

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

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

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function predictTablesClassification() {
  // Configure the endpoint resource
  const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;
  const parameters = helpers.toValue({});

  const instance = helpers.toValue({
    petal_length: '1.4',
    petal_width: '1.3',
    sepal_length: '5.1',
    sepal_width: '2.8',
  });

  const instances = [instance];
  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);

  console.log('Predict tabular classification response');
  console.log(`\tDeployed model id : ${response.deployedModelId}\n`);
  const predictions = response.predictions;
  console.log('Predictions :');
  for (const predictionResultVal of predictions) {
    const predictionResultObj =
      prediction.TabularClassificationPredictionResult.fromValue(
        predictionResultVal
      );
    for (const [i, class_] of predictionResultObj.classes.entries()) {
      console.log(`\tClass: ${class_}`);
      console.log(`\tScore: ${predictionResultObj.scores[i]}\n\n`);
    }
  }
}
predictTablesClassification();

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. 

def predict_tabular_classification_sample(
    project: str,
    location: str,
    endpoint_name: str,
    instances: List[Dict],
):
    """
    Args
        project: Your project ID or project number.
        location: Region where Endpoint is located. For example, 'us-central1'.
        endpoint_name: A fully qualified endpoint name or endpoint ID. Example: "projects/123/locations/us-central1/endpoints/456" or
               "456" when project and location are initialized or passed.
        instances: A list of one or more instances (examples) to return a prediction for.
    """
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint(endpoint_name)

    response = endpoint.predict(instances=instances)

    for prediction_ in response.predictions:
        print(prediction_)

API: Regression

gcloud

  1. Erstellen Sie eine Datei namens request.json mit folgenden Inhalten: 

          {
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}

    Dabei gilt:

    • PREDICTION_DATA_ROW: Ein JSON-Objekt mit Schlüsseln als Merkmalsnamen und Werten als entsprechende Merkmalswerte. Ein Beispiel: Bei einem Dataset mit einer Zahl, einem Array von Zahlen und einer Kategorie kann die Datenzeile wie in der folgenden Beispielanfrage aussehen:

      "age":3.6,
"sq_ft":5392,
"code": "90331"

      Für jedes im Training enthaltene Merkmal muss ein Wert angegeben werden. Das Format der für die Vorhersage verwendeten Daten muss mit dem Format für das Training übereinstimmen. Weitere Informationen finden Sie unter Datenformat für Vorhersagen.

  2. Führen Sie dazu diesen Befehl aus:

    gcloud ai endpoints predict ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json

    Dabei gilt:

    • ENDPOINT_ID: Die ID des Endpunkts.
    • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.

REST

Mit der Methode endpoints.predict können Sie eine Onlinevorhersage anfordern.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • LOCATION_ID: Die Region, in der sich der Endpunkt befindet. Beispiel: us-central1.
  • PROJECT_ID: Ihre Projekt-ID.
  • ENDPOINT_ID: Die ID des Endpunkts.

  • PREDICTION_DATA_ROW: Ein JSON-Objekt mit Schlüsseln als Merkmalsnamen und Werten als entsprechende Merkmalswerte. Ein Beispiel: Bei einem Dataset mit einer Zahl, einem Array von Zahlen und einer Kategorie kann die Datenzeile wie in der folgenden Beispielanfrage aussehen:

    "age":3.6,
"sq_ft":5392,
"code": "90331"

    Für jedes im Training enthaltene Merkmal muss ein Wert angegeben werden. Das Format der für die Vorhersage verwendeten Daten muss mit dem Format für das Training übereinstimmen. Weitere Informationen finden Sie unter Datenformat für Vorhersagen.

  • DEPLOYED_MODEL_ID: Ausgabe durch die Methode predict und als Eingabe durch die Methode explain akzeptiert. Die ID des Modells, das zum Generieren der Vorhersage verwendet wird. Wenn Sie Erläuterungen zu einer zuvor angeforderten Vorhersage erhalten möchten und Sie mehr als ein Modell bereitgestellt haben, können Sie mit dieser ID festlegen, dass die Erläuterungen für das Modell zurückgegeben werden, aus dem die vorherige Vorhersage erstellt wurde.

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}

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/endpoints/ENDPOINT_ID:predict"

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/endpoints/ENDPOINT_ID:predict" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:


{
  "predictions": [
    [
      {
        "value": 65.14233,
        "lower_bound": 4.6572,
        "upper_bound": 164.0279
      }
    ]
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

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.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.cloud.aiplatform.v1.schema.predict.prediction.TabularRegressionPredictionResult;
import com.google.protobuf.ListValue;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.List;

public class PredictTabularRegressionSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String instance = "[{ “feature_column_a”: “value”, “feature_column_b”: “value”}]";
    String endpointId = "YOUR_ENDPOINT_ID";
    predictTabularRegression(instance, project, endpointId);
  }

  static void predictTabularRegression(String instance, String project, String endpointId)
      throws IOException {
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.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 (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings)) {
      String location = "us-central1";
      EndpointName endpointName = EndpointName.of(project, location, endpointId);

      ListValue.Builder listValue = ListValue.newBuilder();
      JsonFormat.parser().merge(instance, listValue);
      List<Value> instanceList = listValue.getValuesList();

      Value parameters = Value.newBuilder().setListValue(listValue).build();
      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instanceList, parameters);
      System.out.println("Predict Tabular Regression Response");
      System.out.format("\tDisplay Model Id: %s\n", predictResponse.getDeployedModelId());

      System.out.println("Predictions");
      for (Value prediction : predictResponse.getPredictionsList()) {
        TabularRegressionPredictionResult.Builder resultBuilder =
            TabularRegressionPredictionResult.newBuilder();

        TabularRegressionPredictionResult result =
            (TabularRegressionPredictionResult) ValueConverter.fromValue(resultBuilder, prediction);

        System.out.printf("\tUpper bound: %f\n", result.getUpperBound());
        System.out.printf("\tLower bound: %f\n", result.getLowerBound());
        System.out.printf("\tValue: %f\n", result.getValue());
      }
    }
  }
}

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.\
 * (Not necessary if passing values as arguments)
 */

// const endpointId = 'YOUR_ENDPOINT_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {prediction} =
  aiplatform.protos.google.cloud.aiplatform.v1.schema.predict;

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

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

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function predictTablesRegression() {
  // Configure the endpoint resource
  const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;
  const parameters = helpers.toValue({});

  // TODO (erschmid): Make this less painful
  const instance = helpers.toValue({
    BOOLEAN_2unique_NULLABLE: false,
    DATETIME_1unique_NULLABLE: '2019-01-01 00:00:00',
    DATE_1unique_NULLABLE: '2019-01-01',
    FLOAT_5000unique_NULLABLE: 1611,
    FLOAT_5000unique_REPEATED: [2320, 1192],
    INTEGER_5000unique_NULLABLE: '8',
    NUMERIC_5000unique_NULLABLE: 16,
    STRING_5000unique_NULLABLE: 'str-2',
    STRUCT_NULLABLE: {
      BOOLEAN_2unique_NULLABLE: false,
      DATE_1unique_NULLABLE: '2019-01-01',
      DATETIME_1unique_NULLABLE: '2019-01-01 00:00:00',
      FLOAT_5000unique_NULLABLE: 1308,
      FLOAT_5000unique_REPEATED: [2323, 1178],
      FLOAT_5000unique_REQUIRED: 3089,
      INTEGER_5000unique_NULLABLE: '1777',
      NUMERIC_5000unique_NULLABLE: 3323,
      TIME_1unique_NULLABLE: '23:59:59.999999',
      STRING_5000unique_NULLABLE: 'str-49',
      TIMESTAMP_1unique_NULLABLE: '1546387199999999',
    },
    TIMESTAMP_1unique_NULLABLE: '1546387199999999',
    TIME_1unique_NULLABLE: '23:59:59.999999',
  });

  const instances = [instance];
  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);

  console.log('Predict tabular regression response');
  console.log(`\tDeployed model id : ${response.deployedModelId}`);
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const predictionResultVal of predictions) {
    const predictionResultObj =
      prediction.TabularRegressionPredictionResult.fromValue(
        predictionResultVal
      );
    console.log(`\tUpper bound: ${predictionResultObj.upper_bound}`);
    console.log(`\tLower bound: ${predictionResultObj.lower_bound}`);
    console.log(`\tLower bound: ${predictionResultObj.value}`);
  }
}
predictTablesRegression();

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. 

def predict_tabular_regression_sample(
    project: str,
    location: str,
    endpoint_name: str,
    instances: List[Dict],
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint(endpoint_name)

    response = endpoint.predict(instances=instances)

    for prediction_ in response.predictions:
        print(prediction_)

Vorhersageergebnisse interpretieren

Klassifizierung

Klassifizierungsmodelle geben einen Konfidenzwert zurück.

Der Konfidenzwert gibt an, wie stark Ihr Modell die einzelnen Klassen oder Labels mit einem Testelement verknüpft. Je höher die Zahl, desto höher die Konfidenz des Modells, dass das Label auf dieses Element angewendet werden sollte. Sie entscheiden, wie hoch der Konfidenzwert für die Annahme der Ergebnisse des Modells sein muss.

Regression

Regressionsmodelle geben einen Vorhersagewert zurück. Für BigQuery-Ziele geben sie auch ein Vorhersageintervall zurück. Das Vorhersageintervall bietet einen Wertebereich, bei dem das Modell eine Konfidenz von 95 % hat, dass er das tatsächliche Ergebnis enthält.

Mit dem bereitgestellten Modell eine Online-Erläuterung erhalten

Sie können eine Vorhersage mit Erläuterungen anfordern, die auch als Featureattribute bezeichnet werden, um zu sehen, wie Ihr Modell zu einer Vorhersage gelangt ist. Die Werte der lokalen Merkmalwichtigkeit geben an, wie viel jedes Feature zum Vorhersageergebnis beigetragen hat. Feature-Attributionen sind in Vertex AI-Vorhersagen über Vertex Explainable AI enthalten.

Console

Wenn Sie mit der Google Cloud Console eine Onlinevorhersage anfordern, werden die Werte für die lokale Merkmalwichtigkeit automatisch zurückgegeben.

Wenn Sie die vorausgefüllten Vorhersagewerte verwendet haben, sind die lokalen Merkmalwichtigkeitswerte null. Dies liegt daran, dass die voreingestellten Werte die Basisvorhersagedaten sind. Die zurückgegebene Vorhersage ist also der Basisvorhersagewert.

gcloud

  1. Erstellen Sie eine Datei mit dem Namen request.json und mit folgendem Inhalt:

    {
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}

    Dabei gilt:

    • PREDICTION_DATA_ROW: Ein JSON-Objekt mit Schlüsseln als Merkmalsnamen und Werten als entsprechende Merkmalswerte. Ein Beispiel: Bei einem Dataset mit einer Zahl, einem Array von Strings und einer Kategorie kann die Datenzeile wie in der folgenden Beispielanfrage aussehen:

      "length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]

      Für jedes im Training enthaltene Merkmal muss ein Wert angegeben werden. Das Format der für die Vorhersage verwendeten Daten muss mit dem Format für das Training übereinstimmen. Weitere Informationen finden Sie unter Datenformat für Vorhersagen.

  2. Führen Sie dazu diesen Befehl aus:

    gcloud ai endpoints explain ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json

    Dabei gilt:

    • ENDPOINT_ID: Die ID des Endpunkts.
    • LOCATION_ID: Die Region, in der Sie Vertex AI verwenden.

    Wenn Sie eine Anfrage für Erläuterungen an ein bestimmtes DeployedModel im Endpoint senden möchten, geben Sie das Flag --deployed-model-id an:

    gcloud ai endpoints explain ENDPOINT_ID \
  --region=LOCATION \
  --deployed-model-id=DEPLOYED_MODEL_ID \
  --json-request=request.json

    Ersetzen Sie zusätzlich zu den zuvor beschriebenen Platzhaltern Folgendes:

    • DEPLOYED_MODEL_ID (optional) ist die ID des bereitgestellten Modells, für das Sie Erläuterungen abrufen möchten. Die ID ist in der Antwort der Methode predict enthalten. Wenn Sie Erläuterungen zu einem bestimmten Modell anfordern möchten und Sie mehr als ein Modell an einem bestimmten Endpunkt bereitgestellt haben, können Sie mit dieser ID festlegen, dass die Erläuterungen für das Modell zurückgegeben werden, das die vorherige Vorhersage bereitgestellt hat.

REST

Das folgende Beispiel zeigt eine Anfrage für eine Onlinevorhersage für ein tabellarisches Klassifizierungsmodell mit lokalen Feature-Attributionen. Das Anfrageformat ist das gleiche wie für Regressionsmodelle.

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • LOCATION: Die Region, in der sich der Endpunkt befindet. Beispiel: us-central1.
  • PROJECT: Ihre Projekt-ID.
  • ENDPOINT_ID: Die ID des Endpunkts.

  • PREDICTION_DATA_ROW: Ein JSON-Objekt mit Schlüsseln als Merkmalsnamen und Werten als entsprechende Merkmalswerte. Ein Beispiel: Bei einem Dataset mit einer Zahl, einem Array von Strings und einer Kategorie kann die Datenzeile wie in der folgenden Beispielanfrage aussehen:

    "length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]

    Für jedes im Training enthaltene Merkmal muss ein Wert angegeben werden. Das Format der für die Vorhersage verwendeten Daten muss mit dem Format für das Training übereinstimmen. Weitere Informationen finden Sie unter Datenformat für Vorhersagen.

  • DEPLOYED_MODEL_ID (optional) ist die ID des bereitgestellten Modells, für das Sie Erläuterungen abrufen möchten. Die ID ist in der Antwort der Methode predict enthalten. Wenn Sie Erläuterungen zu einem bestimmten Modell anfordern möchten und Sie mehr als ein Modell an einem bestimmten Endpunkt bereitgestellt haben, können Sie mit dieser ID festlegen, dass die Erläuterungen für das Modell zurückgegeben werden, das die vorherige Vorhersage bereitgestellt hat.

HTTP-Methode und URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID:explain

JSON-Text der Anfrage:

{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID:explain"

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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID:explain" | Select-Object -Expand Content
 

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. 

def explain_sample(project: str, location: str, endpoint_id: str, instance_dict: Dict):

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

    endpoint = aiplatform.Endpoint(endpoint_id)

    response = endpoint.explain(instances=[instance_dict], parameters={})

    for explanation in response.explanations:
        print(" explanation")
        # Feature attributions.
        attributions = explanation.attributions
        for attribution in attributions:
            print("  attribution")
            print("   baseline_output_value:", attribution.baseline_output_value)
            print("   instance_output_value:", attribution.instance_output_value)
            print("   output_display_name:", attribution.output_display_name)
            print("   approximation_error:", attribution.approximation_error)
            print("   output_name:", attribution.output_name)
            output_index = attribution.output_index
            for output_index in output_index:
                print("   output_index:", output_index)

    for prediction in response.predictions:
        print(prediction)

Erläuterungen für eine zuvor zurückgegebene Vorhersage abrufen

Da Erläuterungen die Ressourcennutzung erhöhen, ist es unter Umständen sinnvoll, Erläuterungen erst anzufordern, wenn Sie diese benötigen. Manchmal kann es hilfreich sein, Erläuterungen für ein Vorhersageergebnis anzufordern, das Sie bereits erhalten haben, etwa weil die Vorhersage ein Ausreißer oder nicht sinnvoll war.

Wenn alle Ihre Vorhersagen aus einem Modell stammen, können Sie die Anfragedaten einfach noch einmal senden, um dabei Erläuterungen anzufordern. Wenn aber mehrere Modelle die Vorhersagen zurückgeben, müssen Sie die Erläuterungsanfrage an das richtige Modell senden. Sie können dazu Erläuterungen für ein bestimmtes Modell aufrufen. Dazu nehmen Sie in Ihre Anfrage die ID deployedModelID des bereitgestellten Modells auf, die in der Antwort auf die ursprüngliche Vorhersageanfrage enthalten ist. Beachten Sie, dass sich die bereitgestellte Modell-ID von der Modell-ID unterscheidet.

Erläuterungsergebnisse interpretieren

Zur Berechnung der lokalen Featurewichtigkeit wird zuerst der Baseline-Vorhersagewert berechnet. Die Basiswerte werden aus den Trainingsdaten berechnet, wobei der Medianwert für numerische Features und der Modus für kategoriale Features verwendet werden. Die aus den Basiswerten generierte Vorhersage ist der Basis-Vorhersagewert. Baselinewerte werden für ein Modell einmal berechnet und bleiben unverändert.

Bei einer bestimmten Vorhersage zeigt Ihnen die lokale Featurewichtigkeit für jedes Feature an, wie viel dieses Feature im Vergleich zum Baseline-Vorhersagewert zum Ergebnis hinzugefügt oder davon abgezogen hat. Die Summe aller Featurewichtigkeitswerte entspricht der Differenz zwischen dem Baseline-Vorhersagewert und dem Vorhersageergebnis.

Bei Klassifizierungsmodellen liegt die Punktzahl immer zwischen 0,0 und 1,0 (einschließlich). Daher liegen die lokalen Featurewichtigkeitswerte für Klassifizierungsmodelle immer zwischen -1.0 und 1.0 (einschließlich).

Beispiele für Feature-Attributionsabfragen und weitere Informationen finden Sie unter Featureattributionen für Klassifizierung und Regression.

Beispielausgabe für Vorhersagen und Erläuterungen

Klassifizierung

Die Rückgabenutzlast für eine Onlinevorhersage aus einem tabellarischen Klassifizierungsmodell mit Featurewichtigkeit sieht etwa wie im folgenden Beispiel aus.

Der instanceOutputValue von 0.928652400970459 ist der Konfidenzwert der Klasse mit der höchsten Punktzahl, in diesem Fall class_a. Das Feld baselineOutputValue enthält den Baseline-Vorhersagewert, 0.808652400970459. Das Feature, das am meisten zu diesem Ergebnis beigetragen hat, war feature_3.

{
"predictions": [
  {
    "scores": [
      0.928652400970459,
      0.071347599029541
    ],
    "classes": [
      "class_a",
      "class_b"
    ]
  }
]
"explanations": [
  {
    "attributions": [
      {
        "baselineOutputValue": 0.808652400970459,
        "instanceOutputValue": 0.928652400970459,
        "approximationError":  0.0058915703929231,
        "featureAttributions": {
          "feature_1": 0.012394922231235,
          "feature_2": 0.050212341234556,
          "feature_3": 0.057392736534209,
        },
        "outputIndex": [
          0
        ],
        "outputName": "scores"
      }
    ],
  }
]
"deployedModelId": "234567"
}

Regression

Die Rückgabenutzlast für eine Onlinevorhersage mit Featurewichtigkeit aus einem tabellarischen Regressionsmodell sieht etwa wie im folgenden Beispiel aus.

Der instanceOutputValue von 1795.1246466281819 ist der vorhergesagte Wert, wobei die Felder lower_bound und upper_bound das Konfidenzintervall von 95 % bieten. Das Feld baselineOutputValue enthält den Baseline-Vorhersagewert, 1788.7423095703125. Das Feature, das am meisten zu diesem Ergebnis beigetragen hat, war feature_3.

{
"predictions": [
  {
    "value": 1795.1246466281819,
    "lower_bound": 246.32196807861328,
    "upper_bound": 8677.51904296875
  }
]
"explanations": [
  {
    "attributions": [
      {
        "baselineOutputValue": 1788.7423095703125,
        "instanceOutputValue": 1795.1246466281819,
        "approximationError": 0.0038215703911553,
        "featureAttributions": {
          "feature_1": 0.123949222312359,
          "feature_2": 0.802123412345569,
          "feature_3": 5.456264423211472,
        },
        "outputIndex": [
          -1
        ]
      }
    ]
  }
],
"deployedModelId": "345678"
}

Nächste Schritte