Onlinevorhersagen

Auf dieser Seite wird beschrieben, wie Sie mit AutoML Tables einzelne Onlinevorhersagen mit geringer Latenz abrufen.

Einführung

Nachdem Sie ein Modell erstellt bzw. trainiert haben, können Sie es bereitstellen und in Echtzeit Onlinevorhersagen anfordern. Bei Onlinevorhersagen wird eine Datenzeile akzeptiert und basierend auf dem Modell eine Vorhersage für diese Daten geliefert. Onlinevorhersagen sind nützlich, wenn Sie eine Vorhersage als Eingabe für Ihren Geschäftslogikfluss benötigen.

Bevor Sie eine Onlinevorhersage anfordern können, müssen Sie das Modell bereitstellen. Für bereitgestellte Modelle fallen Gebühren an. Sie können das Deployment des Modells im Anschluss an die Onlinevorhersage aufheben, um weitere Deployment-Gebühren zu vermeiden. Weitere Informationen

Onlinevorhersage abrufen

Konsole

Im Allgemeinen rufen Sie mithilfe von Onlinevorhersagen Ergebnisse aus Ihren Geschäftsanwendungen ab. Sie können aber AutoML Tables in der Cloud Console verwenden, um Ihr Datenformat oder Ihr Modell mit einem bestimmten Satz von Eingaben zu testen.

  1. Rufen Sie die Seite "AutoML Tables" in der Google Cloud Console auf.

    Zur Seite "AutoML Tables"

  2. Wählen Sie Modelle und dann das gewünschte Modell aus.

  3. Wählen Sie den Tab Test und Nutzung und klicken Sie auf Onlinevorhersage.

  4. Wenn Ihr Modell noch nicht bereitgestellt wurde, klicken Sie jetzt auf Modell bereitstellen.

    Das Modell muss bereitgestellt werden, um Onlinevorhersagen verwenden zu können. Für das Bereitstellen des Modells fallen Gebühren an. Weitere Informationen finden Sie auf der Preisseite.

  5. Geben Sie Ihre Eingabewerte in die angegebenen Textfelder ein.

    Alternativ können Sie JSON-Codeansicht auswählen, um Ihre Eingabewerte im JSON-Format bereitzustellen.

  6. Wenn Sie sehen möchten, wie sich die einzelnen Features auf die Vorhersage auswirken, wählen Sie Merkmalwichtigkeit erstellen aus.

    In der Google Cloud Console werden die Werte für die lokale Merkmalwichtigkeit zur besseren Lesbarkeit gekürzt. Wenn Sie einen genauen Wert benötigen, verwenden Sie die Cloud AutoML API, um die Vorhersageanfrage zu erstellen.

    Informationen zur Wichtigkeit von Funktionen finden Sie unter Wichtigkeit lokaler Funktionen.

  7. Klicken Sie auf Vorhersage, um die Vorhersage abzurufen.

    AutoML Tables-Seite für Vorhersagen

    Informationen zur Interpretation Ihrer Vorhersageergebnisse finden Sie unter Vorhersageergebnisse interpretieren. Informationen über die lokale Merkmalwichtigkeit finden Sie unter Lokale Merkmalwichtigkeit.

  8. (Optional) Wenn Sie keine weiteren Onlinevorhersagen anfordern möchten, können Sie die Bereitstellung des Modells aufheben, um weitere Deployment-Gebühren zu vermeiden. Klicken Sie hierfür auf Bereitstellung des Modells zurücknehmen.

curl-Befehl

Sie können eine Vorhersage für eine Reihe von Werten anfragen. Erstellen Sie dazu Ihr JSON-Objekt mit Ihren Merkmalswerten und verwenden Sie dann die Methode model.predict, um die Vorhersage abzurufen.

Die Werte müssen exakt die in das Training einbezogenen Spalten enthalten. Außerdem müssen sie in derselben Reihenfolge wie im Tab Bewerten angegeben sein. Diesen können Sie durch Klicken auf den Link "Enthaltene Spalten" ansehen.

Wenn Sie die Reihenfolge der Werte ändern möchten, können Sie in die Reihenfolge der Werte optional einen Satz von Spaltenspezifikations-IDs einfügen. Die Spaltenspezifikations-IDs finden Sie im Modellobjekt im Feld TablesModelMetadata.inputFeatureColumnSpecs.

Der Datentyp jedes Wertes bzw. Merkmals im Zeilenobjekt richtet sich nach dem AutoML Tables-Datentyp des Merkmals. Eine Liste der von AutoML Tables akzeptierten Datentypen finden Sie unter Format für Zeilenobjekte.

  1. Wenn Sie das Modell noch nicht bereitgestellt haben, holen Sie das jetzt nach. Mehr erfahren

  2. Fordern Sie die Vorhersage an.

    Ersetzen Sie diese Werte in den folgenden Anweisungen:

    • endpointendpointautoml.googleapis.com: eu-automl.googleapis.com für den globalen Standort und für die EU-Region.
    • project-id: Ihre Google Cloud-Projekt-ID
    • location: Der Standort für die Ressource: us-central1 für global oder eu für die EU.
    • model-id: Die ID des Modells. Beispiel: TBL543
    • valueN: Die Werte für jede Spalte in der richtigen Reihenfolge.

    HTTP-Methode und URL:

    POST https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:predict

    JSON-Text der Anfrage:

    {
      "payload": {
        "row": {
          "values": [
            value1, value2,...
          ]
        }
      }
    }
    

    Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

    curl

    Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

    curl -X POST \
    -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    https://endpoint/v1beta1/projects/project-id/locations/location/models/model-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 application-default print-access-token
    $headers = @{ "Authorization" = "Bearer $cred" }

    Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:predict" | Select-Object -Expand Content
    Fügen Sie den Parameter feature_importance ein, um die Ergebnisse der lokalen Merkmalwichtigkeit einzubeziehen: Informationen über die lokale Merkmalwichtigkeit finden Sie unter Lokale Merkmalwichtigkeit.

  3. Ergebnisse ansehen.

    Die Ausgabe für ein Klassifizierungsmodell sollte in etwa wie unten aussehen. Beachten Sie, dass zwei Ergebnisse mit jeweils einer Konfidenzschätzung (score) zurückgegeben werden. Die Konfidenzschätzung liegt zwischen 0 und 1 und zeigt an, wie wahrscheinlich das Modell dies als den richtigen Vorhersagewert ansieht. Weitere Informationen zur Verwendung der Konfidenzschätzung finden Sie unter Vorhersageergebnisse interpretieren.

    {
     "payload": [
       {
         "tables": {
           "score": 0.11210235,
           "value": "1"
         }
       },
       {
         "tables": {
           "score": 0.8878976,
           "value": "2"
         }
       }
     ]
    }
    

    Bei einem Regressionsmodell enthalten die Ergebnisse einen Vorhersagewert und ein Vorhersageintervall. Das Vorhersageintervall stellt einen Bereich bereit, der den wahren Wert in 95% der Zeit enthält (basierend auf den Daten, auf denen das Modell trainiert wurde). Beachten Sie, dass der vorhergesagte Wert möglicherweise nicht im Intervall zentriert ist (möglicherweise auch außerhalb des Intervalls), da das Vorhersageintervall um den Medianwert herum zentriert wird, während der vorhergesagte Wert der erwartete Wert ist ( oder Mittelwert).

    {
     "payload": [
       {
         "tables": {
           "value": 207.18209838867188,
           "predictionInterval": {
             "start": 29.712770462036133,
             "end": 937.42041015625
           }
         }
       }
     ]
    }
    

    Informationen zu den Ergebnissen der lokalen Merkmalwichtigkeit finden Sie unter Lokale Merkmalwichtigkeit.

  4. (Optional) Wenn Sie keine weiteren Onlinevorhersagen abrufen möchten, können Sie die Bereitstellung des Modells aufheben, um weitere Deployment-Gebühren zu vermeiden. Mehr erfahren

Java

Wenn sich Ihre Ressourcen in der EU-Region befinden, müssen Sie den Endpunkt explizit festlegen. Mehr erfahren

import com.google.cloud.automl.v1beta1.AnnotationPayload;
import com.google.cloud.automl.v1beta1.ExamplePayload;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.PredictRequest;
import com.google.cloud.automl.v1beta1.PredictResponse;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import com.google.cloud.automl.v1beta1.Row;
import com.google.cloud.automl.v1beta1.TablesAnnotation;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

class TablesPredict {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    // Values should match the input expected by your model.
    List<Value> values = new ArrayList<>();
    // values.add(Value.newBuilder().setBoolValue(true).build());
    // values.add(Value.newBuilder().setNumberValue(10).build());
    // values.add(Value.newBuilder().setStringValue("YOUR_STRING").build());
    predict(projectId, modelId, values);
  }

  static void predict(String projectId, String modelId, List<Value> values) throws IOException {
    // 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 client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);
      Row row = Row.newBuilder().addAllValues(values).build();
      ExamplePayload payload = ExamplePayload.newBuilder().setRow(row).build();

      // Feature importance gives you visibility into how the features in a specific prediction
      // request informed the resulting prediction. For more info, see:
      // https://cloud.google.com/automl-tables/docs/features#local
      PredictRequest request =
          PredictRequest.newBuilder()
              .setName(name.toString())
              .setPayload(payload)
              .putParams("feature_importance", "true")
              .build();

      PredictResponse response = client.predict(request);

      System.out.println("Prediction results:");
      for (AnnotationPayload annotationPayload : response.getPayloadList()) {
        TablesAnnotation tablesAnnotation = annotationPayload.getTables();
        System.out.format(
            "Classification label: %s%n", tablesAnnotation.getValue().getStringValue());
        System.out.format("Classification score: %.3f%n", tablesAnnotation.getScore());
        // Get features of top importance
        tablesAnnotation
            .getTablesModelColumnInfoList()
            .forEach(
                info ->
                    System.out.format(
                        "\tColumn: %s - Importance: %.2f%n",
                        info.getColumnDisplayName(), info.getFeatureImportance()));
      }
    }
  }
}

Node.js

Wenn sich Ihre Ressourcen in der EU-Region befinden, müssen Sie den Endpunkt explizit festlegen. Mehr erfahren


/**
 * Demonstrates using the AutoML client to request prediction from
 * automl tables using csv.
 * 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 modelId = '[MODEL_ID]' e.g., "TBL000000000000";
// const inputs = [{ numberValue: 1 }, { stringValue: 'value' }, { stringValue: 'value2' } ...]

const automl = require('@google-cloud/automl');

// Create client for prediction service.
const automlClient = new automl.v1beta1.PredictionServiceClient();

// Get the full path of the model.
const modelFullId = automlClient.modelPath(projectId, computeRegion, modelId);

inputs = JSON.parse(inputs);

async function predict() {
  // Set the payload by giving the row values.
  const payload = {
    row: {
      values: inputs,
    },
  };

  // Params is additional domain-specific parameters.
  // Currently there is no additional parameters supported.
  const [response] = await automlClient.predict({
    name: modelFullId,
    payload: payload,
    params: {feature_importance: true},
  });
  console.log('Prediction results:');

  for (const result of response.payload) {
    console.log(`Predicted class name: ${result.displayName}`);
    console.log(`Predicted class score: ${result.tables.score}`);

    // Get features of top importance
    const featureList = result.tables.tablesModelColumnInfo.map(
      columnInfo => {
        return {
          importance: columnInfo.featureImportance,
          displayName: columnInfo.columnDisplayName,
        };
      }
    );
    // Sort features by their importance, highest importance first
    featureList.sort((a, b) => {
      return b.importance - a.importance;
    });

    // Print top 10 important features
    console.log('Features of top importance');
    console.log(featureList.slice(0, 10));
  }
}
predict();

Python

Die Clientbibliothek für AutoML Tables enthält zusätzliche Python-Methoden, die die Verwendung der AutoML Tables API vereinfachen. Diese Methoden verweisen auf Datasets und Modelle anhand des Namens und nicht der ID. Dataset- und Modellnamen dürfen nur einmal vorkommen. Weitere Informationen finden Sie in der Kundenreferenz.

Wenn sich Ihre Ressourcen in der EU-Region befinden, müssen Sie den Endpunkt explizit festlegen. Mehr erfahren

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_display_name = 'MODEL_DISPLAY_NAME_HERE'
# inputs = {'value': 3, ...}

from google.cloud import automl_v1beta1 as automl

client = automl.TablesClient(project=project_id, region=compute_region)

if feature_importance:
    response = client.predict(
        model_display_name=model_display_name,
        inputs=inputs,
        feature_importance=True,
    )
else:
    response = client.predict(
        model_display_name=model_display_name, inputs=inputs
    )

print("Prediction results:")
for result in response.payload:
    print(
        "Predicted class name: {}".format(result.tables.value.string_value)
    )
    print("Predicted class score: {}".format(result.tables.score))

    if feature_importance:
        # get features of top importance
        feat_list = [
            (column.feature_importance, column.column_display_name)
            for column in result.tables.tables_model_column_info
        ]
        feat_list.sort(reverse=True)
        if len(feat_list) < 10:
            feat_to_show = len(feat_list)
        else:
            feat_to_show = 10

        print("Features of top importance:")
        for feat in feat_list[:feat_to_show]:
            print(feat)

Nächste Schritte